rufus-scheduler 1.0.3 → 1.0.4

data/CHANGELOG.txt

@@ -2,8 +2,9 @@
 = rufus-scheduler CHANGELOG.txt
 
 
-== rufus-scheduler - 1.0.3    released 2008/02/29
+== rufus-scheduler - 1.0.4    released 2008/02/29
 
+- todo  #18474 : implemented to_duration_array() - s183
 - todo  #18472 : added Rufus::to_time_string - s181
 
 

data/lib/rufus/otime.rb

@@ -132,17 +132,14 @@ module Rufus
             index = index + 1
 
             if index >= string.length
-                if number.length > 0
-                    result = result + (Float(number) / 1000.0)
-                end
+                result = result + (Float(number) / 1000.0) if number.length > 0
                 break
             end
 
             c = string[index, 1]
 
-            # TODO : investigate something better than this is_digit?
-
-            if is_digit?(c)
+            #if is_digit?(c)
+            if (c >= "0" and c <= "9")
                 number = number + c
                 next
             end
@@ -161,8 +158,14 @@ module Rufus
         result
     end
 
+    class << self
+        alias_method :parse_duration_string, :parse_time_string
+    end
+
+    #
+    # Returns true if the character c is a digit
     #
-    # returns true if the character c is a digit
+    # (probably better served by a regex)
     #
     def Rufus.is_digit? (c)
 
@@ -201,14 +204,6 @@ module Rufus
 
         rescue Exception => e
 
-            #puts
-            #puts OpenWFE::exception_to_s(e)
-            #puts
-            #puts \
-            #    "\n Date.new() problem. Params :"+
-            #    "\n....y:#{time.year} M:#{time.month} d:#{time.day} "+
-            #    "h:#{time.hour} m:#{time.min} s:#{s} o:#{o}"
-
             DateTime.new(
                 time.year, 
                 time.month, 
@@ -239,11 +234,11 @@ module Rufus
     #
     # Turns a number of seconds into a a time string
     #
-    #     Rufus.to_time_string 0                    # => '0s'
-    #     Rufus.to_time_string 60                   # => '1m'
-    #     Rufus.to_time_string 3661                 # => '1h1m1s'
-    #     Rufus.to_time_string 7 * 24 * 3600        # => '1w'
-    #     Rufus.to_time_string 30 * 24 * 3600 + 1   # => "4w2d1s"
+    #     Rufus.to_duration_string 0                    # => '0s'
+    #     Rufus.to_duration_string 60                   # => '1m'
+    #     Rufus.to_duration_string 3661                 # => '1h1m1s'
+    #     Rufus.to_duration_string 7 * 24 * 3600        # => '1w'
+    #     Rufus.to_duration_string 30 * 24 * 3600 + 1   # => "4w2d1s"
     #
     # It goes from seconds to the year. Months are not counted (as they
     # are of variable length). Weeks are counted.
@@ -253,70 +248,114 @@ module Rufus
     #
     #     Rufus.to_time_string 30 * 24 * 3600 + 1, true   # => "1M1s"
     #
+    # (to_time_string is an alias for to_duration_string)
+    #
     # If a Float value is passed, milliseconds will be displayed without
     # 'marker'
     #
-    #     Rufus.to_time_string 0.051                         #=>"51"
-    #     Rufus.to_time_string 7.051                         #=>"7s51"
-    #     Rufus.to_time_string 0.120 + 30 * 24 * 3600 + 1    #=>"4w2d1s120"
+    #     Rufus.to_duration_string 0.051                         # =>"51"
+    #     Rufus.to_duration_string 7.051                         # =>"7s51"
+    #     Rufus.to_duration_string 0.120 + 30 * 24 * 3600 + 1    # =>"4w2d1s120"
     #
     # (this behaviour mirrors the one found for parse_time_string()).
     #
-    def Rufus.to_time_string (seconds, months=false)
+    # Options are :
+    #
+    # * :months, if set to true, months (M) of 30 days will be taken into
+    #   account when building up the result
+    # * :drop_seconds, if set to true, seconds and milliseconds will be trimmed
+    #   from the result
+    #
+    def Rufus.to_duration_string (seconds, options={})
 
         return '0s' if seconds <= 0
 
-        ms = nil
+        h = to_duration_hash seconds, options
 
-        if seconds.is_a?(Float)
-            ms = (seconds % 1 * 1000).to_i
-            seconds = seconds.to_i
+        s = DU_KEYS.inject("") do |r, key|
+            count = h[key]
+            count = nil if count == 0
+            r << "#{count}#{key}" if count
+            r
         end
 
-        durations = months ? DURATIONS2w : DURATIONS2
+        ms = h[:ms]
+        s << ms.to_s if ms
 
-        s = durations.inject([ seconds, "" ]) { |r, d|
+        s
+    end
 
-            #puts "result :   " + r.inspect
-            #puts "duration : " + d.inspect
+    class << self
+        alias_method :to_time_string, :to_duration_string
+    end
 
-            sec, str = r
-            s, d = d
+    #
+    # Turns a number of seconds (integer or Float) into a hash like in :
+    #
+    #     Rufus.to_duration_hash 0.051                         
+    #         # => { :ms => "51" }
+    #     Rufus.to_duration_hash 7.051
+    #         # => { :s => 7, :ms => "51" }
+    #     Rufus.to_duration_hash 0.120 + 30 * 24 * 3600 + 1
+    #         # => { :w => 4, :d => 2, :s => 1, :ms => "120" }
+    #
+    # This method is used by to_duration_string (to_time_string) behind
+    # the scene.
+    #
+    # Options are :
+    #
+    # * :months, if set to true, months (M) of 30 days will be taken into
+    #   account when building up the result
+    # * :drop_seconds, if set to true, seconds and milliseconds will be trimmed
+    #   from the result
+    #
+    def Rufus.to_duration_hash (seconds, options={})
+
+        h = {}
 
-            count = sec / d
-            rest = sec % d
+        if seconds.is_a?(Float)
+            h[:ms] = (seconds % 1 * 1000).to_i
+            seconds = seconds.to_i
+        end
 
-            str << "#{count}#{s}" if count > 0
+        if options[:drop_seconds]
+            h.delete :ms
+            seconds = (seconds - seconds % 60)
+        end
 
-            [ rest, str ]
-        }[1]
+        durations = options[:months] ? DURATIONS2M : DURATIONS2
 
-        "#{s}#{ms}"
+        durations.each do |key, duration|
+
+            count = seconds / duration
+            seconds = seconds % duration
+
+            h[key.to_sym] = count if count > 0
+        end
+
+        h
     end
 
     protected
 
-        DURATIONS = {
-            "y" => 365 * 24 * 3600,
-            "M" => 30 * 24 * 3600,
-            "w" => 7 * 24 * 3600,
-            "d" => 24 * 3600,
-            "h" => 3600,
-            "m" => 60,
-            "s" => 1
-        }
-
-        DURATIONS2w = [
-            [ "y", DURATIONS["y"] ],
-            [ "M", DURATIONS["M"] ],
-            [ "w", DURATIONS["w"] ],
-            [ "d", DURATIONS["d"] ],
-            [ "h", DURATIONS["h"] ],
-            [ "m", DURATIONS["m"] ],
-            [ "s", DURATIONS["s"] ]
+        DURATIONS2M = [
+            [ "y", 365 * 24 * 3600 ],
+            [ "M", 30 * 24 * 3600 ],
+            [ "w", 7 * 24 * 3600 ],
+            [ "d", 24 * 3600 ],
+            [ "h", 3600 ],
+            [ "m", 60 ],
+            [ "s", 1 ]
         ]
-        DURATIONS2 = DURATIONS2w.dup
+        DURATIONS2 = DURATIONS2M.dup
         DURATIONS2.delete_at 1
 
+        DURATIONS = DURATIONS2M.inject({}) do |r, (k, v)|
+            r[k] = v
+            r
+        end
+
+        DU_KEYS = DURATIONS2M.collect { |k, v| k.to_sym }
+
 end
 

data/test/time_1_test.rb

@@ -36,23 +36,40 @@ class Time1Test < Test::Unit::TestCase
 
     def test_1
 
-        tts 30 * 24 * 3600 + 1, "1M1s", true
+        tts 30 * 24 * 3600 + 1, "1M1s", { :months => true }
     end
 
     def test_2
 
         tts 0.120 + 30 * 24 * 3600 + 1, "4w2d1s120"
         tts 0.130, "130"
+        tts 61.127, "1m", { :drop_seconds => true }
+    end
+
+    def test_3
+
+        tdh 0, {}
+        tdh 0.128, { :ms => 128 }
+        tdh 60.127, { :m => 1, :ms => 127 }
+        tdh 61.127, { :m => 1, :s => 1, :ms => 127 }
+        tdh 61.127, { :m => 1 }, { :drop_seconds => true }
     end
 
     protected
 
-        def tts (seconds, time_string, months=false)
+        def tts (seconds, time_string, options={})
 
             assert_equal(
                 time_string,
-                Rufus::to_time_string(seconds, months),
+                Rufus::to_time_string(seconds, options),
                 "#{seconds} seconds did not map to '#{time_string}'")
         end
 
+        def tdh (seconds, time_hash, options={})
+
+            assert_equal(
+                time_hash,
+                Rufus::to_duration_hash(seconds, options))
+        end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rufus-scheduler
 version: !ruby/object:Gem::Version 
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors: 
 - John Mettraux