fugit 1.8.1 → 1.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1839fa07acc6287be95f8076c19afa2c9d6c9b5500ac1b03febab61959b5057
-  data.tar.gz: 839ff5c0f85ccd51625febfdbfedd017e46962d288cf313307b706830dc838c9
+  metadata.gz: 15a3ea665c020e35ce51dcbc82be9a74e6f4abcaa2441316b514c630ffdbc094
+  data.tar.gz: f99246722de255325b57ea46f7b3f24bbfc11d65f1eb98fde9a2a43a3c249df0
 SHA512:
-  metadata.gz: 5336bf251441fa3f7372d48aec2196cf86831b24c64110955f2ccf2df2e6e1ec84a68b318b53be8282f87794f40c09778bddd47abec3f65fe1469544a758fabb
-  data.tar.gz: 0fdd70455097838c21c3f03c9dca20889b4aba07f67d790136e40be2d8686b0a6ad8a594fff1fe28e7cd4d322ad66a8a31aa71750cd435c7601345487ae89bdb
+  metadata.gz: cc55e7332f5f111ddf27d145fed7fbfeaeed30f492ba343d1f4067e776c96874b42bad9488b9683203040cc50333f74bab56fa6e61744ef92fb059f2a2c9f076
+  data.tar.gz: 5ee65240dd04fddb7777bee327f8fee0cfef5260ed55db9ec71ece64c5e5e6b53283aa7d26ba52facbca3882aee0920ff0dd3715fea5ad9153caca82ea712450

data/CHANGELOG.md

@@ -2,6 +2,54 @@
 # CHANGELOG.md
 
 
+## 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
+* Avoid Hash#partition https://bugs.ruby-lang.org/issues/16252
+* Fix Fugit::Nat "zero dark forty", gh-107
+* Ensure @yearly and other specials accept a timezone
+
+
+## fugit 1.11.1 released 2024-08-15
+
+* Prevent nat parsing chocking on long input (> 256 chars), gh-104
+
+
+## fugit 1.11.0 released 2024-04-24
+
+* Revert gh-86 ban on `every 27 hours` / `* */27 * * *` for gh-103
+
+
+## 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

data/CREDITS.md

@@ -1,6 +1,18 @@
 
 # fugit credits
 
+* 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
+* 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
+* https://github.com/franckduche gh-95 gh-96 et-orbi #rweek
+* 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

data/LICENSE.txt

@@ -1,5 +1,5 @@
 
-Copyright (c) 2017-2023, John Mettraux, jmettraux+flor@gmail.com
+Copyright (c) 2017-2025, 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.
 
@@ -18,26 +17,33 @@ Fugit is a core dependency of [rufus-scheduler](https://github.com/jmettraux/ruf
 
 The intersection of those two projects is where fugit is born:
 
-* [rufus-scheduler](https://github.com/jmettraux/rufus-scheduler) - a cron/at/in/every/interval in-process scheduler, in fact, it's the father project to this fugit project
-* [flor](https://github.com/floraison/flor) - a Ruby workflow engine, fugit provides the foundation for its time scheduling capabilities
+* [rufus-scheduler](https://github.com/jmettraux/rufus-scheduler) — a cron/at/in/every/interval in-process scheduler, in fact, it's the father project to this fugit project
+* [flor](https://github.com/floraison/flor) — a Ruby workflow engine, fugit provides the foundation for its time scheduling capabilities
 
 ### Similar, sometimes overlapping projects
 
-* [chronic](https://github.com/mojombo/chronic) - a pure Ruby natural language date parser
-* [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
+* [chronic](https://github.com/mojombo/chronic) — a pure Ruby natural language date parser
+* [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
+* [CronConfigParser](https://github.com/madogiwa0124/cron_config_parser) — parse the cron configuration for readability
 * ...
 
 ### 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) -
-* [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
+* [arask](https://github.com/Ebbe/arask) — "Automatic RAils taSKs" uses fugit to parse cron strings
+* [sidekiq-cron](https://github.com/ondrejbartas/sidekiq-cron) — uses fugit to parse cron strings since version 1.0.0, it was using rufus-scheduler previously
+* [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
+* [Solid Queue](https://github.com/rails/solid_queue) — a DB-based queuing backend for Active Job, designed with simplicity and performance in mind
+* [qron](https://github.com/floraison/qron) — stupid cron thread that wakes up from time to time to do what's in its crontab
 * ...
 
 ## `Fugit.parse(s)`
@@ -93,7 +99,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
@@ -108,6 +114,7 @@ Fugit.parse_cronish('12y12M')        # ==> nil
 
 Introduced in fugit 1.8.0.
 
+
 ## `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.
@@ -123,8 +130,48 @@ 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
+  #
+  # These two methods are available since fugit 1.10.0.
+  #
+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
+  #
+  # This method is available since fugit 1.10.0.
+  #
+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 ]
@@ -160,13 +207,28 @@ Example of cron strings understood by fugit:
 
 Please note that `'15/30 * * * *'` is interpreted as `'15-59/30 * * * *'` since fugit 1.4.6.
 
+### time zones
+
+Fugit accepts a IANA timezone identifier right after a cron string:
+```ruby
+'5 0 * * *  Europe/Rome'      # 5 minutes after midnight, every day, Rome tz
+'0 22 * * 1-5  Asia/Tbilisi'  # at 2200 on weekdays in Georgia
+
+'@yearly Asia/Kuala_Lumpur'  # turns into '0 0 1 1 * Asia/Kuala_Lumpur'
+'@monthly Asia/Jakarta'      # turns into '0 0 1 * * Asia/Jakarta'
+  #
+  # those two "ats" and friends since fugit 1.11.2...
+```
+
+When no time zone is specified, fugit uses Ruby's provided timezone.
+
 ### the first Monday of the month
 
 Fugit tries to follow the `man 5 crontab` documentation.
 
 There is a surprising thing about this canon, all the columns are joined by ANDs, except for monthday and weekday which are joined together by OR if they are both set (they are not `*`).
 
-Many people (me included) [are suprised](https://superuser.com/questions/428807/run-a-cron-job-on-the-first-monday-of-every-month) when they try to specify "at 05:00 on the first Monday of the month" as `0 5 1-7 * 1` or `0 5 1-7 * mon` and the results are off.
+Many people (me included) [are surprised](https://superuser.com/questions/428807/run-a-cron-job-on-the-first-monday-of-every-month) when they try to specify "at 05:00 on the first Monday of the month" as `0 5 1-7 * 1` or `0 5 1-7 * mon` and the results are off.
 
 The man page says:
 
@@ -212,6 +274,8 @@ p Fugit.parse_cron('59 6 1-7& * 2&').next_time('2020-03-15').to_s
 
 Fugit understands `0 5 * * 1#1` or `0 5 * * mon#1` as "each first Monday of the month, at 05:00".
 
+The hash extension can only be used in the day-of-week field.
+
 ```ruby
 '0 5 * * 1#1'    #
 '0 5 * * mon#1'  # the first Monday of the month at 05:00
@@ -232,125 +296,201 @@ Fugit understands `0 5 * * 1#1` or `0 5 * * mon#1` as "each first Monday of the
 
 ### 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).
 
-But what does it reference to? It starts at 1 on 2019-01-01.
+What does `sun%2` actually mean?
+```ruby
+t.wday == 0 && t.rweek % 2 == 0
+```
 
+What does `tue%3+2` mean?
 ```ruby
-require 'et-orbi' # >= 1.1.8
+t.wday == 2 && t.rweek % 3 == 2
+```
 
-# 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
+#### et-orbi < 1.4.0 : reference set on Tuesday 2019-01-01
 
-# 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
+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.
 
-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
+Consider this iteration through the days around 2019-01-01.
+```ruby
+require 'fugit'
 
-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
+t = EtOrbi.parse('2018-12-28 12:00')
 
-# ...
-```
+15.times do |i|
 
-`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`
+  puts " * %14s / rday: %5d / rweek: %5d" % [
+    t.strftime('%F %a'), t.rday, t.rweek ]
 
+  w = t.rweek
+  t = t.add(24 * 3600)
+  puts if t.rweek != w
 
-## `Fugit::Duration`
+  if i == 7
+    puts "\n  (...)\n\n"
+    t = EtOrbi.parse('2025-10-04 12:00')
+  end
+end
+```
 
-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).
+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
+```
 
-Provides duration arithmetic tools.
+This [was problematic](https://github.com/floraison/fugit/issues/114), since the week started on, well, Tuesday.
 
-```ruby
-require 'fugit'
 
-d = Fugit::Duration.parse('1y2M1d4h')
+#### et-orbi >= 1.4.0 : reference set on Monday 2018-12-31
 
-p d.to_plain_s  # => "1Y2M1D4h"
-p d.to_iso_s    # => "P1Y2M1DT4H" ISO 8601 duration
-p d.to_long_s   # => "1 year, 2 months, 1 day, and 4 hours"
+Since 1.4.0, et-orbi starts by default on Monday (2018-12-31), as rday 0 with rweek 0.
 
-d += Fugit::Duration.parse('1y1h')
+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
+```
 
-p d.to_long_s  # => "2 years, 2 months, 1 day, and 5 hours"
 
-d += 3600
+#### modulo and et-orbi >= 1.4.0 sanity check
 
-p d.to_plain_s  # => "2Y2M1D5h3600s"
+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.
 
-p Fugit::Duration.parse('1y2M1d4h').to_sec # => 36820800
-```
+```ruby
+require 'fugit'
 
-There is a `#deflate` method
+c = Fugit.parse_cron('0 12 * * mon%2,wed%3+1')
 
-```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"
+t = EtOrbi.parse('2025-09-20 12:00')
 
-# or event shorter
-Fugit.parse(1000).deflate.to_plain_s # => "16m40s"
-Fugit.parse(3600).deflate.to_plain_s # => "1h"
-```
+44.times do
 
-There is also an `#inflate` method
+  wd = t.strftime('%a')
+  wd = %w[ Mon Wed ].include?(wd) ? '*' + wd.upcase : ' ' + wd.downcase
 
-```ruby
-Fugit::Duration.parse('1h30m12').inflate.to_plain_s # => "5412s"
-Fugit.parse('1h30m12').inflate.to_plain_s # => "5412s"
+  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 }
 
-Fugit.parse('1h30m12').to_sec # => 5412
-Fugit.parse('1h30m12').to_sec.to_s + 's' # => "5412s"
+  w = t.rweek
+  t = t.add(24 * 3600)
+  puts if t.rweek != w
+end
 ```
 
-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')
-  # => "P1Y2M1DT4H" ISO 8601 duration
-p Fugit::Duration.to_long_s('1y2M1d4h')
-  # => "1 year, 2 months, 1 day, and 4 hours"
+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
 ```
 
-## `Fugit::At`
-
-Points in time are parsed and given back as EtOrbi::EoTime instances.
 
-```ruby
-Fugit::At.parse('2017-12-12').to_s
-  # ==> "2017-12-12 00:00:00 +0900" (at least here in Hiroshima)
+### the second extension
 
-Fugit::At.parse('2017-12-12 12:00:00 America/New_York').to_s
-  # ==> "2017-12-12 12:00:00 -0500"
-```
+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`.
 
-Directly with `Fugit.parse_at(s)` is OK too:
 ```ruby
-Fugit.parse_at('2017-12-12 12:00:00 America/New_York').to_s
-  # ==> "2017-12-12 12:00:00 -0500"
+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
 ```
 
-Directly with `Fugit.parse(s)` is OK too:
-```ruby
-Fugit.parse('2017-12-12 12:00:00 America/New_York').to_s
-  # ==> "2017-12-12 12:00:00 -0500"
-```
 
 ## `Fugit::Nat`
 
@@ -402,7 +542,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
 ```
@@ -413,6 +554,8 @@ Fugit::Nat.parse('every day at 16:15 nada 18:30', multi: true)
 
 `multi: false` is the default behaviour, return a single `Fugit::Cron` instance or nil when it cannot parse.
 
+Please note that "nat" input is limited to 256 characters (fugit 1.11.1).
+
 ### Nat Midnight
 
 `"Every day at midnight"` is supported, but `"Every monday at midnight"` will be interpreted (as of Fugit <= 1.4.x) as `"Every monday at 00:00"`. Sorry about that.
@@ -448,6 +591,96 @@ p Fugit.parse('every day at 12:15 midnight').original  # ==> "15 24 * * *"
 ```
 
 
+## `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).
+
+Provides duration arithmetic tools.
+
+```ruby
+require 'fugit'
+
+d = Fugit::Duration.parse('1y2M1d4h')
+
+p d.to_plain_s  # => "1Y2M1D4h"
+p d.to_iso_s    # => "P1Y2M1DT4H" ISO 8601 duration
+p d.to_long_s   # => "1 year, 2 months, 1 day, and 4 hours"
+
+d += Fugit::Duration.parse('1y1h')
+
+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
+```
+
+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')
+  # => "1Y2M1D4h"
+p Fugit::Duration.to_iso_s('1y2M1d4h')
+  # => "P1Y2M1DT4H" ISO 8601 duration
+p Fugit::Duration.to_long_s('1y2M1d4h')
+  # => "1 year, 2 months, 1 day, and 4 hours"
+```
+
+
+## `Fugit::At`
+
+Points in time are parsed and given back as EtOrbi::EoTime instances.
+
+```ruby
+Fugit::At.parse('2017-12-12').to_s
+  # ==> "2017-12-12 00:00:00 +0900" (at least here in Hiroshima)
+
+Fugit::At.parse('2017-12-12 12:00:00 America/New_York').to_s
+  # ==> "2017-12-12 12:00:00 -0500"
+```
+
+Directly with `Fugit.parse_at(s)` is OK too:
+```ruby
+Fugit.parse_at('2017-12-12 12:00:00 America/New_York').to_s
+  # ==> "2017-12-12 12:00:00 -0500"
+```
+
+Directly with `Fugit.parse(s)` is OK too:
+```ruby
+Fugit.parse('2017-12-12 12:00:00 America/New_York').to_s
+  # ==> "2017-12-12 12:00:00 -0500"
+```
+
+
+## KNOWN ISSUES
+
+The gem [nice_hash](https://github.com/MarioRuiz/nice_hash) gets in the way of `fugit`, as seen in [issue 108](https://github.com/floraison/fugit/issues/108). It prevents `fugit` from correctly parsing cron strings.
+
+
 ## LICENSE
 
 MIT, see [LICENSE.txt](LICENSE.txt)

data/fugit.gemspec

@@ -20,18 +20,18 @@ Time tools for flor and the floraison project. Cron parsing and occurrence compu
 
   s.metadata = {
     'changelog_uri' => s.homepage + '/blob/master/CHANGELOG.md',
-    'documentation_uri' => s.homepage,
     'bug_tracker_uri' => s.homepage + '/issues',
-    #'mailing_list_uri' => 'https://groups.google.com/forum/#!forum/floraison',
+    'documentation_uri' => s.homepage,
     'homepage_uri' =>  s.homepage,
     'source_code_uri' => s.homepage,
+    #'mailing_list_uri' => 'https://groups.google.com/forum/#!forum/floraison',
     #'wiki_uri' => s.homepage + '/wiki',
+    'rubygems_mfa_required' => 'true',
   }
 
   #s.files = `git ls-files`.split("\n")
   s.files = Dir[
-    'README.{md,txt}',
-    'CHANGELOG.{md,txt}', 'CREDITS.{md,txt}', 'LICENSE.{md,txt}',
+    '{README,CHANGELOG,CREDITS,LICENSE}.{md,txt}',
     #'Makefile',
     'lib/**/*.rb', #'spec/**/*.rb', 'test/**/*.rb',
     "#{s.name}.gemspec",
@@ -41,7 +41,7 @@ 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.7'
+  s.add_runtime_dependency 'et-orbi', '~> 1.4'
 
   s.add_development_dependency 'rspec', '~> 3.8'
   s.add_development_dependency 'chronic', '~> 0.10'

data/lib/fugit/cron.rb

@@ -32,23 +32,42 @@ module Fugit
       def parse(s)
 
         return s if s.is_a?(self)
+        return nil unless s.is_a?(String)
 
-        s = SPECIALS[s] || s
+        s0 = s
+        s = s.strip
 
-        return nil unless s.is_a?(String)
+        s =
+          if s[0, 1] == '@'
+            ss = s.split(/\s+/, 2)
+            [ SPECIALS[ss[0]] || ss, *ss[1..-1] ].join(' ')
+          else
+            s
+          end
 
 #p s; Raabro.pp(Parser.parse(s, debug: 3), colors: true)
-        h = Parser.parse(s.strip)
+        h = Parser.parse(s)
 
-        return nil unless h
-
-        self.allocate.send(:init, s, h)
+        self.allocate.send(:init, s0, h)
       end
 
       def do_parse(s)
 
         parse(s) ||
-        fail(ArgumentError.new("invalid cron string #{s.inspect}"))
+        fail(ArgumentError.new("invalid cron string #{trunc(s)}"))
+      end
+
+      protected
+
+      def trunc(s)
+
+        if s.is_a?(String)
+          r = s.length > 28 ? s[0, 28] + "... len #{s.length}" : s
+          r.inspect
+        else
+          r = s.inspect
+          r.length > 35 ? s[0, 35] + '...' : r
+        end
       end
     end
 
@@ -156,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)
@@ -266,6 +281,8 @@ module Fugit
           "please fill an issue at https://git.io/fjJC9"
         ) if (i += 1) > MAX_ITERATION_COUNT
 
+#tt = t.time;
+#puts "  #{tt.strftime('%F %T %:z %A')} #{tt.rweek} #{tt.rweek % 2}"
         (ifrom == t.to_i) && (t.inc(1); next)
         month_match?(t) || (t.inc_month; next)
         day_match?(t) || (t.inc_day; next)
@@ -309,6 +326,8 @@ module Fugit
           "please fill an issue at https://git.io/fjJCQ"
         ) if (i += 1) > MAX_ITERATION_COUNT
 
+#tt = t.time;
+#puts "  #{tt.strftime('%F %T %:z %A')} #{tt.rweek} #{tt.rweek % 4}"
         month_match?(t) || (t.dec_month; next)
         day_match?(t) || (t.dec_day; next)
         hour_match?(t) || (t.dec_hour; next)
@@ -320,6 +339,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 +561,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 +586,15 @@ module Fugit
 
       sta, edn, sla = r
 
+      #return false if sla && sla > max
+        #
+        # let it go, "* */24 * * *" and "* */27 * * *" are okay
+        # gh-86 and gh-103
+
       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 +645,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 +705,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
@@ -646,7 +731,8 @@ module Fugit
           else
             a.collect(&:to_s).join('#')
           end }
-        .join(',')
+        .join(',') +
+      (@day_and ? '&' : '')
     end
 
     module Parser include Raabro

data/lib/fugit/duration.rb

@@ -67,11 +67,20 @@ module Fugit
       day: { a: 'D', r: 'd', i: 'D', s: DAY_S, 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' } }.freeze
-
-    INFLA_KEYS, NON_INFLA_KEYS = KEYS
-      .partition { |k, v| v[:I] }
-      .collect(&:freeze)
+      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] }
+    #  .collect(&:freeze)
+        #
+        # https://bugs.ruby-lang.org/issues/16252
+        #
+    kes = KEYS.entries
+    INFLA_KEYS,
+    NON_INFLA_KEYS =
+      kes.select { |_, v| v[:I] }.freeze,
+      kes.select { |_, v| ! v[:I] }.freeze
 
     def _to_s(key)
 
@@ -258,7 +267,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 add_to_time(a)
       else fail ArgumentError.new(
         "cannot add #{a.class} instance to a Fugit::Duration")
       end

data/lib/fugit/nat.rb

@@ -7,6 +7,8 @@ module Fugit
   #
   module Nat
 
+    MAX_INPUT_LENGTH = 256
+
     class << self
 
       def parse(s, opts={})
@@ -17,6 +19,16 @@ module Fugit
 
         s = s.strip
 
+        if s.length > MAX_INPUT_LENGTH
+
+          fail ArgumentError.new(
+            "input too long for a nat string, " +
+            "#{s.length} > #{MAX_INPUT_LENGTH}"
+          ) if opts[:do_parse]
+
+          return nil
+        end
+
 #p s; Raabro.pp(Parser.parse(s, debug: 3), colours: true)
 #(p s; Raabro.pp(Parser.parse(s, debug: 1), colours: true)) rescue nil
 
@@ -29,7 +41,7 @@ module Fugit
 
       def do_parse(s, opts={})
 
-        parse(s, opts) ||
+        parse(s, opts.merge(do_parse: true)) ||
         fail(ArgumentError.new("could not parse a nat #{s.inspect}"))
       end
     end
@@ -42,7 +54,7 @@ module Fugit
         %w[ zero ] + one_to_nine +
         %w[ ten eleven twelve thirteen fourteen fifteen sixteen seventeen
             eighteen nineteen ] +
-          %w[ twenty thirty fourty fifty ]
+          %w[ twenty thirty forty fifty ]
             .collect { |a|
               ([ nil ] + one_to_nine)
                 .collect { |b| [ a, b ].compact.join('-') } }
@@ -198,7 +210,7 @@ module Fugit
       end
 
       def ampm(i)
-        rex(:ampm, i, /[ \t]*(am|pm|noon|midday|midnight)/i)
+        rex(:ampm, i, /[ \t]*(am|AM|pm|PM|[Nn]oon|[Mm]idday|[Mm]idnight)/)
       end
       def dark(i)
         rex(:dark, i, /[ \t]*dark/i)
@@ -642,9 +654,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 +690,7 @@ module Fugit
           .to_a
       end
 
-      def parse_cron(hm)
+      def parse_cron(hm, opts)
 
         a = [
           slot(:second, '0'),
@@ -691,14 +703,46 @@ 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
+
+      SLASH_REGEX = /^(\d+|\*)\/(\d+)$/.freeze
+
+      # 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[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,6 +2,8 @@
 
 module Fugit
 
+  DO_PARSE_ORDER = %i[ cron duration nat at ].freeze
+
   class << self
 
     def parse_cron(s); ::Fugit::Cron.parse(s); end
@@ -20,17 +22,34 @@ module Fugit
 
       opts[:at] = opts[:in] if opts.has_key?(:in)
 
-      (opts[:cron] != false && parse_cron(s)) ||
-      (opts[:duration] != false && parse_duration(s)) ||
-      (opts[:nat] != false && parse_nat(s, opts)) ||
-      (opts[:at] != false && parse_at(s)) ||
+      (opts[:cron] != false && parse_cron(s)) || # 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
       nil
     end
 
     def do_parse(s, opts={})
 
-      parse(s, opts) ||
-      fail(ArgumentError.new("found no time information in #{s.inspect}"))
+      opts[:at] = opts[:in] if opts.has_key?(:in)
+
+      result = nil
+      errors = []
+
+      DO_PARSE_ORDER
+        .each { |k|
+          begin
+            result ||= (opts[k] != false && self.send("do_parse_#{k}", s))
+          rescue => err
+            errors << err
+          end }
+
+      return result if result
+
+      raise(
+        errors.find { |r| r.class != ArgumentError } ||
+        errors.first ||
+        ArgumentError.new("found no time information in #{s.inspect}"))
     end
 
     def parse_cronish(s, opts={})
@@ -46,6 +65,24 @@ module Fugit
       fail(ArgumentError.new("not cron or 'natural' cron string: #{s.inspect}"))
     end
 
+    def parse_max(s, opts={})
+
+      s0 = s.lines.first
+
+      (0..[ ::Fugit::Nat::MAX_INPUT_LENGTH, s0.length - 1 ].min).each do |i|
+
+        s1 =
+          s0[0, s0.length - i].rstrip
+        f =
+          opts[:cronish] ? parse_cronish(s1, opts) :
+          parse(s1, opts)
+
+        return [ s1, f ] if f
+      end
+
+      nil
+    end
+
     def determine_type(s)
 
       case self.parse(s)

data/lib/fugit.rb

@@ -3,7 +3,7 @@
 
 module Fugit
 
-  VERSION = '1.8.1'
+  VERSION = '1.12.1'
 end
 
 require 'time'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fugit
 version: !ruby/object:Gem::Version
-  version: 1.8.1
+  version: 1.12.1
 platform: ruby
 authors:
 - John Mettraux
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-20 00:00:00.000000000 Z
+date: 2025-10-14 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.7
+        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.7
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -97,10 +91,11 @@ licenses:
 - MIT
 metadata:
   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
+  documentation_uri: https://github.com/floraison/fugit
   homepage_uri: https://github.com/floraison/fugit
   source_code_uri: https://github.com/floraison/fugit
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -116,7 +111,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: time tools for flor