fugit 1.3.1 → 1.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: b6c020a2dc2dea8ee73eae196c502e1353839f84
-  data.tar.gz: d4d43e932e0e4de4d07d402db975bf2a642df687
+SHA256:
+  metadata.gz: 90b61604e15e2cb24d4fb124306affea15a644c2591fc3a49649981616351d66
+  data.tar.gz: 235eec423691346077fd9cfdaed895e28843ecf6681b5aa00a83cfcf9ca711a3
 SHA512:
-  metadata.gz: 7c7f5319195ca991c848826b336023f429fc21ad033b26d67b7011872b91d1e9f8fb639b2618eda9dd1e199d7e473599e356924f302bb5cbaba20817aa6ab050
-  data.tar.gz: 4358df79feebbdb50509b78735fad8210d5c3d001d6a0b3d5a85aa375be08605816ea87510abc8188b5e42d091cd4d47af91a18061d956dc10a115fd9397c7eb
+  metadata.gz: 1fd5abf6871b1cb60220bf7d6089be6bff48dfae80a05db6d031def126275940d50cbc5dfcaad493f2b6d327b66162c2a44329966459bfb3d9d5b912e3b7e68c
+  data.tar.gz: '08a846fcce60834f8f0c289e14317249123f1f4028c478953ed04f759e633080c4d843f55c56fb973a104e1b44bbbbc92eecc978a954d7b0b317d7b23b82611b'

data/CHANGELOG.md

@@ -2,6 +2,33 @@
 # CHANGELOG.md
 
 
+## 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
+
+
+## fugit 1.3.2 released 2019-08-14
+
+* Allow for "* 0-24 * * *", gh-30
+
+
 ## fugit 1.3.1 released 2019-07-27
 
 * Fix nat parsing for 'every day at 18:00 and 18:15', gh-29

data/CREDITS.md

@@ -1,7 +1,11 @@
 
 # fugit credits
 
-* Shai Coleman https://github.com/shaicoleman parse_nat enhancements, gh-24, gh-25, and gh-28
+* 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, 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

@@ -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)`
@@ -63,7 +64,7 @@ Fugit.parse('nada')
 ## `Fugit.do_parse(s)`
 
 `Fugit.do_parse(s)` is equivalent to `Fugit.parse(s)`, but instead of returning nil, it raises an error if the given string contains no time information.
-```
+```ruby
 Fugit.do_parse('nada')
   # ==> /home/jmettraux/w/fugit/lib/fugit/parse.rb:32
   #     :in `do_parse': found no time information in "nada" (ArgumentError)
@@ -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
@@ -184,10 +228,35 @@ p d.to_long_s  # => "2 years, 2 months, 1 day, and 5 hours"
 d += 3600
 
 p d.to_plain_s  # => "2Y2M1D5h3600s"
+
+p Fugit::Duration.parse('1y2M1d4h').to_sec # => 36820800
 ```
 
-The `to_*_s` methods are also available as class methods:
+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')
   # => "1Y2M1D4h"
 p Fugit::Duration.to_iso_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.1'
+  VERSION = '1.3.6'
 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)
@@ -197,7 +209,7 @@ module Fugit
 
     def match?(t)
 
-      t = Fugit.do_parse_at(t)
+      t = Fugit.do_parse_at(t).translate(@timezone)
 
       month_match?(t) && day_match?(t) &&
       hour_match?(t) && min_match?(t) && sec_match?(t)
@@ -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
 
@@ -497,23 +510,28 @@ module Fugit
 
       loop do
 
-#p({ cur: cur })
         a << cur
         break if cur == edn
 
         cur += 1
-        cur = min if cur > max
-#p cur
+        if cur > max
+          cur = min
+          edn = edn - max - 1 if edn > max
+        end
 
         fail RuntimeError.new(
           "too many loops for " +
           { min: omin, max: omax, sta: sta, edn: edn, sla: sla }.inspect +
           " #range, breaking, " +
           "please fill an issue at https://git.io/fjJC9"
-        ) if a.length > omax
+        ) if a.length > 2 * omax
+          # there is a #uniq afterwards, hence the 2* for 0-24 and friends
       end
 
-      a.each_with_index.select { |e, i| i % sla == 0 }.collect(&:first)
+      a.each_with_index
+        .select { |e, i| i % sla == 0 }
+        .collect(&:first)
+        .uniq
     end
 
     def compact(key)
@@ -739,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,451 @@ 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
-
-        h[:min] ||= [ 0 ]
-        h[:min].uniq!
+      def assemble_cron(h)
 
-        h[:hou].uniq!;
-        h[:hou].sort!
+#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[:dow].sort! if h[:dow]
-
-        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]
-
-        s = a.join(' ')
+        Fugit::Cron.parse(s.join(' '))
+      end
 
-        Fugit::Cron.parse(s)
+      def eone(e); e1 = e[1]; e1 == 1 ? '*' : "*/#{e1}"; end
+
+      def parse_interval_elt(e, opts, h)
+
+        e1 = e[1]
+
+        case e[2]
+        when 's', 'sec', 'second', 'seconds'
+          h[:sec] = eone(e)
+        when 'm', 'min', 'mins', 'minute', 'minutes'
+          #(h[:hms] ||= []) << [ '*', eone(e) ]
+          h[:hms] ||= [ [ '*', eone(e) ] ]
+        when 'h', 'hour', 'hours'
+          h[:hms] ||= [ [ eone(e), 0 ] ]
+        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 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 shour(i)
+        rex(:shour, i, /(2[0-4]|[01]?[0-9])/)
+      end
+      def simple_hour(i)
+        seq(:simple_hour, i, :shour, :am_pm, '?')
       end
 
       def digital_hour(i)
         rex(:digital_hour, i, /(2[0-4]|[01][0-9]):?[0-5]\d/)
       end
 
-      def _simple_hour(i)
-        rex(:sh, i, /(2[0-4]|[01]?[0-9])/)
+      def at_point(i)
+        alt(nil, i,
+          :digital_hour, :simple_hour, :named_hour, :numeral_hour,
+          :named_digits)
       end
-      def simple_hour(i)
-        seq(:simple_hour, i, :_simple_hour, :am_pm, '?')
+
+      def weekday(i)
+        rex(:weekday, i, /(#{WEEKDAYS.reverse.join('|')})\s*/i)
       end
 
-      def _numeral_hour(i)
-        rex(:nh, i, /(#{NUMS.join('|')})/i)
+      def and_at(i)
+        seq(nil, i, :_and_or_comma, :at_point)
       end
-      def numeral_hour(i)
-        seq(:numeral_hour, i, :_numeral_hour, :am_pm, '?')
+
+      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 name_hour(i)
-        rex(:name_hour, i, /(#{NHOURS.keys.join('|')})/i)
+      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 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 ordinal(i)
+        rex(:ordinal, i, /\s*(#{ORDINALS.keys.join('|')})\s*/)
+      end
 
-      def range_sep(i); rex(nil, i, / *- *| +(to|through) +/); end
+      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 day_range(i)
-        seq(:day_range, i, :name_day, :range_sep, :name_day)
+      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_name(i)
-        rex(nil, i, /[A-Z][a-zA-Z0-9+\-]+(\/[A-Z][a-zA-Z0-9+\-_]+){0,2}/)
+      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 _tz_delta(i)
-        rex(nil, i, /[-+]([01][0-9]|2[0-4]):?(00|15|30|45)/)
+      def day_of_month(i)
+        alt(nil, i, :dom_noftm, :dom_mod)
       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 dow_class(i)
+        rex(:dow_class, i, /(weekday)(\s+|$)/i)
       end
 
-      def flag(i); rex(:flag, i, /(every|from|at|after|on|in)/i); end
+      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 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 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)/)
+        [ m[1].to_i, m[2].to_i ]
+      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.1
+  version: 1.3.6
 platform: ruby
 authors:
 - John Mettraux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-27 00:00:00.000000000 Z
+date: 2020-06-01 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.0.3
 signing_key: 
 specification_version: 4
 summary: time tools for flor