fugit 1.2.2 → 1.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c85cb2e1a6f9e87e56f09bd46ebc0f23cf41ebc9
-  data.tar.gz: 2c7c9aeb2e20be568fd41d14bea36aa325077134
+  metadata.gz: 0e67fe1fbf7a5e0213b828cc78c59d6cf5b36a6e
+  data.tar.gz: 920ea06ef202094e9b1c9c719fb06c55e0926b51
 SHA512:
-  metadata.gz: abdc614b1f22423e38cd28d89f3a75b7cb53f5c739f007645fc0957e09fde31b78ffa18ac80c85f3cd178ade3102b917edcc1ef540431be75edfb1db4f81ccb4
-  data.tar.gz: df991f815915b44e0fb094a7dcda59f1b3e304c03d1b6ea708a8f6bfceedd1873ad481d1cde8f70db32465af2fe7e4cae34789a0e0344393361e98d79cdaa383
+  metadata.gz: d6f4c28d4e280b73a0b5a3c6bae84e328e06fa33cb573bc8fc1a3660e1c921dd666c793fd17a18f10bc4d630d5db2473c2d75659def60bb6fd7342c9e3dfbb51
+  data.tar.gz: 40ae39ba32717fcc2d0148d2e4a63a2cd179fa61ef5de13670057021b77a95c9bec1ae7f299a3117602e63a1b02c5b1de683748ef793fa74ec394a4a7861992c

data/CHANGELOG.md

@@ -2,6 +2,37 @@
 # CHANGELOG.md
 
 
+## 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
+*   and for 'every day at 18:00, 18:15, 20:00, and 20:15', gh-29
+* Ensure multi: :fail doesn't force into multi, gh-28
+* Fix nat parsing for 'every Fri-Sun at 18:00', gh-27
+
+
+## fugit 1.3.0 released 2019-07-21
+
+* Introduce Fugit.parse_nat('every day at 18:00 and 19:15', multi: true)
+* Rework AM/PM parsing
+
+
+## fugit 1.2.3 released 2019-07-16
+
+* Allow for "from Monday to Friday at 19:22", gh-25
+* Allow for "every Monday to Friday at 18:20", gh-25
+* Allow for "every day at 18:00 and 20:00", gh-24
+
+
 ## fugit 1.2.2 released 2019-06-21
 
 * Fix Fugit.parse vs "every 15 minutes", gh-22

data/CREDITS.md

@@ -1,6 +1,9 @@
 
 # fugit credits
 
+* 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
 * Jan Stevens https://github.com/JanStevens Fugit.parse('every 15 minutes') gh-22
 * Fabio Pitino https://github.com/hspazio nil on February 30 gh-21
 * Cristian Oneț https://github.com/conet #previous_time vs 1/-1 endless loop gh-15

data/README.md

@@ -54,6 +54,39 @@ Fugit.parse('2017-12-12 UTC').class      # ==> ::EtOrbi::EoTime
 Fugit.parse('every day at noon').class   # ==> ::Fugit::Cron
 ```
 
+If fugit cannot extract a cron, duration or point in time out of the string, it will return nil.
+```ruby
+Fugit.parse('nada')
+  # ==> nil
+```
+
+## `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)
+```
+
+## parse_cron, parse_in, parse_at, parse_duration, and parse_nat
+
+```ruby
+require 'fugit'
+
+Fugit.parse_cron('0 0 1 jan *').class       # ==> ::Fugit::Cron
+Fugit.parse_duration('12y12M').class        # ==> ::Fugit::Duration
+
+Fugit.parse_at('2017-12-12').class          # ==> ::EtOrbi::EoTime
+Fugit.parse_at('2017-12-12 UTC').class      # ==> ::EtOrbi::EoTime
+
+Fugit.parse_nat('every day at noon').class  # ==> ::Fugit::Cron
+```
+
+## do_parse_cron, do_parse_in, do_parse_at, do_parse_duration, and do_parse_nat
+
+As `Fugit.parse(s)` returns nil when it doesn't grok its input, and `Fugit.do_parse(s)` fails when it doesn't grok, each of the `parse_` methods has its partner `do_parse_` method.
+
 ## `Fugit::Cron`
 
 A class `Fugit::Cron` to parse cron strings and then `#next_time` and `#previous_time` to compute the next or the previous occurrence respectively.
@@ -151,10 +184,12 @@ 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:
-```
+```ruby
 p Fugit::Duration.to_plain_s('1y2M1d4h')
   # => "1Y2M1D4h"
 p Fugit::Duration.to_iso_s('1y2M1d4h')
@@ -199,6 +234,7 @@ Fugit::Nat.parse('every day at 5 pm')                         # ==> '0 17 * * *'
 Fugit::Nat.parse('every tuesday at 5 pm')                     # ==> '0 17 * * 2'
 Fugit::Nat.parse('every wed at 5 pm')                         # ==> '0 17 * * 3'
 Fugit::Nat.parse('every day at 16:30')                        # ==> '30 16 * * *'
+Fugit::Nat.parse('every day at 16:00 and 18:00')              # ==> '0 16,18 * * *'
 Fugit::Nat.parse('every day at noon')                         # ==> '0 12 * * *'
 Fugit::Nat.parse('every day at midnight')                     # ==> '0 0 * * *'
 Fugit::Nat.parse('every tuesday and monday at 5pm')           # ==> '0 17 * * 1,2'
@@ -216,6 +252,21 @@ Directly with `Fugit.parse(s)` is OK too:
 Fugit.parse('every day at five')  # ==> Fugit::Cron instance '0 5 * * *'
 ```
 
+### Ambiguous nats
+
+Not all strings result in a clean, single, cron expression.
+
+```ruby
+Fugit::Nat.parse('every day at 16:00 and 18:00', multi: true)
+  # ==> [ '0 16,18 * * *' ]
+Fugit::Nat.parse('every day at 16:15 and 18:30')
+  # ==> [ '15 16 * * *' ]
+Fugit::Nat.parse('every day at 16:15 and 18:30', multi: true)
+  # ==> [ '15 16 * * *', '30 18 * * *' ]
+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 * * *)
+```
+
 
 ## LICENSE
 

data/lib/fugit.rb

@@ -1,7 +1,7 @@
 
 module Fugit
 
-  VERSION = '1.2.2'
+  VERSION = '1.3.3'
 end
 
 require 'time'

data/lib/fugit/cron.rb

@@ -197,7 +197,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)
@@ -475,9 +475,50 @@ module Fugit
       sla = 1 if sla == nil
       sta = min if sta == nil
       edn = max if edn == nil
-      sta, edn = edn, sta if sta > edn
 
-      (sta..edn).step(sla).to_a
+      range(min, max, sta, edn, sla)
+    end
+
+    def range(min, max, sta, edn, sla)
+
+      fail ArgumentError.new(
+        'both start and end must be negative in ' +
+        { 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
+
+      loop do
+
+        a << cur
+        break if cur == edn
+
+        cur += 1
+        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 > 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)
+        .uniq
     end
 
     def compact(key)
@@ -529,7 +570,8 @@ module Fugit
           ((a || 0)..(z || (a ? a : 6))).step(sl < 1 ? 1 : sl)
             .each { |i| @weekdays << [ i ] }
         elsif z
-          (a..z).each { |i| @weekdays << [ i ] }
+          z = z + 7 if a > z
+          (a..z).each { |i| @weekdays << [ (i > 6) ? i - 7 : i ] }
         elsif a
           @weekdays << [ a ]
         #else
@@ -538,6 +580,7 @@ module Fugit
 
       @weekdays.each { |wd| wd[0] = 0 if wd[0] == 7 } # turn sun7 into sun0
       @weekdays.uniq!
+      @weekdays.sort!
       @weekdays = nil if @weekdays.empty?
     end
 
@@ -685,7 +728,9 @@ module Fugit
 
         a = at ? rewrite_bound(k, at) : nil
         z = zt ? rewrite_bound(k, zt) : nil
-        a, z = z, a if a && z && a > z
+
+        #a, z = z, a if a && z && a > z
+          # handled downstream since gh-27
 
         [ a, z, sl, ha, mo ]
       end

data/lib/fugit/nat.rb

@@ -8,7 +8,7 @@ module Fugit
 
     class << self
 
-      def parse(s)
+      def parse(s, opts={})
 
         return s if s.is_a?(Fugit::Cron) || s.is_a?(Fugit::Duration)
 
@@ -17,20 +17,54 @@ module Fugit
 #p s; Raabro.pp(Parser.parse(s, debug: 3), colours: true)
         a = Parser.parse(s)
 
-        if a && a.include?([ :flag, 'every' ])
-          parse_cron(a)
-        else
-          nil
-        end
+        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
       end
 
-      def do_parse(s)
+      def do_parse(s, opts={})
 
-        parse(s) ||
+        parse(s, opts) ||
         fail(ArgumentError.new("could not parse a nat #{s.inspect}"))
       end
 
-      def parse_cron(a)
+      protected
+
+      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
+          .uniq
+
+        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
+
+        fail ArgumentError.new(
+          "multiple crons in #{s.inspect} " +
+          "(#{crons.collect(&:original).join(' | ')})"
+        ) if opts[:multi] == :fail && crons.size > 1
+
+        if opts[:multi] == true || (opts[:multi] && opts[:multi] != :fail)
+          crons
+        else
+          crons.first
+        end
+      end
+
+      def parse_cron(a, opts)
 
         h = { min: nil, hou: [], dom: nil, mon: nil, dow: nil }
         hkeys = h.keys
@@ -41,20 +75,25 @@ module Fugit
           elsif key == :simple_hour || key == :numeral_hour
             h[:hou] << val
           elsif key == :digital_hour
-            h[:hou] = [ val[0] ]
-            h[:min] = [ val[1] ]
+            (h[:hou] ||= []) << val[0].to_i
+            (h[:min] ||= []) << val[1].to_i
           elsif key == :name_day
             (h[:dow] ||= []) << val
-          elsif key == :flag && val == 'pm' && h[:hou]
-            h[:hou][-1] = h[:hou][-1] + 12
+          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[:hou].sort! if h[:hou]
+        h[:min].uniq!
+
+        h[:hou].uniq!;
+        h[:hou].sort!
+
         h[:dow].sort! if h[:dow]
 
         a = hkeys
@@ -63,6 +102,7 @@ module Fugit
             (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)
@@ -120,15 +160,28 @@ module Fugit
 
       # piece parsers bottom to top
 
+      def am_pm(i)
+        rex(:am_pm, i, / *(am|pm)/i)
+      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])/)
+      end
       def simple_hour(i)
-        rex(:simple_hour, i, /(2[0-4]|[01]?[0-9])/)
+        seq(:simple_hour, i, :_simple_hour, :am_pm, '?')
+      end
+
+      def _numeral_hour(i)
+        rex(:nh, i, /(#{NUMS.join('|')})/i)
       end
       def numeral_hour(i)
-        rex(:numeral_hour, i, /(#{NUMS.join('|')})/i)
+        seq(:numeral_hour, i, :_numeral_hour, :am_pm, '?')
       end
+
       def name_hour(i)
         rex(:name_hour, i, /(#{NHOURS.keys.join('|')})/i)
       end
@@ -137,6 +190,12 @@ module Fugit
       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 range_sep(i); rex(nil, i, / *- *| +(to|through) +/); end
+
+      def day_range(i)
+        seq(:day_range, i, :name_day, :range_sep, :name_day)
+      end
+
       def _tz_name(i)
         rex(nil, i, /[A-Z][a-zA-Z0-9+\-]+(\/[A-Z][a-zA-Z0-9+\-_]+){0,2}/)
       end
@@ -155,10 +214,11 @@ module Fugit
           /ix)
       end
 
-      def flag(i); rex(:flag, i, /(every|at|after|am|pm|on|in)/i); end
+      def flag(i); rex(:flag, i, /(every|from|at|after|on|in)/i); end
 
       def datum(i)
         alt(nil, i,
+          :day_range,
           :plain_day, :biz_day, :name_day,
           :_tz,
           :flag,
@@ -188,10 +248,6 @@ module Fugit
               [ k, [ tt.string.strip, EtOrbi.get_tzone(tt.string.strip) ] ]
             when :duration
               [ k, [ Fugit::Duration.parse(tt.string.strip) ] ]
-            when :numeral_hour
-              [ k, NUMS.index(v) ]
-            when :simple_hour
-              [ k, v.to_i ]
             when :digital_hour
               v = v.gsub(/:/, '')
               [ k, [ v[0, 2], v[2, 2] ] ]
@@ -199,6 +255,13 @@ module Fugit
               [ :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 }

data/lib/fugit/parse.rb

@@ -5,13 +5,13 @@ module Fugit
 
     def parse_cron(s); ::Fugit::Cron.parse(s); end
     def parse_duration(s); ::Fugit::Duration.parse(s); end
-    def parse_nat(s); ::Fugit::Nat.parse(s); end
+    def parse_nat(s, opts={}); ::Fugit::Nat.parse(s, opts); end
     def parse_at(s); ::Fugit::At.parse(s); end
     def parse_in(s); parse_duration(s); end
 
     def do_parse_cron(s); ::Fugit::Cron.do_parse(s); end
     def do_parse_duration(s); ::Fugit::Duration.do_parse(s); end
-    def do_parse_nat(s); ::Fugit::Nat.do_parse(s); end
+    def do_parse_nat(s, opts={}); ::Fugit::Nat.do_parse(s, opts); end
     def do_parse_at(s); ::Fugit::At.do_parse(s); end
     def do_parse_in(s); do_parse_duration(s); end
 
@@ -21,7 +21,7 @@ module Fugit
 
       (opts[:cron] != false && parse_cron(s)) ||
       (opts[:duration] != false && parse_duration(s)) ||
-      (opts[:nat] != false && parse_nat(s)) ||
+      (opts[:nat] != false && parse_nat(s, opts)) ||
       (opts[:at] != false && parse_at(s)) ||
       nil
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fugit
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.3.3
 platform: ruby
 authors:
 - John Mettraux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-21 00:00:00.000000000 Z
+date: 2019-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: raabro