fugit 1.8.0 → 1.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe369cec5c3fb690ead6f7638fcd430db71fd6525070c45aa48a8c7b3c3d4171
-  data.tar.gz: ce486e692afb9bf796122005314c89185373b07d596684b8c7a3f395bf36d1b4
+  metadata.gz: dfedcc6bdc1657d09a8c7a4dc23ad0cdb7abe7a78d5ec007477794361f678aaf
+  data.tar.gz: 617b8fb21468bb4a6c17294a9c856b2975dd67f5cb6add6569047545a92305ee
 SHA512:
-  metadata.gz: 94b9b504e574dbff1f6b0abab21028c97c0303533a8b45747ae6250c6d866c83c7b1999c5cce4680f5015f62946e9ba2f0a2e28af0faf5dc6194c3649b615b97
-  data.tar.gz: a70bdcd045774d4290cc7d014c62793e28f4a322bf8a3f93d7ee5ce2b2d37744481d32896ce5c88ff89cd3fddfe7ec37bf41c5d3b480dafea45a0d246e1636bd
+  metadata.gz: c22968c95e4986b091ed498a848a1f18800cb3217af2e1a1a999ac15a979c8fce8243672f33704e125e09c4dde1adb38b33c0ee3c639f355003d00e734e097a1
+  data.tar.gz: 99f6e2170a616663f536ddf9d1b627130ff0e4f20277a2b7011b24ecaa50e43ad2a9ce944c51ace296a6151df71583d7f6e921023a91e9aa82c7820389b39abb

data/CHANGELOG.md

@@ -2,6 +2,30 @@
 # CHANGELOG.md
 
 
+## fugit 1.10.1 released 2024-02-29
+
+* Fix on Ruby 2.2.6 thanks to @aunghtain, gh-93
+
+
+## fugit 1.10.0 released 2024-02-22
+
+* Implement `Fugit::Cron#within(time_start, time_end)`
+* Implement `Fugit::Cron#within(time_range)`
+* Implement iterator-returning `Fugit::Cron#next` and `#prev`
+
+
+## fugit 1.9.0 released 2023-10-24
+
+* Let nat parse "last", gh-88
+* Change that I am not sure about, gh-86
+
+
+## fugit 1.8.1 released 2023-01-20
+
+* Fix for month subtraction, gh-84, @mreinsch
+* Fix duration - time, gh-85, @mreinsch
+
+
 ## fugit 1.8.0 released 2022-12-06
 
 * Introduce Fugit.parse_cronish and .do_parse_cronish, gh-70

data/CREDITS.md

@@ -1,6 +1,10 @@
 
 # fugit credits
 
+* https://hithub.com/aunghtain, gh-93, include oneliner vs Ruby 2.6.6
+* Marcos Belluci, https://github.com/delbetu, gh-88, 1st and last nat
+* Michael Reinsch, https://github.com/mreinsch, gh-84 and gh-85
+* Marc Anguera, https://github.com/markets, gh-70 and Sidekiq-Cron
 * ski-nine, https://github.com/ski-nine, gh-81
 * Joseph Halter, https://github.com/JosephHalter, gh-79
 * James Healy, https://github.com/yob, gh-76

data/LICENSE.txt

@@ -1,5 +1,5 @@
 
-Copyright (c) 2017-2022, John Mettraux, jmettraux+flor@gmail.com
+Copyright (c) 2017-2024, 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/README.md

@@ -3,7 +3,6 @@
 
 [![tests](https://github.com/floraison/fugit/workflows/test/badge.svg)](https://github.com/floraison/fugit/actions)
 [![Gem Version](https://badge.fury.io/rb/fugit.svg)](http://badge.fury.io/rb/fugit)
-[![Join the chat at https://gitter.im/floraison/fugit](https://badges.gitter.im/floraison/fugit.svg)](https://gitter.im/floraison/fugit?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 Time tools for [flor](https://github.com/floraison/flor) and the floraison group.
 
@@ -27,17 +26,21 @@ The intersection of those two projects is where fugit is born:
 * [parse-cron](https://github.com/siebertm/parse-cron) - parses cron expressions and calculates the next occurrence after a given date
 * [ice_cube](https://github.com/seejohnrun/ice_cube) - Ruby date recurrence library
 * [ISO8601](https://github.com/arnau/ISO8601) - Ruby parser to work with ISO8601 dateTimes and durations
+* [chrono](https://github.com/r7kamura/chrono) - a chain of logics about chronology
+* [CronCalc](https://github.com/mizinsky/cron_calc) - calculates cron job occurrences
+* [Recurrence](https://github.com/fnando/recurrence) - a simple library to handle recurring events
 * ...
 
 ### Projects using fugit
 
 * [arask](https://github.com/Ebbe/arask) - "Automatic RAils taSKs" uses fugit to parse cron strings
 * [sidekiq-cron](https://github.com/ondrejbartas/sidekiq-cron) - recent versions of Sidekiq-Cron use fugit to parse cron strings
-* [rufus-scheduler](https://github.com/jmettraux/rufus-scheduler) -
+* [rufus-scheduler](https://github.com/jmettraux/rufus-scheduler) - as seen above
 * [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
 * [delayed_cron_job](https://github.com/codez/delayed_cron_job) - an extension to Delayed::Job that allows you to set cron expressions for your jobs
+* [GoodJob](https://github.com/bensheldon/good_job) - a multithreaded, Postgres-based, Active Job backend for Ruby on Rails
 * ...
 
 ## `Fugit.parse(s)`
@@ -93,7 +96,7 @@ As `Fugit.parse(s)` returns nil when it doesn't grok its input, and `Fugit.do_pa
 
 Sometimes you know a cron expression or an "every" natural expression will come in and you want to discard the rest.
 
-```
+```ruby
 require 'fugit'
 
 Fugit.parse_cronish('0 0 1 jan *').class             # ==> ::Fugit::Cron
@@ -123,8 +126,44 @@ c = Fugit::Cron.new('0 0 * *  sun')
 
 p Time.now  # => 2017-01-03 09:53:27 +0900
 
-p c.next_time      # => 2017-01-08 00:00:00 +0900
-p c.previous_time  # => 2017-01-01 00:00:00 +0900
+p c.next_time.to_s      # => 2017-01-08 00:00:00 +0900
+p c.previous_time.to_s  # => 2017-01-01 00:00:00 +0900
+
+p c.next_time(Time.parse('2024-06-01')).to_s
+  # => "2024-06-02 00:00:00 +0900"
+p c.previous_time(Time.parse('2024-06-01')).to_s
+  # => "2024-05-26 00:00:00 +0900"
+    #
+    # `Fugit::Cron#next_time` and `#previous_time` accept a "start time"
+
+c = Fugit.parse_cron('0 12 * * mon#2')
+
+  # `#next` and `#prev` return Enumerable instances
+  #
+c.next(Time.parse('2024-02-16 12:00:00'))
+  .take(3)
+  .map(&:to_s)
+    # => [ '2024-03-11 12:00:00',
+    #      '2024-04-08 12:00:00',
+    #      '2024-05-13 12:00:00' ]
+c.prev(Time.parse('2024-02-16 12:00:00'))
+  .take(3)
+  .map(&:to_s)
+    # => [ '2024-02-12 12:00:00',
+    #      '2024-01-08 12:00:00',
+    #      '2023-12-11 12:00:00' ]
+
+  # `#within` accepts a time range and returns an array of Eo::EoTime
+  # instances that correspond to the occurrences of the cron within
+  # the time range
+  #
+c.within(Time.parse('2024-02-16 12:00')..Time.parse('2024-08-01 12:00'))
+  .map(&:to_s)
+    # => [ '2024-03-11 12:00:00',
+    #      '2024-04-08 12:00:00',
+    #      '2024-05-13 12:00:00',
+    #      '2024-06-10 12:00:00',
+    #      '2024-07-08 12:00:00' ]
 
 p c.brute_frequency  # => [ 604800, 604800, 53 ]
                      #    [ delta min, delta max, occurrence count ]
@@ -269,6 +308,18 @@ c.match?('2019-01-08')  # => false, since (rweek + 1) % 2 == 1
 `tue%x+y` matches if Tuesday and `current_date.rweek + y % x == 0`
 
 
+### the second extension
+
+Fugit accepts cron strings with five elements, `minute hour day-of-month month day-of-week`, the standard cron format or six elements `second minute hour day-of-month month day-of-week`.
+
+```ruby
+c = Fugit.parse('* * * * *') # every minute
+c = Fugit.parse('5 * * * *') # every hour at minute 5
+c = Fugit.parse('* * * * * *') # every second
+c = Fugit.parse('5 * * * * *') # every minute at second 5
+```
+
+
 ## `Fugit::Duration`
 
 A class `Fugit::Duration` to parse duration strings (vanilla [rufus-scheduler](https://github.com/jmettraux/rufus-scheduler) ones and [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) ones).
@@ -402,7 +453,8 @@ Fugit::Nat.parse('every day at 16:15 and 18:30', multi: true)
     # ==> [ '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 * * *)
+  # ==> 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
 ```

data/lib/fugit/cron.rb

@@ -40,8 +40,6 @@ module Fugit
 #p s; Raabro.pp(Parser.parse(s, debug: 3), colors: true)
         h = Parser.parse(s.strip)
 
-        return nil unless h
-
         self.allocate.send(:init, s, h)
       end
 
@@ -320,6 +318,60 @@ module Fugit
       t.time.translate(from.zone)
     end
 
+    # Used by Fugit::Cron#next and Fugit::Cron#prev
+    #
+    class CronIterator
+      include ::Enumerable
+
+      attr_reader :cron, :start, :current, :direction
+
+      def initialize(cron, direction, start)
+
+        @cron = cron
+        @start = start
+        @current = start.dup
+        @direction = direction
+      end
+
+      def each
+
+        loop do
+
+          yield(@current = @cron.send(@direction, @current))
+        end
+      end
+    end
+
+    # Returns an ::Enumerable instance that yields each "next time" in
+    # succession
+    #
+    def next(from=::EtOrbi::EoTime.now)
+
+      CronIterator.new(self, :next_time, from)
+    end
+
+    # Returns an ::Enumerable instance that yields each "previous time" in
+    # succession
+    #
+    def prev(from=::EtOrbi::EoTime.now)
+
+      CronIterator.new(self, :previous_time, from)
+    end
+
+    # Returns an array of EtOrbi::EoTime instances that correspond to
+    # the occurrences of the cron within the given time range
+    #
+    def within(time_range, time_end=nil)
+
+      sta, ned =
+        time_range.is_a?(::Range) ? [ time_range.begin, time_range.end ] :
+        [ ::EtOrbi.make_time(time_range), ::EtOrbi.make_time(time_end) ]
+
+      CronIterator
+        .new(self, :next_time, sta)
+        .take_while { |eot| eot.to_t < ned }
+    end
+
     # Mostly used as a #next_time sanity check.
     # Avoid for "business" use, it's slow.
     #
@@ -488,18 +540,22 @@ module Fugit
 
     def init(original, h)
 
+      return nil unless h
+
       @original = original
       @cron_s = nil # just to be sure
       @day_and = h[:&]
 
-      determine_seconds(h[:sec])
-      determine_minutes(h[:min])
-      determine_hours(h[:hou])
-      determine_monthdays(h[:dom])
-      determine_months(h[:mon])
-      determine_weekdays(h[:dow])
-      determine_timezone(h[:tz])
+      valid =
+        determine_seconds(h[:sec]) &&
+        determine_minutes(h[:min]) &&
+        determine_hours(h[:hou]) &&
+        determine_monthdays(h[:dom]) &&
+        determine_months(h[:mon]) &&
+        determine_weekdays(h[:dow]) &&
+        determine_timezone(h[:tz])
 
+      return nil unless valid
       return nil unless compact_month_days
 
       self
@@ -509,10 +565,12 @@ module Fugit
 
       sta, edn, sla = r
 
+      return false if sla && sla > max
+
       edn = max if sla && edn.nil?
 
-      return [ nil ] if sta.nil? && edn.nil? && sla.nil?
-      return [ sta ] if sta && edn.nil?
+      return nil if sta.nil? && edn.nil? && sla.nil?
+      return sta if sta && edn.nil?
 
       sla = 1 if sla == nil
       sta = min if sta == nil
@@ -563,42 +621,41 @@ module Fugit
         .uniq
     end
 
-    def compact(key)
+    def do_determine(key, arr, min, max)
 
-      arr = instance_variable_get(key)
+      null = false
 
-      return instance_variable_set(key, nil) if arr.include?(nil)
-        # reductio ad astrum
+      r = arr
+        .collect { |v|
+          expand(min, max, v) }
+        .flatten(1)
+        .collect { |e|
+          return false if e == false
+          null = null || e == nil
+          (key == :hours && e == 24) ? 0 : e }
 
-      arr.uniq!
-      arr.sort!
+      return nil if null
+      r.uniq.sort
     end
 
     def determine_seconds(arr)
-      @seconds = (arr || [ 0 ]).inject([]) { |a, s| a.concat(expand(0, 59, s)) }
-      compact(:@seconds)
+      (@seconds = do_determine(:seconds, arr || [ 0 ], 0, 59)) != false
     end
 
     def determine_minutes(arr)
-      @minutes = arr.inject([]) { |a, m| a.concat(expand(0, 59, m)) }
-      compact(:@minutes)
+      (@minutes = do_determine(:minutes, arr, 0, 59)) != false
     end
 
     def determine_hours(arr)
-      @hours = arr
-        .inject([]) { |a, h| a.concat(expand(0, 23, h)) }
-        .collect { |h| h == 24 ? 0 : h }
-      compact(:@hours)
+      (@hours = do_determine(:hours, arr, 0, 23)) != false
     end
 
     def determine_monthdays(arr)
-      @monthdays = arr.inject([]) { |a, d| a.concat(expand(1, 31, d)) }
-      compact(:@monthdays)
+      (@monthdays = do_determine(:monthdays, arr, 1, 31)) != false
     end
 
     def determine_months(arr)
-      @months = arr.inject([]) { |a, m| a.concat(expand(1, 12, m)) }
-      compact(:@months)
+      (@months = do_determine(:months, arr, 1, 12)) != false
     end
 
     def determine_weekdays(arr)
@@ -624,11 +681,15 @@ module Fugit
       @weekdays.uniq!
       @weekdays.sort!
       @weekdays = nil if @weekdays.empty?
+
+      true
     end
 
     def determine_timezone(z)
 
       @zone, @timezone = z
+
+      true
     end
 
     def weekdays_to_cron_s

data/lib/fugit/duration.rb

@@ -68,8 +68,10 @@ module Fugit
       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' } }.freeze
-    INFLA_KEYS, NON_INFLA_KEYS =
-      KEYS.partition { |k, v| v[:I] }.freeze
+
+    INFLA_KEYS, NON_INFLA_KEYS = KEYS
+      .partition { |k, v| v[:I] }
+      .collect(&:freeze)
 
     def _to_s(key)
 
@@ -240,7 +242,7 @@ module Fugit
           n, m = at[1] / 12, at[1] % 12
           at[0], at[1] = at[0] + n, m
         elsif at[1] < 1
-          n, m = -at[1] / 12, -at[1] % 12
+          n, m = (-at[1]) / 12 + 1, (11+at[1]) % 12 + 1
           at[0], at[1] = at[0] - n, m
         end
 
@@ -269,7 +271,7 @@ module Fugit
       when Numeric then add_numeric(-a)
       when Fugit::Duration then add_duration(-a)
       when String then add_duration(-self.class.parse(a))
-      when ::Time, ::EtOrbi::EoTime then add_to_time(a)
+      when ::Time, ::EtOrbi::EoTime then opposite.add_to_time(a)
       else fail ArgumentError.new(
         "cannot subtract #{a.class} instance to a Fugit::Duration")
       end

data/lib/fugit/nat.rb

@@ -642,9 +642,9 @@ module Fugit
           fail(ArgumentError.new(
             "multiple crons in #{opts[:_s].inspect} - #{@slots.inspect}"))
         elsif multi == true
-          hms.collect { |hm| parse_cron(hm) }
+          hms.collect { |hm| parse_cron(hm, opts) }
         else
-          parse_cron(hms.first)
+          parse_cron(hms.first, opts)
         end
       end
 
@@ -678,7 +678,7 @@ module Fugit
           .to_a
       end
 
-      def parse_cron(hm)
+      def parse_cron(hm, opts)
 
         a = [
           slot(:second, '0'),
@@ -691,11 +691,39 @@ module Fugit
         a << tz.data0 if tz
         a.shift if a.first == [ '0' ]
 
+        letters_last = lambda { |x| x.is_a?(Numeric) ? x : 999_999 }
+
         s = a
-          .collect { |e| e.uniq.sort.collect(&:to_s).join(',') }
+          .collect { |e|
+            e.uniq.sort_by(&letters_last).collect(&:to_s).join(',') }
           .join(' ')
 
-        Fugit::Cron.parse(s)
+        c = Fugit::Cron.parse(s)
+
+        if opts[:strict]
+          restrict(a, c)
+        else
+          c
+        end
+      end
+
+      # Return nil if the cron is "not strict"
+      #
+      # For example, "0 0/17 * * *" (gh-86) is a perfectly valid
+      # cron string, but makes not much sense when derived via `.parse_nat`
+      # from "every 17 hours".
+      #
+      # It happens here because it's nat being strict, not cron.
+      #
+      def restrict(a, cron)
+
+        if m = ((a[1] && a[1][0]) || '').match(/^(\d+|\*)\/(\d+)$/)
+#p m
+           sla = m[1].to_i
+          return nil unless [ 1, 2, 3, 4, 5, 6, 8, 12 ].include?(sla)
+        end
+
+        cron
       end
 
       def slot(key, default)

data/lib/fugit.rb

@@ -3,7 +3,7 @@
 
 module Fugit
 
-  VERSION = '1.8.0'
+  VERSION = '1.10.1'
 end
 
 require 'time'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fugit
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 1.10.1
 platform: ruby
 authors:
 - John Mettraux
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-06 00:00:00.000000000 Z
+date: 2024-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: raabro
@@ -116,7 +116,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: time tools for flor