fugit 1.3.3 → 1.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0e67fe1fbf7a5e0213b828cc78c59d6cf5b36a6e
-  data.tar.gz: 920ea06ef202094e9b1c9c719fb06c55e0926b51
+SHA256:
+  metadata.gz: 86abe0dec557524b3ae8c7947f48ab15a52e49b240ecdb3f4103c916348e6e4c
+  data.tar.gz: d440e0d52d49b6ad2893b05c269b7c6f96936cfcb4a3904750b3204568d2344a
 SHA512:
-  metadata.gz: d6f4c28d4e280b73a0b5a3c6bae84e328e06fa33cb573bc8fc1a3660e1c921dd666c793fd17a18f10bc4d630d5db2473c2d75659def60bb6fd7342c9e3dfbb51
-  data.tar.gz: 40ae39ba32717fcc2d0148d2e4a63a2cd179fa61ef5de13670057021b77a95c9bec1ae7f299a3117602e63a1b02c5b1de683748ef793fa74ec394a4a7861992c
+  metadata.gz: 13fe87e6bc9d37cf3822c1bed665651be254b8e4a3d262f20950dc6f14d6170495721a0cd79ca8324b35048d90ce71d996b654f23da2b4780df536b9f4bd8071
+  data.tar.gz: 2623e274a96a689639fbbbcc22f77bc86f8bcc0f49644e459673a54eadfd39deecf8158b85948b6969339b7d6c9e2554537aa4c6575f63a56fd0333626b0ed88

data/CHANGELOG.md

@@ -2,6 +2,33 @@
 # CHANGELOG.md
 
 
+## 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
+
+
 ## fugit 1.3.3 released 2019-08-29
 
 * Fix Cron#match?(t) with respect to the cron's timezone, gh-31

data/CREDITS.md

@@ -1,9 +1,12 @@
 
 # fugit credits
 
+* 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/LICENSE.txt

@@ -1,5 +1,5 @@
 
-Copyright (c) 2017-2019, John Mettraux, jmettraux+flor@gmail.com
+Copyright (c) 2017-2020, John Mettraux, jmettraux+flor@gmail.com
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/Makefile

@@ -31,7 +31,7 @@ build: gemspec_validate
 	mv $(NAME)-$(VERSION).gem pkg/
 
 push: build
-	gem push pkg/$(NAME)-$(VERSION).gem
+	gem push --otp "$(OTP)" pkg/$(NAME)-$(VERSION).gem
 
 spec:
 	bundle exec rspec

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
@@ -36,6 +36,7 @@ The intersection of those two projects is where fugit is born:
 * [rufus-scheduler](https://github.com/jmettraux/rufus-scheduler) -
 * [flor](https://github.com/floraison/flor) - used in the [cron](https://github.com/floraison/flor/blob/master/doc/procedures/cron.md) procedure
 * [que-scheduler](https://github.com/hlascelles/que-scheduler) - a reliable job scheduler for [que](https://github.com/chanks/que)
+* [serial_scheduler](https://github.com/grosser/serial_scheduler) - ruby task scheduler without threading
 * ...
 
 ## `Fugit.parse(s)`
@@ -137,6 +138,49 @@ Example of cron strings understood by fugit:
 # and more...
 ```
 
+### the first Monday of the month
+
+Fugit tries to follow the `man 5 crontab` documentation.
+
+There is a surprising thing about this canon, all the columns are joined by ANDs, except for monthday and weekday which are joined together by OR if they are both set (they are not `*`).
+
+Many people (me included) [are suprised](https://superuser.com/questions/428807/run-a-cron-job-on-the-first-monday-of-every-month) when they try to specify "at 05:00 on the first Monday of the month" as `0 5 1-7 * 1` or `0 5 1-7 * mon` and the results are off.
+
+The man page says:
+
+> Note: The day of a command's execution can be specified by
+> two fields -- day of month, and day of week. If both fields
+> are restricted (ie, are not *), the command will be run when
+> either field matches the current time.
+> For example, ``30 4 1,15 * 5'' would cause a command to be run
+> at 4:30 am on the 1st and 15th of each month, plus every Friday.
+
+Fugit follows this specification.
+
+There is a solution though, please read on.
+
+### the hash extension
+
+Fugit understands `0 5 * * 1#1` or `0 5 * * mon#1` as "each first Monday of the month, at 05:00".
+
+```ruby
+'0 5 * * 1#1'    #
+'0 5 * * mon#1'  # the first Monday of the month at 05:00
+
+'0 6 * * 5#4,5#5'      #
+'0 6 * * fri#4,fri#5'  # the 4th and 5th Fridays of the month at 06:00
+
+'0 7 * * 5#-1'    #
+'0 7 * * fri#-1'  # the last Friday of the month at 07:00
+
+'0 7 * * 5#L'       #
+'0 7 * * fri#L'     #
+'0 7 * * 5#last'    #
+'0 7 * * fri#last'  # the last Friday of the month at 07:00
+
+'0 23 * * mon#2,tue'  # the 2nd Monday of the month and every Tuesday, at 23:00
+```
+
 ### the modulo extension
 
 Fugit, since 1.1.10, also understands cron strings like "`9 0 * * sun%2`" which can be read as "every other Sunday at 9am".
@@ -145,7 +189,7 @@ For odd Sundays, one can write `9 0 * * sun%2+1`.
 
 It can be combined, as in `9 0 * * sun%2,tue%3+2`
 
-But what does it references to? It starts at 1 on 2019-01-01.
+But what does it reference to? It starts at 1 on 2019-01-01.
 
 ```ruby
 require 'et-orbi' # >= 1.1.8
@@ -188,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.3'
+  VERSION = '1.3.8'
 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 ]
@@ -188,6 +189,17 @@ module Fugit
 
       return weekday_match?(nt) || monthday_match?(nt) \
         if @weekdays && @monthdays
+          #
+          # From `man 5 crontab`
+          #
+          # Note: The day of a command's execution can be specified
+          # by two fields -- day of month, and day of week.
+          # If both fields are restricted (ie, are not *), the command will be
+          # run when either field matches the current time.
+          # For example, ``30 4 1,15 * 5'' would cause a command to be run
+          # at 4:30 am on the 1st and 15th of each month, plus every Friday.
+          #
+          # as seen in gh-5 and gh-35
 
       return false unless weekday_match?(nt)
       return false unless monthday_match?(nt)
@@ -336,6 +348,7 @@ module Fugit
         return (a + [ a.first + v1 ])
           .each_cons(2)
           .collect { |a0, a1| a1 - a0 }
+          .select { |d| d > 0 } # weed out zero deltas
           .min * v0
       end
 
@@ -744,7 +757,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.3
+  version: 1.3.8
 platform: ruby
 authors:
 - John Mettraux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-29 00:00:00.000000000 Z
+date: 2020-08-06 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,8 +117,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: time tools for flor