nepdate 1.0.0.rc.1

data/lib/nepdate/lenient.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module NepDate
+  # The deterministic human-input parser of PARSING.md section 2. It tries the strict grammar
+  # first, then a closed token grammar with a fixed month-name list. It never guesses.
+  # @api private
+  module Lenient
+    SEPARATORS = ["-", "/", "\\", "_", " ", "|", "।", ","].freeze
+    MAX_DIGITS = 4
+    KELVIN = "\u212A"
+
+    DEVA_DIGITS = {
+      "०" => "0", "१" => "1", "२" => "2", "३" => "3", "४" => "4",
+      "५" => "5", "६" => "6", "७" => "7", "८" => "8", "९" => "9"
+    }.freeze
+
+    ERA_MARKERS = ["bs", "b.s.", "b.s", "vs", "v.s.", "v.s", "बि.सं.", "वि.सं.", "बि.सं", "वि.सं"].freeze
+    IGNORED_WORDS = ["गते", "मिति"].freeze
+
+    MONTH_WORDS = {
+      "baishakh" => 1, "baisakh" => 1, "baishak" => 1, "vaishakh" => 1, "vaisakh" => 1, "bai" => 1,
+      "बैशाख" => 1, "वैशाख" => 1, "बैसाख" => 1,
+      "jestha" => 2, "jeth" => 2, "jyestha" => 2, "jes" => 2,
+      "जेठ" => 2, "जेष्ठ" => 2, "ज्येष्ठ" => 2,
+      "ashad" => 3, "ashadh" => 3, "asar" => 3, "asadh" => 3, "asa" => 3,
+      "असार" => 3, "आषाढ" => 3, "असाढ" => 3,
+      "shrawan" => 4, "shravan" => 4, "srawan" => 4, "sawan" => 4, "saun" => 4, "shr" => 4,
+      "साउन" => 4, "श्रावण" => 4, "सावन" => 4,
+      "bhadra" => 5, "bhadau" => 5, "bha" => 5,
+      "भदौ" => 5, "भाद्र" => 5, "भाद्रपद" => 5,
+      "ashoj" => 6, "asoj" => 6, "ashwin" => 6, "aso" => 6,
+      "असोज" => 6, "आश्विन" => 6, "असौज" => 6,
+      "kartik" => 7, "kattik" => 7, "kar" => 7,
+      "कार्तिक" => 7, "कात्तिक" => 7,
+      "mangsir" => 8, "mansir" => 8, "margashirsha" => 8, "man" => 8,
+      "मंसिर" => 8, "मङ्सिर" => 8, "मार्गशीर्ष" => 8,
+      "poush" => 9, "paush" => 9, "push" => 9, "pus" => 9, "pou" => 9,
+      "पुष" => 9, "पौष" => 9, "पुस" => 9,
+      "magh" => 10, "mag" => 10, "माघ" => 10,
+      "falgun" => 11, "phalgun" => 11, "fagun" => 11, "fal" => 11,
+      "फागुन" => 11, "फाल्गुन" => 11,
+      "chaitra" => 12, "chait" => 12, "cha" => 12,
+      "चैत" => 12, "चैत्र" => 12
+    }.freeze
+
+    module_function
+
+    def parse(text)
+      begin
+        strict = Parse.strict(text)
+        Calendar.validate(*strict)
+        return strict
+      rescue Error
+        # The strict grammar or the date it reads is unusable: try the token grammar.
+      end
+
+      normalized = text.each_char.map { |char| DEVA_DIGITS.fetch(char, char) }.join
+      numbers, digit_counts, months, unknown = tokens(normalized)
+
+      if unknown
+        raise ParseError.new(ErrorKind::UNRECOGNIZED, "unknown word")
+      end
+      if months.length >= 2
+        raise ParseError.new(ErrorKind::UNRECOGNIZED, "more than one month name")
+      end
+      if months.length == 1 && numbers.length == 2
+        return month_form(months.first, numbers, digit_counts)
+      end
+      if months.empty? && numbers.length == 3
+        return numeric_form(numbers, digit_counts)
+      end
+
+      raise ParseError.new(ErrorKind::UNRECOGNIZED, "unrecognized token count")
+    end
+
+    # [numbers, digit counts, month numbers, saw an unknown word]
+    def tokens(text)
+      numbers = []
+      digit_counts = []
+      months = []
+      unknown = false
+
+      index = 0
+      chars = text.chars
+      while index < chars.length
+        char = chars[index]
+        if SEPARATORS.include?(char)
+          index += 1
+          next
+        end
+
+        chunk = +""
+        while index < chars.length
+          char = chars[index]
+          break if SEPARATORS.include?(char)
+
+          chunk << char
+          index += 1
+        end
+
+        if numeric?(chunk)
+          chunk.split(".").each do |part|
+            next if part.empty?
+            if part.length > MAX_DIGITS
+              raise ParseError.new(ErrorKind::NUMBER_TOO_LONG, "a number has more than 4 digits")
+            end
+
+            numbers << part.to_i
+            digit_counts << part.length
+          end
+          next
+        end
+
+        value = word_value(chunk)
+        if value.positive?
+          months << value
+        elsif value.negative?
+          unknown = true
+        end
+      end
+
+      [numbers, digit_counts, months, unknown]
+    end
+
+    def numeric?(chunk)
+      chunk.each_char.all? { |char| char.between?("0", "9") || char == "." }
+    end
+
+    # A month number, 0 for a dropped marker, or -1 for an unknown word.
+    def word_value(token)
+      folded = fold(token)
+      month = MONTH_WORDS[folded]
+      return month if month
+      return 0 if ERA_MARKERS.include?(folded) || IGNORED_WORDS.include?(folded)
+
+      -1
+    end
+
+    # Exactly ASCII A-Z plus the Kelvin sign fold; no other character changes (PARSING.md).
+    def fold(token)
+      token.each_char.map { |char|
+        if char.between?("A", "Z")
+          (char.ord + 32).chr(Encoding::UTF_8)
+        elsif char == KELVIN
+          "k"
+        else
+          char
+        end
+      }.join
+    end
+
+    def month_form(month, numbers, digit_counts)
+      four = []
+      digit_counts.each_with_index { |count, index| four << index if count == MAX_DIGITS }
+      unless four.length == 1
+        raise ParseError.new(ErrorKind::AMBIGUOUS, "no single four-digit year")
+      end
+
+      year_index = four.first
+      other_index = 1 - year_index
+      if digit_counts[other_index] > 2
+        raise ParseError.new(ErrorKind::AMBIGUOUS, "the day has more than two digits")
+      end
+
+      [numbers[year_index], month, numbers[other_index]]
+    end
+
+    def numeric_form(numbers, digit_counts)
+      return [numbers[0], numbers[1], numbers[2]] if digit_counts[0] == MAX_DIGITS
+      return [numbers[2], numbers[1], numbers[0]] if digit_counts[2] == MAX_DIGITS
+
+      raise ParseError.new(ErrorKind::AMBIGUOUS, "no four-digit year first or last")
+    end
+  end
+end

data/lib/nepdate/month.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module NepDate
+  # A Bikram Sambat month, 1 = Baishakh through 12 = Chaitra. Ruby has no enum, so this is a
+  # small immutable value with the twelve members as constants.
+  class Month
+    include Comparable
+
+    NAMES_EN = Names::MONTH_EN
+    NAMES_NE = Names::MONTH_NE
+    SHORT_EN = Names::MONTH_SHORT_EN
+
+    attr_reader :number
+
+    def initialize(number)
+      number = Integer(number)
+      unless (1..12).cover?(number)
+        raise InvalidMonthError, "month #{number} is outside 1..12"
+      end
+
+      @number = number
+      freeze
+    end
+
+    def self.from(value)
+      return value if value.is_a?(Month)
+
+      new(value)
+    end
+
+    BAISHAKH = new(1)
+    JESTHA = new(2)
+    ASHAD = new(3)
+    SHRAWAN = new(4)
+    BHADRA = new(5)
+    ASHOJ = new(6)
+    KARTIK = new(7)
+    MANGSIR = new(8)
+    POUSH = new(9)
+    MAGH = new(10)
+    FALGUN = new(11)
+    CHAITRA = new(12)
+
+    ALL = [
+      BAISHAKH, JESTHA, ASHAD, SHRAWAN, BHADRA, ASHOJ,
+      KARTIK, MANGSIR, POUSH, MAGH, FALGUN, CHAITRA
+    ].freeze
+
+    def label(lang: :en)
+      Names.month_name(number, Lang.coerce(lang))
+    end
+
+    def short_label(lang: :en)
+      Names.month_short(number, Lang.coerce(lang))
+    end
+
+    def to_i
+      number
+    end
+
+    def to_s
+      label
+    end
+
+    def <=>(other)
+      return nil unless other.is_a?(Month)
+
+      number <=> other.number
+    end
+
+    def ==(other)
+      other.is_a?(Month) && number == other.number
+    end
+    alias_method :eql?, :==
+
+    def hash
+      [Month, number].hash
+    end
+
+    def inspect
+      "#<NepDate::Month #{number} #{label}>"
+    end
+  end
+end

data/lib/nepdate/month_overflow.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module NepDate
+  # What whole-month arithmetic does when the day does not exist in the target month (D-02).
+  # +:clamp+ keeps the last day of the target month; +:spill+ moves the excess into the next
+  # month. There is no fractional month arithmetic.
+  module MonthOverflow
+    CLAMP = :clamp
+    SPILL = :spill
+    ALL = [CLAMP, SPILL].freeze
+
+    def self.coerce(value)
+      return value if value == CLAMP || value == SPILL
+
+      symbol = value.to_s.downcase.to_sym
+      return symbol if ALL.include?(symbol)
+
+      raise ArgumentError, "overflow must be :clamp or :spill, got #{value.inspect}"
+    end
+  end
+end

data/lib/nepdate/names.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module NepDate
+  # The month, weekday and digit names of FORMATTING.md section 1.
+  # @api private
+  module Names
+    MONTH_EN = [
+      "", "Baishakh", "Jestha", "Ashad", "Shrawan", "Bhadra", "Ashoj",
+      "Kartik", "Mangsir", "Poush", "Magh", "Falgun", "Chaitra"
+    ].freeze
+
+    MONTH_NE = [
+      "", "बैशाख", "जेठ", "असार", "साउन", "भदौ", "असोज",
+      "कार्तिक", "मंसिर", "पुष", "माघ", "फागुन", "चैत"
+    ].freeze
+
+    # D-04: Ashad and Ashoj are Asa and Aso, not the C# "Ash" shared by both.
+    MONTH_SHORT_EN = [
+      "", "Bai", "Jes", "Asa", "Shr", "Bha", "Aso",
+      "Kar", "Man", "Pou", "Mag", "Fal", "Cha"
+    ].freeze
+
+    WEEKDAY_EN = %w[Sunday Monday Tuesday Wednesday Thursday Friday Saturday].freeze
+    WEEKDAY_NE = %w[आइतवार सोमवार मङ्गलवार बुधवार बिहिवार शुक्रवार शनिवार].freeze
+    WEEKDAY_SHORT_EN = %w[Sun Mon Tue Wed Thu Fri Sat].freeze
+    WEEKDAY_SHORT_NE = %w[आइत सोम मङ्गल बुध बिहि शुक्र शनि].freeze
+
+    DEVANAGARI_DIGITS = %w[० १ २ ३ ४ ५ ६ ७ ८ ९].freeze
+    ASCII_DIGITS = %w[0 1 2 3 4 5 6 7 8 9].freeze
+
+    def self.month_name(number, lang = :en)
+      (lang == :ne) ? MONTH_NE.fetch(number) : MONTH_EN.fetch(number)
+    end
+
+    def self.month_short(number, lang = :en)
+      return MONTH_NE.fetch(number) if lang == :ne
+
+      MONTH_SHORT_EN.fetch(number)
+    end
+
+    def self.weekday_name(number, lang = :en)
+      (lang == :ne) ? WEEKDAY_NE.fetch(number) : WEEKDAY_EN.fetch(number)
+    end
+
+    def self.weekday_short(number, lang = :en)
+      (lang == :ne) ? WEEKDAY_SHORT_NE.fetch(number) : WEEKDAY_SHORT_EN.fetch(number)
+    end
+
+    # Replaces every ASCII digit with its Devanagari counterpart and leaves every other character
+    # alone (FORMATTING.md section 1).
+    def self.nepali_digits(text)
+      text.tr("0123456789", "०१२३४५६७८९")
+    end
+
+    def self.digits(number, lang = :en, width: 0)
+      if width == 4 && number >= CalendarTable::MIN_YEAR && number <= CalendarTable::MAX_YEAR
+        return (lang == :ne) ? YEAR_NE[number - CalendarTable::MIN_YEAR] : YEAR_EN[number - CalendarTable::MIN_YEAR]
+      end
+      if width == 2 && number >= 0 && number <= 99
+        return (lang == :ne) ? TWO_DIGIT_NE[number] : TWO_DIGIT_EN[number]
+      end
+      if width.zero? && number >= 0 && number <= 99
+        return (lang == :ne) ? NUMBER_NE[number] : NUMBER_EN[number]
+      end
+
+      text = number.to_s
+      text = text.rjust(width, "0") if width.positive?
+      (lang == :ne) ? nepali_digits(text) : text
+    end
+
+    # The short and long forms of every digit string the formatters need, built once at load so a
+    # formatting call only reads a String. Years are 1901 through 2199; the two-digit and plain
+    # tables cover dates, months and the two-digit year.
+    NUMBER_EN = (0..99).map(&:to_s).freeze
+    NUMBER_NE = NUMBER_EN.map { |text| nepali_digits(text) }.freeze
+    TWO_DIGIT_EN = (0..99).map { |number| number.to_s.rjust(2, "0") }.freeze
+    TWO_DIGIT_NE = TWO_DIGIT_EN.map { |text| nepali_digits(text) }.freeze
+    YEAR_EN = (CalendarTable::MIN_YEAR..CalendarTable::MAX_YEAR).map(&:to_s).freeze
+    YEAR_NE = YEAR_EN.map { |text| nepali_digits(text) }.freeze
+  end
+end

data/lib/nepdate/parse.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module NepDate
+  # The strict parser of PARSING.md section 1: year, month, day, with ASCII and Devanagari
+  # digits mixed freely. The scanner walks UTF-8 bytes; the only multi-byte characters it accepts
+  # are the ten Devanagari digits and the danda separator.
+  # @api private
+  module Parse
+    GROUP_COUNT = 3
+    MAX_DIGITS = 4
+    SEPARATOR_BYTES = {
+      0x2D => true, 0x2F => true, 0x2E => true, 0x5F => true,
+      0x5C => true, 0x20 => true, 0x7C => true
+    }.freeze
+    DANDA = "।"
+
+    module_function
+
+    def strict(text)
+      raise TypeError, "date text must be a String, got #{text.class}" unless text.is_a?(String)
+
+      fast = fast_ascii(text)
+      return fast if fast
+
+      groups = [0, 0, 0]
+      count = 0
+      in_group = false
+      digits = 0
+      index = 0
+      length = text.bytesize
+
+      while index < length
+        byte = text.getbyte(index)
+        digit = nil
+        width = 1
+
+        if byte.between?(0x30, 0x39)
+          digit = byte - 0x30
+        elsif byte < 0x80
+          invalid_character(text, index) unless SEPARATOR_BYTES.key?(byte)
+        elsif byte == 0xE0
+          second = text.getbyte(index + 1)
+          third = text.getbyte(index + 2)
+          if second == 0xA5 && third
+            if third.between?(0xA6, 0xAF)
+              digit = third - 0xA6
+              width = 3
+            elsif third == 0xA4
+              width = 3
+            else
+              invalid_character(text, index)
+            end
+          else
+            invalid_character(text, index)
+          end
+        else
+          invalid_character(text, index)
+        end
+
+        if digit
+          if !in_group
+            if count == GROUP_COUNT
+              raise ParseError.new(ErrorKind::WRONG_GROUP_COUNT, "more than three groups")
+            end
+            count += 1
+            in_group = true
+            digits = 0
+          end
+          digits += 1
+          if digits > MAX_DIGITS
+            raise ParseError.new(ErrorKind::NUMBER_TOO_LONG, "a group has more than 4 digits")
+          end
+          groups[count - 1] = groups[count - 1] * 10 + digit
+          index += width
+          next
+        end
+
+        in_group = false
+        index += width
+      end
+
+      if count < GROUP_COUNT
+        raise ParseError.new(ErrorKind::WRONG_GROUP_COUNT, "fewer than three groups")
+      end
+
+      groups
+    end
+
+    # The common YYYY/MM/DD form (and every other one-byte separator) without the byte scanner.
+    # Returns nil when the text is not exactly four, two and two ASCII digits, so the scanner can
+    # report the precise error or accept Devanagari digits.
+    def fast_ascii(text)
+      return nil unless text.bytesize == 10
+
+      first = text.getbyte(0)
+      second = text.getbyte(1)
+      third = text.getbyte(2)
+      fourth = text.getbyte(3)
+      fifth = text.getbyte(5)
+      sixth = text.getbyte(6)
+      eighth = text.getbyte(8)
+      ninth = text.getbyte(9)
+      return nil unless first.between?(0x30, 0x39) &&
+        second.between?(0x30, 0x39) &&
+        third.between?(0x30, 0x39) &&
+        fourth.between?(0x30, 0x39) &&
+        fifth.between?(0x30, 0x39) &&
+        sixth.between?(0x30, 0x39) &&
+        eighth.between?(0x30, 0x39) &&
+        ninth.between?(0x30, 0x39)
+      return nil unless SEPARATOR_BYTES.key?(text.getbyte(4)) && SEPARATOR_BYTES.key?(text.getbyte(7))
+
+      [
+        (first - 0x30) * 1000 + (second - 0x30) * 100 + (third - 0x30) * 10 + (fourth - 0x30),
+        (fifth - 0x30) * 10 + (sixth - 0x30),
+        (eighth - 0x30) * 10 + (ninth - 0x30)
+      ]
+    end
+
+    def invalid_character(text, index)
+      char = text.byteslice(index, 4).to_s.each_char.first
+      raise ParseError.new(ErrorKind::INVALID_CHARACTER, "invalid character #{char.inspect}")
+    end
+  end
+end

data/lib/nepdate/quarter.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module NepDate
+  # A fiscal quarter: Q1 Shrawan-Ashoj through Q4 Baishakh-Ashad of the following year.
+  class Quarter
+    include Comparable
+
+    NAMES = {1 => :q1, 2 => :q2, 3 => :q3, 4 => :q4}.freeze
+    LABELS = {1 => "Q1", 2 => "Q2", 3 => "Q3", 4 => "Q4"}.freeze
+
+    attr_reader :number
+
+    def initialize(number)
+      number = Integer(number)
+      unless (1..4).cover?(number)
+        raise ArgumentError, "quarter #{number} is outside 1..4"
+      end
+
+      @number = number
+      freeze
+    end
+
+    def self.from(value)
+      return value if value.is_a?(Quarter)
+
+      case value
+      when :q1, "q1", 1 then Q1
+      when :q2, "q2", 2 then Q2
+      when :q3, "q3", 3 then Q3
+      when :q4, "q4", 4 then Q4
+      else
+        raise ArgumentError, "quarter must be 1..4 or :q1..:q4, got #{value.inspect}"
+      end
+    end
+
+    Q1 = new(1)
+    Q2 = new(2)
+    Q3 = new(3)
+    Q4 = new(4)
+
+    ALL = [Q1, Q2, Q3, Q4].freeze
+
+    def name
+      NAMES.fetch(number)
+    end
+
+    def label
+      LABELS.fetch(number)
+    end
+
+    def to_i
+      number
+    end
+
+    def to_s
+      label
+    end
+
+    def <=>(other)
+      return nil unless other.is_a?(Quarter)
+
+      number <=> other.number
+    end
+
+    def ==(other)
+      other.is_a?(Quarter) && number == other.number
+    end
+    alias_method :eql?, :==
+
+    def hash
+      [Quarter, number].hash
+    end
+
+    def inspect
+      "#<NepDate::Quarter #{label}>"
+    end
+  end
+end

data/lib/nepdate/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module NepDate
+  VERSION = "1.0.0.rc.1"
+end

data/lib/nepdate/weekday.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module NepDate
+  # A weekday with Sunday = 0, the numbering of ALGORITHM.md section 7 and the shared vectors.
+  class Weekday
+    include Comparable
+
+    attr_reader :number
+
+    def initialize(number)
+      number = Integer(number)
+      unless (0..6).cover?(number)
+        raise ArgumentError, "weekday #{number} is outside 0..6"
+      end
+
+      @number = number
+      freeze
+    end
+
+    def self.from(value)
+      return value if value.is_a?(Weekday)
+
+      new(value)
+    end
+
+    SUNDAY = new(0)
+    MONDAY = new(1)
+    TUESDAY = new(2)
+    WEDNESDAY = new(3)
+    THURSDAY = new(4)
+    FRIDAY = new(5)
+    SATURDAY = new(6)
+
+    ALL = [SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY].freeze
+
+    def label(lang: :en)
+      Names.weekday_name(number, Lang.coerce(lang))
+    end
+
+    def short_label(lang: :en)
+      Names.weekday_short(number, Lang.coerce(lang))
+    end
+
+    def sunday? = number.zero?
+
+    def monday? = number == 1
+
+    def tuesday? = number == 2
+
+    def wednesday? = number == 3
+
+    def thursday? = number == 4
+
+    def friday? = number == 5
+
+    def saturday? = number == 6
+
+    def to_i
+      number
+    end
+
+    def to_s
+      label
+    end
+
+    def <=>(other)
+      return nil unless other.is_a?(Weekday)
+
+      number <=> other.number
+    end
+
+    def ==(other)
+      other.is_a?(Weekday) && number == other.number
+    end
+    alias_method :eql?, :==
+
+    def hash
+      [Weekday, number].hash
+    end
+
+    def inspect
+      "#<NepDate::Weekday #{number} #{label}>"
+    end
+  end
+end

data/lib/nepdate.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "nepdate/version"
+require_relative "nepdate/errors"
+require_relative "nepdate/calendar_table"
+require_relative "nepdate/calendar"
+require_relative "nepdate/names"
+require_relative "nepdate/lang"
+require_relative "nepdate/month"
+require_relative "nepdate/weekday"
+require_relative "nepdate/quarter"
+require_relative "nepdate/format_options"
+require_relative "nepdate/month_overflow"
+require_relative "nepdate/date_diff"
+require_relative "nepdate/parse"
+require_relative "nepdate/lenient"
+require_relative "nepdate/format"
+require_relative "nepdate/date"
+require_relative "nepdate/date_range"
+require_relative "nepdate/fiscal_year"
+
+# Bikram Sambat dates for Ruby. The canonical entry point is +NepDate::Date+;
+# +NepDate::Date.parse+ reads a strict date and +NepDate::Date.today+ reads the clock through an
+# explicit zone and an optional injected clock.
+module NepDate
+  class << self
+    # The date +text+ names, with the strict grammar.
+    def parse(text)
+      Date.parse(text)
+    end
+
+    # Today in +zone+, with an optional clock callable.
+    def today(zone: Date::DEFAULT_ZONE, clock: nil)
+      Date.today(zone: zone, clock: clock)
+    end
+  end
+end