fugit 1.3.5 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2a28ef486584f37659fbcf4e6e4fecfc76aa2a4a6e1fc61d25dd3c44cd3a5c3
-  data.tar.gz: db726ca071f0f98d0f59c3054fca04a537ec2a17fd302013b354d90e1d7dc3c8
+  metadata.gz: 123f788edd6b7510be158be7ffdca00424eea5755aff767ae643180689947636
+  data.tar.gz: c789eaf6ecf0ae363faafa8536b11b97e6c6e02af35983ae13f9c8649fe63ab3
 SHA512:
-  metadata.gz: d1105627f83fd730a7826047679edfd38ad7deb19960715e93769d5c04e80e0079b02b9513f9e5d01614e2e70b75a016a2e16b7a72f568e2a5d3072c42e7e1dc
-  data.tar.gz: eb4b14f1f564bd89ae919c16d6c06ef180b725c81b8d78225661b0a0fb34dee067063de9f2b883e6361e51c0db323224b6ee0a80ab3ca80dd9091a0e872ceae4
+  metadata.gz: a7af25bbc69dcf5f891900d1620f171451a38ea269cb888ff440061ba0d8f1357a3789bcc446b71beba27a5029ad3214a65197d32165c4ed8e7fcc98fd25ad7e
+  data.tar.gz: 89dad0285342e14e9ba1e346a1aae742775048c87bd569b1b8ec5a5edde914435cc3ffb414baa52b948b7af948e5c2cff9ea75cf61503133454eebf780eaebe3

data/CHANGELOG.md

@@ -2,6 +2,35 @@
 # CHANGELOG.md
 
 
+## fugit 1.4.0 released 2020-10-27
+
+* Ensure cron accepts "25-L" for monthday, gh-45
+* Allow for "every weekday 8am to 5pm", gh-44
+* Allow "every day from the 25th to the last", gh-45
+* Rework nat parser
+
+
+## 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

data/CREDITS.md

@@ -1,6 +1,9 @@
 
 # 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

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')
@@ -298,19 +321,35 @@ Fugit.parse('every day at five')  # ==> Fugit::Cron instance '0 5 * * *'
 
 ### Ambiguous nats
 
-Not all strings result in a clean, single, cron expression.
+Not all strings result in a clean, single, cron expression. The `multi: false|true|:fail` argument to `Fugit::Nat.parse` could help.
 
 ```ruby
+Fugit::Nat.parse('every day at 16:00 and 18:00')
+  .to_cron_s
+    # ==> '0 16,18 * * *' (a single Fugit::Cron instances)
 Fugit::Nat.parse('every day at 16:00 and 18:00', multi: true)
-  # ==> [ '0 16,18 * * *' ]
+  .collect(&:to_cron_s)
+    # ==> [ '0 16,18 * * *' ] (array of Fugit::Cron instances, here only one)
+
 Fugit::Nat.parse('every day at 16:15 and 18:30')
-  # ==> [ '15 16 * * *' ]
+  .to_cron_s
+    # ==> '15 16 * * *' (a single of Fugit::Cron instances)
 Fugit::Nat.parse('every day at 16:15 and 18:30', multi: true)
-  # ==> [ '15 16 * * *', '30 18 * * *' ]
+  .collect(&:to_cron_s)
+    # ==> [ '15 16 * * *', '30 18 * * *' ] (two Fugit::Cron instances)
+
 Fugit::Nat.parse('every day at 16:15 and 18:30', multi: :fail)
   # ==> ArgumentError: multiple crons in "every day at 16:15 and 18:30" (15 16 * * * | 30 18 * * *)
+Fugit::Nat.parse('every day at 16:15 nada 18:30', multi: true)
+  # ==> nil
 ```
 
+`multi: true` indicates to `Fugit::Nat` that an array of `Fugit::Cron` instances is expected as a result.
+
+`multi: :fail` tells `Fugit::Nat.parse` to fail if the result is more than 1 `Fugit::Cron` instances.
+
+`multi: false` is the default behaviour, return a single `Fugit::Cron` instance or nil when it cannot parse.
+
 
 ## LICENSE
 

data/fugit.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
   s.platform = Gem::Platform::RUBY
   s.authors = [ 'John Mettraux' ]
   s.email = [ 'jmettraux+flor@gmail.com' ]
-  s.homepage = 'http://github.com/floraison/fugit'
+  s.homepage = 'https://github.com/floraison/fugit'
   s.license = 'MIT'
   s.summary = 'time tools for flor'
 
@@ -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.4'
   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,8 @@
+# frozen_string_literal: true
 
 module Fugit
 
-  VERSION = '1.3.5'
+  VERSION = '1.4.0'
 end
 
 require 'time'

data/lib/fugit/at.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module Fugit
 

data/lib/fugit/cron.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module Fugit
 
@@ -12,9 +13,9 @@ module Fugit
       '@daily' => '0 0 * * *',
       '@midnight' => '0 0 * * *',
       '@noon' => '0 12 * * *',
-      '@hourly' => '0 * * * *' }
+      '@hourly' => '0 * * * *' }.freeze
     MAXDAYS = [
-      nil, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ]
+      nil, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ].freeze
 
     attr_reader(
       :original, :zone)
@@ -236,6 +237,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(
@@ -251,8 +254,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
@@ -328,7 +337,7 @@ module Fugit
       [ :seconds, 1, 60 ],
       [ :minutes, 60, 60 ],
       [ :hours, 3600, 24 ],
-      [ :days, 24 * 3600, 365 ] ]
+      [ :days, 24 * 3600, 365 ] ].freeze
 
     def rough_frequency
 
@@ -487,7 +496,7 @@ module Fugit
 
       sla = 1 if sla == nil
       sta = min if sta == nil
-      edn = max if edn == nil
+      edn = max if edn == nil || edn < 0 && sta > 0
 
       range(min, max, sta, edn, sla)
     end
@@ -499,12 +508,10 @@ module Fugit
         { min: min, max: max, sta: sta, edn: edn, sla: sla }.inspect
       ) if (sta < 0 && edn > 0) || (edn < 0 && sta > 0)
 
-#p({ min: min, max: max, sta: sta, edn: edn, sla: sla })
       a = []
 
       omin, omax = min, max
       min, max = -max, -1 if sta < 0
-#p({ min: min, max: max })
 
       cur = sta
 
@@ -604,10 +611,18 @@ module Fugit
 
     module Parser include Raabro
 
-      WEEKDAYS = %w[ sunday monday tuesday wednesday thursday friday saturday ]
-      WEEKDS = WEEKDAYS.collect { |d| d[0, 3] }
+      WEEKDAYS =
+        %w[ sunday monday tuesday wednesday thursday friday saturday ].freeze
+
+      WEEKDS =
+        WEEKDAYS.collect { |d| d[0, 3] }.freeze
+      DOW_REX =
+        /([0-7]|#{WEEKDS.join('|')})/i.freeze
 
-      MONTHS = %w[ - jan feb mar apr may jun jul aug sep oct nov dec ]
+      MONTHS =
+        %w[ - jan feb mar apr may jun jul aug sep oct nov dec ].freeze
+      MONTH_REX =
+        /(1[0-2]|0?[1-9]|#{MONTHS[1..-1].join('|')})/i.freeze
 
       # piece parsers bottom to top
 
@@ -621,8 +636,8 @@ module Fugit
       def mos(i); rex(:mos, i, /[0-5]?\d/); end # min or sec
       def hou(i); rex(:hou, i, /(2[0-4]|[01]?[0-9])/); end
       def dom(i); rex(:dom, i, /(-?(3[01]|[12][0-9]|0?[1-9])|last|l)/i); end
-      def mon(i); rex(:mon, i, /(1[0-2]|0?[1-9]|#{MONTHS[1..-1].join('|')})/i); end
-      def dow(i); rex(:dow, i, /([0-7]|#{WEEKDS.join('|')})/i); end
+      def mon(i); rex(:mon, i, MONTH_REX); end
+      def dow(i); rex(:dow, i, DOW_REX); end
 
       def dow_hash(i); rex(:hash, i, /#(-?[1-5]|last|l)/i); end
 
@@ -757,7 +772,7 @@ module Fugit
 
       def rewrite_tz(t)
 
-        s = t.string.strip
+        s = t.strim
         z = EtOrbi.get_tzone(s)
 
         [ s, z ]

data/lib/fugit/duration.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module Fugit
 
@@ -66,10 +67,9 @@ module Fugit
       day: { a: 'D', r: 'd', i: 'D', s: 24 * 3600, I: true, l: 'day' },
       hou: { a: 'h', r: 'h', i: 'H', s: 3600, I: true, l: 'hour' },
       min: { a: 'm', r: 'm', i: 'M', s: 60, I: true, l: 'minute' },
-      sec: { a: 's', r: 's', i: 'S', s: 1, I: true, l: 'second' },
-    }
+      sec: { a: 's', r: 's', i: 'S', s: 1, I: true, l: 'second' } }.freeze
     INFLA_KEYS, NON_INFLA_KEYS =
-      KEYS.partition { |k, v| v[:I] }
+      KEYS.partition { |k, v| v[:I] }.freeze
 
     def _to_s(key)
 

data/lib/fugit/misc.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module Fugit
 

data/lib/fugit/nat.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module Fugit
 
@@ -16,16 +17,12 @@ module Fugit
 
 #p s; Raabro.pp(Parser.parse(s, debug: 3), colours: true)
 #(p s; Raabro.pp(Parser.parse(s, debug: 1), colours: true)) rescue nil
-        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
+        if slots = Parser.parse(s)
+          slots.to_crons(opts.merge(_s: s))
+        else
+          nil
+        end
       end
 
       def do_parse(s, opts={})
@@ -33,327 +30,653 @@ module Fugit
         parse(s, opts) ||
         fail(ArgumentError.new("could not parse a nat #{s.inspect}"))
       end
+    end
 
-      protected
+    module Parser include Raabro
 
-      def parse_crons(s, a, opts)
+      one_to_nine =
+        %w[ one two three four five six seven eight nine ]
+      sixties =
+        %w[ zero ] + one_to_nine +
+        %w[ ten eleven twelve thirteen fourteen fifteen sixteen seventeen
+            eighteen nineteen ] +
+          %w[ twenty thirty fourty fifty ]
+            .collect { |a|
+              ([ nil ] + one_to_nine)
+                .collect { |b| [ a, b ].compact.join('-') } }
+            .flatten
+
+      NHOURS = sixties[0, 13]
+        .each_with_index
+        .inject({}) { |h, (n, i)| h[n] = i; h }
+        .merge!(
+          'midnight' => 0, 'oh' => 0, 'noon' => 12)
+        .freeze
+      NMINUTES = sixties
+        .each_with_index
+        .inject({}) { |h, (n, i)| h[n] = i; h }
+        .merge!(
+          "o'clock" => 0, 'hundred' => 0)
+        .freeze
 
-        hms, aa = a
-          .partition { |e| e[0] == :point && e[1][0] == :hour }
-        ms = hms
-          .inject({}) { |h, e| (h[e[1][1]] ||= []) << e[1][2]; h }
-          .values
-          .uniq
-        crons =
-          ms.size > 1 ?
-          hms.collect { |e| parse_cron([ e ] + aa, opts) } :
-          [ parse_cron(a, opts) ]
+      WEEKDAYS = (
+        Fugit::Cron::Parser::WEEKDAYS +
+        Fugit::Cron::Parser::WEEKDS).freeze
 
-        fail ArgumentError.new(
-          "multiple crons in #{s.inspect} " +
-          "(#{crons.collect(&:original).join(' | ')})"
-        ) if opts[:multi] == :fail && crons.size > 1
+      POINTS = %w[
+        minutes? mins? seconds? secs? hours? hou h ].freeze
 
-        if opts[:multi] == true || (opts[:multi] && opts[:multi] != :fail)
-          crons
-        else
-          crons.first
-        end
+      INTERVALS = %w[
+        seconds? minutes? hours? days? months?
+        sec min
+        s m h d M ].freeze
+
+      oh = {
+        '1st' => 1, '2nd' => 2, '3rd' => 3, '21st' => 21, '22nd' => 22,
+        '23rd' => 23, '31st' => 31,
+        'last' => 'L' }
+      (4..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-sixth twenty-seventh twenty-eighth
+        twenty-ninth thirtieth thirty-first ]
+          .each_with_index { |e, i| oh[e] = i + 1 }
+      OMONTHDAYS = oh.freeze
+
+      OMONTHDAY_REX = /#{OMONTHDAYS.keys.join('|')}/i.freeze
+      MONTHDAY_REX = /3[0-1]|[0-2]?[0-9]/.freeze
+      WEEKDAY_REX = /(#{WEEKDAYS.join('|')})(?=($|[-, \t]))/i.freeze
+        # prevent "mon" from eating "monday"
+      NAMED_M_REX = /#{NMINUTES.keys.join('|')}/i.freeze
+      NAMED_H_REX = /#{NHOURS.keys.join('|')}/i.freeze
+      POINT_REX = /(#{POINTS.join('|')})[ \t]+/i.freeze
+      INTERVAL_REX = /[ \t]*(#{INTERVALS.join('|')})/.freeze
+
+      #
+      # parsers bottom to top #################################################
+
+      def _every(i); rex(nil, i, /[ \t]*every[ \t]+/i); end
+      def _from(i); rex(nil, i, /[ \t]*from[ \t]+/i); end
+      def _at(i); rex(nil, i, /[ \t]*at[ \t]+/i); end
+      def _on(i); rex(nil, i, /[ \t]*on[ \t]+/i); end
+      def _to(i); rex(nil, i, /[ \t]*to[ \t]+/i); end
+
+      def _and(i); rex(nil, i, /[ \t]*and[ \t]+/i); end
+      def _and_or_or(i); rex(nil, i, /[ \t]*(and|or)[ \t]+/i); end
+      def _in_or_on(i); rex(nil, i, /(in|on)[ \t]+/i); end
+
+      def _and_or_or_or_comma(i)
+        rex(nil, i, /[ \t]*(,[ \t]*)?((and|or)[ \t]+|,[ \t]*)/i); end
+
+      def _to_or_dash(i);
+        rex(nil, i, /[ \t]*-[ \t]*|[ \t]+(to|through)[ \t]+/i); end
+
+      def _day_s(i); rex(nil, i, /[ \t]*days?[ \t]+/i); end
+      def _the(i); rex(nil, i, /[ \t]*the[ \t]+/i); end
+
+      def _space(i); rex(nil, i, /[ \t]+/); end
+      def _sep(i); rex(nil, i, /([ \t]+|[ \t]*,[ \t]*)/); end
+
+      def count(i); rex(:count, i, /\d+/); end
+
+      def omonthday(i)
+        rex(:omonthday, i, OMONTHDAY_REX)
+      end
+      def monthday(i)
+        rex(:monthday, i, MONTHDAY_REX)
+      end
+      def weekday(i)
+        rex(:weekday, i, WEEKDAY_REX)
       end
 
-      def parse_cron(a, opts)
-
-        h = { min: nil, hou: nil, dom: nil, mon: nil, dow: nil }
-        hkeys = h.keys
-
-        i0s, es = a.partition { |e| e[0] == :interval0 }
-        a = es + i0s
-          # interval0s are fallback
-
-        a.each do |key, val|
-          case key
-          when :biz_day
-            (h[:dow] ||= []) << '1-5'
-          when :name_day
-            (h[:dow] ||= []) << val
-          when :day_range
-            (h[:dow] ||= []) << val.collect { |v| v.to_s[0, 3] }.join('-')
-          when :tz
-            h[:tz] = val
-          when :point
-            process_point(h, *val)
-          when :interval1
-            process_interval1(h, *val[0].to_h.first)
-          when :interval0
-            process_interval0(h, val)
-          end
-        end
+      def omonthdays(i); jseq(nil, i, :omonthday, :_and_or_or_or_comma); end
+      def monthdays(i); jseq(nil, i, :monthday, :_and_or_or_or_comma); end
+
+      def weekdays(i); jseq(:weekdays, i, :weekday, :_and_or_or_or_comma); end
 
-        return nil if h[:fail]
+      def on_the(i); seq(nil, i, :_the, :omonthdays); end
 
-        h[:min] = (h[:min] || [ 0 ]).uniq
-        h[:hou] = (h[:hou] || []).uniq.sort
-        h[:dow].sort! if h[:dow]
+      def _minute(i); rex(nil, i, /[ \t]*minute[ \t]+/i) 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 _dmin(i)
+        rex(:dmin, i, /[0-5]?[0-9]/)
+      end
+      def and_dmin(i)
+        seq(nil, i, :_and_or_or_or_comma, :_minute, '?', :_dmin)
+      end
 
-        s = a.join(' ')
+      def on_minutes(i)
+        seq(:on_minutes, i, :_minute, :_dmin, :and_dmin, '*')
+      end
 
-        Fugit::Cron.parse(s)
+      def on_thex(i);
+        rex(:on_thex, i, /[ \t]*the[ \t]+(hour|minute)[ \t]*/i);
       end
 
-      def process_point(h, key, *value)
+      def on_thes(i); jseq(:on_thes, i, :on_the, :_and_or_or_or_comma); end
+      def on_days(i); seq(:on_days, i, :_day_s, :monthdays); end
+      def on_weekdays(i); ren(:on_weekdays, i, :weekdays); end
 
-        case key
-        when :hour
-          v0, v1 = value
-          v0 = v0.to_i if v0.is_a?(String) && v0.match(/^\d+$/)
-          (h[:hou] ||= []) << v0
-          (h[:min] ||= []) << v1.to_i if v1
-        when :sec, :min
-          (h[key] ||= []) << value[0]
-        end
+      def on_object(i)
+        alt(nil, i, :on_days, :on_weekdays, :on_minutes, :on_thes, :on_thex)
+      end
+      def on_objects(i)
+        jseq(nil, i, :on_object, :_and)
       end
 
-      def process_interval0(h, value)
+        #'every month on day 2 at 10:00' => '0 10 2 * *',
+        #'every month on day 2 and 5 at 10:00' => '0 10 2,5 * *',
+        #'every month on days 1,15 at 10:00' => '0 10 1,15 * *',
+        #
+        #'every week on monday 18:23' => '23 18 * * 1',
+        #
+        # every month on the 1st
+      def on(i)
+        seq(:on, i, :_on, :on_objects)
+      end
 
-        case value
-        when 'sec', 'second'
-          h[:min] = [ '*' ]
-          h[:sec] = [ '*' ]
-        when 'min', 'minute'
-          h[:min] = [ '*' ]
-        when 'hour'
-          unless h[:min] || h[:hou]
-            h[:min] = [ 0 ]
-            h[:hou] = [ '*' ]
-          end
-        when 'day'
-          unless h[:min] || h[:hou]
-            h[:min] = [ 0 ]
-            h[:hou] = [ 0 ]
-          end
-        when 'week'
-          unless h[:min] || h[:hou] || h[:dow]
-            h[:min] = [ 0 ]
-            h[:hou] = [ 0 ]
-            h[:dow] = [ 0 ]
-          end
-        when 'month'
-          unless h[:min] || h[:hou]
-            h[:min] = [ 0 ]
-            h[:hou] = [ 0 ]
-          end
-          (h[:dom] ||= []) << 1
-        when 'year'
-          unless h[:min] || h[:hou]
-            h[:min] = [ 0 ]
-            h[:hou] = [ 0 ]
-          end
-          (h[:dom] ||= []) << 1
-          (h[:mon] ||= []) << 1
-        end
+      def city_tz(i)
+        rex(nil, i, /[A-Z][a-zA-Z0-9+\-]+(\/[A-Z][a-zA-Z0-9+\-_]+){0,2}/)
+      end
+      def named_tz(i)
+        rex(nil, i, /Z|UTC/)
+      end
+      def delta_tz(i)
+        rex(nil, i, /[-+]([01][0-9]|2[0-4])(:?(00|15|30|45))?/)
+      end
+      def tz(i)
+        alt(:tz, i, :city_tz, :named_tz, :delta_tz)
+      end
+      def tzone(i)
+        seq(nil, i, :_in_or_on, '?', :tz)
       end
 
-      def process_interval1(h, interval, value)
+      def digital_hour(i)
+        rex(
+          :digital_hour, i,
+          /(2[0-4]|[0-1]?[0-9]):([0-5][0-9])([ \t]*(am|pm))?/i)
+      end
 
-        if value != 1 && [ :yea, :wee ].include?(interval)
-          int = interval == :year ? 'years' : 'weeks'
-          h[:fail] = "cannot cron for \"every #{value} #{int}\""
-          return
-        end
+      def ampm(i)
+        rex(:ampm, i, /[ \t]*(am|pm)/i)
+      end
+      def dark(i)
+        rex(:dark, i, /[ \t]*dark/i)
+      end
 
-        case interval
-        when :yea
-          h[:hou] = [ 0 ]
-          h[:mon] = [ 1 ]
-          h[:dom] = [ 1 ]
-        when :mon
-          h[:hou] = [ 0 ]
-          h[:dom] = [ 1 ]
-          h[:mon] = [ value == 1 ? '*' : "*/#{value}" ]
-        when :wee
-          h[:hou] = [ 0 ]
-          h[:dow] = [ 0 ] # Sunday
-        when :day
-          h[:hou] = [ 0 ]
-          h[:dom] = [ value == 1 ? '*' : "*/#{value}" ]
-        when :hou
-          h[:hou] = [ value == 1 ? '*' : "*/#{value}" ]
-        when :min
-          h[:hou] = [ '*' ]
-          h[:min] = [ value == 1 ? '*' : "*/#{value}" ]
-        when :sec
-          h[:hou] = [ '*' ]
-          h[:min] = [ '*' ]
-          h[:sec] = [ value == 1 ? '*' : "*/#{value}" ]
-        end
+      def simple_h(i)
+         rex(:simple_h, i, /#{(0..24).to_a.reverse.join('|')}/)
+      end
+      def simple_hour(i)
+        seq(:simple_hour, i, :simple_h, :ampm, '?')
       end
-    end
 
-    module Parser include Raabro
+      def named_m(i)
+        rex(:named_m, i, NAMED_M_REX)
+      end
+      def named_min(i)
+        seq(nil, i, :_space, :named_m)
+      end
 
-      NUMS = %w[
-        zero
-        one two three four five six seven eight nine
-        ten eleven twelve ]
+      def named_h(i)
+        rex(:named_h, i, NAMED_H_REX)
+      end
+      def named_hour(i)
+        seq(:named_hour, i, :named_h, :dark, '?', :named_min, '?', :ampm, '?')
+      end
 
-      WEEKDAYS =
-        Fugit::Cron::Parser::WEEKDS + Fugit::Cron::Parser::WEEKDAYS
+      def _point(i); rex(:point, i, POINT_REX); end
 
-      NHOURS =
-        { 'noon' => [ 12, 0 ], 'midnight' => [ 0, 0 ] }
+      def counts(i)
+        jseq(nil, i, :count, :_and_or_or_or_comma)
+      end
+
+      def at_p(i)
+        seq(:at_p, i, :_point, :counts)
+      end
+      def at_point(i)
+        jseq(nil, i, :at_p, :_and_or_or)
+      end
 
-      # piece parsers bottom to top
+        # at five
+        # at five pm
+        # at five o'clock
+        # at 16:30
+        # at noon
+        # at 18:00 UTC <-- ...tz
+      def at_object(i)
+        alt(nil, i, :named_hour, :digital_hour, :simple_hour, :at_point)
+      end
+      def at_objects(i)
+        jseq(nil, i, :at_object, :_and_or_or_or_comma)
+      end
 
-      def interval0(i)
-        rex(:interval0, i,
-          /(year|month|week|day|hour|min(ute)?|sec(ond)?)(?![a-z])/i)
+      def at(i)
+        seq(:at, i, :_at, '?', :at_objects)
       end
 
-      def am_pm(i)
-        rex(:am_pm, i, / *(am|pm)/i)
+      def interval(i)
+        rex(:interval, i, INTERVAL_REX)
       end
 
-      def digital_hour(i)
-        rex(:digital_hour, i, /(2[0-4]|[01][0-9]):?[0-5]\d/)
+        # every day
+        # every 1 minute
+      def every_interval(i)
+        seq(:every_interval, i, :count, '?', :interval)
       end
 
-      def _simple_hour(i)
-        rex(:sh, i, /(2[0-4]|[01]?[0-9])/)
+      def every_single_interval(i)
+        rex(:every_single_interval, i, /(1[ \t]+)?(week|year)/)
       end
-      def simple_hour(i)
-        seq(:simple_hour, i, :_simple_hour, :am_pm, '?')
+
+      def to_weekday(i)
+        seq(:to_weekday, i, :weekday, :_to_or_dash, :weekday)
       end
 
-      def _numeral_hour(i)
-        rex(:nh, i, /(#{NUMS.join('|')})/i)
+      def weekday_range(i)
+        alt(nil, i, :to_weekday, :weekdays)
       end
-      def numeral_hour(i)
-        seq(:numeral_hour, i, :_numeral_hour, :am_pm, '?')
+
+      def to_omonthday(i)
+        seq(:to_omonthday, i,
+          :_the, '?', :omonthday, :_to, :_the, '?', :omonthday)
       end
 
-      def name_hour(i)
-        rex(:name_hour, i, /(#{NHOURS.keys.join('|')})/i)
+      def to_hour(i)
+        seq(:to_hour, i, :at_object, :_to, :at_object)
       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 from_object(i)
+        alt(nil, i, :to_weekday, :to_omonthday, :to_hour)
+      end
+      def from_objects(i)
+        jseq(nil, i, :from_object, :_and_or_or)
+      end
+      def from(i)
+        seq(nil, i, :_from, '?', :from_objects)
+      end
 
-      def range_sep(i); rex(nil, i, / *- *| +(to|through) +/); end
+        # every monday
+        # every Fri-Sun
+        # every Monday and Tuesday
+      def every_weekday(i)
+        jseq(nil, i, :weekday_range, :_and_or_or)
+      end
 
-      def day_range(i)
-        seq(:day_range, i, :name_day, :range_sep, :name_day)
+      def otm(i)
+        rex(nil, i, /[ \t]+of the month/)
       end
 
-      def _tz_name(i)
-        rex(nil, i, /[A-Z][a-zA-Z0-9+\-]+(\/[A-Z][a-zA-Z0-9+\-_]+){0,2}/)
+        # every 1st of the month
+        # every first of the month
+        # Every 2nd of the month
+        # Every second of the month
+        # every 15th of the month
+      def every_of_the_month(i)
+        seq(nil, i, :omonthdays, :otm)
       end
-      def _tz_delta(i)
-        rex(nil, i, /[-+]([01][0-9]|2[0-4]):?(00|15|30|45)/)
+
+      def every_named(i)
+        rex(:every_named, i, /weekday/i)
       end
-      def _tz(i); alt(:tz, i, :_tz_delta, :_tz_name); end
 
-      def interval1(i)
-        rex(:interval1, i,
-          /
-            \d+
-            \s?
-            (y(ears?)?|months?|w(eeks?)?|d(ays?)?|
-              h(ours?)?|m(in(ute)?s?)?|s(ec(ond)?s?)?)
-          /ix)
+      def every_object(i)
+        alt(
+          nil, i,
+          :every_weekday, :every_of_the_month,
+          :every_interval, :every_named, :every_single_interval)
+      end
+      def every_objects(i)
+        jseq(nil, i, :every_object, :_and_or_or)
       end
 
-      def min_or_sec(i)
-        rex(:min_or_sec, i, /(min(ute)?|sec(ond)?)\s+\d+/i)
+      def every(i)
+        seq(:every, i, :_every, :every_objects)
       end
 
-      def point(i)
-        alt(:point, i,
-          :min_or_sec,
-          :name_hour, :numeral_hour, :digital_hour, :simple_hour)
+      def nat_elt(i)
+        alt(nil, i, :every, :from, :at, :tzone, :on)
+      end
+      def nat(i)
+        jseq(:nat, i, :nat_elt, :_sep)
       end
 
-      def flag(i); rex(:flag, i, /(every|from|at|after|on|in)/i); end
+      #
+      # rewrite parsed tree ###################################################
 
-      def datum(i)
-        alt(nil, i,
-          :flag,
-          :interval1,
-          :point,
-          :interval0,
-          :day_range, :biz_day, :name_day,
-          :_tz)
+      def slot(key, data0, data1=nil, opts=nil)
+        Slot.new(key, data0, data1, opts)
       end
 
-      def sugar(i); rex(nil, i, /(and|or|[, \t]+)/i); end
+      def _rewrite_subs(t, key=nil)
+        t.subgather(key).collect { |ct| rewrite(ct) }
+      end
+      def _rewrite_sub(t, key=nil)
+        st = t.sublookup(key)
+        st ? rewrite(st) : nil
+      end
 
-      def elt(i); alt(nil, i, :sugar, :datum); end
-      def nat(i); rep(:nat, i, :elt, 1); end
+      def rewrite_dmin(t)
+        t.strinp
+      end
 
-      # rewrite parsed tree
+      def rewrite_on_minutes(t)
+#Raabro.pp(t, colours: true)
+        mins = t.subgather(:dmin).collect(&:strinp)
+        #slot(:m, mins.join(','))
+        slot(:hm, '*', mins.join(','), strong: 1)
+      end
 
-      def _rewrite(t)
-        [ t.name, t.string.downcase ]
+      def rewrite_on_thex(t)
+        case s = t.string
+        #when /hour/i then slot(:h, 0)
+        #else slot(:m, '*')
+        when /hour/i then slot(:hm, 0, '*', strong: 0)
+        else slot(:hm, '*', '*', strong: 1)
+        end
       end
-      alias rewrite_flag _rewrite
-      alias rewrite_interval0 _rewrite
-      alias rewrite_biz_day _rewrite
 
-      def rewrite_name_day(t)
-        [ :name_day, WEEKDAYS.index(t.string.downcase[0, 3]) ]
+      def rewrite_on_thes(t)
+        _rewrite_subs(t, :omonthday)
+      end
+      def rewrite_on_days(t)
+        _rewrite_subs(t, :monthday)
       end
 
-      def rewrite_day_range(t)
-        [ :day_range, t.subgather(nil).collect { |st| st.string.downcase } ]
+      def rewrite_on(t)
+        _rewrite_subs(t)
       end
 
-      def rewrite_name_hour(t)
-        [ :hour, *NHOURS[t.string.strip.downcase] ]
+      def rewrite_monthday(t)
+        slot(:monthday, t.string.to_i)
       end
-      def rewrite_numeral_hour(t)
-        vs = t.subgather(nil).collect { |st| st.string.downcase.strip }
-        v = NUMS.index(vs[0])
-        v += 12 if vs[1] == 'pm'
-        [ :hour, v, 0 ]
+
+      def rewrite_omonthday(t)
+        slot(:monthday, OMONTHDAYS[t.string.downcase])
       end
-      def rewrite_simple_hour(t)
-        vs = t.subgather(nil).collect { |st| st.string.downcase.strip }
-        v = vs[0].to_i
-        v += 12 if vs[1] == 'pm'
-        [ :hour, v, 0 ]
+
+      def rewrite_at_p(t)
+        pt = t.sublookup(:point).strinpd
+        pt = pt.start_with?('mon') ? 'M' : pt[0, 1]
+        pts = t.subgather(:count).collect { |e| e.string.to_i }
+#p [ pt, pts ]
+        case pt
+        #when 'm' then slot(:m, pts)
+        when 'm' then slot(:hm, '*', pts, strong: 1)
+        when 's' then slot(:second, pts)
+else slot(pt.to_sym, pts)
+        end
       end
-      def rewrite_digital_hour(t)
-        v = t.string.gsub(/:/, '')
-        [ :hour, v[0, 2], v[2, 2] ]
+
+      def rewrite_every_single_interval(t)
+        case t.string
+        when /year/i then [ slot(:month, 1, :weak), slot(:monthday, 1, :weak) ]
+        #when /week/i then xxx...
+        else slot(:weekday, 0, :weak)
+        end
       end
 
-      def rewrite_min_or_sec(t)
-        unit, num = t.string.split(/\s+/)
-        [ unit[0, 3].to_sym, num.to_i ]
+      def rewrite_every_interval(t)
+
+#Raabro.pp(t, colours: true)
+        ci = t.subgather(nil).collect(&:string)
+        i = ci.pop.strip[0, 3]
+        c = (ci.pop || '1').strip
+        i = (i == 'M' || i.downcase == 'mon') ? 'M' : i[0, 1].downcase
+        cc = c == '1' ? '*' : "*/#{c}"
+
+        case i
+        when 'M' then slot(:month, cc)
+        when 'd' then slot(:monthday, cc, :weak)
+        #when 'h' then slot(:hm, cc, 0, weak: :minute)
+        when 'h' then slot(:hm, cc, 0, weak: 1)
+        when 'm' then slot(:hm, '*', cc, strong: 1)
+        when 's' then slot(:second, cc)
+        else {}
+        end
       end
 
-      def rewrite_point(t)
-        [ :point, rewrite(t.sublookup) ]
+      def rewrite_every_named(t)
+
+        case s = t.string
+        when /weekday/i then slot(:weekday, '1-5', :weak)
+        when /week/i then slot(:weekday, '0', :weak)
+        else fail "cannot rewrite #{s.inspect}"
+        end
       end
 
       def rewrite_tz(t)
-        [ :tz,  [ t.string.strip, EtOrbi.get_tzone(t.string.strip) ] ]
+        slot(:tz, t.string)
       end
 
-      def rewrite_interval1(t)
-        [ t.name, [ Fugit::Duration.parse(t.string.strip) ] ]
+      def rewrite_weekday(t)
+        Fugit::Cron::Parser::WEEKDS.index(t.string[0, 3].downcase)
       end
 
-      def rewrite_nat(t)
+      def rewrite_weekdays(t)
+#Raabro.pp(t, colours: true)
+        slot(:weekday, _rewrite_subs(t, :weekday))
+      end
+      alias rewrite_on_weekdays rewrite_weekdays
+
+      def rewrite_to_weekday(t)
+        wd0, wd1 = _rewrite_subs(t, :weekday)
+        #wd1 = 7 if wd1 == 0
+        slot(:weekday, "#{wd0}-#{wd1}")
+      end
+
+      def rewrite_to_omonthday(t)
+        md0, md1 = _rewrite_subs(t, :omonthday).collect(&:_data0)
+        slot(:monthday, "#{md0}-#{md1}")
+      end
+
+      def rewrite_digital_hour(t)
+        h, m, ap = t.strinpd.split(/[: \t]+/)
+        h, m = h.to_i, m.to_i
+        h += 12 if ap && ap == 'pm'
+        slot(:hm, h.to_i, m.to_i)
+      end
+
+      def rewrite_simple_hour(t)
+        h, ap = t.subgather(nil).collect(&:strinpd)
+        h = h.to_i
+        h = h + 12 if ap == 'pm'
+        slot(:hm, h, 0)
+      end
+
+      def rewrite_named_hour(t)
+
+        ht = t.sublookup(:named_h)
+        mt = t.sublookup(:named_m)
+        apt = t.sublookup(:ampm)
+
+        h = ht.strinp
+        m = mt ? mt.strinp : 0
+#p [ 0, '-->', h, m ]
+        h = NHOURS[h]
+        m = NMINUTES[m] || m
+#p [ 1, '-->', h, m ]
+
+        h += 12 if h < 13 && apt && apt.strinpd == 'pm'
+
+        slot(:hm, h, m)
+      end
+
+      def rewrite_to_hour(t)
+#Raabro.pp(t, colours: true)
+        ht0, ht1 = t.subgather(nil)
+        h0, h1 = rewrite(ht0), rewrite(ht1)
+        fail ArgumentError.new(
+          "cannot deal with #{ht0.strinp} to #{ht1.strinp}, minutes diverge"
+        ) if h0.data1 != h1.data1
+        slot(:hm, "#{h0._data0}-#{h1._data0}", 0, strong: 0)
+      end
+
+      def rewrite_at(t)
+        _rewrite_subs(t)
+      end
+
+      def rewrite_every(t)
+        _rewrite_sub(t)
+      end
 
+      def rewrite_nat(t)
 #Raabro.pp(t, colours: true)
-        t.subgather(nil).collect { |tt| rewrite(tt) }
+        Fugit::Nat::SlotGroup.new(_rewrite_subs(t).flatten)
+      end
+    end
+
+    class Slot
+      attr_reader :key
+      attr_accessor :_data0, :_data1
+      def initialize(key, d0, d1=nil, opts=nil)
+        d1, opts = d1.is_a?(Symbol) ? [ nil, d1 ] : [ d1, opts ]
+        @key, @_data0, @_data1 = key, d0, d1
+        @opts = (opts.is_a?(Symbol) ? { opts => true } : opts) || {}
+      end
+      def data0; @data0 ||= Array(@_data0); end
+      def data1; @data1 ||= Array(@_data1); end
+      def weak; @opts[:weak]; end
+      def strong; @opts[:strong]; end
+      def graded?; weak || strong; end
+      def append(slot)
+        @_data0, @_data1 = conflate(0, slot), conflate(1, slot)
+        @opts.clear
+        self
+      end
+      def inspect
+        a = [ @key, @_data0 ]
+        a << @_data1 if @_data1 != nil
+        a << @opts if @opts && @opts.keys.any?
+        "(slot #{a.collect(&:inspect).join(' ')})"
+      end
+      def a; [ data0, data1 ]; end
+      protected
+      def to_a(x)
+        return [] if x == '*'
+        Array(x)
+      end
+      def conflate(index, slot)
+        a, b = index == 0 ? [ @_data0, slot._data0 ] : [ @_data1, slot._data1 ]
+        return a if b == nil
+        return b if a == nil
+        if ra = (index == 0 && slot.strong == 1 && hour_range)
+          h0, h1 = ra[0], ra[1] - 1; return h0 == h1 ? h0 : "#{h0}-#{h1}"
+        elsif rb = (index == 0 && strong == 1 && slot.hour_range)
+          h0, h1 = rb[0], rb[1] - 1; return h0 == h1 ? h0 : "#{h0}-#{h1}"
+        end
+        return a if strong == index || strong == true
+        return b if slot.strong == index || slot.strong == true
+        return a if slot.weak == index || slot.weak == true
+        return b if weak == index || weak == true
+        return [ '*' ] if a == '*' && b == '*'
+        to_a(a).concat(to_a(b))
+      end
+      def hour_range
+        m = (key == :hm && @_data1 == 0 && @_data0.match(/\A(\d+)-(\d+)\z/))
+        m ? [ m[1].to_i, m[2].to_i ] : nil
+      end
+    end
+
+    class SlotGroup
+
+      def initialize(slots)
+
+#puts "SlotGroup.new " + slots.inspect
+        @slots = {}
+        @hms = []
+
+        slots.each do |s|
+          if s.key == :hm
+            #ls = @hms.last; @hms.pop if ls && ls.key == :hm && ls.weak == true
+            @hms << s
+          elsif hs = @slots[s.key]
+            hs.append(s)
+          else
+            @slots[s.key] = s
+          end
+        end
+
+        if @slots[:monthday] || @slots[:weekday]
+          @hms << make_slot(:hm, 0, 0) if @hms.empty?
+        elsif @slots[:month]
+          @hms << make_slot(:hm, 0, 0) if @hms.empty?
+          @slots[:monthday] ||= make_slot(:monthday, 1)
+        end
+      end
+
+      def to_crons(opts)
+
+        multi = opts.has_key?(:multi) ? opts[:multi] : false
+
+        hms = determine_hms
+
+        if multi == :fail && hms.count > 1
+          fail(ArgumentError.new(
+            "multiple crons in #{opts[:_s].inspect} - #{@slots.inspect}"))
+        elsif multi == true
+          hms.collect { |hm| parse_cron(hm) }
+        else
+          parse_cron(hms.first)
+        end
+      end
+
+      protected
+
+      def make_slot(key, data0, data1=nil)
+
+        Fugit::Nat::Slot.new(key, data0, data1)
+      end
+
+      def determine_hms
+
+        return [ [ [ '*' ], [ '*' ] ] ] if @hms.empty?
+
+        hms = @hms.dup
+          #
+        while ig = (hms.count > 1 && hms.index { |hm| hm.graded? }) do
+          sg = hms[ig]
+          so = hms.delete_at(ig == 0 ? 1 : ig - 1)
+          sg.append(so)
+        end
+
+        hms
+          .collect(&:a)
+          .inject({}) { |r, hm|
+            hm[1].each { |m| (r[m] ||= []).concat(hm[0]) }
+            r }
+          .inject({}) { |r, (m, hs)|
+            (r[hs.sort] ||= []) << m
+            r }
+          .to_a
+      end
+
+      def parse_cron(hm)
+
+        a = [
+          slot(:second, '0'),
+          hm[1],
+          hm[0],
+          slot(:monthday, '*'),
+          slot(:month, '*'),
+          slot(:weekday, '*') ]
+        tz = @slots[:tz]
+        a << tz.data0 if tz
+        a.shift if a.first == [ '0' ]
+
+        s = a
+          .collect { |e| e.uniq.sort.collect(&:to_s).join(',') }
+          .join(' ')
+
+        Fugit::Cron.parse(s)
+      end
+
+      def slot(key, default)
+        s = @slots[key]
+        s ? s.data0 : [ default ]
       end
     end
   end

data/lib/fugit/parse.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module Fugit
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fugit
 version: !ruby/object:Gem::Version
-  version: 1.3.5
+  version: 1.4.0
 platform: ruby
 authors:
 - John Mettraux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-07 00:00:00.000000000 Z
+date: 2020-10-27 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.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: et-orbi
   requirement: !ruby/object:Gem::Requirement
@@ -93,15 +93,15 @@ files:
 - lib/fugit/misc.rb
 - lib/fugit/nat.rb
 - lib/fugit/parse.rb
-homepage: http://github.com/floraison/fugit
+homepage: https://github.com/floraison/fugit
 licenses:
 - MIT
 metadata:
-  changelog_uri: http://github.com/floraison/fugit/blob/master/CHANGELOG.md
-  documentation_uri: http://github.com/floraison/fugit
-  bug_tracker_uri: http://github.com/floraison/fugit/issues
-  homepage_uri: http://github.com/floraison/fugit
-  source_code_uri: http://github.com/floraison/fugit
+  changelog_uri: https://github.com/floraison/fugit/blob/master/CHANGELOG.md
+  documentation_uri: https://github.com/floraison/fugit
+  bug_tracker_uri: https://github.com/floraison/fugit/issues
+  homepage_uri: https://github.com/floraison/fugit
+  source_code_uri: https://github.com/floraison/fugit
 post_install_message: 
 rdoc_options: []
 require_paths: