arturop-chronic_duration 0.9.7

data/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+gem "numerizer", "~> 0.1.1"
+
+group :development do
+  gem "rspec", "~> 2.3.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,30 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    numerizer (0.1.1)
+    rake (0.8.7)
+    rcov (0.9.9)
+    rspec (2.3.0)
+      rspec-core (~> 2.3.0)
+      rspec-expectations (~> 2.3.0)
+      rspec-mocks (~> 2.3.0)
+    rspec-core (2.3.1)
+    rspec-expectations (2.3.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.2)
+  numerizer (~> 0.1.1)
+  rcov
+  rspec (~> 2.3.0)

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) Henry Poydar
+
+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.

data/README.rdoc

@@ -0,0 +1,61 @@
+= Chronic Duration
+
+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 can get strings like 4 mins 31.51 secs (default  format), 4h 3m 30s, or 4:01:29.
+
+== Installation
+
+    $ sudo gem sources -a http://gemcutter.org
+    $ sudo gem install chronic_duration
+
+== Usage
+
+    >> require 'chronic_duration'
+    => true
+    >> ChronicDuration.parse('4 minutes and 30 seconds')
+    => 270
+    >> ChronicDuration.output(270)
+    => 4 mins 30 secs
+    >> ChronicDuration.output(270, :format => :short)
+    => 4m 30s
+    >> ChronicDuration.output(270, :format => :long)
+    => 4 minutes 30 seconds
+    >> ChronicDuration.output(270, :format => :chrono)
+    => 4:30
+    
+Nil is returned if the string can't be parsed
+
+Examples of parse-able strings:
+
+* '12.4 secs'
+* '1:20' 
+* '1:20.51'
+* '4:01:01'
+* '3 mins 4 sec'
+* '2 hrs 20 min'
+* '2h20min'
+* '6 mos 1 day'
+* '47 yrs 6 mos and 4d'
+* 'two hours and twenty minutes'
+* '3 weeks and 2 days'
+
+ChronicDuration.raise_exceptions can be set to true to raise exceptions when the string can't be parsed.
+
+    >> ChronicDuration.raise_exceptions = true
+    => true
+    >> ChronicDuration.parse('4 elephants and 3 Astroids')
+    ChronicDuration::DurationParseError: An invalid word "elephants" was used in the string to be parsed.
+
+    
+== Contributors
+
+brianjlandau, jduff, olauzon, roboman, ianlevesque
+    
+== TODO
+
+* 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')
+* :chrono output option should probably change to something like 4 days 4:00:12 instead of 4:04:00:12
+* Other locale support

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  gem.name = "arturop-chronic_duration"
+  gem.summary = %Q{A Ruby natural language parser for elapsed time}
+  gem.license = "MIT"
+  gem.description = %Q{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 performed via the output method.}
+  gem.email = "hpoydar@gmail.com"
+  gem.homepage = "http://github.com/hpoydar/chronic_duration"
+  gem.authors = ["hpoydar", "Arturo Pie"]
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "chronic_duration #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.9.7

data/chronic_duration.gemspec

@@ -0,0 +1,63 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{chronic_duration}
+  s.version = "0.9.7"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["hpoydar", "Arturo Pie"]
+  s.date = %q{2011-07-06}
+  s.description = %q{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 performed via the output method.}
+  s.email = %q{hpoydar@gmail.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "MIT-LICENSE",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "chronic_duration.gemspec",
+    "lib/chronic_duration.rb",
+    "spec/chronic_duration_spec.rb"
+  ]
+  s.homepage = %q{http://github.com/hpoydar/chronic_duration}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{A Ruby natural language parser for elapsed time}
+  s.test_files = [
+    "spec/chronic_duration_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<numerizer>, ["~> 0.1.1"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<numerizer>, ["~> 0.1.1"])
+      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<numerizer>, ["~> 0.1.1"])
+    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/lib/chronic_duration.rb

@@ -0,0 +1,258 @@
+require 'numerizer' unless defined?(Numerizer)
+module ChronicDuration
+  extend self
+
+  class DurationParseError < StandardError
+  end
+
+  @@raise_exceptions = false
+
+  def self.raise_exceptions
+    !!@@raise_exceptions
+  end
+
+  def self.raise_exceptions=(value)
+    @@raise_exceptions = !!value
+  end
+
+  # Given a string representation of elapsed time,
+  # return an integer (or float, if fractions of a
+  # second are input)
+  def parse(string, opts = {})
+    result = calculate_from_words(cleanup(string), opts)
+    result == 0 ? nil : result
+  end
+
+  # Given an integer and an optional format,
+  # returns a formatted string representing elapsed time
+  def output(seconds, opts = {})
+
+    opts[:format] ||= :default
+    unit_of_measures = [:years, :months, :days, :hours, :minutes]
+    unit_of_measures << :seconds unless opts[:hide_seconds]
+
+    duration = Duration.new seconds
+
+    joiner = ' '
+    process = nil
+
+    case opts[:format]
+    when :micro
+      dividers = {
+        :years => 'y', :months => 'm', :days => 'd', :hours => 'h', :minutes => 'm', :seconds => 's' }
+      joiner = ''
+    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 = []
+    unit_of_measures.each do |t|
+      num = duration.send t
+      num = ("%.#{decimal_places seconds }f" % num) if num.is_a?(Float) && t == :seconds
+      result << humanize_time_unit( num, dividers[t], dividers[:pluralize], dividers[:keep_zero] )
+    end
+
+    result = result.join(joiner).squeeze(' ').strip
+
+    if process
+      result = process.call(result)
+    end
+
+    result.length == 0 ? nil : result
+
+  end
+
+  def decimal_places number
+    number.to_s.split('.').last.length if number.is_a? Float
+  end
+
+  class Duration
+    attr_accessor :seconds, :minutes, :hours, :days, :months, :years
+
+    def initialize seconds
+      @years = @months = @days = @hours = @minutes = 0
+      @seconds = seconds
+
+      compute_measures seconds
+    end
+
+    private
+    def compute_measures seconds
+      quotient = seconds
+      remainder = 0
+
+      unit_of_measures.each do |uom|
+        break unless quotient > uom[:amount]
+        remainder = quotient % uom[:amount]
+        quotient /= uom[:amount]
+        assign uom[:name], remainder
+        assign uom[:parent], quotient.to_i
+      end
+    end
+
+    def unit_of_measures
+      [ { :name => :seconds=, :parent => :minutes=, :amount => 60 },
+        { :name => :minutes=, :parent => :hours=, :amount => 60 },
+        { :name => :hours=, :parent => :days=, :amount => 24 },
+        { :name => :days=, :parent => :months=, :amount => 30 },
+        { :name => :months=, :parent => :years=, :amount => 12 }
+      ]
+    end
+
+    def assign setter, value
+      self.send setter, value
+    end
+  end
+private
+
+  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
+
+  def calculate_from_words(string, opts)
+    val = 0
+    words = string.split(' ')
+    words.each_with_index do |v, k|
+      if v =~ float_matcher
+        val += (convert_to_number(v) * duration_units_seconds_multiplier(words[k + 1] || (opts[:default_unit] || 'seconds')))
+      end
+    end
+    val
+  end
+
+  def cleanup(string)
+    res = string.downcase
+    res = filter_by_type(Numerizer.numerize(res))
+    res = res.gsub(float_matcher) {|n| " #{n} "}.squeeze(' ').strip
+    res = filter_through_white_list(res)
+  end
+
+  def convert_to_number(string)
+    string.to_f % 1 > 0 ? string.to_f : string.to_i
+  end
+
+  def duration_units_list
+    %w(seconds minutes hours days weeks months years)
+  end
+  def duration_units_seconds_multiplier(unit)
+    return 0 unless duration_units_list.include?(unit)
+    case unit
+    when 'years';   31536000 # doesn't accounts for leap years
+    when 'months';  3600 * 24 * 30
+    when 'weeks';   3600 * 24 * 7
+    when 'days';    3600 * 24
+    when 'hours';   3600
+    when 'minutes'; 60
+    when 'seconds'; 1
+    end
+  end
+
+  def error_message
+    'Sorry, that duration could not be parsed'
+  end
+
+  # Parse 3:41:59 and return 3 hours 41 minutes 59 seconds
+  def filter_by_type(string)
+    if string.gsub(' ', '') =~ /#{float_matcher}(:#{float_matcher})+/
+      res = []
+      string.gsub(' ', '').split(':').reverse.each_with_index do |v,k|
+        return unless duration_units_list[k]
+        res << "#{v} #{duration_units_list[k]}"
+      end
+      res = res.reverse.join(' ')
+    else
+      res = string
+    end
+    res
+  end
+
+  def float_matcher
+    /[0-9]*\.?[0-9]+/
+  end
+
+  # Get rid of unknown words and map found
+  # words to defined time units
+  def filter_through_white_list(string)
+    res = []
+    string.split(' ').each do |word|
+      if word =~ float_matcher
+        res << word.strip
+        next
+      end
+      stripped_word = word.strip.gsub(/^,/, '').gsub(/,$/, '')
+      if mappings.has_key?(stripped_word)
+        res << mappings[stripped_word]
+      elsif !join_words.include?(stripped_word) and ChronicDuration.raise_exceptions
+        raise DurationParseError, "An invalid word #{word.inspect} was used in the string to be parsed."
+      end
+    end
+    res.join(' ')
+  end
+
+  def mappings
+    {
+      'seconds' => 'seconds',
+      'second'  => 'seconds',
+      'secs'    => 'seconds',
+      'sec'     => 'seconds',
+      's'       => 'seconds',
+      'minutes' => 'minutes',
+      'minute'  => 'minutes',
+      'mins'    => 'minutes',
+      'min'     => 'minutes',
+      'm'       => 'minutes',
+      'hours'   => 'hours',
+      'hour'    => 'hours',
+      'hrs'     => 'hours',
+      'hr'      => 'hours',
+      'h'       => 'hours',
+      'days'    => 'days',
+      'day'     => 'days',
+      'dy'      => 'days',
+      'd'       => 'days',
+      'weeks'   => 'weeks',
+      'week'    => 'weeks',
+      'w'       => 'weeks',
+      'months'  => 'months',
+      'mos'     => 'months',
+      'month'   => 'months',
+      'years'   => 'years',
+      'year'    => 'years',
+      'yrs'     => 'years',
+      'y'       => 'years'
+    }
+  end
+
+  def join_words
+    ['and', 'with', 'plus']
+  end
+
+  def white_list
+    self.mappings.map {|k, v| k}
+  end
+
+end

data/spec/chronic_duration_spec.rb

@@ -0,0 +1,200 @@
+require 'chronic_duration'
+
+describe ChronicDuration, '.parse' do
+  
+  @exemplars = { 
+    '1:20'                  => 60 + 20,
+    '1:20.51'               => 60 + 20.51,
+    '4:01:01'               => 4 * 3600 + 60 + 1,
+    '3 mins 4 sec'          => 3 * 60 + 4,
+    '3 Mins 4 Sec'          => 3 * 60 + 4,
+    'three mins four sec'          => 3 * 60 + 4,
+    '2 hrs 20 min'          => 2 * 3600 + 20 * 60,
+    '2h20min'               => 2 * 3600 + 20 * 60,
+    '6 mos 1 day'           => 6 * 30 * 24 * 3600 + 24 * 3600,
+    '1 year 6 mos 1 day'    => 1 * 31536000 + 6 * 30 * 24 * 3600 + 24 * 3600,
+    '2.5 hrs'               => 2.5 * 3600,
+    '47 yrs 6 mos and 4.5d' => 47 * 31536000 + 6 * 30 * 24 * 3600 + 4.5 * 24 * 3600,
+    'two hours and twenty minutes' => 2 * 3600 + 20 * 60,
+    'four hours and forty minutes' => 4 * 3600 + 40 * 60,
+    'four hours, and fourty minutes' => 4 * 3600 + 40 * 60,
+    '3 weeks and, 2 days' => 3600 * 24 * 7 * 3 + 3600 * 24 * 2,
+    '3 weeks, plus 2 days' => 3600 * 24 * 7 * 3 + 3600 * 24 * 2,
+    '3 weeks with 2 days' => 3600 * 24 * 7 * 3 + 3600 * 24 * 2,
+    '1 month'               => 3600 * 24 * 30,
+    '2 months'              => 3600 * 24 * 30 * 2
+  }
+  
+  it "should return nil if the string can't be parsed" do
+    ChronicDuration.parse('gobblygoo').should be_nil
+  end
+  
+  it "should raise an exception if the string can't be parsed and @@raise_exceptions is set to true" do
+    ChronicDuration.raise_exceptions = true
+    lambda { ChronicDuration.parse('23 gobblygoos') }.should raise_exception(ChronicDuration::DurationParseError)
+    ChronicDuration.raise_exceptions = false
+  end
+  
+  it "should return a float if seconds are in decimals" do
+    ChronicDuration.parse('12 mins 3.141 seconds').is_a?(Float).should be_true
+  end
+  
+  it "should return an integer unless the seconds are in decimals" do
+    ChronicDuration.parse('12 mins 3 seconds').is_a?(Integer).should be_true
+  end
+  
+  it "should be able to parse minutes by default" do
+    ChronicDuration.parse('5', :default_unit => "minutes").should == 300
+  end
+  
+  @exemplars.each do |k, v|
+    it "should properly parse a duration like #{k}" do
+      ChronicDuration.parse(k).should == v
+    end
+  end
+  
+end
+
+describe ChronicDuration, '.output' do
+  
+  it "should return nil if the input can't be parsed" do
+    ChronicDuration.parse('gobblygoo').should be_nil
+  end
+
+  def self.exemplars
+    { 
+      #(0) => 
+      #{
+      #:micro    => '0s',
+      #:short    => '0s',
+      #:default  => '0 secs',
+      #:long     => '0 seconds',
+      #:chrono   => '0'
+      #},
+      (60 + 20) => 
+      { 
+        :micro    => '1m20s',
+        :short    => '1m 20s',
+        :default  => '1 min 20 secs',
+        :long     => '1 minute 20 seconds',
+        :chrono   => '1:20'
+      },
+      (60 + 20.51) => 
+      { 
+        :micro    => '1m20.51s',
+        :short    => '1m 20.51s',
+        :default  => '1 min 20.51 secs',
+        :long     => '1 minute 20.51 seconds',
+        :chrono   => '1:20.51'
+      },
+      (60 + 20.51928) => 
+      { 
+        :micro    => '1m20.51928s',
+        :short    => '1m 20.51928s',
+        :default  => '1 min 20.51928 secs',
+        :long     => '1 minute 20.51928 seconds',
+        :chrono   => '1:20.51928'
+      },
+      (4 * 3600 + 60 + 1) => 
+      { 
+        :micro    => '4h1m1s',
+        :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) => 
+      { 
+        :micro    => '2h20m',
+        :short    => '2h 20m',
+        :default  => '2 hrs 20 mins',
+        :long     => '2 hours 20 minutes',
+        :chrono   => '2:20'
+      },
+      (2 * 3600 + 20 * 60) => 
+      { 
+        :micro    => '2h20m',
+        :short    => '2h 20m',
+        :default  => '2 hrs 20 mins',
+        :long     => '2 hours 20 minutes',
+        :chrono   => '2:20:00'
+      },
+      (6 * 30 * 24 * 3600 + 24 * 3600) => 
+      { 
+        :micro    => '6m1d',
+        :short    => '6m 1d',
+        :default  => '6 mos 1 day',
+        :long     => '6 months 1 day',
+        :chrono   => '6:01:00:00:00' # Yuck. FIXME
+      }
+    }
+  end
+
+  exemplars.each do |number_seconds, test_cases|
+    test_cases.each do |format, expected_output|
+      it "should properly output a duration of #{number_seconds} seconds as #{expected_output} using the #{format.to_s} format option" do
+        ChronicDuration.output(number_seconds, :format => format).should == expected_output
+      end
+    end
+  end
+
+  context "using :hide_seconds" do
+    it "should return nil if less than 60 seconds are passed" do
+      ChronicDuration.output(59, :hide_seconds => true).should be_nil
+    end
+
+    exemplars.each do |number_seconds, test_cases|
+      test_cases.each do |format, expected_output|
+        regex = (format == :chrono) ? /:\d\d\.?\d*$/ : /\ ?\d+\.?\d*\ ?(seconds*|secs*|s)/
+        expected_output_without_secs = expected_output.gsub(regex, "")
+        it "should properly output a duration of #{number_seconds} seconds as #{expected_output_without_secs} using the #{format.to_s} format option" do
+          ChronicDuration.output(number_seconds, :format => format, :hide_seconds => true).should == expected_output_without_secs
+        end
+      end
+    end
+  end
+
+  it "should use the default format when the format is not specified" do
+    ChronicDuration.output(2 * 3600 + 20 * 60).should == '2 hrs 20 mins'
+  end
+end
+
+
+# Some of the private methods deserve some spec'ing to aid
+# us in development...
+
+describe ChronicDuration, "private methods" do
+  
+  describe ".filter_by_type" do
+    
+    it "should take a chrono-formatted time like 3:14 and return a human time like 3 minutes 14 seconds" do
+      ChronicDuration.instance_eval("filter_by_type('3:14')").should == '3 minutes 14 seconds'
+    end
+    
+    it "should take a chrono-formatted time like 12:10:14 and return a human time like 12 hours 10 minutes 14 seconds" do
+      ChronicDuration.instance_eval("filter_by_type('12:10:14')").should == '12 hours 10 minutes 14 seconds'
+    end
+    
+    it "should return the input if it's not a chrono-formatted time" do
+      ChronicDuration.instance_eval("filter_by_type('4 hours')").should == '4 hours'
+    end
+  
+  end
+  
+  describe ".cleanup" do
+    
+    it "should clean up extraneous words" do
+      ChronicDuration.instance_eval("cleanup('4 days and 11 hours')").should == '4 days 11 hours'
+    end
+    
+    it "should cleanup extraneous spaces" do
+      ChronicDuration.instance_eval("cleanup('  4 days and 11     hours')").should == '4 days 11 hours'
+    end
+    
+    it "should insert spaces where there aren't any" do
+      ChronicDuration.instance_eval("cleanup('4m11.5s')").should == '4 minutes 11.5 seconds'
+    end
+    
+  end
+  
+end 

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification 
+name: arturop-chronic_duration
+version: !ruby/object:Gem::Version 
+  hash: 53
+  prerelease: false
+  segments: 
+  - 0
+  - 9
+  - 7
+  version: 0.9.7
+platform: ruby
+authors: 
+- hpoydar
+- Arturo Pie
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-06 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 0
+        - 1
+        - 1
+        version: 0.1.1
+  requirement: *id001
+  prerelease: false
+  type: :runtime
+  name: numerizer
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  requirement: *id002
+  prerelease: false
+  type: :development
+  name: rspec
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  requirement: *id003
+  prerelease: false
+  type: :development
+  name: bundler
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  requirement: *id004
+  prerelease: false
+  type: :development
+  name: jeweler
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id005
+  prerelease: false
+  type: :development
+  name: rcov
+description: 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 performed via the output method.
+email: hpoydar@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- chronic_duration.gemspec
+- lib/chronic_duration.rb
+- spec/chronic_duration_spec.rb
+has_rdoc: true
+homepage: http://github.com/hpoydar/chronic_duration
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A Ruby natural language parser for elapsed time
+test_files: 
+- spec/chronic_duration_spec.rb