acute 1.0.0

data/lib/acute/grammar/numbers.rb

@@ -0,0 +1,378 @@
+module Acute
+  # Atoms led by digits or a number word: clocks, numeric and ISO dates, years
+  class Grammar
+    MULTIPLIERS = { hundred: 100, thousand: 1000, million: 1_000_000 }.freeze
+
+    private
+
+    # D47: a count said past ninety-nine, "two million eight hundred and sixty seven thousand five hundred and
+    # thirty two", "a hundred": its value and the index of its last token, or nil without a hundred, thousand or
+    # million straight after the first number
+    def spoken(i)
+      t = @t
+      j = i + S
+      # D48: "hundred decades", as "a hundred"; not after a number, which would have read it ("two thousand
+      # three thousand days")
+      if t[i] == L::WORD && MULTIPLIERS[t[i + 1]] && (i == 0 || t[i - S] != L::NUM)
+        group = 1
+        j = i
+      elsif !(t[j] == L::WORD && MULTIPLIERS[t[j + 1]]) then return
+      elsif t[i] == L::ART then group = 1
+      elsif t[i] == L::NUM && t[i + 1].between?(1, 99) then group = t[i + 1]
+      else return
+      end
+      total = 0
+      hundred = false
+      below = nil # each thousand or million is smaller than the one before
+      last = i
+      while j < @n
+        k = t[j]
+        m = k == L::WORD && MULTIPLIERS[t[j + 1]]
+        if m == 100
+          break if hundred || group < 1 || group > 99
+          group *= 100
+          hundred = true
+        elsif m
+          break if group < 1 || (below && m >= below)
+          total += group * m
+          group = 0
+          hundred = false
+          below = m
+        elsif k == L::WORD && t[j + 1] == :and && t[j + S] == L::NUM && t[last] == L::WORD
+          j += S
+          next
+        elsif k == L::NUM && t[last] == L::WORD && group % 100 == 0 && t[j + 1].between?(1, 99) &&
+              t[j + 2] & L::WORDY != 0
+          group += t[j + 1]
+        else
+          break
+        end
+        last = j
+        j += S
+      end
+      [total + group, last]
+    end
+
+    def number_atom(loose)
+      t = @t
+      i = @i
+      v = t[i + 1]
+      flags = t[i + 2]
+      digits = flags & L::DIGITS
+      nk = @t[i + S]
+      if nk.nil?
+        # the last token: none of the forms below
+      elsif nk == L::SLASH || nk == L::DOT
+        return dotted_clock(i) if nk == L::DOT && dotted_clock?(i)
+        return dashed_month(v, digits) if @t[i + 2 * S] == L::MONTH && joined?(i + S) # "25/Sep/2003"
+        # "1/2 hour", "2.5 hours"; not "22/0 y"
+        if @t[i + 3 * S] == L::UNIT && @t[i + 2 * S] == L::NUM && (q = quantity)
+          return shift_tail(q)
+        end
+        return numeric_date(nk == L::SLASH ? :slash : :dot) if @t[i + 2 * S] == L::NUM
+      elsif nk == L::DASH
+        return dashed_month(v, digits) if @t[i + 2 * S] == L::MONTH && joined?(i + S)
+        if @t[i + 2 * S] == L::NUM
+          # "5-2020": a month and its year
+          f = t[i + 2 * S + 2]
+          if digits <= 2 && v >= 1 && v <= 12 && f & L::DIGITS == 4 && f & L::ZERO == 0 && joined?(i + S)
+            @i += 3 * S
+            return Date.new(t[i + 2 * S + 1], v, nil, nil, false)
+          end
+          # D44: "2014-2018" is a range of years; "0900-1700" and "2010-2015-86" are not
+          return iso_date if digits == 4 && (f & L::DIGITS != 4 || flags & L::ZERO != 0 || @t[i + 3 * S] == L::DASH)
+          w = t[i + 2 * S + 1]
+          # D44: not before a month's name, where they are its days ("12-14 June"); D48: nor before a dotted
+          # month ("12-14.06.2021")
+          if @t[i + 3 * S] == L::DASH || (@t[i + 3 * S] != L::MONTH && @t[i + 3 * S] != L::DOT && ((w > 12 && w <= 31 && v <= 12) || v > 12 && v <= 31 && w <= 12))
+            return numeric_date(:dash)
+          end
+          # D48: "05-06 at noon": two padded numbers before a time are a date, not a range of hours
+          k = @t[i + 3 * S]
+          if (k == L::AT || k == L::CLOCK || k == L::NAMED) && digits == 2 && f & L::DIGITS == 2 && (flags | f) & L::ZERO != 0 && joined?(i + S)
+            return numeric_date(:dash)
+          end
+        elsif digits == 4 && @t[i + 2 * S] == L::UNIT && joined?(i + S) && (y = week_year(v, i + S))
+          return y
+        end
+      elsif nk == L::MONTH
+        return day_month(v, i + S) if digits <= 2 && v >= 1 && v <= 31
+      elsif nk == L::UNIT
+        return y if digits == 4 && t[i + 4] == t[i + S + 3] && (y = week_year(v, i))
+        # D5: "1530h", "1530 hrs" are times
+        if digits == 4 && t[i + S + 1] == :hour && @t[i + 2 * S] != L::WORD
+          @i += 2 * S
+          return four_digits(v, flags, i)
+        end
+        if digits <= 2 && v <= 23 && t[i + S + 1] == :hour && t[i + S + 4] - t[i + 4] == 1 && t[i + 4] == t[i + S + 3] &&
+           (c = h_clock(v, i, loose))
+          return c
+        end
+      elsif (nk == L::WDAY || nk == L::WEEKEND || nk == L::HOLIDAY || nk == L::PART || nk == L::SEASON) && counted?(i + S)
+        @i += S
+        return counted(v)
+      elsif nk == L::ORD
+        q = quantity
+        return shift_tail(q) if q
+      elsif nk == L::WORD
+        return clock_words(v) if minutes_to?(i)
+        return shift_tail(q) if MULTIPLIERS[t[i + S + 1]] && (q = quantity)
+        if t[i + S + 1] == :ad && flags & L::WORDY == 0 && v >= 1 # D44: "14 a.d." is the year 14
+          @i += 2 * S
+          return Date.new(v, nil, nil, nil, false)
+        end
+        return Date.new(buddhist(v), nil, nil, nil, false) if buddhist?(i)
+        # D48: "18q4": a year's last two digits, then its quarter, all one word
+        if t[i + S + 1] == :q && digits == 2 && t[i + 2 * S] == L::NUM && t[i + 2 * S + 1].between?(1, 4) && t[i + 4] == t[i + S + 3] &&
+           t[i + S + 4] == t[i + 2 * S + 3]
+          @i += 3 * S
+          return Within.new(Nth.new(t[i + 2 * S + 1], Unit.new(:quarter, nil)), Date.new(v, nil, nil, nil, true))
+        end
+        return w if flags & L::WORDY != 0 && (w = said(v, i))
+        # D44: "15 of february", "20 of next month": a number of a month is its day, as an ordinal is; not
+        # "5 to 6 of April 22", where the month has its own
+        if t[i + S + 1] == :of && digits <= 2 && v >= 1 && v <= 31
+          mk = @t[i + 2 * S]
+          return day_month(v, i + 2 * S) if mk == L::MONTH && !(@t[i + 3 * S] == L::NUM && @t[i + 3 * S + 2] & L::DIGITS <= 2)
+          if mk == L::REL && @t[i + 3 * S] == L::UNIT && @t[i + 3 * S + 1] == :month
+            @i += S
+            return of(Date.new(nil, nil, v, nil, false))
+          end
+        end
+        if t[i + S + 1] == :oclock
+          if v == 24 && @t[i + 2 * S] != L::MER # D44: as "24:00"
+            @i += 2 * S
+            return Clock.new(24, 0, 0, nil, nil, true, false)
+          end
+          @i += S # read from the o'clock, so a meridiem after it is the clock's: "11 o'clock pm"
+          return number(v, flags, true)
+        end
+      elsif nk == L::REL
+        # D44: "2 upcoming weeks", "10 previous weeks" are "next 2 weeks", "previous 10 weeks"
+        if t[i + 2 * S] == L::UNIT && t[i + 2 * S + 2] & L::PLURAL != 0
+          @i += 3 * S
+          return Rel.new(t[i + S + 1], Unit.new(t[i + 2 * S + 1], v))
+        end
+        return clock_words(v) if t[i + S + 1] == :past && flags & L::WORDY != 0 || (v <= 30 && (@t[i + 2 * S] == L::NUM || @t[i + 2 * S] == L::NAMED))
+      elsif nk == L::DECADE
+        # "nineteen seventies"
+        if flags & L::WORDY != 0 && t[i + S + 2] & L::WORDY != 0 && v >= 10
+          @i += 2 * S
+          return Years.new(:decade, v * 100 + t[i + S + 1], false)
+        end
+      elsif nk == L::NUM
+        return w if flags & L::WORDY != 0 && (w = said(v, i))
+        return spaced_date(v, digits) if spaced_date?(i, digits)
+        # D44: "at 3 15", "at 12 05": after "at", an hour then two digits are its minutes, as said aloud
+        if digits <= 2 && v <= 23 && i >= S && t[i - S] == L::AT && t[i + S + 2] & (L::DIGITS | L::WORDY) == 2 && t[i + S + 1] <= 59
+          @i += S
+          return written(v * 10_000 + t[i + S + 1] * 100, flags & L::ZERO)
+        end
+      end
+      if nk == L::UNIT || nk == L::SLASH
+        # D44: "20 minutes past 3pm", "ten minutes to three"
+        return clock_words(v) if t[i + S + 1] == :minute && v.between?(1, 59) && clock_word?(i + 2 * S) && hour?(i + 3 * S)
+        q = quantity
+        return shift_tail(q) if q
+      end
+      loose ||= @n == S + i || nk == L::DASH || (nk == L::WORD && (RANGE[t[i + S + 1]] || t[i + S + 1] == :and)) ||
+                part_next?(i + S) || (@n == 2 * S + i && t[i + S + 1] == :around) # "11ish"
+      number(v, flags, loose)
+    end
+
+    # "6 in the morning", "12 at night", D44: "7 tonight", "8 this evening", "9 tomorrow", "7, this morning":
+    # a part of day or a day after a bare number makes it an hour; D46: so does "on" and a named day,
+    # "5 on may 28", "5 on friday", as "at 5 on may 28"
+    def part_next?(j)
+      k = @t[j]
+      return true if k == L::PART || k == L::DAY || (k == L::REL && @t[j + S] == L::PART)
+      if k == L::WORD && @t[j + 1] == :on
+        k = @t[j + S]
+        return k == L::MONTH || k == L::WDAY || k == L::HOLIDAY
+      end
+      return false unless k == L::AT || (k == L::WORD && @t[j + 1] == :in)
+      j += S
+      j += S if @t[j + 1] == :the
+      @t[j] == L::PART
+    end
+
+    # D13: the year of "2026-W42", "2026W01"; the week follows as its own atom
+    def week_year(v, j)
+      return unless @t[j + S] == L::UNIT && @t[j + S + 1] == :week && week_number?(j + 2 * S)
+      @i = j + S
+      Date.new(v, nil, nil, nil, false)
+    end
+
+    # "10/23", "23/10/2026", "11.9.2003", "8-15": the numbers as written; resolve picks the order
+    def numeric_date(sep)
+      t = @t
+      i = @i
+      a = t[i + 1]
+      b = t[i + 2 * S + 1]
+      @i += 3 * S
+      year = nil
+      short = false
+      if @t[@i] == t[i + S] && @t[@i + S] == L::NUM
+        digits = t[@i + S + 2] & L::DIGITS
+        # D37: year first only when the first number has four digits: "2026/11/23"; D44: or is marked as a
+        # year by an apostrophe, or is past 31: "'69-5-31", "78-12-22"
+        f = t[i + 2]
+        if digits <= 2 && (f & L::DIGITS == 4 || (f & L::DIGITS == 2 && (f & L::SHORT != 0 || a > 31)))
+          @i += 2 * S
+          return Date.new(a, b, t[@i - S + 1], nil, f & L::DIGITS == 2)
+        end
+        return failure(:invalid_date, @i + S) unless digits == 2 || digits == 4
+        year = t[@i + S + 1]
+        short = digits == 2
+        @i += 2 * S
+      elsif (d = t[i + 2 * S + 2] & L::DIGITS) == 4 || t[i + 2] & L::DIGITS == 4
+        # D44: "11/2026", "2013/12": a month and its year
+        return d == 4 ? Date.new(b, a, nil, nil, false) : Date.new(a, b, nil, nil, false) if (d == 4 ? a : b).between?(1, 12)
+      elsif @t[@i] == L::NUM && short_year?(@t[@i + 2]) # D44: "08/12,15", as "3 jan 10"
+        year = @t[@i + 1]
+        short = true
+        @i += S
+      end
+      Date.new(year, a, b, sep, short)
+    end
+
+    # "23 oct", "23 oct 2026"
+    def day_month(day, i)
+      @i = i + S
+      dated(@t[i + 1], day)
+    end
+
+    # D44: a dash or slash with no space either side joins the parts of one written date: "20-Apr",
+    # "30-Mar-11", "2003-Sep-25", "99-Jan-08", "25/Sep/2003". A first number past 31 is the year.
+    def dashed_month(v, digits)
+      m = @t[@i + 2 * S + 1]
+      @i += 3 * S
+      if digits == 4 || v > 31
+        day = nil
+        if joined?(@i) && @t[@i + S] == L::NUM && @t[@i + S + 2] & L::DIGITS <= 2 && @t[@i + S + 1].between?(1, 31)
+          day = @t[@i + S + 1]
+          @i += 2 * S
+        end
+        return Date.new(v, m, day, nil, digits == 2)
+      end
+      return failure(:invalid_date, @i - 3 * S) if v < 1
+      dashed_year(m, v) || dated(m, v)
+    end
+
+    # The "-1999" or "-99" that ends a dashed date
+    def dashed_year(m, day)
+      return unless joined?(@i) && @t[@i + S] == L::NUM
+      digits = @t[@i + S + 2] & L::DIGITS
+      return unless digits == 2 || digits == 4
+      @i += 2 * S
+      Date.new(@t[@i - S + 1], m, day, nil, digits == 2)
+    end
+
+    # A dash, or a slash, at token index i with no space either side
+    def joined?(i) = (@t[i] == L::DASH || @t[i] == L::SLASH) && i >= S && @t[i - 1] == @t[i + 3] && @t[i + 4] == @t[i + S + 3]
+
+    # "oct", "oct 23", "oct 23rd, 2026", "may 2010", "Oct-2", "Sep-25-2003", "Sep-2012", "Sep/25/2003"
+    def month_atom
+      m = @t[@i + 1]
+      @i += S
+      if joined?(@i) && @t[@i + S] == L::NUM
+        f = @t[@i + S + 2]
+        v = @t[@i + S + 1]
+        if f & L::DIGITS == 4 && f & L::ZERO == 0
+          @i += 2 * S
+          return Date.new(v, m, nil, nil, false)
+        elsif f & L::DIGITS <= 2 && v >= 1 && v <= 31
+          @i += 2 * S
+          return dashed_year(m, v) || dated(m, v)
+        end
+      end
+      day = nil
+      k = @t[@i]
+      if (k == L::NUM || k == L::ORD) && @t[@i + 2] & (L::DIGITS | L::SHORT) <= 2 && @t[@i + 1] >= 1 && @t[@i + 1] <= 31 &&
+         @t[@i + S] != L::MER && @t[@i + S] != L::UNIT
+        day = @t[@i + 1]
+        @i += S
+      end
+      dated(m, day)
+    end
+
+    # The date with its optional year after it: four digits, "of 2026", "'26", or after a day two digits that
+    # are not a clock ("3 jan 10", "may 27 79") (D23)
+    def dated(m, day)
+      @i += S if @t[@i + 1] == :of && @t[@i + S] == L::NUM
+      # D48: "march of next year" as "march next year"
+      @i += S if @t[@i + 1] == :of && @t[@i] == L::WORD && @t[@i + S] == L::REL && @t[@i + 2 * S + 1] == :year && @t[@i + 2 * S] == L::UNIT
+      @i += S if day && @t[@i] == L::DOT && @t[@i + S] == L::NUM && @t[@i + S + 2] & L::DIGITS == 4 # D48: "Sep.25.2003"
+      f = @t[@i + 2]
+      if @t[@i] == L::NUM && @t[@i + S + 1] == :ad && @t[@i + S] == L::WORD && f & L::WORDY == 0 # D44: "10 August 88 AD"
+        @i += 2 * S
+        return Date.new(@t[@i - 2 * S + 1], m, day, nil, false)
+      end
+      return Date.new(buddhist(@t[@i + 1]), m, day, nil, false) if buddhist?(@i)
+      # D44: "dec 79", "may 97": with no day, two digits past 31 are the year
+      if @t[@i] == L::NUM && ((f & L::DIGITS == 4 && f & L::ZERO == 0) || f & L::SHORT != 0 ||
+                              ((day || @t[@i + 1] > 31) && short_year?(f)))
+        @i += S
+        return Date.new(@t[@i - S + 1], m, day, nil, f & L::DIGITS != 4)
+      end
+      Date.new(nil, m, day, nil, false)
+    end
+
+    # D48: "2555 BE", a year of the Buddhist era, 543 years ahead; only from 2400, so "by 2025 be ready" is not one
+    def buddhist?(i) = @t[i + S + 1] == :be && @t[i + S] == L::WORD && @t[i] == L::NUM && @t[i + 2] & L::DIGITS == 4 && @t[i + 1] >= 2400
+
+    def buddhist(v)
+      @i += 2 * S
+      v - 543
+    end
+
+    def short_year?(f)
+      return false unless f & L::DIGITS == 2
+      k = @t[@i + S]
+      k != L::MER && k != L::UNIT && k != L::NAMED && k != L::ART && k != L::DASH &&
+        !(k == L::WORD && ((w = @t[@i + S + 1]) == :oclock || RANGE[w] || w == :and))
+    end
+
+    def named(hour) = Clock.new(hour, 0, 0, nil, hour == 12 ? :noon : :midnight, false, false)
+
+    # loose: a bare number counts as an hour (after "at" or another constituent, in a range, or alone)
+    def number(v, flags, loose)
+      digits = flags & L::DIGITS
+      zero = flags & L::ZERO != 0
+      at = @i
+      @i += S
+      return Date.new(v, nil, nil, nil, true) if flags & L::SHORT != 0 # "halloween '11"
+      # D48: "the 24", "the 3 of next month": after "the", a bare number ending the phrase is a day of the month
+      if at >= S && @t[at - S + 1] == :the && @t[at - S] == L::WORD && digits <= 2 && !zero && v >= 1 && v <= 31 &&
+         (@i >= @n || (@t[@i + 1] == :of && @t[@i] == L::WORD))
+        return of(Date.new(nil, nil, v, nil, false))
+      end
+      @i += 2 * S if in_the_meridiem?
+      if @t[@i + 1] == :around && @t[@i + S] == L::MER && @t[@i] == L::WORD && @t[at + 4] == @t[@i + 3] # D48: "3ish pm"
+        @approx = true
+        @i += S
+      end
+      kind = @t[@i]
+      if (kind == L::MER || (kind == L::ART && @t[at + 4] == @t[@i + 3])) && digits <= 2 # "8a"
+        return failure(:invalid_date, at) if (v < 1 && !midnight_am?(kind)) || v > 12
+        meridiem = kind == L::ART || @t[@i + 1] == 0 ? :am : :pm
+        @i += S
+        Clock.new(v, 0, 0, meridiem, nil, false, false)
+      elsif kind == L::NAMED && v == 12 && digits <= 2
+        @i += S
+        named(@t[@i - S + 1])
+      elsif (digits == 3 && at >= S && (@t[at - S] == L::AT || @t[at - S] == L::PART)) || ((digits == 3 || digits == 4) && kind == L::MER)
+        three_digits(v, at)
+      elsif digits == 4
+        four_digits(v, flags, at)
+      elsif digits == 8
+        compact_date(v, at)
+      elsif digits <= 2 && loose && kind != L::NUM
+        return failure(:invalid_date, at) if v > 23
+        Clock.new(v, 0, 0, nil, nil, zero, false)
+      else
+        failure(:incomplete, at)
+      end
+    end
+  end
+end

data/lib/acute/grammar/ordinals.rb

@@ -0,0 +1,101 @@
+module Acute
+  # Atoms led by an ordinal, and what an atom is "of"
+  class Grammar
+    private
+
+    # "3rd", "the 3rd of may", "second tuesday of march", "1st day of next month", "first of next month"
+    def range_word?(j) = @t[j] == L::DASH || (@t[j] == L::WORD && RANGE[@t[j + 1]])
+
+    def day_before?(j) = (@t[j] == L::ORD || @t[j] == L::NUM) && j >= S && @t[j - S] == L::MONTH
+
+    def ordinal_atom
+      n = @t[@i + 1]
+      @i += S
+      k = @t[@i]
+      # D12: "the 15th century", "the 3rd century A.D."
+      if k == L::UNIT && @t[@i + 1] == :century && @t[@i + S + 1] != :of && n >= 1
+        @i += S
+        @i += S if @t[@i + 1] == :ad
+        return Years.new(:century, (n - 1) * 100, false)
+      end
+      return counted(n) if n >= 1 && counted?(@i)
+      return closest(n) if n >= 1 && k == L::WORD && @t[@i + 1] == :closest
+      # D48: "first to last day of 2008" is the whole of it
+      if n == 1 && k == L::WORD && @t[@i + 1] == :to && @t[@i + S + 1] == :last && @t[@i + 2 * S + 1] == :day &&
+         @t[@i + 3 * S + 1] == :of && @t[@i + 3 * S] == L::WORD
+        @i += 4 * S
+        return atom(true)
+      end
+      # D44: "the first half of 2027" is its January to June; "the first 9 months of 1997" its first nine
+      if n <= 2 && k == L::WORD && @t[@i + 1] == :half && @t[@i + S + 1] == :of
+        @i += S
+        return of(half(n))
+      end
+      if n == 1 && k == L::NUM && @t[@i + S] == L::UNIT && @t[@i + 2 * S + 1] == :of
+        q = quantity
+        node = of(q)
+        return Within === node ? Lasting.new(q, node.outer) : failure(:incomplete)
+      end
+      # D48: "the fifth last day of may", "second last friday": counted from the end
+      if k == L::REL && @t[@i + 1] == :last && n >= 1 && ((k2 = @t[@i + S]) == L::WDAY || k2 == L::UNIT || k2 == L::WEEKEND)
+        @i += S
+        k = k2
+        n = -n
+      end
+      # D48: "the 29th day of November" is November 29th, so a weekday may stand beside it
+      if k == L::UNIT && @t[@i + 1] == :day && @t[@i + S + 1] == :of && @t[@i + 2 * S] == L::MONTH && n >= 1 && n <= 31
+        @i += 3 * S
+        return dated(@t[@i - S + 1], n)
+      end
+      if k == L::WDAY || k == L::UNIT || k == L::WEEKEND
+        inner = k == L::WDAY ? Weekday.new(@t[@i + 1]) : k == L::UNIT ? Unit.new(@t[@i + 1], nil) : WEEKEND
+        @i += S
+        return of(Nth.new(n, inner))
+      elsif k == L::MONTH
+        @i += S
+        return dated(@t[@i - S + 1], n)
+      elsif @t[@i + 1] == :of && @t[@i + S] == L::MONTH
+        @i += 2 * S
+        return dated(@t[@i - S + 1], n)
+      end
+      return failure(:invalid_date, @i - S) if n < 1 || n > 31
+      # "first" alone is not a date; "the first", "first of next month", "from ninth till ...", "eighth to
+      # eleventh may" and "april 9th through seventeenth" are
+      if @t[@i - S + 2] & L::WORDY != 0 && @t[@i + 1] != :of && !(@i >= 2 * S && @t[@i - 2 * S] == L::WORD && BEFORE_DAY[@t[@i - 2 * S + 1]]) &&
+         !(@t[@i + S] == L::ORD && range_word?(@i)) && !(@i >= 3 * S && range_word?(@i - 2 * S) && day_before?(@i - 3 * S))
+        return failure(:incomplete, @i - S)
+      end
+      of(Date.new(nil, nil, n, nil, false))
+    end
+
+    def half(n) = Range.new(Date.new(nil, n * 6 - 5, nil, nil, false), Date.new(nil, n * 6, nil, nil, false))
+
+    # "... of <period>": "second tuesday of march", "tuesday of next week", "morning of xmas", "labor day of 2012"
+    def of(node)
+      return node unless @t[@i] == L::WORD && (@t[@i + 1] == :of || from_week?(node) || in_the_unit?(node))
+      @i += S
+      @i += S if @t[@i] == L::WORD && @t[@i + 1] == :the
+      # D42: "the first monday of the month" repeats monthly, so it is the coming one: next month's once passed
+      unit = @t[@i] == L::UNIT && !(@t[@i + S] == L::WORD && @t[@i + S + 1] == :after) # not "the week after next"
+      if unit && @t[@i + 1] == :month && (Date === node || (Nth === node && !(Unit === node.node && UNIT_SIZE[node.node.unit] >= 5)))
+        @i += S
+        return node
+      end
+      outer = unit ? this_unit : atom(true)
+      return outer if Failure === outer
+      Within.new(node, outer)
+    end
+
+    # D48: "sunday from last week" is "sunday of last week"
+    def from_week?(node) = @t[@i + 1] == :from && Weekday === node && @t[@i + S] == L::REL && @t[@i + 2 * S] == L::UNIT
+
+    # D48: "first monday in the month" as "of the month" (D42)
+    def in_the_unit?(node) = @t[@i + 1] == :in && Nth === node && @t[@i + S + 1] == :the && @t[@i + 2 * S] == L::UNIT
+
+    # "the month" in "the first monday of the month": the current one
+    def this_unit
+      @i += S
+      Rel.new(:this, Unit.new(@t[@i - S + 1], nil))
+    end
+  end
+end

data/lib/acute/grammar/ranges.rb

@@ -0,0 +1,112 @@
+module Acute
+  # A range's two ends, and the atoms they share
+  class Grammar
+    private
+
+    # The range's trailing atoms ("between 9:30 and 11:00 on thursday") belong to both ends, and so do its
+    # leading ones ("monday 8-9am"). D44: a bare day takes its month from the other end ("june 3-7", "13 to
+    # 15 july", "4 to 22 this month"), and a year said only at the end is the start's too.
+    def range(from, to, fs, fe, ts)
+      return Range.new(from, to) if Clock === from && Clock === to
+      # D48: "previous week - Monday": a dash between a week and a weekday labels the day, it ends nothing
+      if Weekday === to && Rel === from && Unit === from.node && from.node.unit == :week && @t[fe] == L::DASH
+        return Within.new(to, from)
+      end
+      # "9:30 - 11:00 CST": the zone is a trailing atom too
+      if Zoned === to && Clock === to.node
+        return Zoned.new(Range.new(from, to.node), to.offset, to.numeric) if Clock === from
+        # "15:00 GMT - 18:00 GMT": the same zone at both ends is one zone for the range
+        if Zoned === from && Clock === from.node && from.offset == to.offset
+          return Zoned.new(Range.new(from.node, to.node), to.offset, to.numeric)
+        end
+      end
+      if Date === from && from.month && from.day && !from.sep && (Clock === to || (Date === to && !to.month)) &&
+         (d = bare_day(ts, @i))
+        to = Date.new(from.year, from.month, d, nil, from.short)
+      elsif Date === to && to.month && to.day && !to.sep && (Clock === from || (Date === from && !from.month)) &&
+            (d = bare_day(fs, fe))
+        from = Date.new(to.year, to.month, d, nil, to.short)
+      elsif Date === to && to.sep == :dot && to.year && to.month > 12 && to.day <= 12 && Clock === from && (d = bare_day(fs, fe))
+        # D48: "12.-14.06.2021": a day before a dotted date that can only be day first is a day of its month
+        to = Date.new(to.year, to.day, to.month, nil, to.short)
+        from = Date.new(to.year, to.month, d, nil, to.short)
+      elsif Within === to && size(to.outer) == 5 && (d = bare_day(fs, fe) || (Date === from && !from.month && from.day)) &&
+            (e = Date === to.inner && !to.inner.month ? to.inner.day : Clock === to.inner && bare_day(ts, ts + S))
+        return Range.new(Within.new(Date.new(nil, nil, d, nil, false), to.outer),
+                         Within.new(Date.new(nil, nil, e, nil, false), to.outer))
+      end
+      if Date === from && Date === to && from.month && to.month && !from.year && to.year && from.sep == to.sep
+        later = !from.sep && (from.month > to.month || (from.month == to.month && (from.day || 0) > (to.day || 0)))
+        from = Date.new(later ? to.year - 1 : to.year, from.month, from.day, from.sep, to.short)
+      end
+      # D48: "monday to friday last week" is within that week too; Sunday's place in it is the locale's (D19)
+      # D48: "friday to monday next week" starts in that week and ends on the Monday after it
+      if Within === to && ((Clock === from && Clock === to.inner) ||
+                           (Weekday === from && Weekday === to.inner && from.wday >= 1))
+        return Within.new(Range.new(from, to.inner), to.outer)
+      end
+      return Within.new(Range.new(from.inner, to), from.outer) if Within === from && Clock === from.inner && Clock === to
+      # D51: "Friday, between 9-6 PT": the zone is the day's too
+      if Within === from && Clock === from.inner && Weekday === from.outer && Zoned === to && Clock === to.node
+        return Zoned.new(Within.new(Range.new(from.inner, to.node), from.outer), to.offset, to.numeric)
+      end
+      Range.new(from, to)
+    end
+
+    # D44: "later than 9:30 but before 11:00 on thursday" is the range between two clock times; the day an
+    # after starts on, or ends on, would differ from a range's
+    def between(dir, node)
+      r = Within === node ? node.inner : node
+      return failure(:conflict) unless (dir == :after || dir == :from) && Range === r && Clock === r.from && Clock === r.to
+      node
+    end
+
+    # D44: "2012 or later", "3 pm onwards": from X on; "2012 or earlier": until X's end, with no start. "or
+    # after" and "or before" only end the phrase: "before 2010 or after 2018" is two. D48: "and after" too
+    def open_after(node)
+      return node if Failure === node || Unit === node
+      return failure(:conflict) if @but # "9 but before 11" says after nothing
+      return node unless @t[@i] == L::WORD
+      w = @t[@i + 1]
+      return clipped(node, w) if w == :before || w == :after
+      if (w == :or || w == :and) && @i + 2 * S == @n && @t[@i + S] == L::WORD && ((x = @t[@i + S + 1]) == :after || x == :before)
+        @i += S
+        w = x == :after ? :orlater : :orearlier
+      end
+      return node unless w == :orlater || w == :orearlier
+      @i += S
+      Open.new(w == :orlater ? :from : :through, node)
+    end
+
+    # D48: "tomorrow before 4pm", "tuesday of next week after 2pm": an open end after a day stays inside it
+    def clipped(node, w)
+      return failure(:conflict) if size(node) != 2 || Clock === node
+      @i += S
+      at = @i
+      c = item(true)
+      return c if Failure === c
+      return failure(:conflict, at) unless Clock === c
+      w == :before ? Range.new(node, c) : Within.new(Range.new(c, MIDNIGHT), node)
+    end
+
+    MIDNIGHT = Clock.new(0, 0, 0, nil, :midnight, false, false)
+
+    # D44: "june 12-14, 2021", "august 10 to 22 2012": a bare day and a year end a range begun with a month's
+    # day, and the year is both ends'
+    def day_and_year(from, ts)
+      return unless Date === from && from.month && from.day && !from.year && !from.sep
+      return unless @t[ts + S] == L::NUM && @t[ts + S + 2] & L::DIGITS == 4 && (d = bare_day(ts, ts + S))
+      year = @t[ts + S + 1]
+      @i = ts + 2 * S
+      Range.new(Date.new(year, from.month, from.day, nil, false), Date.new(year, from.month, d, nil, false))
+    end
+
+    # The day a range end written as one number or ordinal names ("15", "the 15th"), or nil
+    def bare_day(s, e)
+      s += S if @t[s + 1] == :the
+      return unless e == s + S && (@t[s] == L::NUM || @t[s] == L::ORD) && @t[s + 2] & (L::DIGITS | L::SHORT) <= 2
+      v = @t[s + 1]
+      v if v >= 1 && v <= 31
+    end
+  end
+end