acute 1.0.0

data/lib/acute/resolve/ranges.rb

@@ -0,0 +1,165 @@
+module Acute
+  module Resolve
+    # Ranges ("monday to friday", "from 3 to 5pm") and open ends ("after friday", "since monday")
+    module Ranges
+      DAY = Period::DAY
+      UNDER_WAY = Assumption.for(:range_under_way)
+
+      def self.spans(node, ctx)
+        from = node.from
+        to = node.to
+        return clocks(meridiem(from, to), to, ctx) if G::Clock === from && G::Clock === to
+        return numeric(node, ctx) if G::Date === from && G::Date === to && from.sep && from.sep == to.sep
+        f = Resolve.spans(from, ctx)[0]
+        return [] unless f
+        # A fixed end gives a range per reading: "through midnight today" to today's end, then its start (D6)
+        ends = G::Clock === to || Periodic.cycle(to) ? [after(to, ctx, f.b)] : Resolve.spans(to, ctx)
+        list = ends.filter_map { _1 && finish(f, _1) }
+        under_way(from, to, f, list, ctx) if !ctx.past? && Periodic.cycle(from) == :year
+        list
+      end
+
+      # D44: a range of dates or months under way ("may to september" in june) is the current one, then the
+      # coming one
+      def self.under_way(from, to, f, list, ctx)
+        now = ctx.now_local
+        if f.b > now
+          b = Periodic.last(from, ctx, Period.index(:year, ctx, now), :year) { |s| s.b <= now }[0]
+          cur = b && (t = after(to, ctx, b.b)) && finish(b, t)
+          return unless cur && cur.e > now
+          list.unshift(cur)
+        else
+          # one that starts today is today's alone, as a date said on its day is
+          return unless list.size == 1 && list[0].e > now && f.b < ctx.today * DAY
+          n = Periodic.first(from, ctx, Period.index(:year, ctx, f.b) + 1, :year) { true }[0]
+          coming = n && (t = after(to, ctx, n.b)) && finish(n, t)
+          return unless coming
+          list << coming
+        end
+        ctx.note(UNDER_WAY)
+      end
+
+      # D10: both ends of "5/1-5/7" are read in the same order, the locale's first
+      def self.numeric(node, ctx)
+        out = []
+        [false, true].each do |swap|
+          f = Dates.order(node.from, ctx, swap)
+          t = Dates.order(node.to, ctx, swap)
+          next unless f && t
+          spans(G::Range.new(f, t), ctx).each { |x| out << x unless out.any? { |o| o.b == x.b && o.e == x.e } }
+        end
+        ctx.note(Dates::ORDER) if out.size > 1
+        out
+      end
+
+      def self.inside(node, outer, s, ctx)
+        from = G::Clock === node.from && G::Clock === node.to ? meridiem(node.from, node.to) : node.from
+        f = Periodic.inside(from, outer, s, ctx)[0]
+        return [] unless f
+        t = G::Clock === node.to ? after(node.to, ctx, f.b) : Periodic.inside(node.to, outer, s, ctx).find { |x| x.b >= f.b }
+        # D48: a weekday earlier in the week than the start is the one after it, out of the week
+        t ||= after(node.to, ctx, f.b) if G::Weekday === node.from && G::Weekday === node.to
+        (x = t && finish(f, t)) ? [x] : []
+      end
+
+      # "2 to 4pm" is 2pm; "11 to 2pm" is 11am
+      def self.meridiem(from, to)
+        return from if from.meridiem || from.named || !to.meridiem || from.hour > 12
+        same = from.hour % 12 < to.hour % 12 || (from.hour % 12 == to.hour % 12 && from.min < to.min)
+        G::Clock.new(from.hour, from.min, from.sec, same ? to.meridiem : (to.meridiem == :pm ? :am : :pm), nil,
+                     false, from.seconds)
+      end
+
+      # D40: a clock range under way is today's, one answer, or yesterday's when it runs past midnight (D44);
+      # otherwise the next one (the previous in past context)
+      def self.clocks(from, to, ctx)
+        now = ctx.now_local
+        f = Periodic.inside(from, nil, Period.span(:day, ctx, ctx.today), ctx)[0]
+        span = Span.new(f.b, clock_after(to, ctx, f.b), f.grain, nil)
+        if span.b > now && span.e - DAY > now
+          span = Span.new(span.b - DAY, span.e - DAY, span.grain, nil)
+        elsif ctx.past? ? span.b > now : span.e <= now
+          k = ctx.past? ? -DAY : DAY
+          span = Span.new(span.b + k, span.e + k, span.grain, nil)
+        end
+        [span]
+      end
+
+      # D9: days and larger include the end; with a clock the end is the stated time
+      # An end's exact UTC is kept, so "1am EDT – 1:30am EST" stays on each side of the repeated hour, and
+      # "1:50am EDT – 1:10am EST" runs forwards
+      def self.finish(f, t)
+        clock = clock?(t)
+        e = clock ? t.b : t.e
+        ue = clock ? t.ub : t.ue
+        forwards = f.ub && ue ? ue > f.ub : e > f.b
+        forwards ? Span.new(f.b, e, f.grain, nil, f.ub, ue) : nil
+      end
+
+      def self.clock?(s) = s.grain == :minute || s.grain == :second
+
+      # The first reading of node from t on
+      def self.after(node, ctx, t)
+        if G::Clock === node
+          grain, len = Clock.grain(node)
+          return Span.new(x = clock_after(node, ctx, t), x + len, grain, nil)
+        end
+        if (cyc = Periodic.cycle(node))
+          return Periodic.first(node, ctx, Period.index(cyc, ctx, t) - 1, cyc) { |s| s.b >= t }[0]
+        end
+        Resolve.spans(node, ctx)[0]
+      end
+
+      # The earliest reading of a clock after t, over every am/pm reading
+      def self.clock_after(c, ctx, t)
+        d = Period.day(t) * DAY
+        best = nil
+        Clock.candidates(c, ctx, true).each do |secs|
+          [d + secs, d + DAY + secs].each { |x| best = x if x > t && (best.nil? || x < best) }
+        end
+        best
+      end
+
+      # D16, D34: since closes at now and looks back; until opens at now; before ends when X starts; after
+      # starts when X ends, or at a clock time itself
+      def self.open(node, ctx)
+        now = ctx.now_local
+        past = ctx.past
+        ctx.past = node.dir == :since && :back
+        list = Resolve.spans(node.node, ctx)
+        ctx.past = past
+        list = current(node.node, ctx) || list if node.dir == :after && G::Holiday === node.node
+        list.map do |s|
+          case node.dir
+          when :since then Span.new(s.b, now, s.grain, nil, s.ub, ctx.now)
+          when :until
+            # D44: until the day's last second ("by EOD") is until the day's end
+            if clock?(s) && !(s.grain == :second && s.e % DAY == 0) then Span.new(now, s.b, s.grain, nil, ctx.now, s.ub)
+            else Span.new(now, s.e, s.grain, nil, ctx.now, s.ue)
+            end
+          when :upto then Span.new(now, s.b, s.grain, nil, ctx.now, s.ub) # D9: "up to <date>" leaves it out
+          when :before then Span.new(nil, s.b, s.grain, nil, nil, s.ub)
+          # D44: "on or before X", "X or earlier": up to X's end, or to a clock time itself
+          when :through then clock?(s) ? Span.new(nil, s.b, s.grain, nil, nil, s.ub) : Span.new(nil, s.e, s.grain, nil, nil, s.ue)
+          when :from then Span.new(s.b, nil, s.grain, nil, s.ub)
+          else clock?(s) ? Span.new(s.b, nil, s.grain, nil, s.ub) : Span.new(s.e, nil, s.grain, nil, s.ue)
+          end
+        end.reject { |s| s.b && s.e && s.e < s.b } # D44: "until 2014" said in 2026 runs backwards, so it is no time
+      end
+
+      # D44: "3 days starting next monday", "the week beginning february 4": that many units from its start
+      def self.lasting(node, ctx)
+        n, u = Period.whole(node.unit.count, node.unit.unit)
+        Resolve.spans(node.start, ctx).map { |s| Span.new(s.b, Period.add(s.b, n, u, ctx), s.grain, nil) }
+      end
+
+      # D40: "after christmas" said on Dec 27 is this year's, whose after still holds now. Only holidays: "after
+      # january" said in October is next year's (D34)
+      def self.current(x, ctx)
+        cyc = Periodic.cycle(x)
+        list = Periodic.at(x, ctx, Period.index(cyc, ctx, ctx.now_local), cyc)
+        list if list.any? && list[0].e <= ctx.now_local
+      end
+    end
+  end
+end

data/lib/acute/resolve/recur.rb

@@ -0,0 +1,187 @@
+module Acute
+  module Resolve
+    # A Recur to a Rule. DTSTART walks the days from now (R2) rather than a one-off cycle: BYSETPOS, -2FR and
+    # lists of days have no one-off node to walk with.
+    module Recur
+      DAY = 86_400
+      FREQ = { second: [:secondly, 1], minute: [:minutely, 1], hour: [:hourly, 1], day: [:daily, 1], week: [:weekly, 1],
+               fortnight: [:weekly, 2], month: [:monthly, 1], quarter: [:monthly, 3], year: [:yearly, 1] }.freeze
+      FINE = { secondly: true, minutely: true, hourly: true }.freeze
+      STEP = { secondly: 1, minutely: 60, hourly: 3600 }.freeze
+      FINE_GRAIN = { second: true, minute: true, hour: true }.freeze
+      SEARCH = 8 * 366 + 1 # R9: the next 29 February can be 8 years away
+      EVERY_DAY = [0, 1, 2, 3, 4, 5, 6].freeze
+      MAX_EXDATES = 24
+
+      # A Rule, or a Failure's code
+      # text: the input, which the Rule carries and nothing here reads
+      def self.call(r, ctx, text)
+        freq, mult = FREQ[r.unit] if r.unit
+        return :conflict if r.unit && !freq
+        interval = (r.interval || 1) * (mult || 1)
+        return :invalid_date if interval == 0 # R15
+        if r.window # R27: the steps inside the window are the rule's clocks, on each day it runs
+          return :conflict unless FINE[freq] && r.clocks.empty? && !r.part
+          steps = window(r.window, interval * STEP[freq], ctx)
+          return steps if Symbol === steps
+          freq = nil
+          interval = 1
+        end
+        days = r.days.uniq
+        days = EVERY_DAY if days.empty? && r.except_days.any? && (freq.nil? || freq == :daily)
+        days -= r.except_days # R12
+        return :invalid_date if days.empty? && r.days.any? || r.except_days.any? && days.empty?
+        month = r.month
+        monthdays = r.monthdays.uniq
+        if r.date
+          d = r.date.sep ? Dates.orders(r.date, ctx)[0] : r.date
+          return :invalid_date unless d
+          month = d.month
+          monthdays = [d.day]
+        end
+        if month
+          return :conflict if monthdays.empty?
+          freq ||= :yearly # R9
+          return :conflict unless freq == :yearly
+        elsif r.nths.any? || r.setpos || monthdays.any?
+          freq ||= :monthly # R8, R9
+          return :conflict unless freq == :monthly
+          return :invalid_date if r.nths.any? { |n, _| n == 0 || n.abs > 5 }
+          days = MON_FRI if r.setpos
+        elsif days.any?
+          freq = :weekly if freq.nil? || freq == :daily # R6
+          return :conflict unless freq == :weekly
+        elsif r.clocks.any? || r.part || steps
+          freq ||= :daily
+        end
+        return :conflict unless freq
+        return :conflict if r.part && r.clocks.empty? # R15: "every morning"
+        return :conflict if [r.until, r.within, r.length].compact.size > 1 || (r.count && (r.until || r.within || r.length))
+
+        secs = steps || r.clocks.map { clock(_1, r.part, ctx) }.uniq.sort
+        return :conflict unless grid?(secs) # R4
+        timed = !secs.empty? || FINE[freq]
+
+        from = ctx.now
+        if r.start || r.within # R13
+          x = first(r.start || r.within, ctx)
+          return x if Symbol === x
+          from = x.begin if x.begin && (r.start || x.begin > from)
+        end
+        rule = Rule::Parts.new(freq, interval, month, monthdays, r.nths.any? ? [] : days, r.nths, r.setpos, secs)
+        start = dtstart(rule, from, ctx)
+        return :invalid_date unless start
+
+        last = r.until || r.within
+        if last
+          x = first(last, ctx)
+          return x if Symbol === x
+          until_ = ending(x, timed, ctx)
+          return until_ if Symbol === until_
+          return :no_occurrence if (timed ? ctx.local(until_) : until_) < start # R9
+        elsif r.length
+          until_ = length(r.length, start, timed, ctx)
+        end
+        bare = nil
+        exdates = r.except.map do |node|
+          x = first(node, ctx)
+          return x if Symbol === x
+          next ctx.local(x.begin) if FINE[freq] && FINE_GRAIN[x.grain] # R12: that instant, an occurrence or not
+          day = ctx.local(x.begin).div(DAY)
+          next day unless timed
+          next secs.map { day * DAY + _1 } unless FINE[freq]
+          bare ||= Rule.new(rule, ctx.zone.name, start, true, nil, nil, [], false, ctx.dst_policy, now: ctx.now, text: text)
+          walls = day_walls(bare, day, ctx)
+          return :conflict if walls.size > MAX_EXDATES # R12: "every 15 minutes except october 18"
+          walls
+        end
+        Rule.new(rule, ctx.zone.name, start, timed, r.count, until_, exdates.flatten, r.start || r.within ? true : false,
+                 ctx.dst_policy, now: ctx.now, text: text)
+      end
+
+      # R4: seconds of the day, as D4, D30 and D35 read the clock, first reading only
+      def self.clock(c, part, ctx)
+        return Clock.candidates(c, ctx, false)[0] unless part
+        day = ctx.today
+        Periodic.clock(c, G::Part.new(part), Named.part(part, day, ctx), ctx)[0].b - day * DAY
+      end
+
+      # R4: each hour with each minute, all at one second, as BYHOUR × BYMINUTE gives them
+      def self.grid?(secs)
+        rest = secs.map { _1 % 3600 }.uniq
+        rest.map { _1 % 60 }.uniq.size <= 1 && secs.size == secs.map { _1 / 3600 }.uniq.size * rest.size
+      end
+
+      # R27: the seconds of the day from the window's start, a step apart, before its end; within one day
+      def self.window(node, step, ctx)
+        x = first(node, ctx)
+        return x if Symbol === x
+        return :incomplete unless x.begin && x.end
+        b = ctx.local(x.begin)
+        day = b.div(DAY)
+        e = ctx.local(x.end) - day * DAY
+        b -= day * DAY
+        return :conflict if e > DAY || e <= b
+        (b...e).step(step).to_a
+      end
+
+      def self.first(node, ctx)
+        readings = Resolve.call(node, ctx, failure: true)
+        return readings.code if Failure === readings
+        readings[0] || :invalid_date
+      end
+
+      # R2, R3, R14: the first occurrence on or after from, as local wall seconds (whole days: a day number)
+      def self.dtstart(rule, from, ctx)
+        local = ctx.local(from)
+        first = local.div(DAY)
+        day = first
+        while day < first + SEARCH
+          if rule.on?(day)
+            return day unless rule.secs.any? || FINE[rule.freq]
+            return day == first ? local : day * DAY if rule.secs.empty?
+            rule.secs.each { |s| return day * DAY + s if ctx.zone.local_to_utc(day * DAY + s, ctx) >= from }
+          end
+          day += 1
+        end
+      end
+
+      # R12: the wall times of an hourly or finer rule's occurrences on a local day, however many hours DST gives
+      # it; past MAX_EXDATES, more than that. The rule's end is left out, as a daily rule's times are.
+      def self.day_walls(rule, day, ctx)
+        from = ctx.zone.local_to_utc(day * DAY, ctx) - 1
+        walls = rule.next(MAX_EXDATES + 2, after: Time.at(from)).filter_map do |t|
+          wall = t.to_i + t.utc_offset
+          wall if wall < (day + 1) * DAY
+        end
+        walls.uniq
+      end
+
+      # R10, R14: through the end of x, inclusive; a clock is that instant
+      def self.ending(x, timed, ctx)
+        if FINE_GRAIN[x.grain]
+          return timed ? x.begin : ctx.local(x.begin).div(DAY)
+        end
+        return :incomplete unless x.end
+        day = ctx.local(x.end - 1).div(DAY)
+        timed ? ctx.zone.local_to_utc((day + 1) * DAY - 1, ctx) : day
+      end
+
+      # R11: from DTSTART, its end left out; days or longer end on the whole day before
+      def self.length(units, start, timed, ctx)
+        t = timed ? start : start * DAY
+        if units.all? { Period::SECONDS[_1.unit] }
+          return ctx.zone.local_to_utc(t, ctx) + units.sum { Period::SECONDS[_1.unit] * _1.count } - 1
+        end
+        units.each do |u|
+          n, unit = Period.whole(u.count, u.unit)
+          t = Period.add(t, n, unit, ctx)
+        end
+        day = t.div(DAY) - 1
+        timed ? ctx.zone.local_to_utc((day + 1) * DAY - 1, ctx) : day
+      end
+
+      MON_FRI = G::MON_FRI
+    end
+  end
+end

data/lib/acute/resolve/rel.rb

@@ -0,0 +1,146 @@
+module Acute
+  module Resolve
+    # next / this / last / past, with a unit ("next week", "past 3 days") or a repeating phrase ("next friday")
+    module Rel
+      DAY = Period::DAY
+      NEXT_TWO = Assumption.for(:next_two_readings)
+      THIS_PASSED = Assumption.for(:this_passed)
+      ROLLING = Assumption.for(:rolling_window)
+      CENTURY = Assumption.for(:century_from_00)
+      TONIGHT = G::Part.new(:tonight).freeze
+
+      def self.spans(node, ctx)
+        x = node.node
+        word = node.word
+        return Period.fiscal(x, ctx, word == :this ? 0 : word == :next || word == :coming ? 1 : -1) if G::Fiscal === x
+        return Dates.orders(x, ctx).flat_map { |d| periodic(word, d, ctx) } if G::Date === x && x.sep # D48: "last 9/11"
+        return periodic(word, x, ctx) unless G::Unit === x || G::Clock === x
+        return unit(word, x.unit, ctx) if G::Unit === x && !x.count
+        word = :next if word == :coming
+        return clock(word, x, ctx) if G::Clock === x
+        counted(word, x.count, x.unit, ctx)
+      end
+
+      # D20, D21, D32, D40
+      def self.periodic(word, x, ctx)
+        cyc = Periodic.cycle(x)
+        return [] unless cyc
+        now = ctx.now_local
+        i = Period.index(cyc, ctx, now)
+        case word
+        when :coming then Periodic.first(x, ctx, i, cyc) { |s| s.b > now } # D40: the first one after now, alone
+        when :next
+          return Periodic.at(x, ctx, i + 1, cyc) if cyc == :day # D40: "next night" is tomorrow night
+          coming = Periodic.first(x, ctx, i, cyc) { |s| s.b > now }
+          # D40: said while one is under way, it means the one after, one answer
+          return coming if under_way?(x, ctx, i, cyc, now)
+          following = Periodic.at(x, ctx, i + 1, cyc)
+          out = merge(coming, following)
+          ctx.note(NEXT_TWO) if out.size > 1 && following.any? && coming.any? && following[0].b != coming[0].b
+          out
+        when :this
+          cur = Periodic.at(x, ctx, i, cyc)
+          return cur if cyc == :day # D1: "this morning" is today's, even once it has passed
+          prev = Periodic.at(x, ctx, i - 1, cyc)
+          return prev if prev.any? && prev[0].b <= now && prev[0].e > now # D8: the weekend under way
+          return cur if cur.empty? || cur[0].e > now || ctx.past # D44: looking back, the one passed
+          ctx.note(THIS_PASSED)
+          merge(Periodic.first(x, ctx, i + 1, cyc) { |s| s.e > now }, cur)
+        else
+          x = TONIGHT if G::Part === x && x.name == :night # D1: last night starts at 17:00
+          # D51: said at exactly 00:00, "last night" is the calendar yesterday's, as D41 reads "tomorrow"
+          return Periodic.last(x, ctx, i, cyc) { |s| s.b < now } if now % DAY == 0 && x.equal?(TONIGHT)
+          Periodic.last(x, ctx, i, cyc) { |s| s.e <= now }
+        end
+      end
+
+      def self.under_way?(x, ctx, i, cyc, now)
+        [i - 1, i].any? do |j|
+          s = Periodic.at(x, ctx, j, cyc)[0]
+          s && s.b <= now && s.e > now
+        end
+      end
+
+      # The main readings first, then the alternatives of each
+      def self.merge(a, b)
+        out = []
+        [a.first(1), b.first(1), a.drop(1), b.drop(1)].each do |list|
+          list.each { |s| out << s unless out.any? { |o| o.b == s.b && o.e == s.e } }
+        end
+        out
+      end
+
+      # "next week", "this month", "last year"; D38 for hours and minutes; D31 for "past week"
+      def self.unit(word, u, ctx)
+        now = ctx.now_local
+        return counted(word == :this || word == :coming ? :next : word, 2, :week, ctx) if u == :fortnight # D40
+        return counted(:past, 1, u, ctx) if word == :past
+        k = word == :next || word == :coming ? 1 : word == :this ? 0 : -1
+        if u == :business_day
+          # D44: "this weekday" on a weekend is Monday
+          b = k == 0 ? Period.business(Period.day(now) * DAY - DAY, 1, ctx) : Period.business(Period.day(now) * DAY, k, ctx)
+          return [Span.new(b, b + DAY, :day, nil)]
+        end
+        cur = Period.unit(u, ctx, now)
+        b = Period.add(cur.b, k, u)
+        calendar = Span.new(b, Period.add(b, 1, u), cur.grain, nil)
+        if u == :century # D12, D44
+          ctx.note(CENTURY)
+          return [calendar, Span.new(Period.add(b, 1, :year), Period.add(calendar.e, 1, :year), cur.grain, nil)]
+        end
+        if u == :decade && k != 0 && word != :coming # D40: the ten years from now first; "this coming" is the next to start
+          rolling = k > 0 ? Span.new(now, Period.add(now, 1, u), u, nil) : Span.new(Period.add(now, -1, u), now, u, nil)
+          return [calendar] if rolling.b == calendar.b
+          ctx.note(ROLLING)
+          return [rolling, calendar]
+        end
+        # D42: not "next second", whose rolling reading would be this second
+        return [calendar] unless (u == :hour || u == :minute) && k != 0
+        ctx.note(ROLLING)
+        [k > 0 ? window(ctx, Period::SECONDS[u], u) : window(ctx, -Period::SECONDS[u], u), calendar]
+      end
+
+      # D7, D31: rolling from now first, then whole units: the next N, or the N ending with this one and the N
+      # before it
+      def self.counted(word, n, u, ctx)
+        n, u = Period.whole(n, u)
+        if u == :fortnight
+          n *= 2
+          u = :week
+        end
+        now = ctx.now_local
+        ctx.note(ROLLING)
+        if word == :next || word == :this
+          return [window(ctx, n * Period::SECONDS[u], u)] if Period::SECONDS[u]
+          out = [Span.new(now, Period.add(now, n, u, ctx), u, nil)]
+          b = Period.add(Period.unit(u, ctx, now).b, 1, u, ctx)
+          out << Span.new(b, Period.add(b, n, u, ctx), u, nil)
+        else
+          return [window(ctx, -n * Period::SECONDS[u], u)] if Period::SECONDS[u]
+          out = [Span.new(Period.add(now, -n, u, ctx), now, u, nil)]
+          cur = Period.unit(u, ctx, now).b
+          e = Period.add(cur, 1, u, ctx)
+          out << Span.new(Period.add(e, -n, u, ctx), e, u, nil) << Span.new(Period.add(cur, -n, u, ctx), cur, u, nil)
+        end
+      end
+
+      # From now to secs away, either way. D23: hours and smaller are absolute time, so "the last 48 hours" across
+      # a DST change is still 48 hours
+      def self.window(ctx, secs, unit)
+        utc = ctx.now + secs
+        t = ctx.local(utc)
+        secs > 0 ? Span.new(ctx.now_local, t, unit, nil, ctx.now, utc) : Span.new(t, ctx.now_local, unit, nil, utc, ctx.now)
+      end
+
+      # D18: "next 3pm" is the nearest one after now, "last 3pm" the nearest before
+      def self.clock(word, c, ctx)
+        return Clock.bare(c, ctx) if word == :next || word == :this
+        past = ctx.past
+        ctx.past = :back
+        out = Clock.bare(c, ctx)
+        ctx.past = past
+        out
+      end
+    end
+  end
+end

data/lib/acute/resolve/shift.rb

@@ -0,0 +1,81 @@
+module Acute
+  module Resolve
+    # "in 3 days", "2 hours ago", "a week from tomorrow", "3 business days after friday"
+    module Shift
+      FINE = { second: 0, minute: 1, hour: 2 }.freeze
+
+      # D23: hours and smaller are absolute time; days and larger are wall-clock arithmetic that keeps the
+      # time of day. With no anchor the result is an instant.
+      def self.spans(node, ctx)
+        n, u = Period.whole(node.count, node.unit)
+        unless node.anchor
+          if (len = Period::SECONDS[u])
+            utc = ctx.now + n * len
+            t = ctx.local(utc)
+            return [Span.new(t, t + 1, :second, nil, utc, utc + 1)]
+          end
+          t = Period.add(ctx.now_local, n, u, ctx)
+          return [Span.new(t, t + 1, :second, nil)]
+        end
+        len = Period::SECONDS[u]
+        Resolve.spans(node.anchor, ctx).map do |s|
+          next calendar(s, n, u, ctx) unless len
+          # D44: from the anchor's instant, at a grain no coarser than the unit
+          ub = (s.ub || ctx.zone.local_to_utc(s.b, ctx, ctx.dst_policy)) + n * len
+          grain = s.grain
+          size = s.ue ? s.ue - s.ub : s.e - s.b
+          if !(r = FINE[grain]) || r > FINE[u]
+            grain = u
+            size = len
+          end
+          Span.new(ctx.local(ub), ctx.local(ub + size), grain, nil, ub, ub + size)
+        end
+      end
+
+      RANK = { second: 0, minute: 1, hour: 2, day: 3, business_day: 3, weekend: 4, week: 4, fortnight: 4, month: 5,
+               quarter: 6, season: 6, year: 7, decade: 8, century: 9 }.freeze
+      GRAIN = { business_day: :day, fortnight: :week }.freeze
+
+      # D44: a shift in days or longer from a longer anchor counts from its start at the unit's grain ("1 day
+      # before next month"); a day or less keeps its length ("a month from today" on 28 February is 28 March)
+      def self.calendar(s, n, u, ctx)
+        b = Period.add(s.b, n, u, ctx)
+        rank = RANK.fetch(s.grain)
+        return Span.new(b, Period.add(b, 1, u, ctx), GRAIN[u] || u, nil) if rank > RANK.fetch(u)
+        return Span.new(b, b + s.e - s.b, s.grain, s.point && s.point - s.b + b) if rank <= 3
+        Span.new(b, Period.add(s.e, n, u, ctx), s.grain, s.point && Period.add(s.point, n, u, ctx))
+      end
+
+      # D44: "3 fridays from now" is the third Friday after now, not counting today's; "2 weekends ago" the
+      # second whose end has passed. One a cycle, so the nth is n - 1 cycles on from the first. From an anchor
+      # with alternatives, each gives one ("friday after next").
+      def self.counted(node, ctx)
+        n = node.n
+        return nth_from(node.node, n, ctx.now_local + (n > 0 ? 1 : 0), ctx) unless node.anchor
+        a = Resolve.spans(node.anchor, ctx)
+        return nth_from(node.node, n, n > 0 ? a[0].e : a[0].b, ctx) if a.size <= 1 && !a.empty?
+        a.flat_map { |s| nth_from(node.node, n, n > 0 ? s.e : s.b, ctx).first(1) }.uniq
+      end
+
+      # D48: one a cycle, so the n nearest lie within n cycles of the anchor's; nearest by start, the earlier
+      # on a tie
+      def self.closest(node, ctx)
+        cyc = Periodic.cycle(node.node)
+        a = Resolve.spans(node.anchor, ctx)
+        return [] if !cyc || a.empty?
+        t = a[0].b
+        i = Period.index(cyc, ctx, t)
+        all = ((i - node.n)..(i + node.n)).flat_map { |j| Periodic.at(node.node, ctx, j, cyc) }
+        all.sort_by { |s| [(s.b - t).abs, s.b] }[node.n - 1, 1] || []
+      end
+
+      def self.nth_from(x, n, t, ctx)
+        cyc = Periodic.cycle(x)
+        i = Period.index(cyc, ctx, t)
+        first = n > 0 ? Periodic.first(x, ctx, i, cyc) { |s| s.b >= t } : Periodic.last(x, ctx, i, cyc) { |s| s.e <= t }
+        return first if first.empty? || n.abs == 1
+        Periodic.at(x, ctx, Period.index(cyc, ctx, first[0].b) + n - (n <=> 0), cyc)
+      end
+    end
+  end
+end