fugit 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b3e0133c5181167fb43ca7228ce7b76d154f402a
-  data.tar.gz: 3ff631d838f4ea26b0af2c11701356f71e9518f4
+  metadata.gz: c52b936431c2d332e82c316fb52d7e786c577027
+  data.tar.gz: 8d82d60d76b8f041771852d688364eab445f2575
 SHA512:
-  metadata.gz: cb8cfb83bb07a6289bc86b24a1c9c26510a807734a1f81b8f132f032c7015081320408515f606696a4fea03fa00bc6c7d2278d0ad6390fc3c8a277034e627683
-  data.tar.gz: b1ec3168fd15980353048e3261e848bf63c7e740f47388e20f0f3c8e3b2bd4a9c1cab324a7663d60b5a71aba7ecc473b9453f0d2ee9eab859a4aa5f017df3d87
+  metadata.gz: 24c0e708a7f42af660d14e3718ec395e7dd2e791cb7f2bb5fa2bb3f9d0d2f850a9c78712772854fd182f47bb479a89658513f7fa9eb6d66f55cdca46b788f34d
+  data.tar.gz: b8ba24ce4f558c3cd174bb1b70cf96b2e444999313aee67b0920e7616725cbfaeb98e75964351802b1a6487cb97044288636f450222ed6424dbb2e6833767de6

data/CHANGELOG.md

@@ -2,9 +2,26 @@
 # fugit CHANGELOG.md
 
 
+## fugit 1.1.0  released 2018-03-27
+
+* Travel in Cron zone in #next_time and #previous_time, return from zone
+* Parse and store timezone in Fugit::Cron
+* Introduce Fugit::Duration#deflate month: d / year: d
+* Introduce Fugit::Duration#drop_seconds
+* Alias Fugit::Duration#to_h to Fugit::Duration#h
+* Introduce to_rufus_s (1y2M3d) vs to_plain_s (1Y2M3D)
+* Ensure Duration#deflate preserves at least `{ sec: 0 }`
+* Stringify 0 seconds as "0s"
+* Ignore "-5" and "-5.", only accept "-5s" and "-5.s"
+* Introduce "signed durations", "-1Y+2Y-3m"
+* Ensure `1.0d1.0w1.0d` gets parsed correctly
+* Ensure Fugit::Cron.next_time returns plain seconds (.0, not .1234...)
+* Introduce Fugit::Frequency for cron
+
+
 ## fugit 1.0.0  released 2017-06-23
 
-* introduce et-orbi dependency (1.0.5 or better)
+* Introduce et-orbi dependency (1.0.5 or better)
 * Wire #deflate into Duration.to_long_s / .to_iso_s / .to_plain_s
 
 

data/CREDITS.md

@@ -1,7 +1,13 @@
 
 # fugit credits
 
-Many thanks to all the rufus-scheduler contributors and people who gave feedback.
+* Harry Lascelles https://github.com/hlascelles timezone reminder
+
+
+## rufus-scheduler credits
+
+As fugit originates in rufus-scheduler, many thanks to all the
+rufus-scheduler contributors and people who gave feedback.
 
 https://github.com/jmettraux/rufus-scheduler/blob/master/CREDITS.txt
 

data/LICENSE.txt

@@ -1,5 +1,5 @@
 
-Copyright (c) 2017-2017, John Mettraux, jmettraux+flor@gmail.com
+Copyright (c) 2017-2018, 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
@@ -19,3 +19,6 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 
+
+Made in Japan
+

data/README.md

@@ -6,6 +6,8 @@
 
 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
 
 
@@ -25,6 +27,22 @@ Fugit will probably become the foundation for [rufus-scheduler](https://github.c
 * ...
 
 
+## `Fugit.parse(s)`
+
+The simplest way to use fugit is via `Fugit.parse(s)`.
+
+```ruby
+require 'fugit'
+
+Fugit.parse('0 0 1 jan *').class         # ==> ::Fugit::Cron
+Fugit.parse('12y12M').class              # ==> ::Fugit::Duration
+
+Fugit.parse('2017-12-12').class          # ==> ::EtOrbi::EoTime
+Fugit.parse('2017-12-12 UTC').class      # ==> ::EtOrbi::EoTime
+
+Fugit.parse('every day at noon').class   # ==> ::Fugit::Cron
+```
+
 ## `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.
@@ -108,6 +126,53 @@ 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"
+```
+
+## `Fugit::Nat`
+
+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'
+```
+
+Directly with `Fugit.parse(s)` is OK too:
+```ruby
+Fugit.parse('every day at five')  # ==> Fugit::Cron instance '0 5 * * *'
+```
+
 
 ## LICENSE
 

data/fugit.gemspec

@@ -20,14 +20,16 @@ Time tools for flor and the floraison project. Cron parsing and occurence comput
 
   #s.files = `git ls-files`.split("\n")
   s.files = Dir[
+    'README.{md,txt}',
+    'CHANGELOG.{md,txt}', 'CREDITS.{md,txt}', 'LICENSE.{md,txt}',
     'Makefile',
     'lib/**/*.rb', #'spec/**/*.rb', 'test/**/*.rb',
-    '*.gemspec', '*.txt', '*.md'
+    "#{s.name}.gemspec",
   ]
 
   #s.add_runtime_dependency 'tzinfo'
   s.add_runtime_dependency 'raabro', '~> 1.1'
-  s.add_runtime_dependency 'et-orbi', '>= 1.0.5'
+  s.add_runtime_dependency 'et-orbi', '>= 1.1.0'
 
   s.add_development_dependency 'rspec', '~> 3.4'
 

data/lib/fugit.rb

@@ -1,7 +1,7 @@
 
 module Fugit
 
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end
 
 require 'time'
@@ -14,5 +14,6 @@ require 'fugit/misc'
 require 'fugit/cron'
 require 'fugit/duration'
 require 'fugit/nat'
+require 'fugit/at'
 require 'fugit/parse'
 

data/lib/fugit/at.rb

@@ -0,0 +1,17 @@
+
+module Fugit
+
+  module At
+
+    def self.parse(s)
+
+      ::EtOrbi.make_time(s) rescue nil
+    end
+
+    def self.do_parse(s)
+
+      ::EtOrbi.make_time(s)
+    end
+  end
+end
+

data/lib/fugit/cron.rb

@@ -14,54 +14,60 @@ module Fugit
       '@hourly' => '0 * * * *',
     }
 
-    attr_reader :original
+    attr_reader :original, :zone
+    attr_reader :minutes, :hours, :monthdays, :months, :weekdays, :timezone
 
-    attr_reader :minutes, :hours, :monthdays, :months, :weekdays
+    class << self
 
-    def self.new(original)
+      def new(original)
 
-      parse(original)
-    end
+        parse(original)
+      end
 
-    def to_cron_s
+      def parse(s)
 
-      @cron_s ||=
-        [
-          @seconds == [ 0 ] ? nil : (@seconds || [ '*' ]).join(','),
-          (@minutes || [ '*' ]).join(','),
-          (@hours || [ '*' ]).join(','),
-          (@monthdays || [ '*' ]).join(','),
-          (@months || [ '*' ]).join(','),
-          (@weekdays || [ [ '*' ] ]).map { |d| d.compact.join('#') }.join(',')
-        ].compact.join(' ')
-    end
+        return s if s.is_a?(self)
 
-    def self.parse(s)
+        original = s
+        s = SPECIALS[s] || s
 
-      return s if s.is_a?(self)
+        return nil unless s.is_a?(String)
 
-      original = s
-      s = SPECIALS[s] || s
+#p s; Raabro.pp(Parser.parse(s, debug: 3), colors: true)
+        h = Parser.parse(s)
 
-      return nil unless s.is_a?(String)
+        return nil unless h
 
-#p s; Raabro.pp(Parser.parse(s, debug: 3))
-      h = Parser.parse(s)
+        self.allocate.send(:init, s, h)
+      end
 
-      return nil unless h
+      def do_parse(s)
 
-      self.allocate.send(:init, s, h)
+        parse(s) ||
+        fail(ArgumentError.new("not a cron string #{s.inspect}"))
+      end
     end
 
-    def self.do_parse(s)
+    def to_cron_s
 
-      parse(s) || fail(ArgumentError.new("not a cron string #{s.inspect}"))
+      @cron_s ||= begin
+        [
+          @seconds == [ 0 ] ? nil : (@seconds || [ '*' ]).join(','),
+          (@minutes || [ '*' ]).join(','),
+          (@hours || [ '*' ]).join(','),
+          (@monthdays || [ '*' ]).join(','),
+          (@months || [ '*' ]).join(','),
+          (@weekdays || [ [ '*' ] ]).map { |d| d.compact.join('#') }.join(','),
+          @timezone ? @timezone.to_s : nil
+        ].compact.join(' ')
+      end
     end
 
     class TimeCursor
 
       def initialize(t)
-        @t = t.is_a?(TimeCursor) ? t.time : ::EtOrbi.make_time(t)
+        @t = t.is_a?(TimeCursor) ? t.time : t
+        @t.seconds = @t.seconds.to_i
       end
 
       def time; @t; end
@@ -163,7 +169,8 @@ module Fugit
 
     def next_time(from=::EtOrbi::EoTime.now)
 
-      t = TimeCursor.new(from)
+      from = ::EtOrbi.make_time(from)
+      t = TimeCursor.new(from.translate(@timezone))
 
       loop do
 #p [ :l, Fugit.time_to_s(t.time) ]
@@ -176,12 +183,13 @@ module Fugit
         break
       end
 
-      t.time
+      t.time.translate(from.zone)
     end
 
     def previous_time(from=::EtOrbi::EoTime.now)
 
-      t = TimeCursor.new(from)
+      from = ::EtOrbi.make_time(from)
+      t = TimeCursor.new(from.translate(@timezone))
 
       loop do
 #p [ :l, Fugit.time_to_s(t.time) ]
@@ -194,13 +202,14 @@ module Fugit
         break
       end
 
-      t.time
+      t.time.translate(from.zone)
     end
 
     # Mostly used as a #next_time sanity check.
     # Avoid for "business" use, it's slow.
     #
-    # 2017 is non leap year (though it is preceded by a leap second)
+    # 2017 is a non leap year (though it is preceded by
+    # a leap second on 2016-12-31)
     #
     # Nota bene: cron with seconds are not supported.
     #
@@ -223,16 +232,38 @@ module Fugit
             t = t1
           end
 
-          occurences = deltas.size
-          span = t1 - t0
-          span_years = span / (365 * 24 * 3600)
-          yearly_occurences = occurences.to_f / span_years
-
-          [ deltas.min, deltas.max, occurences,
-            span.to_i, span_years.to_i, yearly_occurences.to_i ]
+          Frequency.new(deltas, t1 - t0)
         end
     end
 
+    class Frequency
+
+      attr_reader :span, :delta_min, :delta_max, :occurrences
+      attr_reader :span_years, :yearly_occurrences
+
+      def initialize(deltas, span)
+
+        @span = span
+
+        @delta_min = deltas.min; @delta_max = deltas.max
+        @occurrences = deltas.size
+        @span_years = span / (365 * 24 * 3600)
+        @yearly_occurrences = @occurrences.to_f / @span_years
+      end
+
+      def to_debug_s
+
+        {
+          dmin: Fugit::Duration.new(delta_min).deflate.to_plain_s,
+          dmax: Fugit::Duration.new(delta_max).deflate.to_plain_s,
+          ocs: occurrences,
+          spn: Fugit::Duration.new(span.to_i).deflate.to_plain_s,
+          spnys: span_years.to_i,
+          yocs: yearly_occurrences.to_i
+        }.collect { |k, v| "#{k}: #{v}" }.join(', ')
+      end
+    end
+
     def to_a
 
       [ @seconds, @minutes, @hours, @monthdays, @months, @weekdays ]
@@ -264,6 +295,7 @@ module Fugit
       determine_monthdays(h[:dom])
       determine_months(h[:mon])
       determine_weekdays(h[:dow])
+      determine_timezone(h[:tz])
 
       self
     end
@@ -345,6 +377,11 @@ module Fugit
       @weekdays = nil if @weekdays.empty?
     end
 
+    def determine_timezone(z)
+
+      @zone, @timezone = z
+    end
+
     module Parser include Raabro
 
       WEEKDAYS = %w[ sunday monday tuesday wednesday thursday friday saturday ]
@@ -420,11 +457,19 @@ module Fugit
       def lmon_(i); seq(nil, i, :list_mon, :s); end
       alias ldow list_dow
 
+      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 classic_cron(i)
-        seq(:ccron, i, :lmin_, :lhou_, :ldom_, :lmon_, :ldow)
+        seq(:ccron, i, :lmin_, :lhou_, :ldom_, :lmon_, :ldow, :_tz, '?')
       end
       def second_cron(i)
-        seq(:scron, i, :lsec_, :lmin_, :lhou_, :ldom_, :lmon_, :ldow)
+        seq(:scron, i, :lsec_, :lmin_, :lhou_, :ldom_, :lmon_, :ldow, :_tz, '?')
       end
 
       def cron(i)
@@ -469,12 +514,26 @@ module Fugit
           .collect { |et| rewrite_elt(t.name, et) }
       end
 
+      def rewrite_tz(t)
+
+        s = t.string.strip
+        z = EtOrbi.get_tzone(s)
+
+        [ s, z ]
+      end
+
       def rewrite_cron(t)
 
-        t
+        hcron = t
           .sublookup(nil) # go to :ccron or :scron
           .subgather(nil) # list min, hou, mon, ...
-          .inject({}) { |h, tt| h[tt.name] = rewrite_entry(tt); h }
+          .inject({}) { |h, tt|
+            h[tt.name] = tt.name == :tz ? rewrite_tz(tt) : rewrite_entry(tt)
+            h }
+
+        z, tz = hcron[:tz]; return nil if z && ! tz
+
+        hcron
       end
     end
   end

data/lib/fugit/duration.rb

@@ -3,7 +3,7 @@ module Fugit
 
   class Duration
 
-    attr_reader :original, :h
+    attr_reader :original, :h, :options
 
     def self.new(s)
 
@@ -16,13 +16,12 @@ module Fugit
 
       original = s
 
-      s = s.to_s if s.is_a?(Numeric)
+      s = "#{s}s" if s.is_a?(Numeric)
 
       return nil unless s.is_a?(String)
 
       s = s.strip
-      s = s + 's' if s.match(/\A-?(\d*\.)?\d+\z/)
-#p [ original, s ]; Raabro.pp(Parser.parse(s, debug: 3))
+#p [ original, s ]; Raabro.pp(Parser.parse(s, debug: 3), colours: true)
 
       h =
         if opts[:iso]
@@ -32,8 +31,9 @@ module Fugit
         else
           Parser.parse(s) || IsoParser.parse(opts[:stricter] ? s : s.upcase)
         end
+#p h
 
-      h ? self.allocate.send(:init, original, h) : nil
+      h ? self.allocate.send(:init, original, opts, h) : nil
     end
 
     def self.do_parse(s, opts={})
@@ -42,23 +42,30 @@ module Fugit
     end
 
     KEYS = {
-      yea: { a: 'Y', i: 'Y', s: 365 * 24 * 3600, x: 0, l: 'year' },
-      mon: { a: 'M', i: 'M', s: 30 * 24 * 3600, x: 1, l: 'month' },
-      wee: { a: 'W', i: 'W', s: 7 * 24 * 3600, I: true, l: 'week' },
-      day: { a: 'D', i: 'D', s: 24 * 3600, I: true, l: 'day' },
-      hou: { a: 'h', i: 'H', s: 3600, I: true, l: 'hour' },
-      min: { a: 'm', i: 'M', s: 60, I: true, l: 'minute' },
-      sec: { a: 's', i: 'S', s: 1, I: true, l: 'second' },
+      yea: { a: 'Y', r: 'y', i: 'Y', s: 365 * 24 * 3600, x: 0, l: 'year' },
+      mon: { a: 'M', r: 'M', i: 'M', s: 30 * 24 * 3600, x: 1, l: 'month' },
+      wee: { a: 'W', r: 'w', i: 'W', s: 7 * 24 * 3600, I: true, l: 'week' },
+      day: { a: 'D', r: 'd', i: 'D', s: 24 * 3600, 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' },
     }
     INFLA_KEYS, NON_INFLA_KEYS =
       KEYS.partition { |k, v| v[:I] }
 
-    def to_plain_s
+    def _to_s(key)
 
-      KEYS.inject(StringIO.new) { |s, (k, a)|
-        v = @h[k]; next s unless v; s << v.to_s; s << a[:a]
-      }.string
-    end
+      KEYS.inject([ StringIO.new, '+' ]) { |(s, sign), (k, a)|
+        v = @h[k]
+        next [ s, sign ] unless v
+        sign1 = v < 0 ? '-' : '+'
+        s << (sign1 != sign ? sign1 : '') << v.abs.to_s << a[key]
+        [ s, sign1 ]
+      }[0].string
+    end; protected :_to_s
+
+    def to_plain_s; _to_s(:a); end
+    def to_rufus_s; _to_s(:r); end
 
     def to_iso_s
 
@@ -102,6 +109,15 @@ module Fugit
       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
+
+    def to_rufus_h
+
+      KEYS.inject({}) { |h, (ks, kh)| v = @h[ks]; h[kh[:r].to_sym] = v if v; h }
+    end
+
     # Warning: this is an "approximation", months are 30 days and years are
     # 365 days, ...
     #
@@ -123,32 +139,54 @@ module Fugit
           h
         }
 
-      self.class.allocate.init(@original, h)
+      self.class.allocate.init(@original, {}, h)
     end
 
-    def deflate
+    # Round float seconds to 9 decimals when deflating
+    #
+    SECOND_ROUND = 9
+
+    def deflate(options={})
 
       id = inflate
       h = id.h.dup
       s = h.delete(:sec) || 0
 
-      INFLA_KEYS.each do |k, v|
+      keys = INFLA_KEYS
 
-        n = s / v[:s]; next if n == 0
-        m = s % v[:s]
+      mon = options[:month]
+      yea = options[:year]
+      keys = keys.dup if mon || yea
 
-        h[k] = (h[k] || 0) + n
-        s = m
+      if mon
+        mon = 30 if mon == true
+        mon = "#{mon}d" if mon.is_a?(Integer)
+        keys.unshift([ :mon, { s: Fugit::Duration.parse(mon).to_sec } ])
+      end
+      if yea
+        yea = 365 if yea == true
+        yea = "#{yea}d" if yea.is_a?(Integer)
+        keys.unshift([ :yea, { s: Fugit::Duration.parse(yea).to_sec } ])
+      end
+
+      keys[0..-2].each do |k, v|
+
+        vs = v[:s]; next if s < vs
+
+        h[k] = (h[k] || 0) + s.to_i / vs
+        s = s % vs
       end
 
-      self.class.allocate.init(@original, h)
+      h[:sec] = s.is_a?(Integer) ? s : s.round(SECOND_ROUND)
+
+      self.class.allocate.init(@original, {}, h)
     end
 
     def opposite
 
       h = @h.inject({}) { |h, (k, v)| h[k] = -v; h }
 
-      self.class.allocate.init(nil, h)
+      self.class.allocate.init(nil, {}, h)
     end
 
     alias -@ opposite
@@ -158,14 +196,14 @@ module Fugit
       h = @h.dup
       h[:sec] = (h[:sec] || 0) + n.to_i
 
-      self.class.allocate.init(nil, h)
+      self.class.allocate.init(nil,{}, h)
     end
 
     def add_duration(d)
 
       h = d.h.inject(@h.dup) { |h, (k, v)| h[k] = (h[k] || 0) + v; h }
 
-      self.class.allocate.init(nil, h)
+      self.class.allocate.init(nil, {}, h)
     end
 
     def add_to_time(t)
@@ -213,7 +251,7 @@ module Fugit
     end
     alias + add
 
-    def substract(a)
+    def subtract(a)
 
       case a
       when Numeric then add_numeric(-a)
@@ -221,10 +259,10 @@ module Fugit
       when String then add_duration(-self.class.parse(a))
       when ::Time, ::EtOrbi::EoTime then add_to_time(a)
       else fail ArgumentError.new(
-        "cannot substract #{a.class} instance to a Fugit::Duration")
+        "cannot subtract #{a.class} instance to a Fugit::Duration")
       end
     end
-    alias - substract
+    alias - subtract
 
     def ==(o)
 
@@ -242,14 +280,30 @@ module Fugit
       add(from)
     end
 
+    # Returns a copy of this duration, omitting its seconds.
+    #
+    def drop_seconds
+
+      h = @h.dup
+      h.delete(:sec)
+      h[:min] = 0 if h.empty?
+
+      self.class.allocate.init(nil, { literal: true }, h)
+    end
+
     protected
 
-    def init(original, h)
+    def init(original, options, h)
 
       @original = original
+      @options = options
 
-      @h = h.reject { |k, v| v == 0 }
-        # which copies h btw
+      if options[:literal]
+        @h = h
+      else
+        @h = h.reject { |k, v| v == 0 }
+        @h[:sec] = 0 if @h.empty?
+      end
 
       self
     end
@@ -272,23 +326,47 @@ module Fugit
 
       def sep(i); rex(nil, i, /([ \t,]+|and)*/i); end
 
-      def yea(i); rex(:yea, i, /-?\d+ *y(ears?)?/i); end
-      def mon(i); rex(:mon, i, /-?\d+ *(M|months?)/); end
-      def wee(i); rex(:wee, i, /-?\d+ *(weeks?|w)/i); end
-      def day(i); rex(:day, i, /-?\d+ *(days?|d)/i); end
-      def hou(i); rex(:hou, i, /-?\d+ *(hours?|h)/i); end
-      def min(i); rex(:min, i, /-?\d+ *(mins?|minutes?|m)/); end
+      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 sec(i); rex(:sec, i, /(\d+\.\d*|(\d*\.)?\d+) *(secs?|seconds?|s)/i); end 
+      def sek(i); rex(:sec, i, /(\d+\.\d*|\.\d+|\d+)$/); end
 
-      def sec(i); rex(:sec, i, /-?((\d*\.)?\d+) *(secs?|seconds?|s)/i); end
-        # always last!
+      def elt(i); alt(nil, i, :yea, :mon, :wee, :day, :hou, :min, :sec, :sek); end
+      def sign(i); rex(:sign, i, /[-+]?/); end
 
-      def elt(i); alt(nil, i, :yea, :mon, :wee, :day, :hou, :min, :sec); end
+      def sdur(i); seq(:sdur, i, :sign, '?', :elt, '+'); end
 
-      def dur(i); jseq(:dur, i, :elt, :sep); end
+      def dur(i); jseq(:dur, i, :sdur, :sep); end
 
       # rewrite parsed tree
 
-      def rewrite_dur(t); Fugit::Duration.common_rewrite_dur(t); end
+      def merge(h0, h1)
+
+        sign = h1.delete(:sign) || 1
+
+        h1.inject(h0) { |h, (k, v)| h.merge(k => (h[k] || 0) + sign * v) }
+      end
+
+      def rewrite_sdur(t)
+
+        h = Fugit::Duration.common_rewrite_dur(t)
+
+        sign = t.sublookup(:sign)
+        sign = (sign && sign.string == '-') ? -1 : 1
+
+        h.merge(sign: sign)
+      end
+
+      def rewrite_dur(t)
+
+#Raabro.pp(t, colours: true)
+        t.children.inject({}) { |h, ct| merge(h, ct.name ? rewrite(ct) : {}) }
+      end
     end
 
     module IsoParser include Raabro

data/lib/fugit/parse.rb

@@ -1,25 +1,17 @@
 
 module Fugit
 
-  def self.parse_at(s)
-
-    ::EtOrbi.make_time(s) rescue nil
-  end
-
-  def self.do_parse_at(s)
-
-    ::EtOrbi.make_time(s)
-  end
-
   def self.parse_cron(s); ::Fugit::Cron.parse(s); end
   def self.parse_duration(s); ::Fugit::Duration.parse(s); end
-  def self.parse_in(s); parse_duration(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_in(s); do_parse_duration(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={})
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fugit
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - John Mettraux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-23 00:00:00.000000000 Z
+date: 2018-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: raabro
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.5
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.5
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -67,6 +67,7 @@ files:
 - README.md
 - fugit.gemspec
 - lib/fugit.rb
+- lib/fugit/at.rb
 - lib/fugit/cron.rb
 - lib/fugit/duration.rb
 - lib/fugit/misc.rb
@@ -92,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: time tools for flor