fugit 1.3.4 → 1.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a10a8afb99cf16856e53766a86b1f0d13ddb0d2784c756cb525ceea8fbae7bd1
-  data.tar.gz: dcd1d01a8f5f8fc819854f430e12fc6bf69850e64060cffbe93c595be78785a2
+  metadata.gz: d2a28ef486584f37659fbcf4e6e4fecfc76aa2a4a6e1fc61d25dd3c44cd3a5c3
+  data.tar.gz: db726ca071f0f98d0f59c3054fca04a537ec2a17fd302013b354d90e1d7dc3c8
 SHA512:
-  metadata.gz: 4b29f59bffe4f786b90c0f0a42c26c682e78b523183863f7cfc8c486ecca9056bb96f5eae92b2ee9446ece5c84a10aeddd9a52077eece5357af8985853da99ee
-  data.tar.gz: a32ac9539496ff7f4bc1949f97eeefcf836a8f1607569080acafd2d338befd7cb97e10179ffee06d2da3ebead95830147f5f418a883a4bd2a77f549455761788
+  metadata.gz: d1105627f83fd730a7826047679edfd38ad7deb19960715e93769d5c04e80e0079b02b9513f9e5d01614e2e70b75a016a2e16b7a72f568e2a5d3072c42e7e1dc
+  data.tar.gz: eb4b14f1f564bd89ae919c16d6c06ef180b725c81b8d78225661b0a0fb34dee067063de9f2b883e6361e51c0db323224b6ee0a80ab3ca80dd9091a0e872ceae4

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 # CHANGELOG.md
 
 
+## fugit 1.3.5 released 2020-05-07
+
+* Implement cron @noon, gh-37
+* Normalize "every x", gh-37
+
+
 ## fugit 1.3.4 released 2020-04-06
 
 * Prevent #rough_frequency returning 0, gh-36

data/CREDITS.md

@@ -4,7 +4,7 @@
 * 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/lib/fugit.rb

@@ -1,7 +1,7 @@
 
 module Fugit
 
-  VERSION = '1.3.4'
+  VERSION = '1.3.5'
 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 ]

data/lib/fugit/nat.rb

@@ -15,6 +15,7 @@ module Fugit
         return nil unless s.is_a?(String)
 
 #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
@@ -37,20 +38,16 @@ 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 }
+        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 =
-          #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
+          ms.size > 1 ?
+          hms.collect { |e| parse_cron([ e ] + aa, opts) } :
+          [ parse_cron(a, opts) ]
 
         fail ArgumentError.new(
           "multiple crons in #{s.inspect} " +
@@ -66,34 +63,36 @@ module Fugit
 
       def parse_cron(a, opts)
 
-        h = { min: nil, hou: [], dom: nil, mon: nil, dow: nil }
+        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|
-          if key == :biz_day
+          case key
+          when :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
+          when :name_day
             (h[:dow] ||= []) << val
-          elsif key == :day_range
+          when :day_range
             (h[:dow] ||= []) << val.collect { |v| v.to_s[0, 3] }.join('-')
-          elsif key == :tz
+          when :tz
             h[:tz] = val
-          elsif key == :duration
-            process_duration(h, *val[0].to_h.first)
+          when :point
+            process_point(h, *val)
+          when :interval1
+            process_interval1(h, *val[0].to_h.first)
+          when :interval0
+            process_interval0(h, val)
           end
         end
 
-        h[:min] ||= [ 0 ]
-        h[:min].uniq!
-
-        h[:hou].uniq!;
-        h[:hou].sort!
+        return nil if h[:fail]
 
+        h[:min] = (h[:min] || [ 0 ]).uniq
+        h[:hou] = (h[:hou] || []).uniq.sort
         h[:dow].sort! if h[:dow]
 
         a = hkeys
@@ -108,40 +107,92 @@ module Fugit
         Fugit::Cron.parse(s)
       end
 
-      def process_duration(h, interval, value)
-
-        send("process_duration_#{interval}", h, value)
-      end
-
-      def process_duration_mon(h, value)
+      def process_point(h, key, *value)
 
-        h[:hou] = [ 0 ]
-        h[:dom] = [ 1 ]
-        h[:mon] = [ value == 1 ? '*' : "*/#{value}" ]
-      end
-
-      def process_duration_day(h, value)
-
-        h[:hou] = [ 0 ]
-        h[:dom] = [ value == 1 ? '*' : "*/#{value}" ]
+        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
       end
 
-      def process_duration_hou(h, value)
-
-        h[:hou] = [ value == 1 ? '*' : "*/#{value}" ]
+      def process_interval0(h, value)
+
+        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
       end
 
-      def process_duration_min(h, value)
-
-        h[:hou] = [ '*' ]
-        h[:min] = [ value == 1 ? '*' : "*/#{value}" ]
-      end
+      def process_interval1(h, interval, value)
 
-      def process_duration_sec(h, value)
+        if value != 1 && [ :yea, :wee ].include?(interval)
+          int = interval == :year ? 'years' : 'weeks'
+          h[:fail] = "cannot cron for \"every #{value} #{int}\""
+          return
+        end
 
-        h[:hou] = [ '*' ]
-        h[:min] = [ '*' ]
-        h[:sec] = [ value == 1 ? '*' : "*/#{value}" ]
+        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
       end
     end
 
@@ -160,6 +211,11 @@ module Fugit
 
       # piece parsers bottom to top
 
+      def interval0(i)
+        rex(:interval0, i,
+          /(year|month|week|day|hour|min(ute)?|sec(ond)?)(?![a-z])/i)
+      end
+
       def am_pm(i)
         rex(:am_pm, i, / *(am|pm)/i)
       end
@@ -186,7 +242,6 @@ module Fugit
         rex(:name_hour, i, /(#{NHOURS.keys.join('|')})/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
 
@@ -204,26 +259,36 @@ module Fugit
       end
       def _tz(i); alt(:tz, i, :_tz_delta, :_tz_name); end
 
-      def duration(i)
-        rex(
-          :duration, i,
+      def interval1(i)
+        rex(:interval1, i,
           /
             \d+
             \s?
-            (mon(ths?)?|d(ays?)?|h(ours?)?|m(in(ute)?s?)?|s(ec(ond)?s?)?)
+            (y(ears?)?|months?|w(eeks?)?|d(ays?)?|
+              h(ours?)?|m(in(ute)?s?)?|s(ec(ond)?s?)?)
           /ix)
       end
 
+      def min_or_sec(i)
+        rex(:min_or_sec, i, /(min(ute)?|sec(ond)?)\s+\d+/i)
+      end
+
+      def point(i)
+        alt(:point, i,
+          :min_or_sec,
+          :name_hour, :numeral_hour, :digital_hour, :simple_hour)
+      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,
-          :duration,
-          :name_hour, :numeral_hour, :digital_hour, :simple_hour)
+          :interval1,
+          :point,
+          :interval0,
+          :day_range, :biz_day, :name_day,
+          :_tz)
       end
 
       def sugar(i); rex(nil, i, /(and|or|[, \t]+)/i); end
@@ -233,38 +298,62 @@ module Fugit
 
       # rewrite parsed tree
 
+      def _rewrite(t)
+        [ t.name, t.string.downcase ]
+      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]) ]
+      end
+
+      def rewrite_day_range(t)
+        [ :day_range, t.subgather(nil).collect { |st| st.string.downcase } ]
+      end
+
+      def rewrite_name_hour(t)
+        [ :hour, *NHOURS[t.string.strip.downcase] ]
+      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 ]
+      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 ]
+      end
+      def rewrite_digital_hour(t)
+        v = t.string.gsub(/:/, '')
+        [ :hour, v[0, 2], v[2, 2] ]
+      end
+
+      def rewrite_min_or_sec(t)
+        unit, num = t.string.split(/\s+/)
+        [ unit[0, 3].to_sym, num.to_i ]
+      end
+
+      def rewrite_point(t)
+        [ :point, rewrite(t.sublookup) ]
+      end
+
+      def rewrite_tz(t)
+        [ :tz,  [ t.string.strip, EtOrbi.get_tzone(t.string.strip) ] ]
+      end
+
+      def rewrite_interval1(t)
+        [ t.name, [ Fugit::Duration.parse(t.string.strip) ] ]
+      end
+
       def rewrite_nat(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 }
+        t.subgather(nil).collect { |tt| rewrite(tt) }
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fugit
 version: !ruby/object:Gem::Version
-  version: 1.3.4
+  version: 1.3.5
 platform: ruby
 authors:
 - John Mettraux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-05 00:00:00.000000000 Z
+date: 2020-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: raabro