class HtmlSkeleton

# File lib/html_skeleton.rb, line 10
def calendar(options = {}, &)
  set_calendar_options(options, &)
  month = @options[:month]
  frame = month ? "div" : "table"
  body = month ? a_month(@options[:year], month) : a_year(@options[:year])
  %(<#{frame} class="#{@options[:calendar_class]}"> #{body} </#{frame}>)
end

# File lib/html_skeleton.rb, line 18
  def table(rows, cols, options = {}, &)
    set_table_options(options, &)
    <<~TABLE
      <table class="#{@options[:table_class]}">
        #{table_header(cols)}
        #{table_body(rows, cols)}
      </table>
    TABLE
  end

# File lib/html_skeleton_calendar.rb, line 57
def a_day(date, today, block)
  attrs = "day"
  attrs += " weekendDay" if weekend?(date)
  attrs += " today" if date == today
  "<td class=\"#{attrs}\">#{block.call(date)}</td>"
end

# File lib/html_skeleton_calendar.rb, line 26
  def a_month(year, month)
    title = @options[:month_names][month]
    <<~TABLE
      <table class="month">
        <tr class="monthName"><th colspan="7">#{title}</th></tr>
        <tr class="dayName">#{@day_header}</tr>
        #{days_of_month(year, month)}
      </table>
    TABLE
  end

# File lib/html_skeleton_calendar.rb, line 11
  def a_year(year)
    rows = @options[:rows]
    cols = 12 / rows
    raise "html_skeleton_calendar: invalid option <rows>" unless rows * cols == 12

    body = (0..rows - 1).collect { |y|
      str = (1..cols).collect { |x| "<td>#{a_month(year, y * cols + x)}</td>" }
      "<tr>#{str.join}</tr>"
    }
    <<~THEAD
      <thead><th colspan="2">#{@options[:title]}</th></thead>
      #{body.join}
    THEAD
  end

# File lib/html_skeleton_calendar.rb, line 68
def days_between(first, second)
  (first > second) ? second + (7 - first) : second - first
end

# File lib/html_skeleton_calendar.rb, line 37
def days_of_month(year, month)
  first_weekday = @options[:first_day_of_week]
  last_weekday = first_weekday.positive? ? first_weekday - 1 : 6
  cell_proc = @options[:cell_proc]
  bool = Time.respond_to?(:zone) && !(zone = Time.zone).nil?
  today = bool ? zone.now.to_date : Date.today

  first = Date.civil(year, month, 1)
  last = Date.civil(year, month, -1)

  cal = +"<tr>"
  cal << "<td></td>" * days_between(first_weekday, first.wday)
  first.upto(last) { |cur|
    cal << a_day(cur, today, cell_proc)
    cal << "</tr> <tr>" if cur.wday == last_weekday
  }
  cal << "<td></td>" * days_between((last + 1).wday, first_weekday + 7)
  cal << "</tr>"
end

# File lib/html_skeleton.rb, line 30
def set_calendar_options(options, &block)
  year = DateTime.now.year
  @options = {
    year: year,
    title: year,
    rows: 3,
    calendar_class: "skeleton",
    month_names: Date::MONTHNAMES,
    abbrev: (0..1),
    cell_proc: block || ->(d) { d.day.to_s },
    first_day_of_week: 1
  }.merge options

  names = options[:day_names] || Date::DAYNAMES.dup
  @options[:first_day_of_week].times { names.push(names.shift) }

  @day_header = names.collect { |day|
    abbr = day[@options[:abbrev]]
    str = (abbr == day) ? day : %(<abbr title="#{day}">#{abbr}</abbr>)
    %(<th scope="col">#{str}</th>)
  }.join
end

# File lib/html_skeleton.rb, line 53
def set_table_options(options, &block)
  @options = {
    legend: nil,
    col_legend: ->(x) { x.to_s },
    row_legend: ->(x) { x.id },
    th_attribute: ->(_col) {},
    tr_attribute: ->(_row) {},

    table_class: "skeleton",
    cell_proc: block || ->(row, col) { "<td>#{row} #{col}</td>" }
  }.merge options
end

# File lib/html_skeleton_table.rb, line 21
def table_body(rows, cols)
  legend = @options[:legend]
  row_legend = @options[:row_legend]
  tr_attribute = @options[:tr_attribute]
  rows.collect { |row|
    rlegend = ""
    rlegend = %(<td class="legend">#{row_legend.call(row)}</td>) if legend
    cells = table_row(row, cols)
    %(<tr #{tr_attribute.call(row)}>#{rlegend}#{cells}</tr>)
  }.join("\n")
end

# File lib/html_skeleton_table.rb, line 9
def table_header(cols)
  legend = @options[:legend]
  th_attribute = @options[:th_attribute]
  return "" unless legend

  proc = @options[:col_legend]
  col_header = cols.collect { |col|
    "<th #{th_attribute.call(col)}>#{proc.call(col)}</th>"
  }.join
  %(<thead><th class="legend">#{legend}</th>#{col_header}</thead>)
end

# File lib/html_skeleton_table.rb, line 33
def table_row(row, cols)
  cell_proc = @options[:cell_proc]
  cols.collect { |col| cell_proc.call(row, col) }.join
end

# File lib/html_skeleton_calendar.rb, line 64
def weekend?(date)
  [0, 6].include?(date.wday)
end