nepdate 1.0.0.rc.1

data/lib/nepdate/date_range.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+module NepDate
+  # An inclusive, non-empty span of consecutive BS dates. It includes Enumerable, so +each+,
+  # +map+, +select+, +to_a+ and the rest work; +length+ is the inclusive day count.
+  class DateRange
+    include Enumerable
+
+    attr_reader :start, :end
+
+    def initialize(start, finish)
+      raise TypeError, "start must be a NepDate::Date, got #{start.class}" unless start.is_a?(Date)
+      raise TypeError, "end must be a NepDate::Date, got #{finish.class}" unless finish.is_a?(Date)
+      raise OutOfRangeError, "a range must not start after it ends" if start > finish
+
+      @start = start
+      @end = finish
+      freeze
+    end
+
+    class << self
+      def of(start, finish)
+        new(start, finish)
+      end
+
+      def single_day(date)
+        new(date, date)
+      end
+
+      def from_day_count(start, days)
+        days = Date.integer_argument(days, "days")
+        raise OutOfRangeError, "a range must span at least one day" if days < 1
+
+        new(start, start.add_days(days - 1))
+      end
+
+      def for_month(year, month)
+        first = Date.from_bs(year, month, 1)
+        new(first, first.last_day_of_month)
+      end
+
+      def for_year(year)
+        first = Date.from_bs(year, 1, 1)
+        new(first, Date.from_bs(year, 12, Calendar.month_length(year, 12)))
+      end
+
+      def current_month(zone: Date::DEFAULT_ZONE, clock: nil)
+        today = Date.today(zone: zone, clock: clock)
+        for_month(today.year, today.month)
+      end
+
+      def current_fiscal_year(zone: Date::DEFAULT_ZONE, clock: nil)
+        FiscalYear.containing(Date.today(zone: zone, clock: clock)).range
+      end
+
+      def current_calendar_year(zone: Date::DEFAULT_ZONE, clock: nil)
+        for_year(Date.today(zone: zone, clock: clock).year)
+      end
+    end
+
+    def length
+      self.end.serial - start.serial + 1
+    end
+    alias_method :size, :length
+
+    def first(count = nil)
+      return start if count.nil?
+
+      to_a.first(count)
+    end
+
+    def last(count = nil)
+      return self.end if count.nil?
+
+      to_a.last(count)
+    end
+
+    def empty?
+      false
+    end
+
+    def include?(date)
+      raise TypeError, "expected a NepDate::Date, got #{date.class}" unless date.is_a?(Date)
+
+      date.between?(start, self.end)
+    end
+    alias_method :contains?, :include?
+    alias_method :contains, :include?
+
+    def contains_range?(other)
+      expect_range!(other)
+      include?(other.start) && include?(other.end)
+    end
+    alias_method :contains_range, :contains_range?
+
+    def overlaps?(other)
+      expect_range!(other)
+      start <= other.end && other.start <= self.end
+    end
+    alias_method :overlaps, :overlaps?
+
+    # True when one range starts the day after the other ends. A range cannot start before
+    # 1901-01-01 or after 2199-12-30, so a range that ends at the data edge simply has no
+    # adjacent successor and is never advanced past it (D-16).
+    def adjacent_to?(other)
+      expect_range!(other)
+      if self.end < other.start
+        self.end.add_days(1) == other.start
+      elsif other.end < start
+        other.end.add_days(1) == start
+      else
+        false
+      end
+    end
+    alias_method :is_adjacent_to, :adjacent_to?
+
+    # The overlap, or +nil+ when the ranges do not touch (D-01, D-16).
+    def intersect(other)
+      expect_range!(other)
+      first = (start >= other.start) ? start : other.start
+      last = (self.end <= other.end) ? self.end : other.end
+      return nil if first > last
+
+      DateRange.new(first, last)
+    end
+
+    # The smallest range covering both, not a set union.
+    def union(other)
+      expect_range!(other)
+      first = (start <= other.start) ? start : other.start
+      last = (self.end >= other.end) ? self.end : other.end
+      DateRange.new(first, last)
+    end
+
+    # This range with the other removed: zero, one or two ranges.
+    def except(other)
+      expect_range!(other)
+      overlap = intersect(other)
+      return [self] if overlap.nil?
+
+      result = []
+      result << DateRange.new(start, overlap.start.add_days(-1)) if start < overlap.start
+      result << DateRange.new(overlap.end.add_days(1), self.end) if self.end > overlap.end
+      result
+    end
+
+    def split_by_month
+      result = []
+      cursor = start
+      while cursor <= self.end
+        month_end = cursor.last_day_of_month
+        segment_end = (month_end <= self.end) ? month_end : self.end
+        result << DateRange.new(cursor, segment_end)
+        break if segment_end == self.end
+
+        cursor = segment_end.add_days(1)
+      end
+      result
+    end
+
+    def split_by_fiscal_quarter
+      result = []
+      cursor = start
+      while cursor <= self.end
+        quarter_end = cursor.fiscal_year.quarter_range(cursor.quarter).end
+        segment_end = (quarter_end <= self.end) ? quarter_end : self.end
+        result << DateRange.new(cursor, segment_end)
+        break if segment_end == self.end
+
+        cursor = segment_end.add_days(1)
+      end
+      result
+    end
+
+    def dates_with_interval(step = 1)
+      step = Date.integer_argument(step, "step")
+      raise OutOfRangeError, "the step must be at least 1" if step < 1
+
+      result = []
+      cursor = start
+      loop do
+        result << cursor
+        remaining = cursor.days_until(self.end)
+        break if remaining < step
+
+        cursor = cursor.add_days(step)
+      end
+      result
+    end
+
+    # Every day except Saturday, and except Sunday when +exclude_sunday+ is true.
+    def working_days(exclude_sunday: false)
+      each.select do |date|
+        !date.weekday.saturday? && !(exclude_sunday && date.weekday.sunday?)
+      end
+    end
+
+    # Every Saturday, and Sunday when +include_sunday+ is true.
+    def weekend_days(include_sunday: true)
+      each.select do |date|
+        date.weekday.saturday? || (include_sunday && date.weekday.sunday?)
+      end
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      serial = start.serial
+      last = self.end.serial
+      while serial <= last
+        yield Date.from_serial(serial)
+        serial += 1
+      end
+      self
+    end
+
+    def ==(other)
+      other.is_a?(DateRange) && start == other.start && self.end == other.end
+    end
+    alias_method :eql?, :==
+
+    def hash
+      [DateRange, start, self.end].hash
+    end
+
+    def to_s
+      "#{start} - #{self.end}"
+    end
+
+    def to_short_string(order: :ymd, separator: :slash, lang: :en)
+      "#{start.to_short_string(order: order, separator: separator, lang: lang)} - " \
+        "#{self.end.to_short_string(order: order, separator: separator, lang: lang)}"
+    end
+
+    def to_h
+      {start: start, end: self.end}
+    end
+
+    def inspect
+      "#<NepDate::DateRange #{start.iso8601}..#{self.end.iso8601}>"
+    end
+
+    private
+
+    def expect_range!(other)
+      raise TypeError, "expected a NepDate::DateRange, got #{other.class}" unless other.is_a?(DateRange)
+
+      other
+    end
+  end
+end

data/lib/nepdate/errors.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module NepDate
+  # The rule that rejected a date, a parse or an arithmetic operation. The names match the
+  # neutral error kinds of PARSING.md section 4; each is available as a symbol.
+  module ErrorKind
+    OUT_OF_RANGE = :out_of_range
+    INVALID_MONTH = :invalid_month
+    INVALID_DAY = :invalid_day
+    INVALID_GREGORIAN = :invalid_gregorian
+    INVALID_CHARACTER = :invalid_character
+    WRONG_GROUP_COUNT = :wrong_group_count
+    NUMBER_TOO_LONG = :number_too_long
+    AMBIGUOUS = :ambiguous
+    UNRECOGNIZED = :unrecognized
+
+    ALL = [
+      OUT_OF_RANGE, INVALID_MONTH, INVALID_DAY, INVALID_GREGORIAN,
+      INVALID_CHARACTER, WRONG_GROUP_COUNT, NUMBER_TOO_LONG, AMBIGUOUS, UNRECOGNIZED
+    ].freeze
+
+    # The PascalCase spelling used by the shared vectors, for example +InvalidMonth+.
+    def self.name_for(kind)
+      kind.to_s.split("_").map(&:capitalize).join
+    end
+  end
+
+  # Every failure this library raises. +kind+ says which rule failed, so callers match on the
+  # symbol instead of the message.
+  class Error < StandardError
+    attr_reader :kind
+
+    def initialize(kind, message)
+      @kind = kind.to_sym
+      super(message)
+    end
+
+    def kind_name
+      ErrorKind.name_for(kind)
+    end
+  end
+
+  # Raised when a parsed or constructed date, or an arithmetic result, is outside the supported
+  # BS range.
+  class OutOfRangeError < Error
+    def initialize(message)
+      super(ErrorKind::OUT_OF_RANGE, message)
+    end
+  end
+
+  # Raised when a month number is outside 1 to 12.
+  class InvalidMonthError < Error
+    def initialize(message)
+      super(ErrorKind::INVALID_MONTH, message)
+    end
+  end
+
+  # Raised when a day number is outside the month.
+  class InvalidDayError < Error
+    def initialize(message)
+      super(ErrorKind::INVALID_DAY, message)
+    end
+  end
+
+  # Raised when an AD date is not a real Gregorian day.
+  class InvalidGregorianError < Error
+    def initialize(message)
+      super(ErrorKind::INVALID_GREGORIAN, message)
+    end
+  end
+
+  # Raised by strict and lenient parsing. +kind+ is the parse error kind from PARSING.md.
+  class ParseError < Error
+    def initialize(kind, message)
+      super
+    end
+  end
+end

data/lib/nepdate/fiscal_year.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module NepDate
+  # A fiscal year, 1 Shrawan through the end of Ashad of the following BS year. The value
+  # carries the BS year in which it starts, so a date in months 1 to 3 belongs to the fiscal
+  # year that started in the previous BS year (D-08).
+  class FiscalYear
+    include Comparable
+
+    attr_reader :start_year
+
+    def initialize(start_year)
+      @start_year = Integer(start_year)
+      freeze
+    end
+
+    def self.from(value)
+      return value if value.is_a?(FiscalYear)
+
+      new(value)
+    end
+
+    # The fiscal year containing +date+.
+    def self.containing(date)
+      raise TypeError, "expected a NepDate::Date, got #{date.class}" unless date.is_a?(Date)
+
+      new((date.month >= 4) ? date.year : date.year - 1)
+    end
+
+    # 1 Shrawan of the fiscal year.
+    def start
+      Date.from_bs(start_year, 4, 1)
+    end
+
+    # The last day of Ashad of the following BS year.
+    def end
+      year = start_year + 1
+      Date.from_bs(year, 3, Calendar.month_length(year, 3))
+    end
+
+    def range
+      DateRange.new(start, self.end)
+    end
+
+    # The quarter +quarter+ of this fiscal year, clipped to the fiscal year's own bounds.
+    def quarter_range(quarter)
+      quarter = Quarter.from(quarter)
+      start_month, start_offset, end_month, end_offset =
+        case quarter.number
+        when 1 then [4, 0, 6, 0]
+        when 2 then [7, 0, 9, 0]
+        when 3 then [10, 0, 12, 0]
+        else [1, 1, 3, 1]
+        end
+
+      first = Date.from_bs(start_year + start_offset, start_month, 1)
+      last_year = start_year + end_offset
+      last = Date.from_bs(last_year, end_month, Calendar.month_length(last_year, end_month))
+      DateRange.new(first, last)
+    end
+
+    def quarter_start(quarter)
+      quarter_range(quarter).start
+    end
+
+    def quarter_end(quarter)
+      quarter_range(quarter).end
+    end
+
+    # The label, "2081/82", with digits in +lang+.
+    def label(lang: :en)
+      lang = Lang.coerce(lang)
+      "#{Names.digits(start_year, lang, width: 4)}/#{Names.digits((start_year + 1) % 100, lang, width: 2)}"
+    end
+
+    def succ
+      FiscalYear.new(start_year + 1)
+    end
+
+    def <=>(other)
+      return nil unless other.is_a?(FiscalYear)
+
+      start_year <=> other.start_year
+    end
+
+    def ==(other)
+      other.is_a?(FiscalYear) && start_year == other.start_year
+    end
+    alias_method :eql?, :==
+
+    def hash
+      [FiscalYear, start_year].hash
+    end
+
+    def to_s
+      label
+    end
+
+    def inspect
+      "#<NepDate::FiscalYear #{start_year}/#{(start_year + 1) % 100}>"
+    end
+  end
+end

data/lib/nepdate/format.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module NepDate
+  # Formatting for every public form (FORMATTING.md sections 2 to 5). One pass, no regular
+  # expressions in the pattern formatter.
+  # @api private
+  module Format
+    DEFAULT_PATTERNS = ["", "G", "g", "d"].freeze
+
+    module_function
+
+    def default(year, month, day, lang)
+      lang = Lang.coerce(lang)
+      if lang == :ne
+        "#{Names::YEAR_NE[year - CalendarTable::MIN_YEAR]}/#{Names::TWO_DIGIT_NE[month]}/#{Names::TWO_DIGIT_NE[day]}"
+      else
+        "#{Names::YEAR_EN[year - CalendarTable::MIN_YEAR]}/#{Names::TWO_DIGIT_EN[month]}/#{Names::TWO_DIGIT_EN[day]}"
+      end
+    end
+
+    def iso8601(year, month, day, lang)
+      lang = Lang.coerce(lang)
+      if lang == :ne
+        "#{Names::YEAR_NE[year - CalendarTable::MIN_YEAR]}-#{Names::TWO_DIGIT_NE[month]}-#{Names::TWO_DIGIT_NE[day]}"
+      else
+        "#{Names::YEAR_EN[year - CalendarTable::MIN_YEAR]}-#{Names::TWO_DIGIT_EN[month]}-#{Names::TWO_DIGIT_EN[day]}"
+      end
+    end
+
+    def short(year, month, day, order:, separator:, pad:, lang:)
+      lang = Lang.coerce(lang)
+      fields = DateOrder.fields(order)
+      separator = Separator.character(separator)
+      values = {
+        year: Names.digits(year, lang, width: 4),
+        month: Names.digits(month, lang, width: pad ? 2 : 0),
+        day: Names.digits(day, lang, width: pad ? 2 : 0)
+      }
+
+      fields.map { |field| values.fetch(field) }.join(separator)
+    end
+
+    def long(year, month, day, weekday_number:, include_year:, pad:, lang:)
+      lang = Lang.coerce(lang)
+      if lang == :ne
+        day_text = pad ? Names::TWO_DIGIT_NE[day] : Names::NUMBER_NE[day]
+        year_text = Names::YEAR_NE[year - CalendarTable::MIN_YEAR]
+        month_text = Names::MONTH_NE[month]
+        prefix = weekday_number.nil? ? "" : "#{Names::WEEKDAY_NE[weekday_number]}, "
+      else
+        day_text = pad ? Names::TWO_DIGIT_EN[day] : Names::NUMBER_EN[day]
+        year_text = Names::YEAR_EN[year - CalendarTable::MIN_YEAR]
+        month_text = Names::MONTH_EN[month]
+        prefix = weekday_number.nil? ? "" : "#{Names::WEEKDAY_EN[weekday_number]}, "
+      end
+      suffix = include_year ? ", #{year_text}" : ""
+
+      "#{prefix}#{month_text} #{day_text}#{suffix}"
+    end
+
+    def pattern(pattern, year:, month:, day:, lang:)
+      raise TypeError, "format pattern must be a String, got #{pattern.class}" unless pattern.is_a?(String)
+
+      lang = Lang.coerce(lang)
+      return default(year, month, day, lang) if DEFAULT_PATTERNS.include?(pattern)
+      return long(year, month, day, weekday_number: nil, include_year: true, pad: true, lang: lang) if pattern == "D"
+      return iso8601(year, month, day, lang) if pattern == "s"
+
+      tokens = {
+        year: Names.digits(year, lang, width: 4),
+        year2: Names.digits(year % 100, lang, width: 2),
+        month_name: Names.month_name(month, lang),
+        month_short: Names.month_short(month, lang),
+        month_pad: Names.digits(month, lang, width: 2),
+        month: Names.digits(month, lang),
+        day_pad: Names.digits(day, lang, width: 2),
+        day: Names.digits(day, lang)
+      }
+
+      out = +""
+      chars = pattern.chars
+      index = 0
+      while index < chars.length
+        char = chars[index]
+        if char == "\\"
+          # A trailing backslash has nothing to escape, so it is written literally.
+          out << ((index + 1 < chars.length) ? chars[index + 1] : "\\")
+          index += 2
+          next
+        end
+
+        if char == "'"
+          closing = ((index + 1)...chars.length).find { |position| chars[position] == "'" }
+          if closing
+            out << chars[(index + 1)...closing].join
+            index = closing + 1
+          else
+            out << chars[(index + 1)..].join
+            break
+          end
+          next
+        end
+
+        if char == "y"
+          finish = run_end(chars, index, "y")
+          out << ((finish - index >= 4) ? tokens[:year] : tokens[:year2])
+          index = finish
+          next
+        end
+
+        if char == "M"
+          finish = run_end(chars, index, "M")
+          length = finish - index
+          value = if length >= 4
+            tokens[:month_name]
+          elsif length == 3
+            tokens[:month_short]
+          elsif length == 2
+            tokens[:month_pad]
+          else
+            tokens[:month]
+          end
+          out << value
+          index = finish
+          next
+        end
+
+        if char == "d"
+          finish = run_end(chars, index, "d")
+          out << ((finish - index == 2) ? tokens[:day_pad] : tokens[:day])
+          index = finish
+          next
+        end
+
+        out << char
+        index += 1
+      end
+
+      out
+    end
+
+    def run_end(chars, index, char)
+      finish = index + 1
+      finish += 1 while finish < chars.length && chars[finish] == char
+      finish
+    end
+  end
+end

data/lib/nepdate/format_options.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module NepDate
+  # The field order of short and range formatting (FORMATTING.md section 3). Use the symbols
+  # +:ymd+, +:ydm+, +:myd+, +:mdy+, +:dym+ or +:dmy+.
+  module DateOrder
+    ORDER = {
+      ymd: [:year, :month, :day],
+      ydm: [:year, :day, :month],
+      myd: [:month, :year, :day],
+      mdy: [:month, :day, :year],
+      dym: [:day, :year, :month],
+      dmy: [:day, :month, :year]
+    }.freeze
+
+    ALL = ORDER.keys.freeze
+
+    def self.coerce(value)
+      symbol = value.to_s.downcase.to_sym
+      return symbol if ORDER.key?(symbol)
+
+      raise ArgumentError, "date order must be one of #{ALL.join(", ")}, got #{value.inspect}"
+    end
+
+    def self.fields(value)
+      ORDER.fetch(coerce(value))
+    end
+  end
+
+  # The separator of short and range formatting (FORMATTING.md section 3). Use +:slash+,
+  # +:backslash+, +:dot+, +:underscore+, +:dash+ or +:space+, or pass the character itself.
+  module Separator
+    CHARACTERS = {
+      slash: "/",
+      backslash: "\\",
+      dot: ".",
+      underscore: "_",
+      dash: "-",
+      space: " "
+    }.freeze
+
+    ALL = CHARACTERS.keys.freeze
+    BY_CHARACTER = CHARACTERS.invert.freeze
+
+    def self.coerce(value)
+      return BY_CHARACTER.fetch(value) if CHARACTERS.value?(value)
+
+      symbol = value.to_s.downcase.to_sym
+      return symbol if CHARACTERS.key?(symbol)
+
+      raise ArgumentError, "separator must be one of #{ALL.join(", ")}, got #{value.inspect}"
+    end
+
+    def self.character(value)
+      return value if CHARACTERS.value?(value)
+
+      CHARACTERS.fetch(coerce(value))
+    end
+
+    def self.name_for(character)
+      BY_CHARACTER.fetch(character)
+    end
+  end
+end

data/lib/nepdate/lang.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module NepDate
+  # The output language: +:en+ for English, +:ne+ for Nepali. Symbols are the Ruby spelling of
+  # the C# +Lang+ option used by the other ports.
+  module Lang
+    EN = :en
+    NE = :ne
+
+    def self.coerce(value)
+      return value if value == EN || value == NE
+
+      case value
+      when "en" then EN
+      when "ne" then NE
+      else
+        raise ArgumentError, "language must be :en or :ne, got #{value.inspect}"
+      end
+    end
+  end
+end