make_a_calendar_toolkit 0.1.0

data/exe/make-calendar

@@ -0,0 +1,156 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require "json"
+begin
+  require "make_a_calendar"
+rescue LoadError
+  require_relative "../lib/make_a_calendar"
+end
+
+class MakeCalendarCLI
+  def run(argv)
+    command = argv.shift
+    return help if command.nil? || %w[-h --help help].include?(command)
+    options = { format: "json" }
+    options[:converter] = argv.shift if command == "convert"
+    parser = OptionParser.new do |opts|
+      opts.banner = "Usage: make-calendar COMMAND [options]"
+      opts.on("--year YEAR", Integer) { |value| options[:year] = value }
+      opts.on("--month MONTH", Integer) { |value| options[:month] = value }
+      opts.on("--week-start DAY") { |value| options[:week_start] = value.to_sym }
+      opts.on("--format FORMAT", %w[json csv html svg ics]) { |value| options[:format] = value }
+      opts.on("--from DATE") { |value| options[:from] = value }
+      opts.on("--to DATE") { |value| options[:to] = value }
+      opts.on("--date DATE") { |value| options[:date] = value }
+      opts.on("--days COUNT", Integer) { |value| options[:days] = value }
+      opts.on("--country COUNTRY") { |value| options[:country] = value }
+      opts.on("--observed") { options[:observed] = true }
+      opts.on("--pattern PATTERN") { |value| options[:pattern] = value }
+      opts.on("--start DATE") { |value| options[:start] = value }
+      opts.on("--output PATH") { |value| options[:output] = value }
+      opts.on("--input PATH") { |value| options[:input] = value }
+      opts.on("--force") { options[:force] = true }
+      opts.on("--serial VALUE") { |value| options[:serial] = value }
+      opts.on("--system SYSTEM") { |value| options[:system] = value }
+    end
+    parser.parse!(argv)
+    result = execute(command, options)
+    write_result(result, options)
+    0
+  rescue OptionParser::ParseError, ArgumentError, MakeACalendar::Error, KeyError => error
+    warn "make-calendar: #{error.message}"
+    2
+  end
+
+  private
+
+  def execute(command, options)
+    case command
+    when "month"
+      require_options(options, :year, :month)
+      calendar = MakeACalendar.month(year: options[:year], month: options[:month], week_start: options.fetch(:week_start, :sunday))
+      render(calendar, options)
+    when "year"
+      require_options(options, :year)
+      calendar = MakeACalendar.year(year: options[:year], week_start: options.fetch(:week_start, :sunday))
+      render(calendar, options)
+    when "business-days"
+      require_options(options, :from, :to)
+      count = MakeACalendar.business_days_between(options[:from], options[:to], holidays: options[:observed] ? MakeACalendar::Holidays.observed_dates(DateMath.date(options[:from]).year, DateMath.date(options[:to]).year) : [])
+      "#{count}\n"
+    when "add-business-days"
+      require_options(options, :date, :days)
+      MakeACalendar.add_business_days(options[:date], options[:days]).iso8601 + "\n"
+    when "holidays"
+      require_options(options, :year)
+      raise ArgumentError, "only --country us is supported" unless options.fetch(:country, "us").downcase == "us"
+      holidays = MakeACalendar.federal_holidays(options[:year])
+      holidays = holidays.map { |holiday| { name: holiday.name, date: (options[:observed] ? holiday.observed_date : holiday.date).iso8601 } }
+      JSON.pretty_generate(holidays) + "\n"
+    when "fiscal"
+      require_options(options, :year)
+      fiscal = MakeACalendar.fiscal_calendar(year: options[:year], pattern: options.fetch(:pattern, "445"))
+      JSON.pretty_generate(fiscal.to_h) + "\n"
+    when "shifts"
+      require_options(options, :start, :to, :pattern)
+      pattern = options[:pattern].split("-").map(&:to_i)
+      JSON.pretty_generate(MakeACalendar::Scheduling.shift_dates(start_date: options[:start], end_date: options[:to], pattern: pattern).map { |item| { date: item[:date].iso8601, on_duty: item[:on_duty], cycle_day: item[:cycle_day] } }) + "\n"
+    when "convert"
+      convert(options)
+    when "export-ics"
+      require_options(options, :input)
+      events = JSON.parse(File.read(options[:input]), symbolize_names: true)
+      MakeACalendar.to_ics(events)
+    else
+      raise ArgumentError, "unknown command #{command.inspect}; run make-calendar --help"
+    end
+  end
+
+  def render(calendar, options)
+    case options[:format]
+    when "json" then calendar.to_json + "\n"
+    when "csv" then calendar.respond_to?(:to_csv) ? calendar.to_csv : raise(ArgumentError, "CSV is supported for month calendars")
+    when "html" then calendar.to_html + "\n"
+    when "svg" then calendar.to_svg + "\n"
+    else raise ArgumentError, "format must be json, csv, html, or svg for calendars"
+    end
+  end
+
+  def convert(options)
+    case options.fetch(:converter) { raise ArgumentError, "use convert excel --serial VALUE [--system 1900|1904]" }
+    when "excel"
+      require_options(options, :serial)
+      MakeACalendar::Converters.excel(options[:serial], system: options.fetch(:system, "1900")).to_s + "\n"
+    when "ordinal"
+      require_options(options, :serial)
+      MakeACalendar::Converters.ordinal(options[:serial]).iso8601 + "\n"
+    when "unix"
+      require_options(options, :serial)
+      MakeACalendar::Converters.unix(options[:serial], unit: options.fetch(:system, "seconds").to_sym).iso8601 + "\n"
+    else
+      raise ArgumentError, "converter must be excel, ordinal, or unix"
+    end
+  end
+
+  def require_options(options, *keys)
+    missing = keys.reject { |key| options.key?(key) }
+    raise ArgumentError, "missing required option(s): #{missing.map { |key| "--#{key.to_s.tr('_', '-')}" }.join(', ')}" unless missing.empty?
+  end
+
+  def write_result(result, options)
+    if options[:output]
+      path = File.expand_path(options[:output])
+      raise ArgumentError, "refusing to overwrite #{path}; pass --force to replace it" if File.exist?(path) && !options[:force]
+      File.write(path, result)
+    else
+      print result
+    end
+  end
+
+  def help
+    puts <<~HELP
+      Usage: make-calendar COMMAND [options]
+
+      Commands:
+        month --year YEAR --month MONTH [--week-start sunday|monday] [--format json|csv|html|svg]
+        year --year YEAR [--format json|html|svg]
+        holidays --year YEAR [--country us] [--observed]
+        business-days --from DATE --to DATE [--observed]
+        add-business-days --date DATE --days N
+        fiscal --year YEAR [--pattern 445|454|544]
+        shifts --start DATE --to DATE --pattern 2-2-3
+        convert excel --serial VALUE [--system 1900|1904]
+        convert ordinal --serial YYYY-DDD
+        convert unix --serial VALUE [--system seconds|milliseconds|microseconds|nanoseconds]
+        export-ics --input events.json [--output FILE]
+
+      Output goes to stdout by default. --output refuses existing files unless --force is set.
+      Business-day ranges include both endpoints; adding days does not count the start date.
+    HELP
+    0
+  end
+end
+
+exit MakeCalendarCLI.new.run(ARGV)

data/lib/make_a_calendar/calendar.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require "json"
+require "csv"
+require "cgi"
+
+module MakeACalendar
+  class Calendar
+    attr_reader :year, :month, :week_start, :grid, :holidays
+
+    def initialize(year:, month:, week_start: :sunday, fixed_rows: nil, holidays: [])
+      @year = Integer(year)
+      @month = Integer(month)
+      @week_start = week_start.to_sym
+      @grid = DateMath.month_grid(@year, @month, week_start: @week_start, fixed_rows: fixed_rows)
+      @holidays = holidays.freeze
+      freeze
+    end
+
+    def to_h
+      { year: year, month: month, week_start: week_start,
+        weekdays: weekday_names, weeks: grid.map { |row| row.map { |cell| cell[:date]&.iso8601 } } }
+    end
+
+    def to_json(*_args)
+      JSON.pretty_generate(to_h)
+    end
+
+    def to_csv
+      CSV.generate do |csv|
+        csv << weekday_names
+        grid.each { |row| csv << row.map { |cell| cell[:date]&.day } }
+      end
+    end
+
+    def to_html(title: nil, theme: :editorial, page_size: :letter)
+      title ||= Date::MONTHNAMES[month] + " #{year}"
+      cells = grid.flatten.map do |cell|
+        date = cell[:date]
+        label = date ? date.day.to_s : ""
+        holiday = date && holidays.find { |item| item.observed_date == date }
+        %(<td class="#{cell[:in_month] ? "in-month" : "adjacent"}">#{label}#{holiday ? "<small>#{escape(holiday.name)}</small>" : ""}</td>)
+      end.each_slice(7).map { |row| "<tr>#{row.join}</tr>" }.join
+      headers = weekday_names.map { |name| "<th scope=\"col\">#{name}</th>" }.join
+      %(<!doctype html><html lang="en"><meta charset="utf-8"><title>#{escape(title)}</title><style>#{html_css(theme, page_size)}</style><main><h1>#{escape(title)}</h1><table><thead><tr>#{headers}</tr></thead><tbody>#{cells}</tbody></table></main></html>)
+    end
+
+    def to_svg(title: nil, theme: :editorial, page_size: :letter)
+      title ||= Date::MONTHNAMES[month] + " #{year}"
+      width, height = page_dimensions(page_size)
+      pad = 40.0
+      header_h = 78.0
+      cell_w = (width - 2 * pad) / 7
+      cell_h = (height - 2 * pad - header_h) / (grid.length + 1)
+      colors = theme_colors(theme)
+      out = [%(<svg xmlns="http://www.w3.org/2000/svg" role="img" aria-labelledby="title desc" viewBox="0 0 #{width} #{height}">),
+             %(<title id="title">#{escape(title)}</title><desc id="desc">Monthly calendar, #{escape(title)}</desc>),
+             %(<rect width="100%" height="100%" fill="#{colors[:background]}"/>),
+             %(<text x="#{pad}" y="#{pad + 32}" font-family="Arial,sans-serif" font-size="28" font-weight="700" fill="#{colors[:ink]}">#{escape(title)}</text>)]
+      weekday_names.each_with_index do |name, index|
+        x = pad + index * cell_w
+        y = pad + header_h
+        out << %(<rect x="#{x}" y="#{y}" width="#{cell_w}" height="#{cell_h}" fill="#{colors[:header]}" stroke="#{colors[:grid]}"/> )
+        out << %(<text x="#{x + cell_w / 2}" y="#{y + cell_h / 2 + 5}" text-anchor="middle" font-family="Arial,sans-serif" font-size="12" font-weight="700" fill="#{colors[:ink]}">#{name}</text>)
+      end
+      grid.each_with_index do |row, row_index|
+        row.each_with_index do |cell, col_index|
+          x = pad + col_index * cell_w
+          y = pad + header_h + (row_index + 1) * cell_h
+          date = cell[:date]
+          fill = cell[:in_month] ? colors[:cell] : colors[:muted]
+          out << %(<rect x="#{x}" y="#{y}" width="#{cell_w}" height="#{cell_h}" fill="#{fill}" stroke="#{colors[:grid]}"/> )
+          next unless date
+          out << %(<text x="#{x + 9}" y="#{y + 20}" font-family="Arial,sans-serif" font-size="13" fill="#{colors[:ink]}">#{date.day}</text>)
+          holiday = holidays.find { |item| item.observed_date == date }
+          out << %(<text x="#{x + 9}" y="#{y + 38}" font-family="Arial,sans-serif" font-size="8" fill="#{colors[:ink]}">#{escape(holiday.name[0, 18])}</text>) if holiday
+        end
+      end
+      out << "</svg>"
+      out.join("\n")
+    end
+
+    private
+
+    def weekday_names
+      names = DateMath::WEEKDAYS.map { |name| name.to_s[0, 2].capitalize }
+      offset = DateMath.weekday_index(week_start)
+      names.rotate(offset)
+    end
+
+    def escape(text)
+      CGI.escapeHTML(text.to_s)
+    end
+
+    def page_dimensions(size)
+      case size.to_sym
+      when :letter then [612, 792]
+      when :letter_landscape then [792, 612]
+      when :a4 then [595, 842]
+      when :a4_landscape then [842, 595]
+      else raise ArgumentError, "page_size must be :letter or :a4"
+      end
+    end
+
+    def theme_colors(theme)
+      themes = {
+        editorial: { background: "#ffffff", ink: "#20252b", grid: "#c7cdd2", header: "#edf1f4", cell: "#ffffff", muted: "#f7f8f9" },
+        business: { background: "#ffffff", ink: "#17324d", grid: "#aebdca", header: "#e5eef5", cell: "#ffffff", muted: "#f5f7f9" },
+        academic: { background: "#ffffff", ink: "#312d44", grid: "#cbc5dc", header: "#f0edf7", cell: "#ffffff", muted: "#faf9fc" },
+        ink_saver: { background: "#ffffff", ink: "#000000", grid: "#555555", header: "#ffffff", cell: "#ffffff", muted: "#f1f1f1" }
+      }
+      themes.fetch(theme.to_sym) { raise ArgumentError, "theme must be editorial, business, academic, or ink_saver" }
+    end
+
+    def html_css(theme, size)
+      colors = theme_colors(theme)
+      width, height = page_dimensions(size)
+      paper = size.to_s.start_with?("a4") ? "A4" : "Letter"
+      orientation = size.to_s.end_with?("landscape") ? " landscape" : ""
+      %(@page{size:#{paper}#{orientation};margin:12mm}body{font-family:Arial,sans-serif;color:#{colors[:ink]};max-width:#{width}px;margin:0 auto}table{border-collapse:collapse;width:100%;height:#{height - 130}px;table-layout:fixed}th,td{border:1px solid #{colors[:grid]};vertical-align:top;padding:6px}th{background:#{colors[:header]}}td{height:18%;font-size:14px}td.adjacent{color:#999;background:#{colors[:muted]}}small{display:block;font-size:9px;margin-top:5px}@media print{body{max-width:none}h1{font-size:18pt}})
+    end
+  end
+
+  class YearCalendar
+    attr_reader :year, :week_start, :holidays
+
+    def initialize(year:, week_start: :sunday, holidays: [])
+      @year = Integer(year)
+      @week_start = week_start.to_sym
+      @holidays = holidays.freeze
+      freeze
+    end
+
+    def months
+      (1..12).map { |month| Calendar.new(year: year, month: month, week_start: week_start, holidays: holidays) }.freeze
+    end
+
+    def to_json(*_args)
+      JSON.pretty_generate(year: year, months: months.map(&:to_h))
+    end
+
+    def to_html(title: "#{year} Calendar", theme: :editorial, page_size: :letter)
+      cards = months.map do |calendar|
+        html = calendar.to_html(theme: theme, page_size: page_size)
+        table = html[/<table>.*?<\/table>/m]
+        %(<section><h2>#{Date::MONTHNAMES[calendar.month]}</h2>#{table}</section>)
+      end
+      %(<html lang="en"><meta charset="utf-8"><title>#{CGI.escapeHTML(title)}</title><style>@page{size:#{page_size == :a4 ? "A4" : "Letter"};margin:8mm}body{font-family:Arial,sans-serif}h1{text-align:center}.year{display:grid;grid-template-columns:repeat(3,1fr);gap:10px}section{break-inside:avoid}h2{font-size:12px;margin:4px 0}table{border-collapse:collapse;width:100%;table-layout:fixed;font-size:8px}td,th{border:1px solid #aaa;padding:2px;text-align:center}@media print{.year{gap:6px}}</style><h1>#{CGI.escapeHTML(title)}</h1><div class="year">#{cards.join}</div></html>)
+    end
+
+    def to_svg(title: "#{year} Calendar", theme: :editorial)
+      width = 900
+      height = 1160
+      margin = 24
+      card_w = (width - margin * 2) / 3.0
+      card_h = (height - 100) / 4.0
+      ink = theme.to_sym == :ink_saver ? "#000000" : "#25313b"
+      out = [%(<svg xmlns="http://www.w3.org/2000/svg" role="img" aria-labelledby="title desc" viewBox="0 0 #{width} #{height}">),
+             %(<title id="title">#{CGI.escapeHTML(title)}</title><desc id="desc">Twelve month calendar for #{year}</desc>),
+             %(<rect width="100%" height="100%" fill="#fff"/><text x="#{width / 2}" y="38" text-anchor="middle" font-family="Arial" font-size="26" font-weight="bold" fill="#{ink}">#{CGI.escapeHTML(title)}</text>)]
+      months.each_with_index do |calendar, index|
+        x0 = margin + (index % 3) * card_w
+        y0 = 60 + (index / 3) * card_h
+        out << %(<text x="#{x0 + card_w / 2}" y="#{y0 + 18}" text-anchor="middle" font-family="Arial" font-size="15" font-weight="bold" fill="#{ink}">#{Date::MONTHNAMES[index + 1]}</text>)
+        cell_w = (card_w - 20) / 7.0
+        cell_h = 19
+        names = calendar.send(:weekday_names)
+        names.each_with_index do |name, column|
+          x = x0 + 10 + column * cell_w
+          y = y0 + 27
+          out << %(<text x="#{x + cell_w / 2}" y="#{y + 12}" text-anchor="middle" font-family="Arial" font-size="8" font-weight="bold" fill="#{ink}">#{name}</text>)
+        end
+        calendar.grid.each_with_index do |row, row_index|
+          row.each_with_index do |cell, column|
+            x = x0 + 10 + column * cell_w
+            y = y0 + 42 + row_index * cell_h
+            fill = cell[:in_month] ? "#fff" : "#f4f5f6"
+            out << %(<rect x="#{x}" y="#{y}" width="#{cell_w}" height="#{cell_h}" fill="#{fill}" stroke="#c7cdd2"/>)
+            out << %(<text x="#{x + cell_w / 2}" y="#{y + 13}" text-anchor="middle" font-family="Arial" font-size="9" fill="#{ink}">#{cell[:in_month] ? cell[:day] : ""}</text>)
+          end
+        end
+      end
+      out << "</svg>"
+      out.join("\n")
+    end
+  end
+end

data/lib/make_a_calendar/converters.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "date"
+require "time"
+
+module MakeACalendar
+  module Converters
+    EXCEL_EPOCH_1900 = Date.new(1899, 12, 31).freeze
+    EXCEL_EPOCH_1904 = Date.new(1904, 1, 1).freeze
+    FILETIME_EPOCH = Time.utc(1601, 1, 1).freeze
+    module_function
+
+    def unix(value, unit: :seconds)
+      unit_divisors = { seconds: 1, milliseconds: 1_000, microseconds: 1_000_000, nanoseconds: 1_000_000_000 }
+      divisor = unit_divisors[unit.to_sym] or raise ArgumentError, "unsupported Unix timestamp unit"
+      seconds = Rational(value.to_s) / divisor
+      Time.at(seconds).utc
+    rescue ArgumentError, TypeError, ZeroDivisionError
+      raise ArgumentError, "invalid Unix timestamp or unit"
+    end
+
+    def to_unix(time, unit: :seconds)
+      time = parse_time(time)
+      factors = { seconds: 1, milliseconds: 1_000, microseconds: 1_000_000, nanoseconds: 1_000_000_000 }
+      factor = factors[unit.to_sym] or raise ArgumentError, "unsupported Unix timestamp unit"
+      (time.to_r * factor).to_i
+    end
+
+    def excel(serial, system: "1900")
+      value = Rational(serial.to_s)
+      days = value.floor
+      fraction = value - days
+      mode = system.to_s
+      case mode
+      when "1900"
+        raise ArgumentError, "Excel serial 60 is the fictitious 1900-02-29" if days == 60
+        date = EXCEL_EPOCH_1900 + days - (days > 60 ? 1 : 0)
+      when "1904"
+        date = EXCEL_EPOCH_1904 + days
+      else
+        raise ArgumentError, "system must be :1900 or :1904"
+      end
+      return date if fraction.zero?
+      seconds = (fraction * 86_400).round
+      Time.utc(date.year, date.month, date.day) + seconds
+    rescue TypeError, ArgumentError, ZeroDivisionError
+      raise unless $!.message.include?("fictitious") || $!.message.start_with?("system must")
+      raise
+    end
+
+    def filetime(ticks)
+      FILETIME_EPOCH + Rational(Integer(ticks), 10_000_000)
+    rescue ArgumentError, TypeError
+      raise ArgumentError, "FILETIME must be an integer count of 100-nanosecond intervals"
+    end
+
+    def to_filetime(time)
+      ((parse_time(time).to_r - FILETIME_EPOCH.to_r) * 10_000_000).to_i
+    end
+
+    def iso8601(value)
+      value.is_a?(DateTime) ? value.iso8601 : (value.is_a?(Date) ? value.iso8601 : parse_time(value).iso8601)
+    end
+
+    def parse_time(value)
+      return value.getutc if value.is_a?(Time)
+      return value.to_time.getutc if value.is_a?(DateTime)
+      text = value.to_s
+      raise ArgumentError unless text.match?(/(?:Z|[+-]\d{2}:?\d{2})\z/i)
+      Time.iso8601(text).getutc
+    rescue ArgumentError, TypeError
+      raise ArgumentError, "expected an ISO 8601 timestamp with an explicit offset"
+    end
+
+    def ordinal(value)
+      text = value.to_s
+      if text.match?(/\A\d{4}-\d{3}\z/)
+        year, day = text.split("-").map(&:to_i)
+      elsif text.match?(/\A\d{7}\z/)
+        year = text[0, 4].to_i
+        day = text[4, 3].to_i
+      else
+        raise ArgumentError, "ordinal date must use YYYY-DDD or YYYYDDD"
+      end
+      Date.ordinal(year, day)
+    rescue Date::Error
+      raise ArgumentError, "ordinal day is outside the year"
+    end
+  end
+end

data/lib/make_a_calendar/core/date_math.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "date"
+
+module MakeACalendar
+  module DateMath
+    WEEKDAYS = %i[sunday monday tuesday wednesday thursday friday saturday].freeze
+    module_function
+
+    def date(value)
+      raise InvalidDate, "expected a date-only value, not a timestamp" if value.is_a?(DateTime)
+      if value.is_a?(Date)
+        result = value
+      else
+        text = value.to_s
+        raise InvalidDate, "expected an ISO YYYY-MM-DD date" unless text.match?(/\A\d{4}-\d{2}-\d{2}\z/)
+        result = Date.iso8601(text)
+      end
+      raise InvalidDate, "expected a Gregorian date" unless result.gregorian?
+      result
+    rescue ArgumentError, TypeError
+      raise InvalidDate, "invalid date: #{value.inspect}"
+    end
+
+    def month_start(year, month)
+      Date.new(Integer(year), Integer(month), 1)
+    rescue ArgumentError, TypeError
+      raise InvalidDate, "invalid year or month: #{year.inspect}-#{month.inspect}"
+    end
+
+    def month_end(year, month)
+      (month_start(year, month) >> 1) - 1
+    end
+
+    def quarter(date)
+      date = self.date(date)
+      first_month = ((date.month - 1) / 3) * 3 + 1
+      quarter_start = Date.new(date.year, first_month, 1)
+      [quarter_start, (quarter_start >> 3) - 1]
+    end
+
+    def month_grid(year, month, week_start: :sunday, fixed_rows: nil, undated: false)
+      first = month_start(year, month)
+      start_index = weekday_index(week_start)
+      offset = (first.wday - start_index) % 7
+      grid_start = first - offset
+      rows = fixed_rows ? Integer(fixed_rows) : ((offset + ((first >> 1) - 1).day + 6) / 7)
+      raise ArgumentError, "fixed_rows must be 4, 5, or 6" unless (4..6).cover?(rows)
+      (0...(rows * 7)).map do |index|
+        current = grid_start + index
+        in_month = current.month == first.month
+        { date: undated && !in_month ? nil : current, day: undated && !in_month ? nil : current.day,
+          in_month: in_month, weekday: WEEKDAYS[(start_index + index % 7) % 7],
+          week: current.cweek, week_year: current.cwyear }.freeze
+      end.each_slice(7).map(&:freeze).freeze
+    end
+
+    def weekday_index(value)
+      key = value.is_a?(Integer) ? value : WEEKDAYS.index(value.to_sym)
+      raise ArgumentError, "week_start must be a weekday name or 0..6" unless key && (0..6).cover?(key)
+      key
+    end
+
+    def each_date(from, to)
+      return enum_for(:each_date, from, to) unless block_given?
+      first = date(from)
+      last = date(to)
+      step = first <= last ? 1 : -1
+      current = first
+      while step == 1 ? current <= last : current >= last
+        yield current
+        current += step
+      end
+    end
+
+    def ordinal(date)
+      date = self.date(date)
+      [date.year, date.yday]
+    end
+
+    def iso_week(date)
+      date = self.date(date)
+      [date.cwyear, date.cweek, date.cwday]
+    end
+  end
+end

data/lib/make_a_calendar/errors.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module MakeACalendar
+  class Error < StandardError; end
+  class InvalidDate < Error; end
+  class UnsupportedConversion < Error; end
+end

data/lib/make_a_calendar/export/ics.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "time"
+
+module MakeACalendar
+  module ICS
+    module_function
+
+    def calendar(events, name: "Make a Calendar Toolkit")
+      raise ArgumentError, "at most 10,000 events may be exported at once" if events.length > 10_000
+      lines = ["BEGIN:VCALENDAR", "VERSION:2.0", "PRODID:-//Make a Calendar Toolkit//EN", "CALSCALE:GREGORIAN", "X-WR-CALNAME:#{escape(name)}"]
+      events.each_with_index do |event, index|
+        date = DateMath.date(event.fetch(:date))
+        uid = event[:uid] || "#{date.strftime('%Y%m%d')}-#{index + 1}@make-a-calendar-toolkit"
+        summary = event.fetch(:summary)
+        lines.concat(["BEGIN:VEVENT", "UID:#{escape(uid)}", "DTSTAMP:#{Time.now.utc.strftime('%Y%m%dT%H%M%SZ')}",
+                      "DTSTART;VALUE=DATE:#{date.strftime('%Y%m%d')}", "DTEND;VALUE=DATE:#{(date + 1).strftime('%Y%m%d')}",
+                      "SUMMARY:#{escape(summary)}"])
+        lines << "DESCRIPTION:#{escape(event[:description])}" if event[:description]
+        lines << "LOCATION:#{escape(event[:location])}" if event[:location]
+        lines << "END:VEVENT"
+      end
+      lines << "END:VCALENDAR"
+      lines.map { |line| fold(line) }.join("\r\n") + "\r\n"
+    end
+
+    def holiday_calendar(year)
+      calendar(Holidays.us_federal(year).map { |holiday| { date: holiday.observed_date, summary: holiday.name } }, name: "US Federal Holidays #{year}")
+    end
+
+    def escape(value)
+      value.to_s.gsub(/\\/, "\\\\").gsub(/\r?\n/, "\\n").gsub(/;/, "\\;").gsub(/,/, "\\,")
+    end
+
+    def fold(line)
+      # RFC 5545 folds at 75 octets; UTF-8 code points are kept intact.
+      result = +""
+      count = 0
+      line.each_char do |character|
+        length = character.bytesize
+        if count + length > 75
+          result << "\r\n "
+          count = 1
+        end
+        result << character
+        count += length
+      end
+      result
+    end
+    private_class_method :fold
+  end
+end

data/lib/make_a_calendar/scheduling/business_days.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "date"
+
+module MakeACalendar
+  module BusinessDays
+    MAX_RANGE_DAYS = 36_600
+    module_function
+
+    def between(from, to, weekend: [0, 6], holidays: [], inclusive: true)
+      first = DateMath.date(from)
+      last = DateMath.date(to)
+      ensure_reasonable_range(first, last)
+      weekend_days = weekend.map { |day| DateMath.weekday_index(day) }
+      holiday_dates = holidays.map { |item| item.respond_to?(:observed_date) ? item.observed_date : DateMath.date(item) }
+      DateMath.each_date(first, last).count do |date|
+        included = inclusive || (date != first && date != last)
+        included && !weekend_days.include?(date.wday) && !holiday_dates.include?(date)
+      end
+    end
+
+    def each_workday(from, to, weekend: [0, 6], holidays: [])
+      return enum_for(:each_workday, from, to, weekend: weekend, holidays: holidays) unless block_given?
+      first = DateMath.date(from)
+      last = DateMath.date(to)
+      ensure_reasonable_range(first, last)
+      weekend_days = weekend.map { |day| DateMath.weekday_index(day) }
+      holiday_dates = holidays.map { |item| item.respond_to?(:observed_date) ? item.observed_date : DateMath.date(item) }
+      DateMath.each_date(first, last) do |date|
+        yield date unless weekend_days.include?(date.wday) || holiday_dates.include?(date)
+      end
+    end
+
+    def add(date, days, weekend: [0, 6], holidays: [])
+      current = DateMath.date(date)
+      count = Integer(days)
+      return current if count.zero?
+      step = count.positive? ? 1 : -1
+      remaining = count.abs
+      weekend_days = weekend.map { |day| DateMath.weekday_index(day) }
+      holiday_dates = holidays.map { |item| item.respond_to?(:observed_date) ? item.observed_date : DateMath.date(item) }
+      while remaining.positive?
+        current += step
+        next if weekend_days.include?(current.wday) || holiday_dates.include?(current)
+        remaining -= 1
+      end
+      current
+    end
+
+    def next(date, **options)
+      add(date, 1, **options)
+    end
+
+    def previous(date, **options)
+      add(date, -1, **options)
+    end
+
+    def in_month(year, month, **options)
+      first = Date.new(Integer(year), Integer(month), 1)
+      between(first, (first >> 1) - 1, **options)
+    end
+
+    def in_year(year, **options)
+      between(Date.new(Integer(year), 1, 1), Date.new(Integer(year), 12, 31), **options)
+    end
+
+    def ensure_reasonable_range(first, last)
+      raise ArgumentError, "business-day range is limited to 100 years" if (last - first).abs > MAX_RANGE_DAYS
+    end
+    private_class_method :ensure_reasonable_range
+  end
+end