chronic_duration 0.10.2 → 0.10.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: db9c9caba8412e38577177bed6d7a36e21a5ca86
+  data.tar.gz: b0d3a2a4f52825ef58698c314d5e33ca3a2cb145
+SHA512:
+  metadata.gz: 8b9ac709e3c106593f91f0272b48b3a593181e821b1207f05c157afe4cafbd14fda60dbe1e7a5f8d24ffd9f155f61cac9b29622d49a39c6936b4af41f2180f87
+  data.tar.gz: e1e8bb348ca38af8cbe0c5f7f94cb5094b1839d3456b4da0f071612d5cf2ea620ffdc9b231e3558db5031db996c7ed13ceeab620671c84e5cec4195a7ff0155e

data/README.md

@@ -65,7 +65,7 @@ Also looking for additional maintainers.
 
 ## Contributors
 
-pdf, brianjlandau, jduff, olauzon, roboman, ianlevesque
+errm,pdf, brianjlandau, jduff, olauzon, roboman, ianlevesque
 
 ## TODO
 

data/lib/chronic_duration.rb

@@ -8,6 +8,8 @@ module ChronicDuration
   end
 
   @@raise_exceptions = false
+  @@hours_per_day = 24
+  @@days_per_week = 7
 
   def self.raise_exceptions
     !!@@raise_exceptions
@@ -17,6 +19,22 @@ module ChronicDuration
     @@raise_exceptions = !!value
   end
 
+  def self.hours_per_day
+    @@hours_per_day
+  end
+
+  def self.hours_per_day=(value)
+    @@hours_per_day = value
+  end
+
+  def self.days_per_week
+    @@days_per_week
+  end
+
+  def self.days_per_week=(value)
+    @@days_per_week = value
+  end
+
   # Given a string representation of elapsed time,
   # return an integer (or float, if fractions of a
   # second are input)
@@ -38,19 +56,32 @@ module ChronicDuration
 
     decimal_places = seconds.to_s.split('.').last.length if seconds.is_a?(Float)
 
-    if seconds >= 60
+    minute = 60
+    hour = 60 * minute
+    day = ChronicDuration.hours_per_day * hour
+    month = 30 * day
+    year = 31557600
+
+    if seconds >= 31557600 && seconds%year < seconds%month
+      years = seconds / year
+      months = seconds % year / month
+      days = seconds % year % month / day
+      hours = seconds % year % month % day / hour
+      minutes = seconds % year % month % day % hour / minute
+      seconds = seconds % year % month % day % hour % minute
+    elsif seconds >= 60
       minutes = (seconds / 60).to_i
       seconds = seconds % 60
       if minutes >= 60
         hours = (minutes / 60).to_i
         minutes = (minutes % 60).to_i
-        if hours >= 24
-          days = (hours / 24).to_i
-          hours = (hours % 24).to_i
+        if hours >= ChronicDuration.hours_per_day
+          days = (hours / ChronicDuration.hours_per_day).to_i
+          hours = (hours % ChronicDuration.hours_per_day).to_i
           if opts[:weeks]
-            if days >= 7
-              weeks = (days / 7).to_i
-              days = (days % 7).to_i
+            if days >= ChronicDuration.days_per_week
+              weeks = (days / ChronicDuration.days_per_week).to_i
+              days = (days % ChronicDuration.days_per_week).to_i
               if weeks >= 4
                 months = (weeks / 4).to_i
                 weeks = (weeks % 4).to_i
@@ -62,11 +93,6 @@ module ChronicDuration
               days = (days % 30).to_i
             end
           end
-          if months >= 12
-            years = (months / 12).to_i
-            months = (months % 12).to_i
-            days = days - (5 * years)
-          end
         end
       end
     end
@@ -166,20 +192,16 @@ private
   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 'years';   31557600
+    when 'months';  3600 * ChronicDuration.hours_per_day * 30
+    when 'weeks';   3600 * ChronicDuration.hours_per_day * ChronicDuration.days_per_week
+    when 'days';    3600 * ChronicDuration.hours_per_day
     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)
     chrono_units_list = duration_units_list.reject {|v| v == "weeks"}
@@ -244,6 +266,8 @@ private
       'd'       => 'days',
       'weeks'   => 'weeks',
       'week'    => 'weeks',
+      'wks'     => 'weeks',
+      'wk'      => 'weeks',
       'w'       => 'weeks',
       'months'  => 'months',
       'mo'      => 'months',
@@ -260,9 +284,4 @@ private
   def join_words
     ['and', 'with', 'plus']
   end
-
-  def white_list
-    self.mappings.keys
-  end
-
 end

data/lib/chronic_duration/version.rb

@@ -1,3 +1,3 @@
 module ChronicDuration
-  VERSION = '0.10.2'
+  VERSION = '0.10.3'
 end

data/spec/lib/chronic_duration_spec.rb

@@ -14,9 +14,9 @@ describe ChronicDuration do
       '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,
+      '1 year 6 mos 1 day'    => 1 * 31557600 + 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,
+      '47 yrs 6 mos and 4.5d' => 47 * 31557600 + 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,
@@ -24,7 +24,11 @@ describe ChronicDuration do
       '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
+      '2 months'              => 3600 * 24 * 30 * 2,
+      '18 months'             => 3600 * 24 * 30 * 18,
+      '1 year 6 months'       => (3600 * 24 * (365.25 + 6 * 30)).to_i,
+      'day'                   => 3600 * 24,
+      'minute 30s'            => 90
     }
 
     context "when string can't be parsed" do
@@ -33,11 +37,15 @@ describe ChronicDuration do
         ChronicDuration.parse('gobblygoo').should be_nil
       end
 
+      it "cannot parse zero" do
+        ChronicDuration.parse('0').should be_nil
+      end
+
       context "when @@raise_exceptions set to true" do
 
         it "raises with ChronicDuration::DurationParseError" do
           ChronicDuration.raise_exceptions = true
-          lambda { ChronicDuration.parse('23 gobblygoos') }.should raise_exception(ChronicDuration::DurationParseError)
+          expect { ChronicDuration.parse('23 gobblygoos') }.to raise_error(ChronicDuration::DurationParseError)
           ChronicDuration.raise_exceptions = false
         end
 
@@ -45,6 +53,10 @@ describe ChronicDuration do
 
     end
 
+    it "should return zero if the string parses as zero and the keep_zero option is true" do
+      ChronicDuration.parse('0', :keep_zero => true).should == 0
+    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
@@ -124,7 +136,7 @@ describe ChronicDuration do
           :long     => '6 months 1 day',
           :chrono   => '6:01:00:00:00' # Yuck. FIXME
         },
-      (365 * 24 * 3600 + 24 * 3600 ) =>
+      (365.25 * 24 * 3600 + 24 * 3600 ).to_i =>
         {
           :micro    => '1y1d',
           :short    => '1y 1d',
@@ -132,7 +144,7 @@ describe ChronicDuration do
           :long     => '1 year 1 day',
           :chrono   => '1:00:01:00:00:00'
         },
-      (3  * 365 * 24 * 3600 + 24 * 3600 ) =>
+      (3  * 365.25 * 24 * 3600 + 24 * 3600 ).to_i =>
         {
           :micro    => '3y1d',
           :short    => '3y 1d',
@@ -140,6 +152,14 @@ describe ChronicDuration do
           :long     => '3 years 1 day',
           :chrono   => '3:00:01:00:00:00'
         },
+      (3600 * 24 * 30 * 18) =>
+        {
+          :micro    => '18mo',
+          :short    => '18mo',
+          :default  => '18 mos',
+          :long     => '18 months',
+          :chrono   => '18:00:00:00:00'
+        }
     }
 
     @exemplars.each do |k, v|
@@ -150,8 +170,35 @@ describe ChronicDuration do
       end
     end
 
+    @keep_zero_exemplars = {
+      (true) =>
+      {
+        :micro    => '0s',
+        :short    => '0s',
+        :default  => '0 secs',
+        :long     => '0 seconds',
+        :chrono   => '0'
+      },
+        (false) =>
+      {
+        :micro    => nil,
+        :short    => nil,
+        :default  => nil,
+        :long     => nil,
+        :chrono   => '0'
+      },
+    }
+
+    @keep_zero_exemplars.each do |k, v|
+      v.each do |key, val|
+        it "should properly output a duration of 0 seconds as #{val.nil? ? "nil" : val} using the #{key.to_s} format option, if the keep_zero option is #{k.to_s}" do
+          ChronicDuration.output(0, :format => key, :keep_zero => k).should == val
+        end
+      end
+    end
+
     it "returns weeks when needed" do
-      ChronicDuration.output(15*24*60*60, :weeks => true).should =~ /.*wk.*/
+      ChronicDuration.output(45*24*60*60, :weeks => true).should =~ /.*wk.*/
     end
 
     it "returns the specified number of units if provided" do
@@ -209,4 +256,21 @@ describe ChronicDuration do
 
   end
 
+  describe "work week" do
+    before(:all) do
+      ChronicDuration.hours_per_day = 8
+      ChronicDuration.days_per_week = 5
+    end
+
+    after(:all) do
+      ChronicDuration.hours_per_day = 24
+      ChronicDuration.days_per_week = 7
+    end
+
+    it "should parse knowing the work week" do
+      week = ChronicDuration.parse('5d')
+      ChronicDuration.parse('40h').should == week
+      ChronicDuration.parse('1w').should == week
+    end
+  end
 end

metadata

@@ -1,62 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: chronic_duration
 version: !ruby/object:Gem::Version
-  version: 0.10.2
-  prerelease: 
+  version: 0.10.3
 platform: ruby
 authors:
 - hpoydar
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-24 00:00:00.000000000 Z
+date: 2014-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numerizer
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.1.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.1.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 10.0.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 10.0.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 2.12.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 2.12.0
 description: A simple Ruby natural language parser for elapsed time. (For example,
@@ -70,8 +63,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - MIT-LICENSE
 - README.md
@@ -79,34 +72,31 @@ files:
 - chronic_duration.gemspec
 - lib/chronic_duration.rb
 - lib/chronic_duration/version.rb
-- spec/chronic_duration_spec.rb
 - spec/lib/chronic_duration_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/hpoydar/chronic_duration
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.2.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A simple Ruby natural language parser for elapsed time
 test_files:
-- spec/chronic_duration_spec.rb
 - spec/lib/chronic_duration_spec.rb
 - spec/spec_helper.rb

data/spec/chronic_duration_spec.rb

@@ -1,300 +0,0 @@
-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,
-    'day'                   => 3600 * 24,
-    'minute 30s'            => 90
-  }
-
-  it "should return nil if the string can't be parsed" do
-    ChronicDuration.parse('gobblygoo').should be_nil
-  end
-
-  it "should return nil if the string parses as zero" do
-    ChronicDuration.parse('0').should be_nil
-  end
-
-  it "should return zero if the string parses as zero and the keep_zero option is true" do
-    ChronicDuration.parse('0', :keep_zero => true).should == 0
-  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
-
-  @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 + 0.0) =>
-      {
-        :micro    => '1m20s',
-        :short    => '1m 20s',
-        :default  => '1 min 20 secs',
-        :long     => '1 minute 20 seconds',
-        :chrono   => '1:20'
-      },
-    (60 + 20.01) =>
-      {
-        :micro    => '1m20.01s',
-        :short    => '1m 20.01s',
-        :default  => '1 min 20.01 secs',
-        :long     => '1 minute 20.01 seconds',
-        :chrono   => '1:20.01'
-      },
-    (60 + 20.1) =>
-      {
-        :micro    => '1m20.1s',
-        :short    => '1m 20.1s',
-        :default  => '1 min 20.1 secs',
-        :long     => '1 minute 20.1 seconds',
-        :chrono   => '1:20.1'
-      },
-    (60 + 0.1) =>
-      {
-        :micro    => '1m0.1s',
-        :short    => '1m 0.1s',
-        :default  => '1 min 0.1 secs',
-        :long     => '1 minute 0.1 seconds',
-        :chrono   => '1:00.1'
-      },
-    (60*60) =>
-      {
-        :micro    => '1h',
-        :short    => '1h',
-        :default  => '1 hr',
-        :long     => '1 hour',
-        :chrono   => '1:00:00'
-      },
-    (60*60 + 0.1) =>
-      {
-        :micro    => '1h0.1s',
-        :short    => '1h 0.1s',
-        :default  => '1 hr 0.1 secs',
-        :long     => '1 hour 0.1 seconds',
-        :chrono   => '1:00:00.1'
-      },
-    (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    => '6mo1d',
-        :short    => '6mo 1d',
-        :default  => '6 mos 1 day',
-        :long     => '6 months 1 day',
-        :chrono   => '6:01:00:00:00' # Yuck. FIXME
-      },
-    (365 * 24 * 3600 + 24 * 3600 ) =>
-      {
-        :micro    => '1y1d',
-        :short    => '1y 1d',
-        :default  => '1 yr 1 day',
-        :long     => '1 year 1 day',
-        :chrono   => '1:00:01:00:00:00'
-      },
-    (3  * 365 * 24 * 3600 + 24 * 3600 ) =>
-      {
-        :micro    => '3y1d',
-        :short    => '3y 1d',
-        :default  => '3 yrs 1 day',
-        :long     => '3 years 1 day',
-        :chrono   => '3:00:01:00:00:00'
-      },
-  }
-
-  @exemplars.each do |k, v|
-    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
-
-  @keep_zero_exemplars = {
-    (true) =>
-      {
-        :micro    => '0s',
-        :short    => '0s',
-        :default  => '0 secs',
-        :long     => '0 seconds',
-        :chrono   => '0'
-      },
-    (false) =>
-      {
-        :micro    => nil,
-        :short    => nil,
-        :default  => nil,
-        :long     => nil,
-        :chrono   => '0'
-      },
-  }
-
-  @keep_zero_exemplars.each do |k, v|
-    v.each do |key, val|
-      it "should properly output a duration of 0 seconds as #{val.nil? ? "nil" : val} using the #{key.to_s} format option, if the keep_zero option is #{k.to_s}" do
-        ChronicDuration.output(0, :format => key, :keep_zero => k).should == val
-      end
-    end
-  end
-
-  it "should show weeks when needed" do
-    ChronicDuration.output(15*24*60*60, :weeks => true).should =~ /.*wk.*/
-  end
-
-  it "should show the specified number of units if provided" do
-    ChronicDuration.output(4 * 3600 + 60 + 1, units: 2).should == '4 hrs 1 min'
-    ChronicDuration.output(6 * 30 * 24 * 3600 + 24 * 3600 + 3600 + 60 + 1, units: 3, format: :long).should == '6 months 1 day 1 hour'
-  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
-
-  @exemplars.each do |seconds,format_spec|
-    format_spec.each do |format,_|
-      it "it should properly output a duration for #{seconds} that parses back to the same thing when using the #{format.to_s} format" do
-        ChronicDuration.parse(ChronicDuration.output(seconds, :format => format)).should == seconds
-      end
-    end
-  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