fugit 1.3.4 → 1.3.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a10a8afb99cf16856e53766a86b1f0d13ddb0d2784c756cb525ceea8fbae7bd1
-  data.tar.gz: dcd1d01a8f5f8fc819854f430e12fc6bf69850e64060cffbe93c595be78785a2
+  metadata.gz: ff6ed980e9137d5c51dda0b2ca0a66dffb35ae99352168a50e92fadbf272442a
+  data.tar.gz: '00977091b588564591b180debb728806bce562eaf2145b413e752c2eda90652e'
 SHA512:
-  metadata.gz: 4b29f59bffe4f786b90c0f0a42c26c682e78b523183863f7cfc8c486ecca9056bb96f5eae92b2ee9446ece5c84a10aeddd9a52077eece5357af8985853da99ee
-  data.tar.gz: a32ac9539496ff7f4bc1949f97eeefcf836a8f1607569080acafd2d338befd7cb97e10179ffee06d2da3ebead95830147f5f418a883a4bd2a77f549455761788
+  metadata.gz: 1c9290c85529fefb3ec1d8c664f4dabaa0e1bbe8d9430555a1af1c5c382e15afeb9f729fbc4b9eba00bf7db0a47625daf0f12a5328743b3f25af66728bd3d0b2
+  data.tar.gz: 67e65d620ebfb16c4c9d649e61ac743691c1bb77a2573ce750d8202bf5bb4f090a8d1feb86aab362b6916de9b028c3e7e00bdad8a708d3397736ede1c14f1b61

data/CHANGELOG.md

@@ -2,6 +2,33 @@
 # CHANGELOG.md
 
 
+## fugit 1.3.9 released 2020-09-17
+
+* Prevent "New York skip", gh-43, thanks @honglooker
+
+
+## fugit 1.3.8 released 2020-08-06
+
+* Parse 'every day at 8:30' and ' at 8:30 pm', gh-42
+
+
+## fugit 1.3.7 released 2020-08-05
+
+* Parse 'every 12 hours at minute 50', gh-41
+
+
+## fugit 1.3.6 released 2020-06-01
+
+* Introduce new nat syntaxed, gh-38
+* Rework nat parser
+
+
+## fugit 1.3.5 released 2020-05-07
+
+* Implement cron @noon, gh-37
+* Normalize "every x", gh-37
+
+
 ## fugit 1.3.4 released 2020-04-06
 
 * Prevent #rough_frequency returning 0, gh-36

data/CREDITS.md

@@ -1,10 +1,13 @@
 
 # fugit credits
 
+* Honglooker https://github.com/honglooker gh-43, New York cron skip
+* Jérôme Dalbert https://github.com/jeromedalbert gh-41, gh-42
+* Danny Ben Shitrit https://github.com/DannyBen nat variants, gh-38
 * Dominik Sander https://github.com/dsander #rough_frequency 0, gh-36
 * Milovan Zogovic https://github.com/assembler Cron#match? vs TZ, gh-31
 * Jessica Stokes https://github.com/ticky 0-24 issue with cron, gh-30
-* Shai Coleman https://github.com/shaicoleman parse_nat enhancements, gh-24, gh-25, and gh-28
+* Shai Coleman https://github.com/shaicoleman parse_nat enhancements, gh-24, gh-25, gh-28, and gh-37
 * Jan Stevens https://github.com/JanStevens Fugit.parse('every 15 minutes') gh-22
 * Fabio Pitino https://github.com/hspazio nil on February 30 gh-21
 * Cristian Oneț https://github.com/conet #previous_time vs 1/-1 endless loop gh-15

data/README.md

@@ -9,7 +9,7 @@ Time tools for [flor](https://github.com/floraison/flor) and the floraison group
 
 It uses [et-orbi](https://github.com/floraison/et-orbi) to represent time instances and [raabro](https://github.com/floraison/raabro) as a basis for its parsers.
 
-Fugit is a core dependency of [rufus-scheduler](https://github.com/jmettraux/rufus-scheduler) 3.5.x.
+Fugit is a core dependency of [rufus-scheduler](https://github.com/jmettraux/rufus-scheduler) >= 3.5.
 
 
 ## Related projects
@@ -232,6 +232,29 @@ p d.to_plain_s  # => "2Y2M1D5h3600s"
 p Fugit::Duration.parse('1y2M1d4h').to_sec # => 36820800
 ```
 
+There is a `#deflate` method
+
+```ruby
+Fugit::Duration.parse(1000).to_plain_s # => "1000s"
+Fugit::Duration.parse(3600).to_plain_s # => "3600s"
+Fugit::Duration.parse(1000).deflate.to_plain_s # => "16m40s"
+Fugit::Duration.parse(3600).deflate.to_plain_s # => "1h"
+
+# or event shorter
+Fugit.parse(1000).deflate.to_plain_s # => "16m40s"
+Fugit.parse(3600).deflate.to_plain_s # => "1h"
+```
+
+There is also an `#inflate` method
+
+```ruby
+Fugit::Duration.parse('1h30m12').inflate.to_plain_s # => "5412s"
+Fugit.parse('1h30m12').inflate.to_plain_s # => "5412s"
+
+Fugit.parse('1h30m12').to_sec # => 5412
+Fugit.parse('1h30m12').to_sec.to_s + 's' # => "5412s"
+```
+
 The `to_*_s` methods are also available as class methods:
 ```ruby
 p Fugit::Duration.to_plain_s('1y2M1d4h')

data/fugit.gemspec

@@ -40,7 +40,7 @@ Time tools for flor and the floraison project. Cron parsing and occurrence compu
   #s.add_runtime_dependency 'tzinfo'
     # this dependency appears in 'et-orbi'
 
-  s.add_runtime_dependency 'raabro', '~> 1.1'
+  s.add_runtime_dependency 'raabro', '~> 1.3'
   s.add_runtime_dependency 'et-orbi', '~> 1.1', '>= 1.1.8'
 
   s.add_development_dependency 'rspec', '~> 3.8'

data/lib/fugit.rb

@@ -1,7 +1,7 @@
 
 module Fugit
 
-  VERSION = '1.3.4'
+  VERSION = '1.3.9'
 end
 
 require 'time'

data/lib/fugit/cron.rb

@@ -11,6 +11,7 @@ module Fugit
       '@weekly' => '0 0 * * 0',
       '@daily' => '0 0 * * *',
       '@midnight' => '0 0 * * *',
+      '@noon' => '0 12 * * *',
       '@hourly' => '0 * * * *' }
     MAXDAYS = [
       nil, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ]
@@ -235,6 +236,8 @@ module Fugit
         # the translation occurs in the timezone of
         # this Fugit::Cron instance
 
+      zfrom = t.time.strftime('%z|%Z')
+
       loop do
 
         fail RuntimeError.new(
@@ -250,8 +253,14 @@ module Fugit
         min_match?(t) || (t.inc_min; next)
         sec_match?(t) || (t.inc_sec; next)
 
-        st = t.time.strftime('%F|%T')
-        (from, sfrom, ifrom = t.time, st, t.to_i; next) if st == sfrom
+        tt = t.time
+        st = tt.strftime('%F|%T')
+        zt = tt.strftime('%z|%Z')
+          #
+        if st == sfrom && zt != zfrom
+          from, sfrom, zfrom, ifrom = tt, st, zt, t.to_i
+          next
+        end
           #
           # when transitioning out of DST, this prevents #next_time from
           # yielding the same literal time twice in a row, see gh-6
@@ -756,7 +765,7 @@ module Fugit
 
       def rewrite_tz(t)
 
-        s = t.string.strip
+        s = t.strim
         z = EtOrbi.get_tzone(s)
 
         [ s, z ]

data/lib/fugit/nat.rb

@@ -15,16 +15,8 @@ module Fugit
         return nil unless s.is_a?(String)
 
 #p s; Raabro.pp(Parser.parse(s, debug: 3), colours: true)
-        a = Parser.parse(s)
-
-        return nil unless a
-
-        return parse_crons(s, a, opts) \
-          if a.include?([ :flag, 'every' ])
-        return parse_crons(s, a, opts) \
-          if a.include?([ :flag, 'from' ]) && a.find { |e| e[0] == :day_range }
-
-        nil
+#(p s; Raabro.pp(Parser.parse(s, debug: 1), colours: true)) rescue nil
+        parse_crons(s, Parser.parse(s), opts)
       end
 
       def do_parse(s, opts={})
@@ -37,20 +29,37 @@ module Fugit
 
       def parse_crons(s, a, opts)
 
-        dhs, aa = a
-          .partition { |e| e[0] == :digital_hour }
-        ms = dhs
-          .inject({}) { |h, dh| (h[dh[1][0]] ||= []) << dh[1][1]; h }
-          .values
+#p a
+        return nil unless a
+
+        h = a
+          .reverse
+          .inject({}) { |r, e| send("parse_#{e[0]}_elt", e, opts, r); r }
+            #
+            # the reverse ensure that in "every day at five", the
+            # "at five" is placed before the "every day" so that
+            # parse_x_elt calls have the right sequence
+#p h
+
+        if f = h[:_fail]
+          #fail ArgumentError.new(f)
+          return nil
+        end
+
+        hms = h[:hms]
+
+        hours = (hms || [])
           .uniq
+          .inject({}) { |r, hm| (r[hm[1]] ||= []) << hm[0]; r }
+          .inject({}) { |r, (m, hs)| (r[hs.sort] ||= []) << m; r }
+          .to_a
+          .sort_by { |hs, ms| -hs.size }
+        if hours.empty?
+          hours << (h[:dom] ? [ [ '0' ], [ '0' ] ] : [ [ '*' ], [ '*' ] ])
+        end
 
-        crons =
-          #if ms.size <= 1 || hs.size <= 1
-          if ms.size <= 1
-            [ parse_cron(a, opts) ]
-          else
-            dhs.collect { |dh| parse_cron([ dh ] + aa, opts) }
-          end
+        crons = hours
+          .collect { |hm| assemble_cron(h.merge(hms: hm)) }
 
         fail ArgumentError.new(
           "multiple crons in #{s.inspect} " +
@@ -64,207 +73,461 @@ module Fugit
         end
       end
 
-      def parse_cron(a, opts)
-
-        h = { min: nil, hou: [], dom: nil, mon: nil, dow: nil }
-        hkeys = h.keys
-
-        a.each do |key, val|
-          if key == :biz_day
-            (h[:dow] ||= []) << '1-5'
-          elsif key == :simple_hour || key == :numeral_hour
-            h[:hou] << val
-          elsif key == :digital_hour
-            (h[:hou] ||= []) << val[0].to_i
-            (h[:min] ||= []) << val[1].to_i
-          elsif key == :name_day
-            (h[:dow] ||= []) << val
-          elsif key == :day_range
-            (h[:dow] ||= []) << val.collect { |v| v.to_s[0, 3] }.join('-')
-          elsif key == :tz
-            h[:tz] = val
-          elsif key == :duration
-            process_duration(h, *val[0].to_h.first)
-          end
-        end
+      def assemble_cron(h)
 
-        h[:min] ||= [ 0 ]
-        h[:min].uniq!
+#puts "ac: " + h.inspect
+        s = []
+        s << h[:sec] if h[:sec]
+        s << h[:hms][1].join(',')
+        s << h[:hms][0].join(',')
+        s << (h[:dom] || '*') << (h[:mon] || '*') << (h[:dow] || '*')
+        s << h[:tz] if h[:tz]
 
-        h[:hou].uniq!;
-        h[:hou].sort!
+        Fugit::Cron.parse(s.join(' '))
+      end
 
-        h[:dow].sort! if h[:dow]
+      def eone(e); e1 = e[1]; e1 == 1 ? '*' : "*/#{e1}"; end
 
-        a = hkeys
-          .collect { |k|
-            v = h[k]
-            (v && v.any?) ? v.collect(&:to_s).join(',') : '*' }
-        a.insert(0, h[:sec]) if h[:sec]
-        a << h[:tz].first if h[:tz]
+      def parse_interval_elt(e, opts, h)
 
-        s = a.join(' ')
+        e1 = e[1]
 
-        Fugit::Cron.parse(s)
+        case e[2]
+        when 's', 'sec', 'second', 'seconds'
+          h[:sec] = eone(e)
+        when 'm', 'min', 'mins', 'minute', 'minutes'
+          h[:hms] ||= [ [ '*', eone(e) ] ]
+        when 'h', 'hour', 'hours'
+          hms = h[:hms]
+          if hms && hms.size == 1 && hms.first.first == '*'
+            hms.first[0] = eone(e)
+          elsif ! hms
+            h[:hms] = [ [ eone(e), 0 ] ]
+          end
+        when 'd', 'day', 'days'
+          h[:dom] = "*/#{e1}" if e1 > 1
+          h[:hms] ||= [ [ 0, 0 ] ]
+        when 'w', 'week', 'weeks'
+          h[:_fail] = "cannot have crons for \"every #{e1} weeks\"" if e1 > 1
+          h[:hms] ||= [ [ 0, 0 ] ]
+          h[:dow] ||= 0
+        when 'M', 'month', 'months'
+          h[:_fail] = "cannot have crons for \"every #{e1} months\"" if e1 > 12
+          h[:hms] ||= [ [ 0, 0 ] ]
+          h[:dom] = 1
+          h[:mon] = eone(e)
+        when 'Y', 'y', 'year', 'years'
+          h[:_fail] = "cannot have crons for \"every #{e1} years\"" if e1 > 1
+          h[:hms] ||= [ [ 0, 0 ] ]
+          h[:dom] = 1
+          h[:mon] = 1
+        end
       end
 
-      def process_duration(h, interval, value)
+      def parse_dow_list_elt(e, opts, h)
 
-        send("process_duration_#{interval}", h, value)
+        h[:hms] ||= [ [ 0, 0 ] ]
+        h[:dow] = e[1..-1].collect(&:to_s).sort.join(',')
       end
 
-      def process_duration_mon(h, value)
+      def parse_dow_range_elt(e, opts, h)
 
-        h[:hou] = [ 0 ]
-        h[:dom] = [ 1 ]
-        h[:mon] = [ value == 1 ? '*' : "*/#{value}" ]
+        h[:hms] ||= [ [ 0, 0 ] ]
+        h[:dow] = e[1] == e[2] ? e[1] : "#{e[1]}-#{e[2]}"
       end
 
-      def process_duration_day(h, value)
+      def parse_day_of_month_elt(e, opts, h)
 
-        h[:hou] = [ 0 ]
-        h[:dom] = [ value == 1 ? '*' : "*/#{value}" ]
+        h[:dom] = e[1..-1].join(',')
       end
 
-      def process_duration_hou(h, value)
+      def parse_at_elt(e, opts, h)
 
-        h[:hou] = [ value == 1 ? '*' : "*/#{value}" ]
+        (h[:hms] ||= []).concat(e[1])
+
+        l = h[:hms].last
+        h[:sec] = l.pop if l.size > 2
       end
 
-      def process_duration_min(h, value)
+      def parse_on_elt(e, opts, h)
+
+        e1 = e[1]
+        h[:dow] = e1[0]
+        h[:hms] = [ e1[1] ]
 
-        h[:hou] = [ '*' ]
-        h[:min] = [ value == 1 ? '*' : "*/#{value}" ]
+        l = h[:hms].last
+        h[:sec] = l.pop if l.size > 2
       end
 
-      def process_duration_sec(h, value)
+      def parse_tz_elt(e, opts, h)
 
-        h[:hou] = [ '*' ]
-        h[:min] = [ '*' ]
-        h[:sec] = [ value == 1 ? '*' : "*/#{value}" ]
+        h[:tz] = e[1]
       end
     end
 
     module Parser include Raabro
 
       NUMS = %w[
-        zero
-        one two three four five six seven eight nine
-        ten eleven twelve ]
+        zero one two three four five six seven eight nine ten eleven twelve ]
 
       WEEKDAYS =
         Fugit::Cron::Parser::WEEKDS + Fugit::Cron::Parser::WEEKDAYS
 
-      NHOURS =
-        { 'noon' => [ 12, 0 ], 'midnight' => [ 0, 0 ] }
+      NHOURS = {
+        'noon' => [ 12, 0 ],
+        'midnight' => [ 0, 0 ], 'oh' => [ 0, 0 ] }
+      NMINUTES = {
+        "o'clock" => 0, 'five' => 5,
+        'ten' => 10, 'fifteen' => 15,
+        'twenty' => 20, 'twenty-five' => 25,
+        'thirty' => 30, 'thirty-five' => 35,
+        'fourty' => 40, 'fourty-five' => 45,
+        'fifty' => 50, 'fifty-five' => 55 }
+
+      oh = {
+        '1st' => 1, '2nd' => 2, '3rd' => 3, '21st' => 21, '22nd' => 22,
+        '23rd' => 23, '31st' => 31 }
+      %w[ 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 24 25 26 27 28 29 30 ]
+        .each { |i| oh["#{i}th"] = i.to_i }
+      %w[
+        first second third fourth fifth sixth seventh eighth ninth tenth
+        eleventh twelfth thirteenth fourteenth fifteenth sixteenth seventeenth
+        eighteenth nineteenth twentieth twenty-first twenty-second twenty-third
+        twenty-fourth twenty-fifth twenty-fifth twenty-sixth twenty-seventh
+        twenty-eighth twenty-ninth thirtieth thirty-first ]
+          .each_with_index { |e, i| oh[e] = i + 1 }
+      ORDINALS = oh
 
       # piece parsers bottom to top
 
+      def _from(i); rex(nil, i, /\s*from\s+/i); end
+      def _every(i); rex(nil, i, /\s*(every)\s+/i); end
+      def _at(i); rex(nil, i, /\s*at\s+/i); end
+      def _in(i); rex(nil, i, /\s*(in|on)\s+/i); end
+      def _to(i); rex(nil, i, /\s*to\s+/i); end
+      def _dash(i); rex(nil, i, /-\s*/i); end
+      def _and(i); rex(nil, i, /\s*and\s+/i); end
+      def _on(i); rex(nil, i, /\s*on\s+/i); end
+
+      def _and_or_comma(i)
+        rex(nil, i, /\s*(,?\s*and\s|,?\s*or\s|,)\s*/i)
+      end
+      def _at_comma(i)
+        rex(nil, i, /\s*(at\s|,|)\s*/i)
+      end
+      def _to_through(i)
+        rex(nil, i, /\s*(to|through)\s+/i)
+      end
+
+      def integer(i); rex(:int, i, /\d+\s*/); end
+
+      def tz_name(i)
+        rex(nil, i,
+          /\s*[A-Z][a-zA-Z0-9+\-]+(\/[A-Z][a-zA-Z0-9+\-_]+){0,2}(\s+|$)/)
+      end
+      def tz_delta(i)
+        rex(nil, i,
+          /\s*[-+]([01][0-9]|2[0-4]):?(00|15|30|45)(\s+|$)/)
+      end
+      def tzone(i)
+        alt(:tzone, i, :tz_delta, :tz_name)
+      end
+
+      def and_named_digits(i)
+rex(:xxx, i, 'TODO')
+      end
+
+      def dname(i)
+        rex(:dname, i, /(s(ec(onds?)?)?|m(in(utes?)?)?)\s+/i)
+      end
+      def named_digit(i)
+        seq(:named_digit, i, :dname, :integer)
+      end
+      def named_digits(i)
+        seq(nil, i, :named_digit, '+', :and_named_digits, '*')
+      end
+
       def am_pm(i)
-        rex(:am_pm, i, / *(am|pm)/i)
+        rex(:am_pm, i, /\s*(am|pm|dark)\s*/i)
       end
 
-      def digital_hour(i)
-        rex(:digital_hour, i, /(2[0-4]|[01][0-9]):?[0-5]\d/)
+      def nminute(i)
+        rex(:nminute, i, /(#{NMINUTES.keys.join('|')})\s*/i)
+      end
+      def nhour(i)
+        rex(:nhour, i, /(#{NUMS.join('|')})\s*/i)
+      end
+      def numeral_hour(i)
+        seq(:numeral_hour, i, :nhour, :am_pm, '?', :nminute, '?')
+      end
+
+      def named_hour(i)
+        rex(:named_hour, i, /(#{NHOURS.keys.join('|')})/i)
       end
 
-      def _simple_hour(i)
-        rex(:sh, i, /(2[0-4]|[01]?[0-9])/)
+      def shour(i)
+        rex(:shour, i, /(2[0-4]|[01]?[0-9])/)
       end
       def simple_hour(i)
-        seq(:simple_hour, i, :_simple_hour, :am_pm, '?')
+        seq(:simple_hour, i, :shour, :am_pm, '?')
       end
 
-      def _numeral_hour(i)
-        rex(:nh, i, /(#{NUMS.join('|')})/i)
+      def dig_hour_b(i); rex(nil, i, /(2[0-4]|[01][0-9]|[0-9]):[0-5]\d/); end
+      def dig_hour_a(i); rex(nil, i, /(2[0-4]|[01][0-9])[0-5]\d/); end
+      def dig_hour(i); alt(nil, i, :dig_hour_a, :dig_hour_b); end
+        #
+      def digital_hour(i)
+        seq(:digital_hour, i, :dig_hour, :am_pm, '?')
       end
-      def numeral_hour(i)
-        seq(:numeral_hour, i, :_numeral_hour, :am_pm, '?')
+
+      def at_point(i)
+        alt(nil, i,
+          :digital_hour, :simple_hour, :named_hour, :numeral_hour,
+          :named_digits)
       end
 
-      def name_hour(i)
-        rex(:name_hour, i, /(#{NHOURS.keys.join('|')})/i)
+      def weekday(i)
+        rex(:weekday, i, /(#{WEEKDAYS.reverse.join('|')})\s*/i)
       end
 
-      def plain_day(i); rex(:plain_day, i, /day/i); end
-      def biz_day(i); rex(:biz_day, i, /(biz|business|week) *day/i); end
-      def name_day(i); rex(:name_day, i, /#{WEEKDAYS.reverse.join('|')}/i); end
+      def and_at(i)
+        seq(nil, i, :_and_or_comma, :at_point)
+      end
 
-      def range_sep(i); rex(nil, i, / *- *| +(to|through) +/); end
+      def _intervals(i)
+        rex(:intervals, i,
+          /(
+            y(ears?)?|months?|w(eeks?)?|d(ays?)?|
+            h(ours?)?|m(in(ute)?s?)?|s(ec(ond)?s?)?
+          )(\s+|$)/ix)
+      end
 
-      def day_range(i)
-        seq(:day_range, i, :name_day, :range_sep, :name_day)
+      def sinterval(i)
+        rex(:sinterval, i,
+          /(year|month|week|day|hour|min(ute)?|sec(ond)?)(\s+|$)/i)
+      end
+      def ninterval(i)
+        seq(:ninterval, i, :integer, :_intervals)
       end
 
-      def _tz_name(i)
-        rex(nil, i, /[A-Z][a-zA-Z0-9+\-]+(\/[A-Z][a-zA-Z0-9+\-_]+){0,2}/)
+      def ordinal(i)
+        rex(:ordinal, i, /\s*(#{ORDINALS.keys.join('|')})\s*/)
       end
-      def _tz_delta(i)
-        rex(nil, i, /[-+]([01][0-9]|2[0-4]):?(00|15|30|45)/)
+
+      def _mod(i); rex(nil, i, /\s*month\s+on\s+days?\s+/i); end
+      def _oftm(i); rex(nil, i, /\s*(day\s)?\s*of\s+the\s+month\s*/i); end
+
+      def dom(i)
+        rex(:int, i, /([12][0-9]|3[01]|[0-9])/)
+      end
+      def and_or_dom(i)
+        seq(nil, i, :_and_or_comma, :dom)
+      end
+      def dom_list(i)
+        seq(:dom_list, i, :dom, :and_or_dom, '*')
       end
-      def _tz(i); alt(:tz, i, :_tz_delta, :_tz_name); end
 
-      def duration(i)
-        rex(
-          :duration, i,
-          /
-            \d+
-            \s?
-            (mon(ths?)?|d(ays?)?|h(ours?)?|m(in(ute)?s?)?|s(ec(ond)?s?)?)
-          /ix)
+      def dom_mod(i) # every month on day
+        seq(:dom, i, :_mod, :dom_list)
+      end
+      def dom_noftm(i) # every nth of month
+        seq(:dom, i, :ordinal, :_oftm)
+      end
+      def day_of_month(i)
+        alt(nil, i, :dom_noftm, :dom_mod)
       end
 
-      def flag(i); rex(:flag, i, /(every|from|at|after|on|in)/i); end
+      def dow_class(i)
+        rex(:dow_class, i, /(weekday)(\s+|$)/i)
+      end
 
-      def datum(i)
-        alt(nil, i,
-          :day_range,
-          :plain_day, :biz_day, :name_day,
-          :_tz,
-          :flag,
-          :duration,
-          :name_hour, :numeral_hour, :digital_hour, :simple_hour)
+      def dow(i)
+        seq(:dow, i, :weekday)
+      end
+      def and_or_dow(i)
+        seq(nil, i, :_and_or_comma, :dow)
+      end
+      def dow_list(i)
+        seq(:dow_list, i, :dow, :and_or_dow, '*')
+      end
+
+      def to_dow_range(i)
+        seq(:dow_range, i, :weekday, :_to_through, :weekday)
+      end
+      def dash_dow_range(i)
+        seq(:dow_range, i, :weekday, :_dash, :weekday)
+      end
+      def dow_range(i)
+        alt(nil, i, :to_dow_range, :dash_dow_range)
+      end
+
+      def day_of_week(i)
+        alt(nil, i, :dow_range, :dow_list, :dow_class)
+      end
+
+      def interval(i)
+        alt(nil, i, :sinterval, :ninterval)
+      end
+
+      def every_object(i)
+        alt(nil, i, :day_of_month, :interval, :day_of_week)
+      end
+      def from_object(i)
+        alt(nil, i, :interval, :to_dow_range)
+      end
+
+      def tz(i)
+        seq(nil, i, :_in, '?', :tzone)
+      end
+      def on(i)
+        seq(:on, i, :_on, :weekday, :at_point, :and_at, '*')
+      end
+      def at(i)
+        seq(:at, i, :_at_comma, :at_point, :and_at, '*')
+      end
+      def from(i)
+        seq(:from, i, :_from, :from_object)
+      end
+      def every(i)
+        seq(:every, i, :_every, :every_object)
+      end
+
+      def at_from(i)
+        seq(nil, i, :at, :from, :tz, '?')
+      end
+      def at_every(i)
+        seq(nil, i, :at, :every, :tz, '?')
+      end
+
+      def from_at(i)
+        seq(nil, i, :from, :at, '?', :tz, '?')
       end
 
-      def sugar(i); rex(nil, i, /(and|or|[, \t]+)/i); end
+      def every_(i)
+        seq(nil, i, :every, :tz, '?')
+      end
+      def every_on(i)
+        seq(nil, i, :every, :on, :tz, '?')
+      end
+      def every_at(i)
+        seq(nil, i, :every, :at, :tz, '?')
+      end
 
-      def elt(i); alt(nil, i, :sugar, :datum); end
-      def nat(i); rep(:nat, i, :elt, 1); end
+      def nat(i)
+        alt(:nat, i,
+          :every_at, :every_on, :every_,
+          :from_at,
+          :at_every, :at_from)
+      end
 
       # rewrite parsed tree
 
-      def rewrite_nat(t)
+      #def _rewrite_single(t)
+      #  [ t.name, rewrite(t.sublookup(nil)) ]
+      #end
+      def _rewrite_children(t)
+        t.subgather(nil).collect { |tt| rewrite(tt) }
+      end
+      def _rewrite_multiple(t)
+        [ t.name, _rewrite_children(t) ]
+      end
+      def _rewrite_child(t)
+        rewrite(t.sublookup(nil))
+      end
+
+      def rewrite_int(t); t.string.to_i; end
+
+      def rewrite_tzone(t)
+
+        [ :tz, t.strim ]
+      end
+
+      def rewrite_sinterval(t)
+
+        [ :interval, 1, t.strim ]
+      end
+
+      def rewrite_ninterval(t)
+
+        [ :interval,
+          t.sublookup(:int).string.to_i,
+          t.sublookup(:intervals).strim ]
+      end
+
+      def rewrite_named_digit(t)
+
+        i = t.sublookup(:int).string.to_i
+
+        case n = t.sublookup(:dname).strim
+        when /^s/ then [ '*', '*', i ]
+        when /^m/ then [ '*', i ]
+        end
+      end
+
+      def rewrite_named_hour(t)
+        NHOURS[t.strim.downcase]
+      end
+      def rewrite_numeral_hour(t)
+        vs = t.subgather(nil).collect { |st| st.strim.downcase }
+        v = NUMS.index(vs[0])
+        v += 12 if vs[1] == 'pm'
+        m = NMINUTES[vs[2]] || 0
+        [ v, m ]
+      end
+      def rewrite_simple_hour(t)
+        vs = t.subgather(nil).collect { |st| st.strim.downcase }
+        v = vs[0].to_i
+        v += 12 if vs[1] == 'pm'
+        [ v, 0 ]
+      end
+      def rewrite_digital_hour(t)
+        m = t.string.match(/(\d\d?):?(\d\d)(\s+pm)?/i)
+        hou = m[1].to_i; hou += 12 if m[3] && hou < 12
+        min = m[2].to_i
+        [ hou, min ]
+      end
+
+      def rewrite_weekday(t)
+
+        WEEKDAYS.index(t.strim.downcase[0, 3])
+      end
+
+      def rewrite_ordinal(t); ORDINALS[t.strim]; end
+
+      def rewrite_dom(t)
 
 #Raabro.pp(t, colours: true)
-        t
-          .subgather(nil)
-          .collect { |tt|
-
-            k = tt.name
-            v = tt.string.downcase
-
-            case k
-            when :tz
-              [ k, [ tt.string.strip, EtOrbi.get_tzone(tt.string.strip) ] ]
-            when :duration
-              [ k, [ Fugit::Duration.parse(tt.string.strip) ] ]
-            when :digital_hour
-              v = v.gsub(/:/, '')
-              [ k, [ v[0, 2], v[2, 2] ] ]
-            when :name_hour
-              [ :digital_hour, NHOURS[v] ]
-            when :name_day
-              [ k, WEEKDAYS.index(v[0, 3]) ]
-            when :day_range
-              [ k, tt.subgather(nil).collect { |st| st.string.downcase } ]
-            when :numeral_hour, :simple_hour
-              vs = tt.subgather(nil).collect { |ttt| ttt.string.downcase.strip }
-              v = k == :simple_hour ? vs[0].to_i : NUMS.index(vs[0])
-              v += 12 if vs[1] == 'pm'
-              [ k, v ]
-            else
-              [ k, v ]
-            end }
+        [ :day_of_month,
+          *_rewrite_children(t).flatten.select { |e| e.is_a?(Integer) } ]
+      end
+
+      alias rewrite_dow _rewrite_child
+
+      def rewrite_dom_list(t); [ :dom_list, *_rewrite_children(t) ]; end
+      def rewrite_dow_list(t); [ :dow_list, *_rewrite_children(t) ]; end
+
+      def rewrite_dow_class(t)
+
+        [ :dow_range, 1, 5 ] # only "weekday" for now
+      end
+
+      def rewrite_dow_range(t)
+
+        tts = t.subgather(nil)
+
+        [ :dow_range, rewrite(tts[0]), rewrite(tts[1]) ]
+      end
+
+      alias rewrite_on _rewrite_multiple
+      alias rewrite_at _rewrite_multiple
+
+      alias rewrite_from _rewrite_child
+      alias rewrite_every _rewrite_child
+
+      def rewrite_nat(t)
+
+        t.subgather(nil).collect { |tt| rewrite(tt) }
+#.tap { |x| pp x }
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fugit
 version: !ruby/object:Gem::Version
-  version: 1.3.4
+  version: 1.3.9
 platform: ruby
 authors:
 - John Mettraux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-05 00:00:00.000000000 Z
+date: 2020-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: raabro
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: et-orbi
   requirement: !ruby/object:Gem::Requirement
@@ -117,7 +117,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: time tools for flor