fugit 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 23a78b668f05dc4bbe20ff46e0596a1211767f8a
-  data.tar.gz: a93498a901fa05952adf0afa0362ca5621a24b3b
+  metadata.gz: c2828bf125d6707c54707f45157f4b84972370fe
+  data.tar.gz: 620ab55025dcebea9b332b4e2610631527659313
 SHA512:
-  metadata.gz: a059da28856f3695800f15449b2245c844a3927170a2df6f9b09081570dfaa7239c4e240dca42d518828a615bc9ad73331d34e83948e352bd7eda18aa8edbb77
-  data.tar.gz: 7588ef1425a8c11e3663ea2ec5de69d1f9ff76ff947a2871f9cc33b4479f7595c340a1058fb3b5f287a29b589d4ec30404167f4926b02efc41508642d9106130
+  metadata.gz: 3012a5dccfb5a63d860a1b83dff62a331f903d470e34084a7f35fca2d47e3facf5a8615f5d0fd818e6fba7650e3015208b6754336fa41b20b0e623f3bf48bb31
+  data.tar.gz: 320140191d5baffc8765ae2776e534a0b5f041f6e8bc315548d03969ebe011e6f79cd152366859e7486659e4eb2679159ac2905b646e7444919ed25ba2d25474

data/CHANGELOG.md

@@ -2,6 +2,13 @@
 # fugit CHANGELOG.md
 
 
+## fugit 0.9.1  released 2017-01-03
+
+* Implement Fugit::Duration #inflate and #deflate
+* Bring in Fugit::Duration
+* Implement Fugit .parse, .parse_at and .parse_cron
+
+
 ## fugit 0.9.0  released 2017-01-03
 
 * Initial release

data/README.md

@@ -4,18 +4,52 @@
 [![Build Status](https://secure.travis-ci.org/floraison/fugit.svg)](http://travis-ci.org/floraison/fugit)
 [![Gem Version](https://badge.fury.io/rb/fugit.svg)](http://badge.fury.io/rb/fugit)
 
-Time tools for [flor](https://github.com/floraison/flor) and the floraison project.
+Time tools for [flor](https://github.com/floraison/flor) and the floraison group.
+
+Fugit will probably become the foundation for [rufus-scheduler](https://github.com/jmettraux/rufus-scheduler) 4.x
+
+
+## Related projects
+
+### Sister projects
+
+* [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, somehow 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 occurence 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
+* ...
+
 
 ## `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.
+
+There is also a `#brute_frequency` method which returns an array `[ shortest delta, longest delta, occurrence count ]` where delta is the time between two occurences.
+
 ```ruby
 require 'fugit'
 
 c = Fugit::Cron.parse('0 0 * *  sun')
+  # or
+c = Fugit::Cron.new('0 0 * *  sun')
 
-p Time.now # => 2017-01-03 09:53:27 +0900
+p Time.now  # => 2017-01-03 09:53:27 +0900
 
-p c.next_time # => 2017-01-08 00:00:00 +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.brute_frequency  # => [ 604800, 604800, 53 ]
+                     #    [ delta min, delta max, occurrence count ]
+
+p c.match?(Time.parse('2017-08-06'))  # => true
+p c.match?(Time.parse('2017-08-07'))  # => false
+p c.match?('2017-08-06')              # => true
+p c.match?('2017-08-06 12:00')        # => false
 ```
 
 Example of cron strings understood by fugit:
@@ -40,6 +74,32 @@ Example of cron strings understood by fugit:
 # and more...
 ```
 
+## `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"
+```
+TODO: continue me
+
+
 ## LICENSE
 
 MIT, see [LICENSE.txt](LICENSE.txt)

data/lib/fugit/core.rb

@@ -0,0 +1,70 @@
+#--
+# Copyright (c) 2017-2017, 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
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+#++
+
+
+module Fugit
+
+  def self.parse_at(s)
+
+    Time.parse(s) rescue nil
+  end
+
+  def self.do_parse_at(s)
+
+    return s if s.is_a?(Time)
+    Time.parse(s)
+  end
+
+  def self.parse_cron(s)
+
+    ::Fugit::Cron.parse(s)
+  end
+
+  def self.do_parse_cron(s)
+
+    ::Fugit::Cron.do_parse(s)
+  end
+
+  def self.parse_duration(s)
+
+    ::Fugit::Duration.parse(s)
+  end
+
+  def self.do_parse_duration(s)
+
+    ::Fugit::Duration.do_parse(s)
+  end
+
+  def self.parse(s)
+
+    parse_duration(s) || parse_at(s) || parse_cron(s)
+  end
+
+  def self.do_parse(s)
+
+    parse(s) ||
+    fail(ArgumentError.new("fugit found no time information in #{s}.inspect"))
+  end
+end
+

data/lib/fugit/cron.rb

@@ -61,19 +61,24 @@ module Fugit
 
     def self.parse(s)
 
+      return s if s.is_a?(self)
+
       original = s
       s = SPECIALS[s] || s
 
 #p s; Raabro.pp(Parser.parse(s, debug: 3))
       h = Parser.parse(s)
 
-      fail ArgumentError.new(
-        "couldn't parse #{original.inspect}"
-      ) unless h
+      return nil unless h
 
       self.allocate.send(:init, s, h)
     end
 
+    def self.do_parse(s)
+
+      parse(s) || fail(ArgumentError.new("not a cron string #{s.inspect}"))
+    end
+
     class NextTime # TODO at some point, use ZoTime
 
       def initialize(t)
@@ -175,6 +180,7 @@ module Fugit
 
     def match?(t)
 
+      t = Fugit.do_parse_at(t)
       t = NextTime.new(t)
 
       month_match?(t) && day_match?(t) && hour_match?(t) && min_match?(t)
@@ -216,7 +222,7 @@ module Fugit
     # Returns [ min delta, max delta, occurence count ]
     # Computes for a non leap year (2017).
     #
-    def frequency(year=2017)
+    def brute_frequency(year=2017)
 
       FREQUENCY_CACHE["#{to_cron_s}|#{year}"] ||=
         begin
@@ -234,6 +240,22 @@ module Fugit
         end
     end
 
+    def to_a
+
+      [ @minutes, @hours, @monthdays, @months, @weekdays ]
+    end
+
+    def ==(o)
+
+      o.is_a?(::Fugit::Cron) && o.to_a == to_a
+    end
+    alias eql? ==
+
+    def hash
+
+      to_a.hash
+    end
+
     protected
 
     FREQUENCY_CACHE = {}

data/lib/fugit/duration.rb

@@ -0,0 +1,331 @@
+#--
+# Copyright (c) 2017-2017, 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
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+#++
+
+
+module Fugit
+
+  class Duration
+
+    attr_reader :original, :h
+
+    def self.new(s)
+
+      parse(s)
+    end
+
+    def self.parse(s, opts={})
+
+      return s if s.is_a?(self)
+
+      original = s
+
+      s = s
+      s = s.to_i if s.is_a?(Numeric)
+      s = s.to_s.strip
+      s = s + 's' if s.match(/\A-?\d+\z/)
+#p [ original, s ]; Raabro.pp(Parser.parse(s, debug: 3))
+
+      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, h) : nil
+    end
+
+    def self.do_parse(s, opts={})
+
+      parse(s, opts) || fail(ArgumentError.new("not a duration #{s.inspect}"))
+    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' },
+    }
+    INFLA_KEYS, NON_INFLA_KEYS =
+      KEYS.partition { |k, v| v[:I] }
+
+    def to_plain_s
+
+      KEYS.inject(StringIO.new) { |s, (k, a)|
+        v = @h[k]; next s unless v; s << v.to_s; s << a[:a]
+      }.string
+    end
+
+    def to_iso_s
+
+      t = false
+
+      s = StringIO.new
+      s << 'P'
+
+      KEYS.each_with_index do |(k, a), i|
+        v = @h[k]; next unless v
+        if i > 3 && t == false
+          t = true
+          s << 'T'
+        end
+        s << v.to_s; s << a[:i]
+      end
+
+      s.string
+    end
+
+    def to_long_s(opts={})
+
+      s = StringIO.new
+      adn = [ false, 'no' ].include?(opts[:oxford]) ? ' and ' : ', and '
+
+      a = @h.to_a
+      while kv = a.shift
+        k, v = kv
+        aa = KEYS[k]
+        s << v.to_i
+        s << ' '; s << aa[:l]; s << 's' if v > 1
+        s << (a.size == 1 ? adn : ', ') if a.size > 0
+      end
+
+      s.string
+    end
+
+    # Warning: this is an "approximation", months are 30 days and years are
+    # 365 days, ...
+    #
+    def to_sec
+
+      KEYS.inject(0) { |s, (k, a)| v = @h[k]; next s unless v; s += v * a[:s] }
+    end
+
+    def inflate
+
+      h =
+        @h.inject({ sec: 0 }) { |h, (k, v)|
+          a = KEYS[k]
+          if a[:I]
+            h[:sec] += (v * a[:s])
+          else
+            h[k] = v
+          end
+          h
+        }
+
+      self.class.allocate.init(@original, h)
+    end
+
+    def deflate
+
+      id = inflate
+      h = id.h.dup
+      s = h.delete(:sec)
+
+      INFLA_KEYS.each do |k, v|
+
+        n = s / v[:s]; next if n == 0
+        m = s % v[:s]
+
+        h[k] = (h[k] || 0) + n
+        s = m
+      end
+
+      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)
+    end
+
+    alias -@ opposite
+
+    def add_numeric(n)
+
+      h = @h.dup
+      h[:sec] = (h[:sec] || 0) + n.to_i
+
+      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)
+    end
+
+    def add_to_time(t)
+
+      INFLA_KEYS.each do |k, a|
+
+        v = @h[k]; next unless v
+
+        t = t + v * a[:s]
+      end
+
+      NON_INFLA_KEYS.each do |k, a|
+
+        v = @h[k]; next unless v
+        at = [ t.year, t.month, t.day, t.hour, t.min, t.sec ]
+
+        at[a[:x]] += v
+
+        if at[1] > 12
+          n, m = at[1] / 12, at[1] % 12
+          at[0], at[1] = at[0] + n, m
+        elsif at[1] < 1
+          n, m = -at[1] / 12, -at[1] % 12
+          at[0], at[1] = at[0] - n, m
+        end
+
+        t = Time.send(t.utc? ? :utc : :local, *at)
+      end
+
+      t
+    end
+
+    def add(a)
+
+      case a
+        when Numeric then add_numeric(a)
+        when Fugit::Duration then add_duration(a)
+        when String then add_duration(self.class.parse(a))
+        when Time then add_to_time(a)
+        else fail ArgumentError.new(
+          "cannot add #{a.class} instance to a Fugit::Duration")
+      end
+    end
+    alias + add
+
+    def substract(a)
+
+      case a
+        when Numeric then add_numeric(-a)
+        when Fugit::Duration then add_duration(-a)
+        when String then add_duration(-self.class.parse(a))
+        when Time then opposite.add_to_time(a)
+        else fail ArgumentError.new(
+          "cannot substract #{a.class} instance to a Fugit::Duration")
+      end
+    end
+    alias - substract
+
+    def ==(o)
+
+      o.is_a?(Fugit::Duration) && o.h == @h
+    end
+    alias eql? ==
+
+    def hash
+
+      @h.hash
+    end
+
+    protected
+
+    def init(original, h)
+
+      @original = original
+
+      @h = h.reject { |k, v| v == 0 }
+        # which copies h btw
+
+      self
+    end
+
+    module Parser include Raabro
+
+      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 sec(i); rex(:sec, i, /-?\d+ *(secs?|seconds?|s)/i); end
+        # always last!
+
+      def elt(i); alt(nil, i, :yea, :mon, :wee, :day, :hou, :min, :sec); end
+
+      def dur(i); jseq(:dur, i, :elt, :sep); end
+
+      def rewrite_dur(t)
+
+        t
+          .subgather(nil)
+          .inject({}) { |h, t|
+            h[t.name] = (h[t.name] || 0) + t.string.to_i
+              # drops ending ("y", "m", ...) by itself
+            h
+          }
+      end
+    end
+
+    module IsoParser include Raabro
+
+      def p(i); rex(nil, i, /P/); end
+      def t(i); rex(nil, i, /T/); end
+
+      def yea(i); rex(:yea, i, /-?\d+Y/); end
+      def mon(i); rex(:mon, i, /-?\d+M/); end
+      def wee(i); rex(:wee, i, /-?\d+W/); end
+      def day(i); rex(:day, i, /-?\d+D/); end
+      def hou(i); rex(:hou, i, /-?\d+H/); end
+      def min(i); rex(:min, i, /-?\d+M/); end
+      def sec(i); rex(:sec, i, /-?\d+S/); end
+
+      def delt(i); alt(nil, i, :yea, :mon, :wee, :day); end
+      def telt(i); alt(nil, i, :hou, :min, :sec); end
+
+      def date(i); rep(nil, i, :delt, 1); end
+      def time(i); rep(nil, i, :telt, 1); end
+      def t_time(i); seq(nil, i, :t, :time); end
+
+      def dur(i); seq(:dur, i, :p, :date, '?', :t_time, '?'); end
+
+      def rewrite_dur(t)
+
+        t
+          .subgather(nil)
+          .inject({}) { |h, t|
+            h[t.name] = (h[t.name] || 0) + t.string.to_i
+              # drops ending ("y", "m", ...) by itself
+            h
+          }
+      end
+    end
+  end
+end
+

data/lib/fugit.rb

@@ -25,13 +25,16 @@
 
 module Fugit
 
-  VERSION = '0.9.0'
+  VERSION = '0.9.1'
 end
 
 require 'time'
+require 'stringio'
 
 require 'raabro'
 
+require 'fugit/core'
 require 'fugit/misc'
 require 'fugit/cron'
+require 'fugit/duration'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fugit
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.1
 platform: ruby
 authors:
 - John Mettraux
@@ -14,28 +14,28 @@ dependencies:
   name: raabro
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.1.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.1.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
 description: Time tools for flor and the floraison project. Cron parsing and occurence
@@ -46,15 +46,17 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- Makefile
-- lib/fugit/cron.rb
-- lib/fugit/misc.rb
-- lib/fugit.rb
-- fugit.gemspec
-- LICENSE.txt
 - CHANGELOG.md
 - CREDITS.md
+- LICENSE.txt
+- Makefile
 - README.md
+- fugit.gemspec
+- lib/fugit.rb
+- lib/fugit/core.rb
+- lib/fugit/cron.rb
+- lib/fugit/duration.rb
+- lib/fugit/misc.rb
 homepage: http://github.com/floraison/fugit
 licenses:
 - MIT
@@ -65,17 +67,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: time tools for flor