acute 1.0.0

data/lib/acute/grammar/rule.rb

@@ -0,0 +1,277 @@
+module Acute
+  # Rules, read only by Acute.recurrence. The words that make one ("every", "daily", a plural weekday) fail a
+  # one-off parse, so phrase never comes here.
+  class Grammar
+    # interval: units between occurrences; days: weekdays picked (0 = Sunday); nths: [n, wday] within the month
+    # (R8); monthdays: days of the month, -1 the last; setpos: BYSETPOS over Monday to Friday; month and date:
+    # what was said (R9); until, start, within, except and window hold one-off trees; length the Units of "for 6
+    # weeks"
+    Recur = Struct.new(:interval, :unit, :days, :nths, :monthdays, :setpos, :month, :date, :clocks, :part,
+                       :until, :start, :within, :except_days, :except, :count, :length, :window)
+
+    # R5
+    FREQUENCY = { daily: [:day, 1], hourly: [:hour, 1], weekly: [:week, 1], monthly: [:month, 1], yearly: [:year, 1],
+                  quarterly: [:month, 3], semiannual: [:month, 6], biweekly: [:week, 2], bimonthly: [:month, 2] }.freeze
+    TAIL = { until: true, through: true, except: true, starting: true, in: true, for: true }.freeze
+    MON_FRI = [1, 2, 3, 4, 5].freeze
+    SAT_SUN = [6, 0].freeze
+
+    MARKS = { every: true, once: true, **FREQUENCY.transform_values { true } }.freeze
+
+    def self.rule(tokens) = new(tokens).rule
+
+    # Whether the tokens hold a word that makes a rule: "every", a frequency, or a plural day or part of day
+    def self.rule?(t)
+      (0...t.size).step(S).any? do |i|
+        k = t[i]
+        (k == L::WORD && MARKS[t[i + 1]]) ||
+          ((k == L::WDAY || k == L::PART || k == L::WEEKEND || (k == L::UNIT && t[i + 1] == :business_day)) && t[i + 2] & L::PLURAL != 0)
+      end
+    end
+
+    COUNTS = { "twice" => "2 times", "thrice" => "3 times" }.freeze
+
+    # R15: whether text that failed as a rule says how often but not when: a count per period with no days or
+    # times ("twice a week", "3 times a day"), or a part of the day with no clock ("every morning"). Only
+    # recurrence! asks, once the phrase has failed, so "twice" is no word the lexer has to know.
+    def self.vague?(text)
+      t = Lexer.lex(text.gsub(/\b(twice|thrice)\b/i) { COUNTS[$1.downcase] })
+      return false unless Array === t
+      count = days = part = false
+      (0...t.size).step(S) do |i|
+        k = t[i]
+        return false if k == L::CLOCK || k == L::AT || k == L::MER
+        days ||= k == L::WDAY || k == L::ORD || k == L::MONTH
+        part ||= k == L::PART
+        next unless k == L::NUM && t[i + S] == L::WORD && t[i + S + 1] == :times
+        j = i + 2 * S
+        count ||= (t[j] == L::WORD && FREQUENCY[t[j + 1]]) || # "3 times daily"
+                  ((t[j] == L::ART || (t[j] == L::WORD && t[j + 1] == :every)) && t[j + S] == L::UNIT)
+      end
+      (count && !days) || (part && rule?(t))
+    end
+
+    def rule
+      r = Recur.new(nil, nil, [], [], [], nil, nil, nil, [], nil, nil, nil, nil, [], [], nil, nil, nil)
+      every = false
+      while @i < @n
+        k = @t[@i]
+        v = @t[@i + 1]
+        if k == L::WORD && v == :every
+          every = true
+          @i += S
+          k = @t[@i]
+          if k == L::WORD && @t[@i + 1] == :other # R7
+            r.interval = 2
+            @i += S
+          elsif k == L::ORD && @t[@i + 1] == 2 && !r.unit && every_second?(@i) # R5: "every second" is the unit, not the 2nd of the month
+            r.unit = :second
+            @i += @i + S < @n && @t[@i + S + 1] == :of ? 4 * S : S
+          elsif (k == L::NUM || (k == L::ORD && @t[@i + 2 * S + 1] != :of)) && @t[@i + S] == L::UNIT &&
+                @t[@i + S + 1] != :business_day # R5: "every 2 weeks", "every third day"
+            r.interval = @t[@i + 1]
+            @i += S
+          end
+        elsif k == L::WORD && (f = FREQUENCY[v])
+          return failure(:conflict) if r.unit
+          every = true
+          r.unit, r.interval = f
+          @i += S
+        elsif k == L::WORD && v == :once && @t[@i + S] == L::ART && @t[@i + 2 * S] == L::UNIT # R5: "once a week"
+          every = true
+          @i += 2 * S
+        elsif k == L::WORD && (v == :the || v == :on)
+          @i += S
+        elsif k == L::WORD && v == :of
+          @i += S
+          k = @t[@i]
+          if k == L::WORD && ((w = @t[@i + 1]) == :every || w == :the) && @t[@i + S] == L::UNIT && @t[@i + S + 1] == :month
+            every ||= w == :every
+            @i += 2 * S
+          elsif k != L::MONTH
+            return failure(:conflict)
+          end
+        elsif k == L::WORD && v == :except
+          @i += S
+          if (k = @t[@i]) == L::WDAY || k == L::WEEKEND || (k == L::UNIT && @t[@i + 1] == :business_day)
+            while (k = @t[@i]) == L::WDAY || k == L::WEEKEND || (k == L::UNIT && @t[@i + 1] == :business_day)
+              r.except_days.concat(k == L::WDAY ? [@t[@i + 1]] : k == L::WEEKEND ? SAT_SUN : MON_FRI)
+              @i += S
+              @i += S if @t[@i] == L::WORD && @t[@i + 1] == :and
+            end
+          else
+            loop do
+              x = tail_phrase(true)
+              return x if Failure === x
+              r.except << x
+              break unless @t[@i] == L::WORD && @t[@i + 1] == :and
+              @i += S
+            end
+          end
+        elsif k == L::WORD && (v == :until || v == :through)
+          return failure(:conflict) if r.until
+          @i += S
+          r.until = tail_phrase
+          return r.until if Failure === r.until
+        elsif starting?(@i)
+          @i += S
+          r.start = tail_phrase
+          return r.start if Failure === r.start
+        elsif k == L::WORD && (v == :from || v == :between) && r.unit && !r.window # R27: "every 15 minutes from 9 to 5"
+          stop = @i + S
+          stop += S while stop < @n && !window_end?(stop)
+          r.window = Grammar.new(@t[@i...stop]).phrase
+          return r.window if Failure === r.window
+          @i = stop
+        elsif k == L::WORD && v == :in
+          @i += S
+          r.within = tail_phrase
+          return r.within if Failure === r.within
+        elsif k == L::WORD && v == :for
+          @i += S
+          if @t[@i] == L::NUM && @t[@i + S + 1] == :times # R11: "for 10 occurrences"
+            r.count = @t[@i + 1]
+            @i += 2 * S
+          else
+            stop = tail_end(@i)
+            units = Grammar.new(@t[@i...stop]).duration
+            return units if Failure === units
+            r.length = units
+            @i = stop
+          end
+        elsif k == L::NUM && @t[@i + S + 1] == :times && @t[@i + S] == L::WORD
+          @i += 2 * S
+          # R15: "3 times a day" is a count per period
+          return failure(:conflict) if (k = @t[@i]) == L::ART || (k == L::WORD && @t[@i + 1] == :every)
+          r.count = @t[@i - 2 * S + 1]
+        elsif k == L::ORD || (k == L::REL && v == :last)
+          ords = rule_ords
+          k = @t[@i]
+          if k == L::WDAY # R8
+            days, plural = rule_days
+            every ||= plural
+            ords.each { |n| days.each { |w| r.nths << [n, w] } }
+          elsif k == L::UNIT && @t[@i + 1] == :business_day
+            r.setpos = ords
+            @i += S
+          else
+            @i += S if k == L::UNIT && @t[@i + 1] == :day
+            return failure(:conflict) if ords.any? { |n| n == 0 || n > 31 }
+            r.monthdays.concat(ords)
+          end
+        elsif k == L::WDAY
+          days, plural = rule_days
+          every ||= plural
+          r.days.concat(days)
+        elsif k == L::WEEKEND || (k == L::UNIT && v == :business_day) # R6
+          every ||= @t[@i + 2] & L::PLURAL != 0
+          r.days.concat(k == L::WEEKEND ? SAT_SUN : MON_FRI)
+          @i += S
+        elsif k == L::UNIT
+          return failure(:conflict) if r.unit
+          r.unit = v
+          @i += S
+        elsif k == L::PART
+          return failure(:conflict) if r.part
+          every ||= @t[@i + 2] & L::PLURAL != 0
+          r.part = v
+          @i += S
+        elsif k == L::MONTH
+          d = month_atom
+          return failure(:conflict) if d.year || r.month
+          r.month = d.month
+          r.date = d if d.day
+        elsif k == L::AT || clock_at?(@i) || k == L::NUM
+          @i += S if k == L::AT
+          loop do
+            at = @i
+            c = atom(true)
+            return c if Failure === c
+            if Date === c && !c.year && c.month && c.day && !r.month # "each 4/15"
+              r.date = c
+              break
+            end
+            return failure(:conflict, at) unless Clock === c
+            r.clocks << c
+            break unless @t[@i] == L::WORD && @t[@i + 1] == :and && (clock_at?(@i + S) || @t[@i + S] == L::AT)
+            @i += S
+            @i += S if @t[@i] == L::AT
+          end
+        else
+          return failure(:conflict)
+        end
+      end
+      every ? r : failure(:incomplete)
+    end
+
+    private
+
+    # R5: an ORD 2 after "every" that is "second" written as a word, and ends the phrase, goes on with a rule word
+    # or is "of the day": "every second", "every second until 5pm". Before a day, a unit or "of the month" it is
+    # an ordinal.
+    def every_second?(i)
+      return false unless @t[i + 2] & L::ENGLISH != 0
+      j = i + S
+      return true if j >= @n
+      return false unless @t[j] == L::WORD
+      w = @t[j + 1]
+      TAIL[w] || (w == :of && (@t[j + S + 1] == :the || @t[j + S + 1] == :every) && @t[j + 2 * S] == L::UNIT &&
+                  @t[j + 2 * S + 1] == :day)
+    end
+
+    # "first and third", "last", "second to last" (R8)
+    def rule_ords
+      out = []
+      loop do
+        if @t[@i] == L::ORD && @t[@i + S + 1] == :to && @t[@i + 2 * S] == L::REL && @t[@i + 2 * S + 1] == :last
+          out << -@t[@i + 1]
+          @i += 3 * S
+        else
+          out << (@t[@i] == L::REL ? -1 : @t[@i + 1])
+          @i += S
+        end
+        break unless @t[@i] == L::WORD && @t[@i + 1] == :and && (@t[@i + S] == L::ORD || @t[@i + S + 1] == :last)
+        @i += S
+      end
+      out
+    end
+
+    # "monday and wednesday", "mondays, wednesdays and fridays", and whether one was plural (R6)
+    def rule_days
+      out = []
+      plural = false
+      loop do
+        out << @t[@i + 1]
+        plural ||= @t[@i + 2] & L::PLURAL != 0
+        @i += S
+        break unless @t[@i] == L::WDAY || (@t[@i] == L::WORD && @t[@i + 1] == :and && @t[@i + S] == L::WDAY)
+        @i += S if @t[@i] == L::WORD
+      end
+      [out, plural]
+    end
+
+    # The one-off phrase up to the next rule word, or with and_stop: true also up to "and"
+    def tail_phrase(and_stop = false)
+      stop = tail_end(@i, and_stop)
+      return failure(:incomplete) if stop == @i
+      node = Grammar.new(@t[@i...stop]).phrase
+      @i = stop
+      node
+    end
+
+    # A window's clock range ends at the days it is on, or at the next rule word
+    def window_end?(j)
+      k = @t[j]
+      w = @t[j + 1]
+      (k == L::WORD && (TAIL[w] || w == :on || w == :every)) || k == L::WDAY || k == L::WEEKEND ||
+        (k == L::UNIT && w == :business_day) || (k == L::NUM && @t[j + S + 1] == :times)
+    end
+
+    def tail_end(j, and_stop = false)
+      j += S
+      j += S while j < @n && !(@t[j] == L::WORD && (TAIL[w = @t[j + 1]] || (and_stop && w == :and))) &&
+                   !(@t[j] == L::NUM && @t[j + S + 1] == :times)
+      j > @n ? @n : j
+    end
+  end
+end

data/lib/acute/grammar/shifts.rb

@@ -0,0 +1,226 @@
+module Acute
+  # Counts of units: "3 days", "a week"; moved from now or an anchor: "3 days ago", "2 years 4 months ago", "+2 days"
+  class Grammar
+    private
+
+    WEEKS = { week: true, fortnight: true }.freeze
+
+    # After a quantity: "ago", "from now", "from tomorrow", "after next tuesday", or nothing. D44: more
+    # quantities before the tail are each applied in the order said ("1 week and a day from now").
+    def shift_tail(q)
+      start = @i
+      more = more_units(q)
+      w = @t[@i + 1]
+      w = :after if w == :past && @t[@i] == L::REL # "three hours past noon"
+      if more && !SHIFT_TAIL[w]
+        @i = start
+        more = nil
+      end
+      case w
+      when :ago
+        @i += S
+        shifts(-1, q, more, nil)
+      when :hence, :later
+        @i += S
+        shifts(1, q, more, nil)
+      when :from, :after, :before
+        @i += S
+        anchor = item(true)
+        return anchor if Failure === anchor
+        shifts(w == :before ? -1 : 1, q, more, Now === anchor ? nil : anchor)
+      else
+        # "a week today", "a fortnight on tuesday": that long after the day
+        if WEEKS[q.unit] && !more && (@t[@i] == L::DAY || (@t[@i + 1] == :on && @t[@i + S] == L::WDAY))
+          @i += S if @t[@i] != L::DAY
+          anchor = atom(true)
+          return Failure === anchor ? anchor : shifts(1, q, nil, anchor)
+        end
+        return q unless !more && starting?(@i)
+        @i += S
+        @i += S if @t[@i + 1] == :from
+        start = item(true)
+        Failure === start ? start : Lasting.new(q, start)
+      end
+    end
+
+    # D44: "for 3 days from today", "for 1 week, from 20th dec": that long from the start of what follows;
+    # nil when no "from" or "starting" follows the length
+    def for_from
+      i = @i
+      @i += S
+      q = duration_quantity
+      if q && !(Failure === q) && (@t[@i + 1] == :from || starting?(@i))
+        @i += S
+        @i += S if @t[@i + 1] == :from
+        start = item(true)
+        return Failure === start ? start : Lasting.new(q, start)
+      end
+      @i = i
+      nil
+    end
+
+    # D48: "from 4pm for thirty minutes", "from 18th Dec for 10 days": that long from its start, as "for 10
+    # days from 18th Dec"
+    def lasting(start)
+      @i += S
+      q = duration_quantity
+      return q if Failure === q
+      q ? Lasting.new(q, start) : failure(@i < @n ? :conflict : :incomplete)
+    end
+
+    # D44: "starting", "commencing", or "beginning" with no "of" after it: from the start of what follows. Not
+    # "start from october", a verb before its own "from".
+    def starting?(i)
+      return true if @t[i] == L::WORD && @t[i + 1] == :starting
+      @t[i] == L::FUZZ && @t[i + 1] == :start && (w = @t[i + S + 1]) != :of && w != :from
+    end
+
+    # D44: "3 fridays from now", "2nd monday before may 25", "two weekends ago", D46: "5 mornings ago": i is the day after the count
+    def counted?(i)
+      k = @t[i]
+      (k == L::WDAY || k == L::WEEKEND || k == L::HOLIDAY || k == L::PART || k == L::SEASON) && @t[i + S] == L::WORD &&
+        SHIFT_TAIL[@t[i + S + 1]]
+    end
+
+    # D44: "the sunday after next wed", "the monday before christmas" are the first one after or before the
+    # day named; "friday after next", "March after the next", "tuesday before last" the one after next friday
+    def around(node)
+      return node unless @t[@i] == L::WORD && ((w = @t[@i + 1]) == :after || w == :before)
+      j = @i + S
+      j += S if @t[j] == L::WORD && @t[j + 1] == :the
+      k = @t[j]
+      if k == L::REL && (r = @t[j + 1]) == (w == :after ? :next : :last) && nothing_own?(j + S)
+        @i = j + S
+        return Counted.new(w == :after ? 1 : -1, node, Rel.new(r, node))
+      end
+      return node unless k == L::REL || k == L::WDAY || k == L::DAY || k == L::HOLIDAY || k == L::MONTH
+      @i += S
+      anchor = item(true)
+      return anchor if Failure === anchor
+      Counted.new(w == :after ? 1 : -1, node, anchor)
+    end
+
+    # "next" in "the week after next" has nothing of its own when what follows is a time or nothing
+    def nothing_own?(j)
+      k = @t[j]
+      !k || k == L::CLOCK || k == L::NUM || k == L::AT || k == L::PART || (k == L::WORD && @t[j + 1] == :in)
+    end
+
+    def counted(n)
+      k = @t[@i]
+      v = @t[@i + 1]
+      node = k == L::WDAY ? Weekday.new(v) : k == L::HOLIDAY ? Holiday.new(v) : k == L::PART ? Part.new(v) :
+             k == L::SEASON ? Season.new(v) : WEEKEND
+      w = @t[@i + S + 1]
+      @i += 2 * S
+      return Counted.new(-n, node, nil) if w == :ago
+      return Counted.new(n, node, nil) if w == :hence || w == :later
+      anchor = item(true)
+      return anchor if Failure === anchor
+      Counted.new(w == :before ? -n : n, node, Now === anchor ? nil : anchor)
+    end
+
+    def shifts(sign, q, more, anchor)
+      node = Shift.new(sign * q.count, q.unit, anchor)
+      more&.each { |u| node = Shift.new(sign * u.count, u.unit, node) }
+      node
+    end
+
+    # "4 months" in "2 years 4 months ago", "a day" in "1 week and a day", "and a half" in "an hour and a
+    # half ago"; nil when none follow
+    def more_units(last)
+      list = nil
+      while @i < @n
+        save = @i
+        @i += S if @t[@i + 1] == :and
+        unless (q = duration_tail(last.unit) || quantity)
+          @i = save
+          break
+        end
+        (list ||= []) << q
+        last = q
+      end
+      list
+    end
+
+    # D44: "+2 days", "-3y", "- 3 seconds", "2023-12-29 -10days": a signed count of units shifts what comes
+    # before it, or now. After other atoms a minus needs a space before it and none after.
+    def signed?(last)
+      return false unless @t[@i + S] == L::NUM && unit_at(@i + 2 * S)
+      # "now - 2 hours" is two hours ago, never a range
+      @t[@i] == L::PLUS || last.nil? || last.equal?(NOW) || (@t[@i + 3] > @t[@i - 1] && @t[@i + 4] == @t[@i + S + 3])
+    end
+
+    # Each sign holds for the unsigned counts after it: "+1 day 2 hours", "+1 decade -2 years"
+    def signed_shifts(node)
+      sign = 1
+      while @i < @n
+        k = @t[@i]
+        if (signed = k == L::PLUS || k == L::DASH)
+          sign = k == L::PLUS ? 1 : -1
+          @i += S
+        end
+        unless (q = quantity)
+          return failure(:incomplete) if signed
+          break
+        end
+        node = Shift.new(sign * q.count, q.unit, node)
+      end
+      node
+    end
+
+    # "a week", "3 days", "1/2 hour"; nil (nothing read) unless the tokens are a count and a unit
+    def quantity
+      i = @i
+      count = nil
+      if (said = spoken(i))
+        count, i = said
+      elsif @t[i] == L::ART then count = 1
+      elsif @t[i] == L::NUM
+        count = @t[i + 1]
+        if @t[i + S] == L::SLASH && @t[i + 2 * S] == L::NUM && @t[i + 2 * S + 1] > 0
+          count = Rational(count, @t[i + 2 * S + 1])
+          i += 2 * S
+        elsif @t[i + S] == L::DOT && @t[i + 2 * S] == L::NUM && unit_at(i + 3 * S) && touching?(i, i + 2 * S) # "2.5 hours", not "1. 5 hours" (D47)
+          count += Rational(@t[i + 2 * S + 1], 10**(@t[i + 2 * S + 2] & L::DIGITS))
+          i += 2 * S
+        end
+      elsif @t[i + 1] == :half && @t[i + S] == L::ART # "half an hour"
+        count = Rational(1, 2)
+        i += S
+      elsif @t[i + 1] == :couple # D44: "a couple of days" is two
+        count = 2
+      elsif @t[i] == L::DECADE && @t[i + 2] & (L::WORDY | L::QUOTED) == 0 # "30s", "5400s": seconds, not a decade (D47); "70's" and "nineties" are decades (D50)
+        @i = i + S
+        return Unit.new(:second, @t[i + 1])
+      else return
+      end
+      unit = unit_at(i + S)
+      return unless unit
+      @i = i + 2 * S
+      Unit.new(unit, count)
+    end
+
+    # "this time tomorrow", "same time next week": now moved by the day or unit
+    def same_time
+      i = @i
+      @i += S
+      return failure(:incomplete) if @i >= @n
+      x = atom(true)
+      if DayRef === x then Shift.new(x.offset, :day, nil)
+      elsif Rel === x && Unit === x.node && !x.node.count && (x.word == :next || x.word == :last)
+        Shift.new(x.word == :next ? 1 : -1, x.node.unit, nil)
+      else Failure === x ? x : failure(:conflict, i)
+      end
+    end
+
+    def touching?(from, to) = (from...to).step(S).all? { |j| @t[j + 4] == @t[j + S + 3] }
+
+    # "second" is the ordinal unless it follows a count
+    def unit_at(i)
+      k = @t[i]
+      return @t[i + 1] if k == L::UNIT
+      :second if k == L::ORD && @t[i + 1] == 2 && @t[i + 2] & L::WORDY != 0 && @t[i + S] != L::UNIT # not "2005 second quarter"
+    end
+  end
+end