fugit 1.11.2 → 1.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0951fa769cae432ad6e27c721a2abd80464c0d664a9254ba034de7dfcaaef23
-  data.tar.gz: 27bf22062b2e54764ae30cf68d39e8f514a5e5fdb43034a33b738ae3be9326b8
+  metadata.gz: 15c7da961f6616177b4837e7db2b8d2cbef8a73af0e39d482bbde88ca927d420
+  data.tar.gz: bdb787682ba39f3bd873c935378d7097291ff275c9c2443a4bf42990e71dfa92
 SHA512:
-  metadata.gz: 5ceb6ff8033f80397465ddbb2b0d8ba17739208c7d0ecf3ce594fde86912c7d6ef8cccbff4b1f4e094bfa4fee6eeedbf9a3e136ba7732894e810c63a584442b8
-  data.tar.gz: 24ad8e57d86132aac3231e56f162abc5454d608bab8fa61d90c22ea9af334b30a3b32d072db72fa425cce244f38da18dfbb814a2b0e23bd588b5d86006ff5f4e
+  metadata.gz: c920de689a07b8e5b082afa2d67ff26a2ad3422e0a35afc0c02fee71d92d6a76da391d7ec6d03e55d62cbc1a46cbf1296bccb4a37ec9df9d72f35d3e4ecaf0ad
+  data.tar.gz: 11694200215f7506f64f862d7f63e86b3fc79be5ad4a4ddfe9278143c40991bcd2c89356e9e314d5caad125b0b26623daf3da64ee2e92b49ca1480b59fc220f3

data/CHANGELOG.md

@@ -2,6 +2,35 @@
 # CHANGELOG.md
 
 
+## fugit 1.13.0 released 2026-07-10
+
+* Random values support in cron string `"10 ~ * * *"` gh-121 Nicols Bachschmidt
+
+
+## fugit 1.12.3 released 2026-07-01
+
+* Wrap-around for weekday ranges with step value, gh-119 Nicolas Bachschmidt
+
+
+## fugit 1.12.2 released 2026-05-28
+
+* Fix "divide by zero" gh-117
+* Let at parse 'now', gh-111
+* Let Fugit::At pass options to Chronic, gh-116
+
+
+## fugit 1.12.1 released 2025-10-14
+
+* Fix Fugit::Cron#to_cron_s to include & if @day_and
+
+
+## fugit 1.12.0 released 2025-09-30
+
+* Upgrade et-orbi to ~> 1.4.0 for EtOrbi.rweek_ref=, gh-114
+  this changes the rweek reference point to 2018-12-31 (Monday)
+* Fix `12 0 * * wed%4+1,wed%4` issue where 1 wed was ignored, gh-114
+
+
 ## fugit 1.11.2 released 2025-08-22
 
 * Fix "every day at midnight America/Los_Angeles", gh-113, Mark R. James

data/CREDITS.md

@@ -1,10 +1,14 @@
 
 # fugit credits
 
+* Nicolas Bachschmidt https://github.com/baarde gh-120 weekday wrap fix
+* JebeenLee https://github.com/JebeenLee gh-117 divide by zero
+* Eric Claerhout https://github.com/swebra gh-114 rweek readme clarity
+* Hugh Kelsey https://github.com/hughkelsey gh-114 rweek/rday / wed%4+1,wed%4
 * Mark R. James, https://github.com/mrj, AM vs America/Los_Angeles, gh-113
 * Tejas Bubane, https://github.com/tejasbubane, r3.4 in test matrix, gh-109
 * Luis Castillo, https://github.com/lekastillo, nice_hash gh-108
-* Geremia Taglialatela, https://github.com/tagliala, gh-105 gh-107
+* Geremia Taglialatela, https://github.com/tagliala, gh-105 gh-107 gh-122
 * https://github.com/personnumber3377, gh-104 Fugit.parse choke on long input
 * Michael Scrivo, https://github.com/mscrivo, gh-103
 * Benjamin Darcet, https://github.com/bdarcet gh-95 gh-96 et-orbi #rweek

data/LICENSE.txt

@@ -1,5 +1,5 @@
 
-Copyright (c) 2017-2025, John Mettraux, jmettraux+flor@gmail.com
+Copyright (c) 2017-2026, 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

@@ -1,6 +1,12 @@
 
 # fugit
 
+> Sed fugit interea, fugit irreparabile tempus
+
+Virgil, _Georgics_ Book III
+
+---
+
 [![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)
 
@@ -296,43 +302,211 @@ The hash extension can only be used in the day-of-week field.
 
 ### 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".
+Since 1.1.10, fugit also understands cron strings like `9 0 * * sun%2` which can be read as "every other Sunday at 9am" or `12 0 * * mon%4` for "every fourth monday at noon".
 
 The modulo extension can only be used in the day-of-week field.
 
 For odd Sundays, one can write `9 0 * * sun%2+1`.
 
-It can be combined, as in `9 0 * * sun%2,tue%3+2`
+It can be combined, as in `9 0 * * sun%2,tue%3+2`, which will match every other Sunday and 1 in 3 Tuesdays (with an offset of 2).
+
+What does `sun%2` actually mean?
+```ruby
+t.wday == 0 && t.rweek % 2 == 0
+```
+
+What does `tue%3+2` mean?
+```ruby
+t.wday == 2 && t.rweek % 3 == 2
+```
+
+#### et-orbi < 1.4.0 : reference set on Tuesday 2019-01-01
 
-But what does it reference to? It starts at 1 on 2019-01-01 (in the EtOrbi instance timezone, not the UTC "timezone").
+The original implementation of `#rweek` (and `#rday`) found in [et-orbi](https://github.com/floraison/et-orbi) was initially pointing to "Tuesday 2019-01-01" and it was set as rday 1 and rweek 1.
 
+Consider this iteration through the days around 2019-01-01.
 ```ruby
-require 'et-orbi' # >= 1.1.8
+require 'fugit'
+
+t = EtOrbi.parse('2018-12-28 12:00')
 
-# the reference
-p EtOrbi.parse('2019-01-01').wday       # => 2
-p EtOrbi.parse('2019-01-01').rweek      # => 1
-p EtOrbi.parse('2019-01-01').rweek % 2  # => 1
+15.times do |i|
 
-# today (as of this coding...)
-p EtOrbi.parse('2019-04-11').wday       # => 4
-p EtOrbi.parse('2019-04-11').rweek      # => 15
-p EtOrbi.parse('2019-04-11').rweek % 2  # => 1
+  puts " * %14s / rday: %5d / rweek: %5d" % [
+    t.strftime('%F %a'), t.rday, t.rweek ]
 
-c = Fugit.parse('* * * * tue%2')
-c.match?('2019-01-01')  # => false, since rweek % 2 == 1
-c.match?('2019-01-08')  # => true, since rweek % 2 == 0
+  w = t.rweek
+  t = t.add(24 * 3600)
+  puts if t.rweek != w
+
+  if i == 7
+    puts "\n  (...)\n\n"
+    t = EtOrbi.parse('2025-10-04 12:00')
+  end
+end
+```
+
+For et-orbi 1.2.11, it yields:
+```
+ * 2018-12-28 Fri / rday:    -3 / rweek:     0
+ * 2018-12-29 Sat / rday:    -2 / rweek:     0
+ * 2018-12-30 Sun / rday:    -1 / rweek:     0
+ * 2018-12-31 Mon / rday:     0 / rweek:     0
+
+ * 2019-01-01 Tue / rday:     1 / rweek:     1
+ * 2019-01-02 Wed / rday:     2 / rweek:     1
+ * 2019-01-03 Thu / rday:     3 / rweek:     1
+ * 2019-01-04 Fri / rday:     4 / rweek:     1
+ * 2019-01-05 Sat / rday:     5 / rweek:     1
+
+  (...)
+
+ * 2025-10-04 Sat / rday:  2469 / rweek:   353
+ * 2025-10-05 Sun / rday:  2470 / rweek:   353
+ * 2025-10-06 Mon / rday:  2471 / rweek:   353
+
+ * 2025-10-07 Tue / rday:  2472 / rweek:   354
+ * 2025-10-08 Wed / rday:  2473 / rweek:   354
+ * 2025-10-09 Thu / rday:  2474 / rweek:   354
+```
+
+This [was problematic](https://github.com/floraison/fugit/issues/114), since the week started on, well, Tuesday.
+
+
+#### et-orbi >= 1.4.0 : reference set on Monday 2018-12-31
+
+Since 1.4.0, et-orbi starts by default on Monday (2018-12-31), as rday 0 with rweek 0.
+
+Thus, the above code yields:
+```
+ * 2018-12-28 Fri / rday:    -3 / rweek:    -1
+ * 2018-12-29 Sat / rday:    -2 / rweek:    -1
+ * 2018-12-30 Sun / rday:    -1 / rweek:    -1
+
+ * 2018-12-31 Mon / rday:     0 / rweek:     0
+ * 2019-01-01 Tue / rday:     1 / rweek:     0
+ * 2019-01-02 Wed / rday:     2 / rweek:     0
+ * 2019-01-03 Thu / rday:     3 / rweek:     0
+ * 2019-01-04 Fri / rday:     4 / rweek:     0
+ * 2019-01-05 Sat / rday:     5 / rweek:     0
+
+  (...)
+
+ * 2025-10-04 Sat / rday:  2469 / rweek:   352
+ * 2025-10-05 Sun / rday:  2470 / rweek:   352
+
+ * 2025-10-06 Mon / rday:  2471 / rweek:   353
+ * 2025-10-07 Tue / rday:  2472 / rweek:   353
+ * 2025-10-08 Wed / rday:  2473 / rweek:   353
+ * 2025-10-09 Thu / rday:  2474 / rweek:   353
+```
 
-c = Fugit.parse('* * * * tue%2+1')
-c.match?('2019-01-01')  # => true, since (rweek + 1) % 2 == 0
-c.match?('2019-01-08')  # => false, since (rweek + 1) % 2 == 1
 
-# ...
+#### modulo and et-orbi >= 1.4.0 sanity check
+
+Given the cron `"0 12 * * mon%2,wed%3+1"`, here is a piece of code that considers a range of 44 days and tells in its last column if YES or no if each of the days matches the cron.
+
+```ruby
+require 'fugit'
+
+c = Fugit.parse_cron('0 12 * * mon%2,wed%3+1')
+
+t = EtOrbi.parse('2025-09-20 12:00')
+
+44.times do
+
+  wd = t.strftime('%a')
+  wd = %w[ Mon Wed ].include?(wd) ? '*' + wd.upcase : ' ' + wd.downcase
+
+  puts "%14s | rweek: %3d | %%2: %d == 0 | %%3: %d == 1 | ? %3s" % [
+    t.strftime('%F') + ' ' + wd,
+    t.rweek,
+    t.rweek % 2, t.rweek % 3,
+    c.match?(t)
+      ].map { |e| e == true ? 'YES' : e == false ? 'no' : e }
+
+  w = t.rweek
+  t = t.add(24 * 3600)
+  puts if t.rweek != w
+end
+```
+
+Here's the output:
+```
+2025-09-20  sat | rweek: 350 | %2: 0 == 0 | %3: 2 == 1 | ?  no
+2025-09-21  sun | rweek: 350 | %2: 0 == 0 | %3: 2 == 1 | ?  no
+
+2025-09-22 *MON | rweek: 351 | %2: 1 == 0 | %3: 0 == 1 | ?  no
+2025-09-23  tue | rweek: 351 | %2: 1 == 0 | %3: 0 == 1 | ?  no
+2025-09-24 *WED | rweek: 351 | %2: 1 == 0 | %3: 0 == 1 | ?  no
+2025-09-25  thu | rweek: 351 | %2: 1 == 0 | %3: 0 == 1 | ?  no
+2025-09-26  fri | rweek: 351 | %2: 1 == 0 | %3: 0 == 1 | ?  no
+2025-09-27  sat | rweek: 351 | %2: 1 == 0 | %3: 0 == 1 | ?  no
+2025-09-28  sun | rweek: 351 | %2: 1 == 0 | %3: 0 == 1 | ?  no
+
+2025-09-29 *MON | rweek: 352 | %2: 0 == 0 | %3: 1 == 1 | ? YES
+2025-09-30  tue | rweek: 352 | %2: 0 == 0 | %3: 1 == 1 | ?  no
+2025-10-01 *WED | rweek: 352 | %2: 0 == 0 | %3: 1 == 1 | ? YES
+2025-10-02  thu | rweek: 352 | %2: 0 == 0 | %3: 1 == 1 | ?  no
+2025-10-03  fri | rweek: 352 | %2: 0 == 0 | %3: 1 == 1 | ?  no
+2025-10-04  sat | rweek: 352 | %2: 0 == 0 | %3: 1 == 1 | ?  no
+2025-10-05  sun | rweek: 352 | %2: 0 == 0 | %3: 1 == 1 | ?  no
+
+2025-10-06 *MON | rweek: 353 | %2: 1 == 0 | %3: 2 == 1 | ?  no
+2025-10-07  tue | rweek: 353 | %2: 1 == 0 | %3: 2 == 1 | ?  no
+2025-10-08 *WED | rweek: 353 | %2: 1 == 0 | %3: 2 == 1 | ?  no
+2025-10-09  thu | rweek: 353 | %2: 1 == 0 | %3: 2 == 1 | ?  no
+2025-10-10  fri | rweek: 353 | %2: 1 == 0 | %3: 2 == 1 | ?  no
+2025-10-11  sat | rweek: 353 | %2: 1 == 0 | %3: 2 == 1 | ?  no
+2025-10-12  sun | rweek: 353 | %2: 1 == 0 | %3: 2 == 1 | ?  no
+
+2025-10-13 *MON | rweek: 354 | %2: 0 == 0 | %3: 0 == 1 | ? YES
+2025-10-14  tue | rweek: 354 | %2: 0 == 0 | %3: 0 == 1 | ?  no
+2025-10-15 *WED | rweek: 354 | %2: 0 == 0 | %3: 0 == 1 | ?  no
+2025-10-16  thu | rweek: 354 | %2: 0 == 0 | %3: 0 == 1 | ?  no
+2025-10-17  fri | rweek: 354 | %2: 0 == 0 | %3: 0 == 1 | ?  no
+2025-10-18  sat | rweek: 354 | %2: 0 == 0 | %3: 0 == 1 | ?  no
+2025-10-19  sun | rweek: 354 | %2: 0 == 0 | %3: 0 == 1 | ?  no
+
+2025-10-20 *MON | rweek: 355 | %2: 1 == 0 | %3: 1 == 1 | ?  no
+2025-10-21  tue | rweek: 355 | %2: 1 == 0 | %3: 1 == 1 | ?  no
+2025-10-22 *WED | rweek: 355 | %2: 1 == 0 | %3: 1 == 1 | ? YES
+2025-10-23  thu | rweek: 355 | %2: 1 == 0 | %3: 1 == 1 | ?  no
+2025-10-24  fri | rweek: 355 | %2: 1 == 0 | %3: 1 == 1 | ?  no
+2025-10-25  sat | rweek: 355 | %2: 1 == 0 | %3: 1 == 1 | ?  no
+2025-10-26  sun | rweek: 355 | %2: 1 == 0 | %3: 1 == 1 | ?  no
+
+2025-10-27 *MON | rweek: 356 | %2: 0 == 0 | %3: 2 == 1 | ? YES
+2025-10-28  tue | rweek: 356 | %2: 0 == 0 | %3: 2 == 1 | ?  no
+2025-10-29 *WED | rweek: 356 | %2: 0 == 0 | %3: 2 == 1 | ?  no
+2025-10-30  thu | rweek: 356 | %2: 0 == 0 | %3: 2 == 1 | ?  no
+2025-10-31  fri | rweek: 356 | %2: 0 == 0 | %3: 2 == 1 | ?  no
+2025-11-01  sat | rweek: 356 | %2: 0 == 0 | %3: 2 == 1 | ?  no
+2025-11-02  sun | rweek: 356 | %2: 0 == 0 | %3: 2 == 1 | ?  no
+```
+
+
+### the random extension
+
+Fugit accepts the `~` character to specify a range from which a random value is picked. Either or both the start and the end of the range may be omitted.
+
+```ruby
+'~ * * * *'    # every hour on a random minute
+'~29 * * * *'  # every hour on a random minute between 0 and 29
+'30~ * * * *'  # every hour on a random minute between 30 and 59
+'~/10 * * * *' # every 10 minutes starting on a random minute between 0 and 9
+'0 12 * * 1~5' # every week at noon on a random workday
+```
+
+You may customize how random values are generated by adding the `:random` option with a boolean or an object that implements the `#rand` method.
+
+```ruby
+Fugit.parse('~ * * * *', random: false)        # on a non-random minute ==> '0 * * * *'
+Fugit.parse('~ * * * *', random: true)         # on a random minute (default)
+Fugit.parse('~ * * * *', random: SecureRandom) # on a cryptographically secure random minute
 ```
 
-`sun%2` matches if Sunday and `current_date.rweek % 2 == 0`
-`tue%3+2` matches if Tuesday and `current_date.rweek + 2 % 3 == 0`
-`tue%x+y` matches if Tuesday and `current_date.rweek + y % x == 0`
+Please note that the random values are determined at parse time. So `"~29 * * * *"` at parse time could become `"17 * * * *"` for example and go on triggering every hour at minute 17, until a new parsing occurs and another (or the same) minute is picked. This aligns with the OpenBSD [`man 5 crontab`](https://man.openbsd.org/crontab.5), OpenBSD `crond` rolling the dice at load time.
 
 
 ### the second extension

data/fugit.gemspec

@@ -41,10 +41,11 @@ Time tools for flor and the floraison project. Cron parsing and occurrence compu
     # this dependency appears in 'et-orbi'
 
   s.add_runtime_dependency 'raabro', '~> 1.4'
-  s.add_runtime_dependency 'et-orbi', '~> 1', '>= 1.2.11'
+  s.add_runtime_dependency 'et-orbi', '~> 1.4'
 
   s.add_development_dependency 'rspec', '~> 3.8'
   s.add_development_dependency 'chronic', '~> 0.10'
+  s.add_development_dependency 'ostruct'
 
   s.require_path = 'lib'
 end

data/lib/fugit/at.rb

@@ -6,14 +6,19 @@ module Fugit
 
     class << self
 
-      def parse(s)
+      def parse(s, opts={})
 
-        ::EtOrbi.make_time(s) rescue nil
+        do_parse(s, opts || {}) rescue nil
       end
 
-      def do_parse(s)
+      def do_parse(s, opts={})
 
-        ::EtOrbi.make_time(s)
+        case s
+        when /^now$/i then ::EtOrbi::EoTime.now
+        when String then ::EtOrbi.parse(s, opts || {})
+        when ::EtOrbi::EoTime then s
+        else ::EtOrbi.make_time(s)
+        end
       end
     end
   end

data/lib/fugit/cron.rb

@@ -29,7 +29,7 @@ module Fugit
         parse(original)
       end
 
-      def parse(s)
+      def parse(s, opts={})
 
         return s if s.is_a?(self)
         return nil unless s.is_a?(String)
@@ -48,12 +48,12 @@ module Fugit
 #p s; Raabro.pp(Parser.parse(s, debug: 3), colors: true)
         h = Parser.parse(s)
 
-        self.allocate.send(:init, s0, h)
+        self.allocate.send(:init, s0, h, opts)
       end
 
-      def do_parse(s)
+      def do_parse(s, opts={})
 
-        parse(s) ||
+        parse(s, opts) ||
         fail(ArgumentError.new("invalid cron string #{trunc(s)}"))
       end
 
@@ -175,34 +175,30 @@ module Fugit
 
     def weekday_hash_match?(nt, hsh)
 
+      return false unless hsh.is_a?(Integer)
+
       phsh, nhsh = nt.wday_in_month
+        #
+        # positive wday, from the beginning of the month
+        # negative wday, from the end of the month, -1 == last
 
-      if hsh > 0
-        hsh == phsh # positive wday, from the beginning of the month
-      else
-        hsh == nhsh # negative wday, from the end of the month, -1 == last
-      end
+      (hsh == phsh) || (hsh == nhsh)
     end
 
     def weekday_modulo_match?(nt, mod)
 
-      (nt.rweek % mod[0]) == (mod[1] % mod[0])
+      mod.is_a?(Array) &&
+      ((nt.rweek % mod[0]) == (mod[1] % mod[0]))
     end
 
     def weekday_match?(nt)
 
-      return true if @weekdays.nil?
-
-      wd, hom = @weekdays.find { |d, _| d == nt.wday }
-
-      return false unless wd
-      return true if hom.nil?
-
-      if hom.is_a?(Array)
-        weekday_modulo_match?(nt, hom)
-      else
-        weekday_hash_match?(nt, hom)
-      end
+      @weekdays.nil? ||
+      @weekdays.find { |wd, hom|
+        (nt.wday == wd) &&
+        (hom.nil? ||
+         weekday_modulo_match?(nt, hom) ||
+         weekday_hash_match?(nt, hom)) }
     end
 
     def monthday_match?(nt)
@@ -563,7 +559,7 @@ module Fugit
 
     FREQUENCY_CACHE = {}
 
-    def init(original, h)
+    def init(original, h, opts)
 
       return nil unless h
 
@@ -572,12 +568,12 @@ module Fugit
       @day_and = h[:&]
 
       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_seconds(h[:sec], opts) &&
+        determine_minutes(h[:min], opts) &&
+        determine_hours(h[:hou], opts) &&
+        determine_monthdays(h[:dom], opts) &&
+        determine_months(h[:mon], opts) &&
+        determine_weekdays(h[:dow], opts) &&
         determine_timezone(h[:tz])
 
       return nil unless valid
@@ -586,15 +582,22 @@ module Fugit
       self
     end
 
-    def expand(min, max, r)
+    def expand(min, max, opts, r)
 
-      sta, edn, sla = r
+      sta, edn, sep, sla = r
 
       #return false if sla && sla > max
         #
         # let it go, "* */24 * * *" and "* */27 * * *" are okay
         # gh-86 and gh-103
 
+      return false if sla && sla < 1
+
+      if sep == :tilde
+        sta = random(min, max, sta, edn, sla, opts)
+        edn = nil unless sla
+      end
+
       edn = max if sla && edn.nil?
 
       return nil if sta.nil? && edn.nil? && sla.nil?
@@ -607,6 +610,24 @@ module Fugit
       range(min, max, sta, edn, sla)
     end
 
+    def random(min, max, sta, edn, sla, opts)
+
+      sta = min if sta.nil?
+      edn = max if edn.nil?
+
+      random = opts.fetch(:random, true)
+      random = Random if random == true
+      return sta unless random
+
+      n = edn - sta + 1
+      n = max - min + 1 + n if n <= 0
+      n = sla if sla && sla < n
+
+      r = sta + random.rand(n)
+      r = r + min - max - 1 if r > max
+      r
+    end
+
     def range(min, max, sta, edn, sla)
 
       return [ nil ] if sta == min && edn == max && sla == 1
@@ -649,13 +670,13 @@ module Fugit
         .uniq
     end
 
-    def do_determine(key, arr, min, max)
+    def do_determine(key, arr, min, max, opts)
 
       null = false
 
       r = arr
         .collect { |v|
-          expand(min, max, v) }
+          expand(min, max, opts, v) }
         .flatten(1)
         .collect { |e|
           return false if e == false
@@ -666,36 +687,44 @@ module Fugit
       r.uniq.sort
     end
 
-    def determine_seconds(arr)
-      (@seconds = do_determine(:seconds, arr || [ 0 ], 0, 59)) != false
+    def determine_seconds(arr, opts)
+      (@seconds = do_determine(:seconds, arr || [ 0 ], 0, 59, opts)) != false
     end
 
-    def determine_minutes(arr)
-      (@minutes = do_determine(:minutes, arr, 0, 59)) != false
+    def determine_minutes(arr, opts)
+      (@minutes = do_determine(:minutes, arr, 0, 59, opts)) != false
     end
 
-    def determine_hours(arr)
-      (@hours = do_determine(:hours, arr, 0, 23)) != false
+    def determine_hours(arr, opts)
+      (@hours = do_determine(:hours, arr, 0, 23, opts)) != false
     end
 
-    def determine_monthdays(arr)
-      (@monthdays = do_determine(:monthdays, arr, 1, 31)) != false
+    def determine_monthdays(arr, opts)
+      (@monthdays = do_determine(:monthdays, arr, 1, 31, opts)) != false
     end
 
-    def determine_months(arr)
-      (@months = do_determine(:months, arr, 1, 12)) != false
+    def determine_months(arr, opts)
+      (@months = do_determine(:months, arr, 1, 12, opts)) != false
     end
 
-    def determine_weekdays(arr)
+    def determine_weekdays(arr, opts)
 
       @weekdays = []
 
-      arr.each do |a, z, sl, ha, mo| # a to z, slash, hash, and mod
+      arr.each do |a, z, sp, sl, ha, mo| # a to z, seperator, slash, hash, and mod
+        if sp == :tilde
+          a = random(0, 6, a, z, sl, opts)
+          z = nil unless sl
+        end
+
         if ha || mo
           @weekdays << [ a, ha || mo ]
         elsif sl
-          ((a || 0)..(z || (a ? a : 6))).step(sl < 1 ? 1 : sl)
-            .each { |i| @weekdays << [ i ] }
+          z ||= (a ? a : 6)
+          a ||= 0
+          z = z + 7 if a > z
+          (a..z).step(sl < 1 ? 1 : sl)
+            .each { |i| @weekdays << [ (i > 6) ? i - 7 : i ] }
         elsif z
           z = z + 7 if a > z
           (a..z).each { |i| @weekdays << [ (i > 6) ? i - 7 : i ] }
@@ -735,7 +764,8 @@ module Fugit
           else
             a.collect(&:to_s).join('#')
           end }
-        .join(',')
+        .join(',') +
+      (@day_and ? '&' : '')
     end
 
     module Parser include Raabro
@@ -757,7 +787,8 @@ module Fugit
 
       def s(i); rex(nil, i, /[ \t]+/); end
       def star(i); str(nil, i, '*'); end
-      def hyphen(i); str(nil, i, '-'); end
+      def hyphen(i); str(:hyphen, i, '-'); end
+      def tilde(i); str(:tilde, i, '~'); end
       def comma(i); rex(nil, i, /,([ \t]*,)*/); end
       def comma?(i); rex(nil, i, /([ \t]*,)*/); end
       def and?(i); rex(nil, i, /&?/); end
@@ -785,12 +816,19 @@ module Fugit
       def r_mon(i); seq(nil, i, :mon, :_mon, '?'); end
       def r_dow(i); seq(nil, i, :dow, :_dow, '?'); end
 
+      # t: tilde range
+      def t_mos(i); seq(nil, i, :mos, '?', :tilde, :mos, '?'); end
+      def t_hou(i); seq(nil, i, :hou, '?', :tilde, :hou, '?'); end
+      def t_dom(i); seq(nil, i, :dom, '?', :tilde, :dom, '?'); end
+      def t_mon(i); seq(nil, i, :mon, '?', :tilde, :mon, '?'); end
+      def t_dow(i); seq(nil, i, :dow, '?', :tilde, :dow, '?'); end
+
       # sor: star or range
-      def sor_mos(i); alt(nil, i, :star, :r_mos); end
-      def sor_hou(i); alt(nil, i, :star, :r_hou); end
-      def sor_dom(i); alt(nil, i, :star, :r_dom); end
-      def sor_mon(i); alt(nil, i, :star, :r_mon); end
-      def sor_dow(i); alt(nil, i, :star, :r_dow); end
+      def sor_mos(i); alt(nil, i, :star, :t_mos, :r_mos); end
+      def sor_hou(i); alt(nil, i, :star, :t_hou, :r_hou); end
+      def sor_dom(i); alt(nil, i, :star, :t_dom, :r_dom); end
+      def sor_mon(i); alt(nil, i, :star, :t_mon, :r_mon); end
+      def sor_dow(i); alt(nil, i, :star, :t_dow, :r_dow); end
 
       # sorws: star or range with[out] slash
       def sorws_mos(i); seq(nil, i, :sor_mos, :slash, '?'); end
@@ -870,12 +908,16 @@ module Fugit
 
       def rewrite_elt(k, t)
 
-        at, zt, slt, hat, mot = nil; t.subgather(nil).each do |tt|
+        at, zt, spt, slt, hat, mot = nil
+
+        t.subgather(nil).each do |tt|
           case tt.name
           when :slash then slt = tt
           when :hash then hat = tt
           when :mod then mot = tt
-          else if at; zt ||= tt; else; at = tt; end
+          when :hyphen then spt = tt
+          when :tilde then spt = tt
+          else if spt; zt ||= tt; else; at = tt; end
           end
         end
 
@@ -889,11 +931,12 @@ module Fugit
 
         a = at ? rewrite_bound(k, at) : nil
         z = zt ? rewrite_bound(k, zt) : nil
+        sp = spt ? spt.name : nil
 
         #a, z = z, a if a && z && a > z
           # handled downstream since gh-27
 
-        [ a, z, sl, ha, mo ]
+        [ a, z, sp, sl, ha, mo ]
       end
 
       def rewrite_entry(t)

data/lib/fugit/nat.rb

@@ -710,7 +710,7 @@ module Fugit
             e.uniq.sort_by(&letters_last).collect(&:to_s).join(',') }
           .join(' ')
 
-        c = Fugit::Cron.parse(s)
+        c = Fugit::Cron.parse(s, opts)
 
         if opts[:strict]
           restrict(a, c)
@@ -719,6 +719,8 @@ module Fugit
         end
       end
 
+      SLASH_REGEX = /^(\d+|\*)\/(\d+)$/.freeze
+
       # Return nil if the cron is "not strict"
       #
       # For example, "0 0/17 * * *" (gh-86) is a perfectly valid
@@ -729,16 +731,18 @@ module Fugit
       #
       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)
+        if m = ((a[0] && a[0] != [ 0 ] && a[0][0]) || '').match(SLASH_REGEX)
+          return nil unless (1..60).include?(m[1].to_i)
+        end
+        if m = ((a[1] && a[1][0]) || '').match(SLASH_REGEX)
+          return nil unless [ 1, 2, 3, 4, 5, 6, 8, 12 ].include?(m[1].to_i)
         end
 
         cron
       end
 
       def slot(key, default)
+
         s = @slots[key]
         s ? s.data0 : [ default ]
       end

data/lib/fugit/parse.rb

@@ -2,17 +2,19 @@
 
 module Fugit
 
+  DO_PARSE_ORDER = %i[ cron duration nat at ].freeze
+
   class << self
 
-    def parse_cron(s); ::Fugit::Cron.parse(s); end
+    def parse_cron(s, opts={}); ::Fugit::Cron.parse(s, opts || {}); end
     def parse_duration(s); ::Fugit::Duration.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_nat(s, opts={}); ::Fugit::Nat.parse(s, opts || {}); end
+    def parse_at(s, opts={}); ::Fugit::At.parse(s, opts || {}); end
     def parse_in(s); parse_duration(s); end
 
-    def do_parse_cron(s); ::Fugit::Cron.do_parse(s); end
+    def do_parse_cron(s, opts={}); ::Fugit::Cron.do_parse(s, opts || {}); end
     def do_parse_duration(s); ::Fugit::Duration.do_parse(s); end
-    def do_parse_nat(s, opts={}); ::Fugit::Nat.do_parse(s, opts); 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
 
@@ -20,10 +22,10 @@ module Fugit
 
       opts[:at] = opts[:in] if opts.has_key?(:in)
 
-      (opts[:cron] != false && parse_cron(s)) || # 542ms 616ms
+      (opts[:cron] != false && parse_cron(s, opts || {})) || # 542ms 616ms
       (opts[:duration] != false && parse_duration(s)) || # 645ms # 534ms
-      (opts[:nat] != false && parse_nat(s, opts)) || # 2s # 35s
-      (opts[:at] != false && parse_at(s)) || # 568ms 622ms
+      (opts[:nat] != false && parse_nat(s, opts || {})) || # 2s # 35s
+      (opts[:at] != false && parse_at(s, opts || {})) || # 568ms 622ms
       nil
     end
 
@@ -34,7 +36,7 @@ module Fugit
       result = nil
       errors = []
 
-      %i[ cron duration nat at ]
+      DO_PARSE_ORDER
         .each { |k|
           begin
             result ||= (opts[k] != false && self.send("do_parse_#{k}", s))
@@ -52,14 +54,14 @@ module Fugit
 
     def parse_cronish(s, opts={})
 
-      r = parse_cron(s) || parse_nat(s, opts)
+      r = parse_cron(s, opts) || parse_nat(s, opts)
 
       r.is_a?(::Fugit::Cron) ? r : nil
     end
 
     def do_parse_cronish(s, opts={})
 
-      parse_cronish(s) ||
+      parse_cronish(s, opts) ||
       fail(ArgumentError.new("not cron or 'natural' cron string: #{s.inspect}"))
     end
 

data/lib/fugit.rb

@@ -3,7 +3,7 @@
 
 module Fugit
 
-  VERSION = '1.11.2'
+  VERSION = '1.13.0'
 end
 
 require 'time'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fugit
 version: !ruby/object:Gem::Version
-  version: 1.11.2
+  version: 1.13.0
 platform: ruby
 authors:
 - John Mettraux
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-22 00:00:00.000000000 Z
+date: 2026-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: raabro
@@ -30,20 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.2.11
+        version: '1.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.2.11
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -72,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Time tools for flor and the floraison project. Cron parsing and occurrence
   computing. Timestamps and more.
 email: