fugit 1.1.3 → 1.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cf9112604503de8154a134544a4a30a8a5faee5f
-  data.tar.gz: 648f1f1215a0609b22afeed98849e9f2741f98d3
+  metadata.gz: d3a2d6e072a2ae0ce68473054ef7701ce45a4867
+  data.tar.gz: a1c5e3b9c36b2ee907d617943b5baff6de9005a4
 SHA512:
-  metadata.gz: 0e0d0983c4bf016caf168a02a666f3de7ba516073e6610133bcf5324f6ddf37f3e48e410d439a8834c65af098c642e0e9ed45e11268ab00ac880abc789c35341
-  data.tar.gz: b960fddc42f5ef1eabffac55a6f54b316e9eecc878d703a1a4b4248f2d3b381c18877b2896015f793dd4177a082ea6283835aa4bbf020029fc1682eb5f75da2f
+  metadata.gz: 2c1cc2399627c451105219913f9668dfbd55ea77259e8fad5a356da4d828bd136bb72de28446451bf77bbf7455f62c8a73ec25f59d3426b89cd438382ee2a973
+  data.tar.gz: bb30951b92097750810dc700fa0d5d80ade2bc80d5da398776b9f554db3e889e4086c52fd412ba33bacb5f2d66742b3726aa6a694f64653a12780e76970b0e30

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 # fugit CHANGELOG.md
 
 
+## fugit 1.1.4  released 2018-07-20
+
+* Add duration support for Fugit::Nat (@cristianbica gh-7)
+* Fix Duration not correctly parsing minutes and seconds long format (@cristianbica gh-7)
+* Add timezone support for Fugit::Nat (@cristianbica gh-7)
+* Use timezone name when converting a Fugit::Cron to cron string (@cristianbica gh-7)
+
+
 ## fugit 1.1.3  released 2018-06-21
 
 * Silenced Ruby warnings (Utilum in gh-4)

data/CREDITS.md

@@ -1,6 +1,8 @@
 
 # fugit credits
 
+* jakemack https://github.com/jakemack issue when going out of DST, gh-6
+* Cristian Bica https://github.com/cristianbica Nat improvements, gh-7
 * Utilum https://github.com/utilum silenced Ruby warnings
 * Tero Marttila https://github.com/SpComb added missing Cron#seconds
 * Harry Lascelles https://github.com/hlascelles timezone reminder

data/Makefile

@@ -13,7 +13,7 @@ cl: count_lines
 
 gemspec_validate:
 	@echo "---"
-	ruby -e "s = eval(File.read(Dir['*.gemspec'].first)); s.validate"
+	ruby -e "s = eval(File.read(Dir['*.gemspec'].first)); p s.validate"
 	@echo "---"
 
 name: gemspec_validate
@@ -30,6 +30,10 @@ build: gemspec_validate
 push: build
 	gem push pkg/$(NAME)-$(VERSION).gem
 
+spec:
+	bundle exec rspec
+test: spec
 
-.PHONY: build push cw
+
+.PHONY: count_lines gemspec_validate name cw build push spec
 

data/README.md

@@ -8,7 +8,7 @@ Time tools for [flor](https://github.com/floraison/flor) and the floraison group
 
 It uses [et-orbi](https://github.com/floraison/et-orbi) to represent time instances and [raabro](https://github.com/floraison/raabro) as a basis for its parsers.
 
-Fugit will probably become the foundation for [rufus-scheduler](https://github.com/jmettraux/rufus-scheduler) 4.x
+Fugit is a core dependency of [rufus-scheduler](https://github.com/jmettraux/rufus-scheduler) 3.5.x.
 
 
 ## Related projects
@@ -156,16 +156,22 @@ Fugit understand some kind of "natural" language:
 
 For example, those "every" get turned into `Fugit::Cron` instances:
 ```ruby
-Fugit::Nat.parse('every day at five')                  # ==> '0 5 * * *'
-Fugit::Nat.parse('every weekday at five')              # ==> '0 5 * * 1,2,3,4,5'
-Fugit::Nat.parse('every day at 5 pm')                  # ==> '0 17 * * *'
-Fugit::Nat.parse('every tuesday at 5 pm')              # ==> '0 17 * * 2'
-Fugit::Nat.parse('every wed at 5 pm')                  # ==> '0 17 * * 3'
-Fugit::Nat.parse('every day at 16:30')                 # ==> '30 16 * * *'
-Fugit::Nat.parse('every day at noon')                  # ==> '0 12 * * *'
-Fugit::Nat.parse('every day at midnight')              # ==> '0 0 * * *'
-Fugit::Nat.parse('every tuesday and monday at 5pm')    # ==> '0 17 * * 1,2'
-Fugit::Nat.parse('every wed or Monday at 5pm and 11')  # ==> '0 11,17 * * 1,3'
+Fugit::Nat.parse('every day at five')                         # ==> '0 5 * * *'
+Fugit::Nat.parse('every weekday at five')                     # ==> '0 5 * * 1,2,3,4,5'
+Fugit::Nat.parse('every day at 5 pm')                         # ==> '0 17 * * *'
+Fugit::Nat.parse('every tuesday at 5 pm')                     # ==> '0 17 * * 2'
+Fugit::Nat.parse('every wed at 5 pm')                         # ==> '0 17 * * 3'
+Fugit::Nat.parse('every day at 16:30')                        # ==> '30 16 * * *'
+Fugit::Nat.parse('every day at noon')                         # ==> '0 12 * * *'
+Fugit::Nat.parse('every day at midnight')                     # ==> '0 0 * * *'
+Fugit::Nat.parse('every tuesday and monday at 5pm')           # ==> '0 17 * * 1,2'
+Fugit::Nat.parse('every wed or Monday at 5pm and 11')         # ==> '0 11,17 * * 1,3'
+Fugit::Nat.parse('every day at 5 pm on America/Los_Angeles')  # ==> '0 17 * * * America/Los_Angeles'
+Fugit::Nat.parse('every day at 6 pm in Asia/Tokyo')           # ==> '0 18 * * * Asia/Tokyo'
+Fugit::Nat.parse('every 3 hours')                             # ==> '0 */3 * * *'
+Fugit::Nat.parse('every 4 months')                            # ==> '0 0 1 */4 *'
+Fugit::Nat.parse('every 5 minutes')                           # ==> '*/5 * * * *'
+Fugit::Nat.parse('every 15s')                                 # ==> '*/15 * * * * *'
 ```
 
 Directly with `Fugit.parse(s)` is OK too:

data/fugit.gemspec

@@ -29,7 +29,7 @@ Time tools for flor and the floraison project. Cron parsing and occurrence compu
 
   #s.add_runtime_dependency 'tzinfo'
   s.add_runtime_dependency 'raabro', '~> 1.1'
-  s.add_runtime_dependency 'et-orbi', '~> 1.1', '>= 1.1.1'
+  s.add_runtime_dependency 'et-orbi', '~> 1.1', '>= 1.1.3'
 
   s.add_development_dependency 'rspec', '~> 3.7'
 

data/lib/fugit.rb

@@ -1,7 +1,7 @@
 
 module Fugit
 
-  VERSION = '1.1.3'
+  VERSION = '1.1.4'
 end
 
 require 'time'

data/lib/fugit/at.rb

@@ -3,14 +3,17 @@ module Fugit
 
   module At
 
-    def self.parse(s)
+    class << self
 
-      ::EtOrbi.make_time(s) rescue nil
-    end
+      def parse(s)
+
+        ::EtOrbi.make_time(s) rescue nil
+      end
 
-    def self.do_parse(s)
+      def do_parse(s)
 
-      ::EtOrbi.make_time(s)
+        ::EtOrbi.make_time(s)
+      end
     end
   end
 end

data/lib/fugit/cron.rb

@@ -57,7 +57,7 @@ module Fugit
           (@monthdays || [ '*' ]).join(','),
           (@months || [ '*' ]).join(','),
           (@weekdays || [ [ '*' ] ]).map { |d| d.compact.join('#') }.join(','),
-          @timezone ? @timezone.to_s : nil
+          @timezone ? @timezone.name : nil
         ].compact.join(' ')
       end
     end
@@ -169,20 +169,35 @@ module Fugit
     def next_time(from=::EtOrbi::EoTime.now)
 
       from = ::EtOrbi.make_time(from)
+      sfrom = from.strftime('%F/%T')
+
       t = TimeCursor.new(from.translate(@timezone))
+        #
+        # the translation occurs in the timezone of
+        # this Fugit::Cron instance
 
       loop do
-#p [ :l, Fugit.time_to_s(t.time) ]
+
         (from.to_i == t.to_i) && (t.inc(1); next)
         month_match?(t) || (t.inc_month; next)
         day_match?(t) || (t.inc_day; next)
         hour_match?(t) || (t.inc_hour; next)
         min_match?(t) || (t.inc_min; next)
         sec_match?(t) || (t.inc_sec(@seconds); next)
+
+        st = t.time.strftime('%F/%T')
+        (from, sfrom = t.time, st; next) if st == sfrom
+          #
+          # when transitioning out of DST, this prevents #next_time from
+          # yielding the same literal time twice in a row, see gh-6
+
         break
       end
 
       t.time.translate(from.zone)
+        #
+        # the answer time is in the same timezone as the `from`
+        # starting point
     end
 
     def previous_time(from=::EtOrbi::EoTime.now)

data/lib/fugit/duration.rb

@@ -5,40 +5,58 @@ module Fugit
 
     attr_reader :original, :h, :options
 
-    def self.new(s)
+    class << self
 
-      parse(s)
-    end
+      def new(s)
+
+        parse(s)
+      end
 
-    def self.parse(s, opts={})
+      def parse(s, opts={})
 
-      return s if s.is_a?(self)
+        return s if s.is_a?(self)
 
-      original = s
+        original = s
 
-      s = "#{s}s" if s.is_a?(Numeric)
+        s = "#{s}s" if s.is_a?(Numeric)
 
-      return nil unless s.is_a?(String)
+        return nil unless s.is_a?(String)
 
-      s = s.strip
+        s = s.strip
 #p [ original, s ]; Raabro.pp(Parser.parse(s, debug: 3), colours: true)
 
-      h =
-        if opts[:iso]
-          IsoParser.parse(opts[:stricter] ? s : s.upcase)
-        elsif opts[:plain]
-          Parser.parse(s)
-        else
-          Parser.parse(s) || IsoParser.parse(opts[:stricter] ? s : s.upcase)
-        end
-#p h
+        h =
+          if opts[:iso]
+            IsoParser.parse(opts[:stricter] ? s : s.upcase)
+          elsif opts[:plain]
+            Parser.parse(s)
+          else
+            Parser.parse(s) || IsoParser.parse(opts[:stricter] ? s : s.upcase)
+          end
 
-      h ? self.allocate.send(:init, original, opts, h) : nil
-    end
+        h ? self.allocate.send(:init, original, opts, h) : nil
+      end
+
+      def do_parse(s, opts={})
+
+        parse(s, opts) ||
+        fail(ArgumentError.new("not a duration #{s.inspect}"))
+      end
 
-    def self.do_parse(s, opts={})
+      def to_plain_s(o); do_parse(o).deflate.to_plain_s; end
+      def to_iso_s(o); do_parse(o).deflate.to_iso_s; end
+      def to_long_s(o, opts={}); do_parse(o).deflate.to_long_s(opts); end
 
-      parse(s, opts) || fail(ArgumentError.new("not a duration #{s.inspect}"))
+      def common_rewrite_dur(t)
+
+        t
+          .subgather(nil)
+          .inject({}) { |h, tt|
+            v = tt.string; v = v.index('.') ? v.to_f : v.to_i
+              # drops ending ("y", "m", ...) by itself
+            h[tt.name] = (h[tt.name] || 0) + v
+            h }
+      end
     end
 
     KEYS = {
@@ -103,12 +121,6 @@ module Fugit
       s.string
     end
 
-    class << self
-      def to_plain_s(o); do_parse(o).deflate.to_plain_s; end
-      def to_iso_s(o); do_parse(o).deflate.to_iso_s; end
-      def to_long_s(o, opts={}); do_parse(o).deflate.to_long_s(opts); end
-    end
-
     # For now, let's alias to #h
     #
     def to_h; h; end
@@ -308,18 +320,6 @@ module Fugit
       self
     end
 
-    def self.common_rewrite_dur(t)
-
-      t
-        .subgather(nil)
-        .inject({}) { |h, tt|
-          v = tt.string; v = v.index('.') ? v.to_f : v.to_i
-            # drops ending ("y", "m", ...) by itself
-          h[tt.name] = (h[tt.name] || 0) + v
-          h
-        }
-    end
-
     module Parser include Raabro
 
       # piece parsers bottom to top
@@ -328,12 +328,12 @@ module Fugit
 
       def yea(i); rex(:yea, i, /(\d+\.\d*|(\d*\.)?\d+) *y(ears?)?/i); end
       def mon(i); rex(:mon, i, /(\d+\.\d*|(\d*\.)?\d+) *(M|months?)/); end
-      def wee(i); rex(:wee, i, /(\d+\.\d*|(\d*\.)?\d+) *(weeks?|w)/i); end
-      def day(i); rex(:day, i, /(\d+\.\d*|(\d*\.)?\d+) *(days?|d)/i); end
-      def hou(i); rex(:hou, i, /(\d+\.\d*|(\d*\.)?\d+) *(hours?|h)/i); end
-      def min(i); rex(:min, i, /(\d+\.\d*|(\d*\.)?\d+) *(mins?|minutes?|m)/); end
+      def wee(i); rex(:wee, i, /(\d+\.\d*|(\d*\.)?\d+) *w(eeks?)?/i); end
+      def day(i); rex(:day, i, /(\d+\.\d*|(\d*\.)?\d+) *d(ays?)?/i); end
+      def hou(i); rex(:hou, i, /(\d+\.\d*|(\d*\.)?\d+) *h(ours?)?/i); end
+      def min(i); rex(:min, i, /(\d+\.\d*|(\d*\.)?\d+) *m(in(ute)?s?)?/); end
 
-      def sec(i); rex(:sec, i, /(\d+\.\d*|(\d*\.)?\d+) *(secs?|seconds?|s)/i); end 
+      def sec(i); rex(:sec, i, /(\d+\.\d*|(\d*\.)?\d+) *s(ec(ond)?)?s?/i); end
       def sek(i); rex(:sec, i, /(\d+\.\d*|\.\d+|\d+)$/); end
 
       def elt(i); alt(nil, i, :yea, :mon, :wee, :day, :hou, :min, :sec, :sek); end

data/lib/fugit/misc.rb

@@ -1,32 +1,35 @@
 
 module Fugit
 
-  def self.isostamp(show_date, show_time, show_usec, time)
+  class << self
 
-    t = time || Time.now
-    s = StringIO.new
+    def isostamp(show_date, show_time, show_usec, time)
 
-    s << t.strftime('%Y-%m-%d') if show_date
-    s << t.strftime('T%H:%M:%S') if show_time
-    s << sprintf('.%06d', t.usec) if show_time && show_usec
-    s << 'Z' if show_time && time.utc?
+      t = time || Time.now
+      s = StringIO.new
 
-    s.string
-  end
+      s << t.strftime('%Y-%m-%d') if show_date
+      s << t.strftime('T%H:%M:%S') if show_time
+      s << sprintf('.%06d', t.usec) if show_time && show_usec
+      s << 'Z' if show_time && time.utc?
 
-  def self.time_to_s(t)
+      s.string
+    end
 
-    isostamp(true, true, false, t)
-  end
+    def time_to_s(t)
 
-  def self.time_to_plain_s(t=Time.now, z=true)
+      isostamp(true, true, false, t)
+    end
 
-    t.strftime('%Y-%m-%d %H:%M:%S') + (z && t.utc? ? ' Z' : '')
-  end
+    def time_to_plain_s(t=Time.now, z=true)
+
+      t.strftime('%Y-%m-%d %H:%M:%S') + (z && t.utc? ? ' Z' : '')
+    end
 
-  def self.time_to_zone_s(t=Time.now)
+    def time_to_zone_s(t=Time.now)
 
-    t.strftime('%Y-%m-%d %H:%M:%S %Z %z')
+      t.strftime('%Y-%m-%d %H:%M:%S %Z %z')
+    end
   end
 end
 

data/lib/fugit/nat.rb

@@ -6,52 +6,93 @@ module Fugit
   #
   module Nat
 
-    def self.parse(s)
+    class << self
 
-      return s if s.is_a?(Fugit::Cron) || s.is_a?(Fugit::Duration)
+      def parse(s)
 
-      return nil unless s.is_a?(String)
+        return s if s.is_a?(Fugit::Cron) || s.is_a?(Fugit::Duration)
 
-#p s; Raabro.pp(Parser.parse(s, debug: 3))
-      a = Parser.parse(s)
+        return nil unless s.is_a?(String)
 
-#p a
-      return nil unless a
+#p s; Raabro.pp(Parser.parse(s, debug: 3), colours: true)
+        a = Parser.parse(s)
 
-      if a.include?([ :flag, 'every' ])
-        parse_cron(a)
-      else
-        nil
+        if a && a.include?([ :flag, 'every' ])
+          parse_cron(a)
+        else
+          nil
+        end
       end
-    end
 
-    def self.do_parse(s)
+      def do_parse(s)
 
-      parse(s) || fail(ArgumentError.new("could not parse a nat #{s.inspect}"))
-    end
+        parse(s) ||
+        fail(ArgumentError.new("could not parse a nat #{s.inspect}"))
+      end
 
-    def self.parse_cron(a)
-
-      h = { min: nil, hou: [], dom: [ nil ], mon: [ nil ], dow: [ nil ] }
-
-      a.each do |key, val|
-        if key == :biz_day
-          h[:dow] = [ [ 1, 5 ] ]
-        elsif key == :simple_hour || key == :numeral_hour
-          (h[:hou] ||= []) << [ val ]
-        elsif key == :digital_hour
-          h[:hou] = [ val[0, 1] ]
-          h[:min] = [ val[1, 1] ]
-        elsif key == :name_day
-          (h[:dow] ||= []) << [ val ]
-        elsif key == :flag && val == 'pm' && h[:hou]
-          h[:hou][-1] =  [ h[:hou][-1].first + 12 ]
+      def parse_cron(a)
+
+        h = { min: nil, hou: [], dom: [ nil ], mon: [ nil ], dow: [ nil ] }
+
+        a.each do |key, val|
+          if key == :biz_day
+            h[:dow] = [ [ 1, 5 ] ]
+          elsif key == :simple_hour || key == :numeral_hour
+            (h[:hou] ||= []) << [ val ]
+          elsif key == :digital_hour
+            h[:hou] = [ val[0, 1] ]
+            h[:min] = [ val[1, 1] ]
+          elsif key == :name_day
+            (h[:dow] ||= []) << [ val ]
+          elsif key == :flag && val == 'pm' && h[:hou]
+            h[:hou][-1] =  [ h[:hou][-1].first + 12 ]
+          elsif key == :tz
+            h[:tz] = val
+          elsif key == :duration
+            process_duration(h, *val[0].to_h.first)
+          end
         end
+        h[:min] ||= [ 0 ]
+        h[:dow].sort_by! { |d, _| d || 0 }
+
+        Fugit::Cron.allocate.send(:init, nil, h)
+      end
+
+      def process_duration(h, interval, value)
+
+        send("process_duration_#{interval}", h, value)
       end
-      h[:min] ||= [ 0 ]
-      h[:dow].sort_by! { |d, _| d || 0 }
 
-      Fugit::Cron.allocate.send(:init, nil, h)
+      def process_duration_mon(h, 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}" ]
+      end
+
+      def process_duration_hou(h, value)
+
+        h[:hou] = [ value == 1 ? '*' : "*/#{value}" ]
+      end
+
+      def process_duration_min(h, value)
+
+        h[:hou] = [ '*' ]
+        h[:min] = [ value == 1 ? '*' : "*/#{value}" ]
+      end
+
+      def process_duration_sec(h, value)
+
+        h[:hou] = [ '*' ]
+        h[:min] = [ '*' ]
+        h[:sec] = [ value == 1 ? '*' : "*/#{value}" ]
+      end
     end
 
     module Parser include Raabro
@@ -81,20 +122,37 @@ module Fugit
       def name_hour(i)
         rex(:name_hour, i, /(#{NHOURS.keys.join('|')})/i)
       end
-      def hour(i)
-        alt(nil, i, :numeral_hour, :name_hour, :digital_hour, :simple_hour);
-      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
 
-      def flag(i); rex(:flag, i, /(every|day|at|after|am|pm)/i); end
+      def _tz_name(i)
+        rex(nil, i, /[A-Z][a-zA-Z0-9]+(\/[A-Z][a-zA-Z0-9\_]+){0,2}/)
+      end
+      def _tz_delta(i)
+        rex(nil, i, /[-+]([01][0-9]|2[0-4]):?(00|15|30|45)/)
+      end
+      def _tz(i); alt(:tz, i, :_tz_delta, :_tz_name); end
+
+      def duration(i)
+        rex(
+          :duration, i,
+          /
+            \d+
+            \s?
+            (mon(ths?)?|d(ays?)?|h(ours?)?|m(in(ute)?s?)?|s(ec(ond)?s?)?)
+          /ix)
+      end
+
+      def flag(i); rex(:flag, i, /(every|at|after|am|pm|on|in)/i); end
 
       def datum(i)
         alt(nil, i,
-          :flag,
           :plain_day, :biz_day, :name_day,
+          :_tz,
+          :flag,
+          :duration,
           :name_hour, :numeral_hour, :digital_hour, :simple_hour)
       end
 
@@ -107,7 +165,7 @@ module Fugit
 
       def rewrite_nat(t)
 
-#Raabro.pp(t)
+#Raabro.pp(t, colours: true)
         t
           .subgather(nil)
           .collect { |tt|
@@ -116,6 +174,10 @@ module Fugit
             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 :numeral_hour
               [ k, NUMS.index(v) ]
             when :simple_hour
@@ -129,8 +191,7 @@ module Fugit
               [ k, WEEKDAYS.index(v[0, 3]) ]
             else
               [ k, v ]
-            end
-          }
+            end }
       end
     end
   end

data/lib/fugit/parse.rb

@@ -1,42 +1,45 @@
 
 module Fugit
 
-  def self.parse_cron(s); ::Fugit::Cron.parse(s); end
-  def self.parse_duration(s); ::Fugit::Duration.parse(s); end
-  def self.parse_nat(s); ::Fugit::Nat.parse(s); end
-  def self.parse_at(s); ::Fugit::At.parse(s); end
-  def self.parse_in(s); parse_duration(s); end
-
-  def self.do_parse_cron(s); ::Fugit::Cron.do_parse(s); end
-  def self.do_parse_duration(s); ::Fugit::Duration.do_parse(s); end
-  def self.do_parse_nat(s); ::Fugit::Nat.do_parse(s); end
-  def self.do_parse_at(s); ::Fugit::At.do_parse(s); end
-  def self.do_parse_in(s); do_parse_duration(s); end
-
-  def self.parse(s, opts={})
-
-    opts[:at] = opts[:in] if opts.has_key?(:in)
-
-    (opts[:cron] != false && parse_cron(s)) ||
-    (opts[:duration] != false && parse_duration(s)) ||
-    (opts[:at] != false && parse_at(s)) ||
-    (opts[:nat] != false && parse_nat(s)) ||
-    nil
-  end
+  class << self
 
-  def self.do_parse(s, opts={})
+    def parse_cron(s); ::Fugit::Cron.parse(s); end
+    def parse_duration(s); ::Fugit::Duration.parse(s); end
+    def parse_nat(s); ::Fugit::Nat.parse(s); end
+    def parse_at(s); ::Fugit::At.parse(s); end
+    def parse_in(s); parse_duration(s); end
 
-    parse(s, opts) ||
-    fail(ArgumentError.new("found no time information in #{s.inspect}"))
-  end
+    def do_parse_cron(s); ::Fugit::Cron.do_parse(s); end
+    def do_parse_duration(s); ::Fugit::Duration.do_parse(s); end
+    def do_parse_nat(s); ::Fugit::Nat.do_parse(s); end
+    def do_parse_at(s); ::Fugit::At.do_parse(s); end
+    def do_parse_in(s); do_parse_duration(s); end
+
+    def parse(s, opts={})
+
+      opts[:at] = opts[:in] if opts.has_key?(:in)
+
+      (opts[:cron] != false && parse_cron(s)) ||
+      (opts[:duration] != false && parse_duration(s)) ||
+      (opts[:at] != false && parse_at(s)) ||
+      (opts[:nat] != false && parse_nat(s)) ||
+      nil
+    end
+
+    def do_parse(s, opts={})
+
+      parse(s, opts) ||
+      fail(ArgumentError.new("found no time information in #{s.inspect}"))
+    end
 
-  def self.determine_type(s)
+    def determine_type(s)
 
-    case self.parse(s)
-    when ::Fugit::Cron then 'cron'
-    when ::Fugit::Duration then 'in'
-    when ::Time, ::EtOrbi::EoTime then 'at'
-    else nil
+      case self.parse(s)
+      when ::Fugit::Cron then 'cron'
+      when ::Fugit::Duration then 'in'
+      when ::Time, ::EtOrbi::EoTime then 'at'
+      else nil
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fugit
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.1.4
 platform: ruby
 authors:
 - John Mettraux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-21 00:00:00.000000000 Z
+date: 2018-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: raabro
@@ -33,7 +33,7 @@ dependencies:
         version: '1.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.1
+        version: 1.1.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -43,7 +43,7 @@ dependencies:
         version: '1.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.1
+        version: 1.1.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -99,7 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.5.2.3
 signing_key: 
 specification_version: 4
 summary: time tools for flor