hpoydar-chronic_duration 0.4.1 → 0.5.0

data/README.rdoc

@@ -2,7 +2,7 @@
 
 A simple Ruby natural language parser for elapsed time. (For example, 4 hours and 30 minutes, 6 minutes 4 seconds, 3 days, etc.) Returns all results in seconds. Will return an integer unless you get tricky and need a float. (4 minutes and 13.47 seconds, for example.) 
 
-The reverse can also be accomplished with the output method.  So pass in seconds and you will get values like 4 ins 31.51 secs.
+The reverse can also be accomplished with the output method.  So pass in seconds and you can get strings like 4 mins 31.51 secs (default  format), 4h 3m 30s, or 4:01:29.
 
 == Installation
 
@@ -17,6 +17,12 @@ The reverse can also be accomplished with the output method.  So pass in seconds
     => 270
     >> ChronicDuration.output(270)
     => 4 mins 30 secs
+    >> ChronicDuration.output(270, :short)
+    => 4m 30s
+    >> ChronicDuration.output(270, :long)
+    => 4 minutes 30 seconds
+    >> ChronicDuration.output(270, :chrono)
+    => 4:30
     
 Nil is returned if the string can't be parsed
 
@@ -35,7 +41,8 @@ Examples of parse-able strings:
     
 == TODO
 
-* Benchmark and optimize
-* Context specific matching (E.g., for '4m30s', assume 'm' is minutes)
+* Benchmark, optimize
+* Context specific matching (E.g., for '4m30s', assume 'm' is minutes not months)
 * Smartly parse vacation-like durations (E.g., '4 days and 3 nights')
-* Allow alternative formatting for output
+* :chrono output option should probably change to something like 4 days 4:00:12 instead of 4:04:00:12
+* Correct rdoc whine on gem install

data/lib/chronic_duration.rb

@@ -7,10 +7,12 @@ module ChronicDuration
   end  
   
   # Refactor, DRY up, make recursive
-  def output(seconds)
+  def output(seconds, opts = {})
+    
+    opts[:format] ||= :default
     
     years = months = days = hours = minutes = 0
-
+    
     if seconds >= 60
       minutes = (seconds / 60).to_i 
       seconds = seconds % 60
@@ -32,28 +34,56 @@ module ChronicDuration
       end
     end
     
+    joiner = ' '
+    process = nil
+    
+    case opts[:format]
+    when :short
+      dividers = { 
+        :years => 'y', :months => 'm', :days => 'd', :hours => 'h', :minutes => 'm', :seconds => 's' }
+    when :default 
+      dividers = {
+        :years => ' yr', :months => ' mo', :days => ' day', :hours => ' hr', :minutes => ' min', :seconds => ' sec',
+        :pluralize => true }
+    when :long 
+      dividers = {
+        :years => ' year', :months => ' month', :days => ' day', :hours => ' hour', :minutes => ' minute', :seconds => ' second', 
+        :pluralize => true }
+    when :chrono
+      dividers = {
+        :years => ':', :months => ':', :days => ':', :hours => ':', :minutes => ':', :seconds => ':', :keep_zero => true }
+      process = lambda do |str|
+        # Pad zeros
+        # Get rid of lead off times if they are zero
+        # Get rid of lead off zero
+        # Get rid of trailing :
+        str.gsub(/\b\d\b/) { |d| ("%02d" % d) }.gsub(/^(00:)+/, '').gsub(/^0/, '').gsub(/:$/, '')
+      end
+      joiner = ''
+    end
+    
     result = []
+    [:years, :months, :days, :hours, :minutes, :seconds].each do |t|
+      result << humanize_time_unit( eval(t.to_s), dividers[t], dividers[:pluralize], dividers[:keep_zero] )
+    end
     
-    result << pluralize(years, 'yr')
-    result << pluralize(months, 'mo')
-    result << pluralize(days, 'day')
-    result << pluralize(hours, 'hr')
-    result << pluralize(minutes, 'min')
-    result << pluralize(seconds, 'sec')
-
-    result = result.join(' ').squeeze(' ').strip
-    return nil if result.length == 0
+    result = result.join(joiner).squeeze(' ').strip
+    
+    if process
+      result = process.call(result)
+    end
+    
+    result.length == 0 ? nil : result
 
-    result
   end
   
 private
   
-  # A poor man's pluralizer
-  def pluralize(number, word)
-    return '' if number == 0
-    res = "#{number} #{word}"
-    res << 's' unless number == 1
+  def humanize_time_unit(number, unit, pluralize, keep_zero)
+    return '' if number == 0 && !keep_zero
+    res = "#{number}#{unit}"
+    # A poor man's pluralizer
+    res << 's' if !(number == 1) && pluralize
     res
   end
   

data/spec/chronic_duration_spec.rb

@@ -52,24 +52,56 @@ describe ChronicDuration, '.output' do
     ChronicDuration.parse('gobblygoo').should be_nil
   end
   
-  
   @exemplars = { 
-    '1 min 20 secs'                  => 60 + 20,
-    '1 min 20.51 secs'               => 60 + 20.51,
-    '3 mins 20.51 secs'               => 3 * 60 + 20.51,
-    '4 hrs 1 min 1 sec'               => 4 * 3600 + 60 + 1,
-    '3 mins 4 secs'          => 3 * 60 + 4,
-    '2 hrs 20 mins'          => 2 * 3600 + 20 * 60,
-    '1 mo 1 day'           => 1 * 30 * 24 * 3600 + 24 * 3600,
-    '6 mos 1 day'           => 6 * 30 * 24 * 3600 + 24 * 3600,
-    '6 mos 2 days'           => 6 * 30 * 24 * 3600 + 2 * 24 * 3600,
-    '2 hrs 30 mins'               => 2.5 * 3600
+    (60 + 20) => 
+      { 
+        :short    => '1m 20s',
+        :default  => '1 min 20 secs',
+        :long     => '1 minute 20 seconds',
+        :chrono   => '1:20'
+      },
+    (60 + 20.51) => 
+      { 
+        :short    => '1m 20.51s',
+        :default  => '1 min 20.51 secs',
+        :long     => '1 minute 20.51 seconds',
+        :chrono   => '1:20.51'
+      },
+    (4 * 3600 + 60 + 1) => 
+      { 
+        :short    => '4h 1m 1s',
+        :default  => '4 hrs 1 min 1 sec',
+        :long     => '4 hours 1 minute 1 second',
+        :chrono   => '4:01:01'
+      },
+    (2 * 3600 + 20 * 60) => 
+      { 
+        :short    => '2h 20m',
+        :default  => '2 hrs 20 mins',
+        :long     => '2 hours 20 minutes',
+        :chrono   => '2:20'
+      },
+    (2 * 3600 + 20 * 60) => 
+      { 
+        :short    => '2h 20m',
+        :default  => '2 hrs 20 mins',
+        :long     => '2 hours 20 minutes',
+        :chrono   => '2:20:00'
+      },
+    (6 * 30 * 24 * 3600 + 24 * 3600) => 
+      { 
+        :short    => '6m 1d',
+        :default  => '6 mos 1 day',
+        :long     => '6 months 1 day',
+        :chrono   => '6:01:00:00:00' # Yuck. FIXME
+      }
   }
   
-  
   @exemplars.each do |k, v|
-    it "should properly output a duration of #{v}" do
-      ChronicDuration.output(v).should == k
+    v.each do |key, val|
+      it "should properly output a duration of #{k} seconds as #{val} using the #{key.to_s} format option" do
+        ChronicDuration.output(k, :format => key).should == val
+      end
     end
   end
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: hpoydar-chronic_duration
 version: !ruby/object:Gem::Version 
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors: 
 - Henry Poydar
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-14 00:00:00 -08:00
+date: 2009-01-16 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -23,7 +23,7 @@ extra_rdoc_files: []
 
 files: 
 - lib/chronic_duration.rb
-- LICENSE
+- MIT-LICENSE
 - Rakefile
 - README.rdoc
 has_rdoc: true