dotiw 1.1.1 → 2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d7ac361d8ee4fa014e09e9f77026c08b4fecbe8c
+  data.tar.gz: 0dc62da9541e16dd15228c7659b502013cae5a49
+SHA512:
+  metadata.gz: 8effe0793345b5319dd18ccf19bb018c4940d1ffab22094e97490a951548f07e1b22c2273130f09a557ecaefe06572901b33b082d4b5940bd4ad50d0aea44ba4
+  data.tar.gz: b659b4568937f7dfc770dc271b9bdc894bd253c5008fed536f8d0aff65257e948d3ea9c45869365fac064020a5ef7a349ddbcdd9fcec56ca9be39be0684a91bc

data/.travis.yml

@@ -0,0 +1,5 @@
+rvm:
+  - 2.1.3
+  - 2.0.0
+  - 1.9.3
+  - jruby-19mode

data/Gemfile

@@ -1,3 +1,3 @@
 source 'http://rubygems.org'
 
-gemspec
+gemspec

data/README.markdown

@@ -1,4 +1,4 @@
-# dotiw
+# dotiw [![](https://travis-ci.org/radar/dotiw.png)](https://travis-ci.org/radar/dotiw)
 
 dotiw is a plugin for Rails that overrides the default `distance_of_time_in_words` and provides a more accurate output. Do you crave accuracy down to the second? So do I. That's why I made this plugin. Take this for a totally kickass example:
 
@@ -23,11 +23,18 @@ The third argument for this method is whether or not to include seconds. By defa
     >> distance_of_time_in_words(Time.now, Time.now + 1.year + 1.second, true)
     => "1 year, and 1 second" 
 
-Yes this could just be merged into the options hash but I'm leaving it here to ensure "backwards-compatibility".
+Yes this could just be merged into the options hash but I'm leaving it here to ensure "backwards-compatibility",
+because that's just an insanely radical thing to do. \m/
 
-The last argument is an optional options hash that can be used to manipulate behavior and (which uses `to_sentence`). 
+The last argument is an optional options hash that can be used to manipulate behavior and (which uses `to_sentence`).
 
-Oh, and did I mention it supports I18n? Oh yeah.
+Don't like having to pass in `Time.now` all the time? Then use `time_ago_in_words` which also will *rock your
+world*:
+
+    >> time_ago_in_words(Time.now + 3.days + 1.second)
+    => "3 days, and 1 second"
+
+Oh, and did I mention it supports I18n? Oh yeah. Rock on!
 
 ### Options
 
@@ -35,7 +42,7 @@ Oh, and did I mention it supports I18n? Oh yeah.
 
 You can pass in a locale and it'll output it in whatever language you want (provided you have translations, otherwise it'll default to English):
 
-    >> distance_of_time_in_words(Time.now, Time.now + 1.minute, false, :locale => "es")
+    >> distance_of_time_in_words(Time.now, Time.now + 1.minute, false, :locale => :es)
     => "1 minuto"
     
 This will also be passed to `to_sentence`
@@ -44,57 +51,65 @@ This will also be passed to `to_sentence`
 
 Specify this if you want it to use the old `distance_of_time_in_words`. The value can be anything except `nil` or `false`.
 
-#### :singularize
-
-Specify if all values of the hash should be presented in their singular form. By default they will be pluralized whenever outside the `-1..1` range. If you wish to have them signularized, just add the option `:singularize => :always`.
-
-This option is useful for Russian and Icelandic folks (https://github.com/radar/dotiw/issues#issue/2).
-
-    >> distance_of_time_in_words(Time.now, Time.now + 2.hour + 2.minute, true, :singularize => :always)
-    => "2 hour and 2 minute"
-
 #### :accumulate_on
 
 Specifies the maximum output unit which will accumulate all the surplus. Say you set it to seconds and your time difference is of 2 minutes then the output would be 120 seconds. Here's a code example:
 
-    >> distance_of_time_in_words(Time.now, Time.now + 2.hour + 70.second, true, :accumulate_on => :minutes)
-    => "121 minutes minute and 10 seconds"
+    >> distance_of_time_in_words(Time.now, Time.now + 2.hours + 70.seconds, true, :accumulate_on => :minutes)
+    => "121 minutes and 10 seconds"
 
 #### :only
 
-**Note that values passed into this option must be passed in as strings!**
-
 Only want a specific measurement of time? No problem!
 
-    >> distance_of_time_in_words(Time.now, Time.now + 1.hour + 1.minute, false, :only => "minutes")
+    >> distance_of_time_in_words(Time.now, Time.now + 1.hour + 1.minute, false, :only => :minutes)
     => "1 minute"
 
 You only want some? No problem too!
 
-    >> distance_of_time_in_words(Time.now, Time.now + 1.hour + 1.day + 1.minute, false, :only => ["minutes", "hours"])
+    >> distance_of_time_in_words(Time.now, Time.now + 1.hour + 1.day + 1.minute, false, :only => [:minutes, :hours])
     => "1 hour and 1 minute"
 
 #### :except
 
-**Note that values passed into this option must be passed in as strings!**
-
 Don't want a measurement of time? No problem!
 
-    >> distance_of_time_in_words(Time.now, Time.now + 1.hour + 1.minute, false, :except => "minutes")
+    >> distance_of_time_in_words(Time.now, Time.now + 1.hour + 1.minute, false, :except => :minutes)
     => "1 hour"
 
 Culling a whole group of measurements of time:
 
-    >> distance_of_time_in_words(Time.now, Time.now + 1.hour + 1.day + 1.minute, false, :except => ["minutes", "hours"])
+    >> distance_of_time_in_words(Time.now, Time.now + 1.hour + 1.day + 1.minute, false, :except => [:minutes, :hours])
     => "1 day"
     
+#### :highest\_measure\_only
+
+For times when Rails `distance_of_time_in_words` is not precise enough and `DOTIW` is too precise. For instance, if you only want to know the highest time part (measure) that elapsed between two dates.
+
+    >> distance_of_time_in_words(Time.now, Time.now + 1.hour + 1.minute + 1.second, true, :highest_measure_only => true)
+    => "1 hour"
+
+Notice how minutes and seconds were removed from the output. Another example:
+
+    >> distance_of_time_in_words(Time.now, Time.now + 1.minute + 1.second, true, :highest_measure_only => true)
+    => "1 minute"
+
+Minutes are the highest measure, so seconds were discarded from the output.
+
+#### :highest\_measures
+
+When you want variable precision from `DOTIW`:
+
+    >> distance_of_time_in_words(Time.now, Time.now + 1.hour + 1.minute + 1.second, true, :highest_measures => 2)
+    => "1 hour and 1 minute"
+
 #### :words_connector
 
 **This is an option for `to_sentence`, defaults to ', '**
 
 Using something other than a comma:
 
-    >> distance_of_time_in_words(Time.now, Time.now + 1.hour + 1.minute + 1.second, true, { :words_connector => ' - ' })
+    >> distance_of_time_in_words(Time.now, Time.now + 1.hour + 1.minute + 1.second, true, :words_connector => ' - ')
     => "1 hour - 1 minute, and 1 second"
     
 #### :two\_words\_connector
@@ -103,7 +118,7 @@ Using something other than a comma:
 
 Using something other than 'and':
 
-    >> distance_of_time_in_words(Time.now, Time.now + 1.hour + 1.minute, true, { :two_words_connector => ' plus ' })
+    >> distance_of_time_in_words(Time.now, Time.now + 1.hour + 1.minute, true, :two_words_connector => ' plus ')
     => "1 hour plus 1 minute"
 
 #### :last\_word\_connector 
@@ -112,23 +127,9 @@ Using something other than 'and':
 
 Using something other than ', and':
 
-    >> distance_of_time_in_words(Time.now, Time.now + 1.hour + 1.minute + 1.second, true, { :last_word_connector => ', finally ' })
+    >> distance_of_time_in_words(Time.now, Time.now + 1.hour + 1.minute + 1.second, true, :last_word_connector => ', finally ')
     => "1 hour, 1 minute, finally 1 second"
 
-#### :highest\_measure\_only
-
-For times when Rails `distance_of_time_in_words` is not precise enough and `DOTIW` is too precise. For instance, if you only want to know the highest time part (measure) that elapsed between two dates.
-
-    >> distance_of_time_in_words(Time.now, Time.now + 1.hour + 1.minute + 1.second, true, { :highest_measure_only => true })
-    => "1 hour"
-
-Notice how minutes and seconds were removed from the output. Another example:
-
-    >> distance_of_time_in_words(Time.now, Time.now + 1.minute + 1.second, true, { :highest_measure_only => true })
-    => "1 minute"
-
-Minutes are the highest measure, so seconds were discarded from the output.
-
 ## distance\_of\_time
 
 If you have simply a number of seconds you can get the "stringified" version of this by using `distance_of_time`:
@@ -141,19 +142,20 @@ If you have simply a number of seconds you can get the "stringified" version of
 Don't like any format you're given? That's cool too! Here, have an indifferent hash version:
 
     >> distance_of_time_in_words_hash(Time.now, Time.now + 1.year + 2.months + 3.days + 4.hours + 5.minutes + 6.seconds)
-    => {"days"=>3, "seconds"=>6, "minutes"=>5, "years"=>1, "hours"=>4, "months"=>2}
+    => {:days => 3, :seconds => 6, :minutes => 5, :years => 1, :hours => 4, :months => 2}
 
 Indifferent means that you can access all keys by their `String` or `Symbol` version.
     
 ## distance\_of\_time\_in\_percent
 
-If you want to calculate a distance of time in percent, use `distance_of_time_in_percent`. The first argument is the beginning time, the second argument the "current" time and the third argument is the end time. This method takes the same options as [`number_with_precision`][http://api.rubyonrails.org/classes/ActionView/Helpers/NumberHelper.html#M001687].
+If you want to calculate a distance of time in percent, use `distance_of_time_in_percent`. The first argument is the beginning time, the second argument the "current" time and the third argument is the end time. This method takes the same options as [`number_with_precision`](http://api.rubyonrails.org/classes/ActionView/Helpers/NumberHelper.html#method-i-number_with_precision).
 
     distance_of_time_in_percent("04-12-2009".to_time, "29-01-2010".to_time, "04-12-2010".to_time, options)
     
 
 ## Contributors
 
-* [chendo][http://github.com/chendo] - for talking through it with me and drawing on the whiteboard
-* [Derander][http://github.com/derander] - correct Spanish translations
-* [DBA][http://github.com/dba] - Commits leading up to the 0.7 release. 
+* [chendo](http://github.com/chendo) - for talking through it with me and drawing on the whiteboard
+* [Derander](http://github.com/derander) - correct Spanish translations
+* [DBA](http://github.com/dba) - commits leading up to the 0.7 release
+* [Sija](http://github.com/Sija) - rails 4 support, v2.0 release

data/Rakefile

@@ -1,13 +1,12 @@
 require 'rubygems'
 require 'rake'
 require 'bundler'
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
 Bundler::GemHelper.install_tasks
 
+RSpec::Core::RakeTask.new(:spec)
 
-begin
-  require 'rspec/core/rake_task'
-  [:spec, :rcov].each { |task| RSpec::Core::RakeTask.new(task) }
-  task :default => :spec
-rescue LoadError
-  raise 'RSpec could not be loaded. Run `bundle install` to get all development dependencies.'
-end
+task :default => :spec

data/dotiw.gemspec

@@ -1,24 +1,26 @@
 # dotiw.gemspec
 # -*- encoding: utf-8 -*-
 
-$:.unshift File.join(File.dirname(__FILE__), 'lib') unless $:.include? File.join(File.dirname(__FILE__), 'lib')
+$:.push File.expand_path("../lib", __FILE__)
 require 'dotiw/version'
 
 Gem::Specification.new do |s|
   s.name = 'dotiw'
   s.version = DOTIW::VERSION
-  s.platform = Gem::Platform::RUBY
-  s.required_rubygems_version = '>= 1.3.6'
+
   s.authors = ["Ryan Bigg"]
   s.date = %q{2010-12-23}
   s.description = "Better distance_of_time_in_words for Rails"
   s.summary = "Better distance_of_time_in_words for Rails"
   s.email = "radarlistener@gmail.com"
 
-  s.add_dependency "actionpack", "~> 3"
-  
-  s.add_development_dependency "bundler", "~> 1.0.0"
-  s.add_development_dependency "rspec", "~> 2.0"
+  s.add_dependency "actionpack", ">= 3"
+  s.add_dependency "i18n"
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "rspec", "~> 3.0"
+  s.add_development_dependency "tzinfo"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/dotiw.rb

@@ -1,83 +1,30 @@
 # encoding: utf-8
 
+require 'i18n'
+
+# Rails hacks
+if defined?(ActionView::Helpers)
+  require 'dotiw/action_view_ext/helpers/date_helper'
+end
+
 module DOTIW
+  extend self
+  
   autoload :VERSION, 'dotiw/version'
   autoload :TimeHash, 'dotiw/time_hash'
-end # DOTIW
-
-module ActionView
-  module Helpers
-    module DateHelper
-      alias_method :old_distance_of_time_in_words, :distance_of_time_in_words
-
-      def distance_of_time_in_words_hash(from_time, to_time, options = {})
-        from_time = from_time.to_time if !from_time.is_a?(Time) && from_time.respond_to?(:to_time)
-        to_time   = to_time.to_time   if !to_time.is_a?(Time)   && to_time.respond_to?(:to_time)
-
-        DOTIW::TimeHash.new((from_time - to_time).abs, from_time, to_time, options).to_hash
-      end
-
-      def distance_of_time(seconds, options = {})
-        display_time_in_words DOTIW::TimeHash.new(seconds).to_hash, options
-      end
-
-      def distance_of_time_in_words(from_time, to_time, include_seconds = false, options = {})
-        return old_distance_of_time_in_words(from_time, to_time, include_seconds, options) if options.delete(:vague)
-        hash = distance_of_time_in_words_hash(from_time, to_time, options)
-        display_time_in_words(hash, include_seconds, options)
-      end
-
-      def distance_of_time_in_percent(from_time, current_time, to_time, options = {})
-        options[:precision] ||= 0
-        distance = to_time - from_time
-        result = ((current_time - from_time) / distance) * 100
-        number_with_precision(result, options).to_s + "%"
-      end
 
-      private
-        def display_time_in_words(hash, include_seconds = false, options = {})
-          options.symbolize_keys!
-          I18n.locale = options[:locale] if options[:locale]
+  DEFAULT_I18N_SCOPE = :'datetime.dotiw'
 
-          time_measurements = ActiveSupport::OrderedHash.new
-          time_measurements[:years]   = I18n.t(:years,   :default => "years")
-          time_measurements[:months]  = I18n.t(:months,  :default => "months")
-          time_measurements[:weeks]   = I18n.t(:weeks,   :default => "weeks")
-          time_measurements[:days]    = I18n.t(:days,    :default => "days")
-          time_measurements[:hours]   = I18n.t(:hours,   :default => "hours")
-          time_measurements[:minutes] = I18n.t(:minutes, :default => "minutes")
-          time_measurements[:seconds] = I18n.t(:seconds, :default => "seconds")
+  def init_i18n
+    I18n.load_path.unshift(*locale_files)
+    I18n.reload!
+  end
 
-          hash.delete(time_measurements[:seconds]) if !include_seconds && hash[time_measurements[:minutes]]
-
-          # Remove all the values that are nil or excluded. Keep the required ones.
-          time_measurements.delete_if do |measure, key|
-            hash[key].nil? || hash[key].zero? || (!options[:except].nil? && options[:except].include?(key)) ||
-              (options[:only] && !options[:only].include?(key))
-          end
-
-          options.delete(:except)
-          options.delete(:only)
-
-          output = []
-
-          time_measurements = Hash[*time_measurements.first] if options.delete(:highest_measure_only)
-
-          time_measurements.each do |measure, key|
-            name = options[:singularize] == :always || hash[key].between?(-1, 1) ? key.singularize : key
-            output += ["#{hash[key]} #{name}"]
-          end
-
-          options.delete(:singularize)
-
-          # maybe only grab the first few values
-          if options[:precision]
-            output = output[0...options[:precision]]
-            options.delete(:precision)
-          end
+protected
+  # Returns all locale files shipped with library
+  def locale_files
+    Dir[File.join(File.dirname(__FILE__), 'dotiw', 'locale', '**/*')]
+  end
+end # DOTIW
 
-          output.to_sentence(options)
-        end
-    end # DateHelper
-  end # Helpers
-end # ActionView
+DOTIW.init_i18n

data/lib/dotiw/action_view_ext/helpers/date_helper.rb

@@ -0,0 +1,92 @@
+module ActionView
+  module Helpers
+    module DateHelper
+      alias_method :old_distance_of_time_in_words, :distance_of_time_in_words
+
+      def distance_of_time_in_words_hash(from_time, to_time, options = {})
+        from_time = from_time.to_time if !from_time.is_a?(Time) && from_time.respond_to?(:to_time)
+        to_time   = to_time.to_time   if !to_time.is_a?(Time)   && to_time.respond_to?(:to_time)
+
+        DOTIW::TimeHash.new((from_time - to_time).abs, from_time, to_time, options).to_hash
+      end
+
+      def distance_of_time(seconds, options = {})
+        options[:include_seconds] ||= true
+        display_time_in_words DOTIW::TimeHash.new(seconds, nil, nil, options).to_hash, options
+      end
+
+      def distance_of_time_in_words(from_time, to_time = 0, include_seconds_or_options = {}, options = {})
+        if include_seconds_or_options.is_a?(Hash)
+          options = include_seconds_or_options
+        else
+          options[:include_seconds] ||= !!include_seconds_or_options
+        end
+        return distance_of_time(from_time, options) if to_time == 0
+        return old_distance_of_time_in_words(from_time, to_time, options) if options.delete(:vague)
+        hash = distance_of_time_in_words_hash(from_time, to_time, options)
+        display_time_in_words(hash, options)
+      end
+
+      def distance_of_time_in_percent(from_time, current_time, to_time, options = {})
+        options[:precision] ||= 0
+        distance = to_time - from_time
+        result = ((current_time - from_time) / distance) * 100
+        number_with_precision(result, options).to_s + "%"
+      end
+
+      alias_method :old_time_ago_in_words, :time_ago_in_words
+
+      def time_ago_in_words(from_time, include_seconds_or_options = {})
+        distance_of_time_in_words(from_time, Time.now, include_seconds_or_options)
+      end
+
+    private
+      def display_time_in_words(hash, options = {})
+        options.reverse_merge!(
+          :include_seconds => false
+        ).symbolize_keys!
+
+        include_seconds = options.delete(:include_seconds)
+        hash.delete(:seconds) if !include_seconds && hash[:minutes]
+
+        options[:except] = Array.wrap(options[:except]).map!(&:to_s) if options[:except]
+        options[:only] = Array.wrap(options[:only]).map!(&:to_s) if options[:only]
+
+        # Remove all the values that are nil or excluded. Keep the required ones.
+        hash.delete_if do |key, value|
+          value.nil? || value.zero? ||
+            (options[:except] && options[:except].include?(key.to_s)) ||
+            (options[:only] && !options[:only].include?(key.to_s))
+        end
+        return I18n.t('datetime.distance_in_words.less_than_x_seconds', :count => 1, :locale => options[:locale]) if hash.empty?
+
+        options.delete(:except)
+        options.delete(:only)
+
+        i18n_scope = options.delete(:scope) || DOTIW::DEFAULT_I18N_SCOPE
+        output = []
+        I18n.with_options :locale => options[:locale], :scope => i18n_scope do |locale|
+          output = hash.map { |key, value| locale.t(key, :count => value) }
+        end
+
+        highest_measures = options.delete(:highest_measures)
+        highest_measures = 1 if options.delete(:highest_measure_only)
+        if highest_measures
+          output = output[0...highest_measures]
+        end
+
+        options[:words_connector] ||= I18n.translate :'datetime.dotiw.words_connector',
+          :default => :'support.array.words_connector',
+          :locale => options[:locale]
+        options[:two_words_connector] ||= I18n.translate :'datetime.dotiw.two_words_connector',
+          :default => :'support.array.two_words_connector',
+          :locale => options[:locale]
+        options[:last_word_connector] ||= I18n.translate :'datetime.dotiw.last_word_connector',
+          :default => :'support.array.last_word_connector',
+          :locale => options[:locale]
+
+        output.to_sentence(options)
+      end
+    end # DateHelper
+  end # Helpers
+end # ActionView

data/lib/dotiw/locale/en.yml

@@ -0,0 +1,24 @@
+en:
+  datetime:
+    dotiw:
+      seconds:
+        one: 1 second
+        other: "%{count} seconds"
+      minutes:
+        one: 1 minute
+        other: "%{count} minutes"
+      hours:
+        one: 1 hour
+        other: "%{count} hours"
+      days:
+        one: 1 day
+        other: "%{count} days"
+      weeks:
+        one: 1 week
+        other: "%{count} weeks"
+      months:
+        one: 1 month
+        other: "%{count} months"
+      years:
+        one: 1 year
+        other: "%{count} years"

data/lib/dotiw/time_hash.rb

@@ -4,18 +4,16 @@ module DOTIW
   class TimeHash
     TIME_FRACTIONS = [:seconds, :minutes, :hours, :days, :months, :years]
 
-    attr_accessor :distance, :smallest, :largest, :from_time, :to_time, :options
+    attr_accessor :distance, :smallest, :largest, :from_time, :to_time
 
     def initialize(distance, from_time = nil, to_time = nil, options = {})
-      self.output     = {}
+      self.output     = ActiveSupport::OrderedHash.new
       self.options    = options
       self.distance   = distance
       self.from_time  = from_time || Time.now
       self.to_time    = to_time   || (self.from_time + self.distance.seconds)
       self.smallest, self.largest = [self.from_time, self.to_time].minmax
 
-      I18n.locale = options[:locale] if options[:locale]
-
       build_time_hash
     end
 
@@ -23,84 +21,87 @@ module DOTIW
       output
     end
 
-    private
-      attr_accessor :options, :output
-
-      def build_time_hash
-        if accumulate_on = options.delete(:accumulate_on)
-          return build_time_hash if accumulate_on == :years
-          TIME_FRACTIONS.index(accumulate_on).downto(0) { |i| self.send("build_#{TIME_FRACTIONS[i]}") }
-        else
-          while distance > 0
-            if distance < 1.minute
-              build_seconds
-            elsif distance < 1.hour
-              build_minutes
-            elsif distance < 1.day
-              build_hours
-            elsif distance < 28.days
-              build_days
-            else # greater than a month
-              build_years_months_days
-            end
+  private
+    attr_accessor :options, :output
+
+    def build_time_hash
+      if accumulate_on = options.delete(:accumulate_on)
+        accumulate_on = accumulate_on.to_sym
+        if accumulate_on == :years
+          return build_time_hash
+        end
+        TIME_FRACTIONS.index(accumulate_on).downto(0) { |i| self.send("build_#{TIME_FRACTIONS[i]}") }
+      else
+        while distance > 0
+          if distance < 1.minute
+            build_seconds
+          elsif distance < 1.hour
+            build_minutes
+          elsif distance < 1.day
+            build_hours
+          elsif distance < 28.days
+            build_days
+          else # greater than a month
+            build_years_months_days
           end
         end
-
-        output
       end
 
-      def build_seconds
-        output[I18n.t(:seconds, :default => "seconds")] = distance.to_i
-        self.distance = 0
-      end
+      output
+    end
 
-      def build_minutes
-        output[I18n.t(:minutes, :default => "minutes")], self.distance = distance.divmod(1.minute)
-      end
+    def build_seconds
+      output[:seconds] = distance.to_i
+      self.distance = 0
+    end
 
-      def build_hours
-        output[I18n.t(:hours, :default => "hours")], self.distance = distance.divmod(1.hour)
-      end
+    def build_minutes
+      output[:minutes], self.distance = distance.divmod(1.minute)
+    end
 
-      def build_days
-        output[I18n.t(:days, :default => "days")], self.distance = distance.divmod(1.day)
-      end
+    def build_hours
+      output[:hours], self.distance = distance.divmod(1.hour)
+    end
 
-      def build_months
-        build_years_months_days
+    def build_days
+      output[:days], self.distance = distance.divmod(1.day)
+    end
 
-        if (years = output.delete(I18n.t(:years, :default => "years"))) > 0
-          output[I18n.t(:months, :default => "months")] += (years * 12)
-        end
+    def build_months
+      build_years_months_days
+
+      if (years = output.delete(:years)) > 0
+        output[:months] += (years * 12)
       end
+    end
 
-      def build_years_months_days
-        months = (largest.year - smallest.year) * 12 + (largest.month - smallest.month)
-        years, months = months.divmod(12)
+    def build_years_months_days
+      months = (largest.year - smallest.year) * 12 + (largest.month - smallest.month)
+      years, months = months.divmod(12)
 
-        days = largest.day - smallest.day
+      days = largest.day - smallest.day
 
-        # Will otherwise incorrectly say one more day if our range goes over a day.
-        days -= 1 if largest.hour < smallest.hour
+      # Will otherwise incorrectly say one more day if our range goes over a day.
+      days -= 1 if largest.hour < smallest.hour
 
-        if days < 0
-          # Convert the last month to days and add to total
-          months -= 1
-          last_month = largest.advance(:months => -1)
-          days += Time.days_in_month(last_month.month, last_month.year)
-        end
+      if days < 0
+        # Convert the last month to days and add to total
+        months -= 1
+        last_month = largest.advance(:months => -1)
+        days += Time.days_in_month(last_month.month, last_month.year)
+      end
 
-        if months < 0
-          # Convert a year to months
-          years -= 1
-          months += 12
-        end
+      if months < 0
+        # Convert a year to months
+        years -= 1
+        months += 12
+      end
 
-        output[I18n.t(:years,   :default => "years")]   = years
-        output[I18n.t(:months,  :default => "months")]  = months
-        output[I18n.t(:days,    :default => "days")]    = days
+      output[:years]   = years
+      output[:months]  = months
+      output[:days]    = days
 
-        total_days, self.distance = (from_time - to_time).abs.divmod(1.day)
-      end
+      total_days, self.distance = (from_time - to_time).abs.divmod(1.day)
+    end
   end # TimeHash
-end # DOTIW
+end # DOTIW

data/lib/dotiw/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module DOTIW
-  VERSION = "1.1.1"
+  VERSION = "2.0"
 end

data/spec/lib/dotiw_spec.rb

@@ -10,22 +10,38 @@ describe "A better distance_of_time_in_words" do
   before do
     I18n.locale = :en
     time = "01-08-2009".to_time
-    Time.stub!(:now).and_return(time)
-    Time.zone.stub!(:now).and_return(time)
+    allow(Time).to receive(:now).and_return(time)
+    allow(Time.zone).to receive(:now).and_return(time)
   end
 
   describe "distance of time" do
-    [
+    fragments = [
+      [0.5.minutes, "30 seconds"],
+      [4.5.minutes, "4 minutes and 30 seconds"],
       [5.minutes.to_i, "5 minutes"],
       [10.minutes.to_i, "10 minutes"],
       [1.hour.to_i, "1 hour"],
+      [1.hour + 30.seconds, "1 hour and 30 seconds"],
       [4.weeks.to_i, "28 days"],
       [24.weeks.to_i, "5 months and 15 days"]
-    ].each do |number, result|
+    ]
+    fragments.each do |number, result|
       it "#{number} == #{result}" do
-        distance_of_time(number).should eql(result)
+        expect(distance_of_time(number)).to eq(result)
       end
     end
+
+    describe "with options" do
+      it "except:seconds should skip seconds" do
+        expect(distance_of_time(1.2.minute, except: 'seconds')).to eq("1 minute")
+        expect(distance_of_time(2.5.hours + 30.seconds, except: 'seconds')).to eq("2 hours and 30 minutes")
+      end
+
+      it "except:seconds har higher presedence than include_seconds:true" do
+        expect(distance_of_time(1.2.minute, include_seconds: true, except: 'seconds')).to eq('1 minute')
+      end
+    end
+
   end
 
   describe "hash version" do
@@ -35,12 +51,12 @@ describe "A better distance_of_time_in_words" do
         describe name do
           it "exactly" do
             hash = distance_of_time_in_words_hash(Time.now, Time.now + 1.send(name))
-            hash[name.to_s].should eql(1)
+            expect(hash[name]).to eq(1)
           end
 
           it "two" do
             hash = distance_of_time_in_words_hash(Time.now, Time.now + 2.send(name))
-            hash[name.to_s].should eql(2)
+            expect(hash[name]).to eq(2)
           end
         end
       end
@@ -48,47 +64,29 @@ describe "A better distance_of_time_in_words" do
       it "should be happy with lots of measurements" do
         hash = distance_of_time_in_words_hash(Time.now,
                                               Time.now + 1.year + 2.months + 3.days + 4.hours + 5.minutes + 6.seconds)
-        hash["years"].should eql(1)
-        hash["months"].should eql(2)
-        hash["days"].should eql(3)
-        hash["hours"].should eql(4)
-        hash["minutes"].should eql(5)
-        hash["seconds"].should eql(6)
-      end
-
-      it "debe estar contento con las mediciones en español" do
-        hash = distance_of_time_in_words_hash(Time.now,
-                                              Time.now + 1.year + 2.months + 3.days + 4.hours + 5.minutes + 6.seconds,
-                                              :locale => "es")
-        hash["años"].should eql(1)
-        hash["meses"].should eql(2)
-        hash["días"].should eql(3)
-        hash["horas"].should eql(4)
-        hash["minutos"].should eql(5)
-        hash["segundos"].should eql(6)
-      end
-
-      it "debe hablar español" do
-        I18n.locale = :es
-        hash = distance_of_time_in_words_hash(Time.now, Time.now + 5.days)
-        hash["días"].should eql(5)
+        expect(hash[:years]).to eq(1)
+        expect(hash[:months]).to eq(2)
+        expect(hash[:days]).to eq(3)
+        expect(hash[:hours]).to eq(4)
+        expect(hash[:minutes]).to eq(5)
+        expect(hash[:seconds]).to eq(6)
       end
     end
   end
 
   describe "real version" do
     it "debe hablar español" do
-      distance_of_time_in_words(Time.now, Time.now + 5.days, true, :locale => "es").should eql("5 días")
+      expect(distance_of_time_in_words(Time.now, Time.now + 1.days, true, :locale => :es)).to eq("un día")
+      expect(distance_of_time_in_words(Time.now, Time.now + 5.days, true, :locale => :es)).to eq("5 días")
     end
 
-    [
+    fragments = [
       [Time.now, Time.now + 5.days + 3.minutes, "5 days and 3 minutes"],
       [Time.now, Time.now + 1.minute, "1 minute"],
       [Time.now, Time.now + 3.years, "3 years"],
       [Time.now, Time.now + 10.years, "10 years"],
+      [Time.now, Time.now + 10.years, "10 years"],
       [Time.now, Time.now + 3.hour, "3 hours"],
-      # Need to be +1.day because it will output "1 year and 30 days" otherwise.
-      # Haven't investigated fully how this is caused.
       [Time.now, Time.now + 13.months, "1 year and 1 month"],
       # Any numeric sequence is merely coincidental.
       [Time.now, Time.now + 1.year + 2.months + 3.days + 4.hours + 5.minutes + 6.seconds, "1 year, 2 months, 3 days, 4 hours, 5 minutes, and 6 seconds"],
@@ -97,14 +95,15 @@ describe "A better distance_of_time_in_words" do
       ["2009-4-14".to_time, "2008-3-16".to_time, "1 year and 29 days"],
       ["2009-2-01".to_time, "2009-3-01".to_time, "1 month"],
       ["2008-2-01".to_time, "2008-3-01".to_time, "1 month"]
-    ].each do |start, finish, output|
+    ]
+    fragments.each do |start, finish, output|
       it "should be #{output}" do
-        distance_of_time_in_words(start, finish, true).should eql(output)
+        expect(distance_of_time_in_words(start, finish, true)).to eq(output)
       end
     end
 
     describe "accumulate on" do
-      [
+      fragments = [
         [Time.now,
          Time.now + 10.minute,
          :seconds,
@@ -124,21 +123,37 @@ describe "A better distance_of_time_in_words" do
         [Time.now,
          Time.now + 2.day + 10000.hour + 10.second,
          :months,
-         "13 months, 16 hours, and 10 seconds"],
-        [Time.now,
-         Time.now + 2.day + 10000.hour + 10.second,
-         :years,
-         "1 year, 1 month, 22 days, 16 hours, and 10 seconds"]
-      ].each do |start, finish, accumulator, output|
+         "13 months, 16 hours, and 10 seconds"]
+      ]
+      fragments.each do |start, finish, accumulator, output|
         it "should be #{output}" do
-          distance_of_time_in_words(start, finish, true, :accumulate_on => accumulator).should eql(output)
+          expect(distance_of_time_in_words(start, finish, true, :accumulate_on => accumulator)).to eq(output)
         end
       end
     end # :accumulate_on
+
+    describe "without finish time" do
+      # A missing finish argument should default to zero, essentially returning
+      # the equivalent of distance_of_time in order to be backwards-compatible
+      # with the original rails distance_of_time_in_words helper.
+      fragments = [
+        [5.minutes.to_i, "5 minutes"],
+        [10.minutes.to_i, "10 minutes"],
+        [1.hour.to_i, "1 hour"],
+        [4.weeks.to_i, "28 days"],
+        [24.weeks.to_i, "5 months and 15 days"]
+      ]
+      fragments.each do |start, output|
+        it "should be #{output}" do
+          expect(distance_of_time_in_words(start)).to eq(output)
+        end
+      end
+    end
+
   end
 
   describe "with output options" do
-    [
+    fragments = [
       # Any numeric sequence is merely coincidental.
       [Time.now,
        Time.now + 1.year + 2.months + 3.days + 4.hours + 5.minutes + 6.seconds,
@@ -167,18 +182,6 @@ describe "A better distance_of_time_in_words" do
        Time.now + 1.hour + 1.day + 1.minute,
        { :only => ["minutes", "hours"]},
        "1 hour and 1 minute"],
-      [Time.now,
-       Time.now + 1.year + 2.months + 3.days + 4.hours + 5.minutes + 6.seconds,
-       { :precision => 2 },
-       "1 year and 2 months"],
-      [Time.now,
-       Time.now + 1.year + 2.months + 3.days + 4.hours + 5.minutes + 6.seconds,
-       { :precision => 3 },
-       "1 year, 2 months, and 3 days"],
-      [Time.now,
-       Time.now + 1.year + 2.months + 3.days + 4.hours + 5.minutes + 6.seconds,
-       { :precision => 10 },
-       "1 year, 2 months, 3 days, 4 hours, 5 minutes, and 6 seconds"],
       [Time.now,
        Time.now + 1.year + 2.months + 3.days + 4.hours + 5.minutes + 6.seconds,
        { :vague => true },
@@ -197,31 +200,48 @@ describe "A better distance_of_time_in_words" do
        "1 year, 2 months, 3 days, 4 hours, 5 minutes, and 6 seconds"],
       [Time.now,
        Time.now + 1.year + 2.months + 3.days + 4.hours + 5.minutes + 6.seconds,
-       { "except" => "minutes" },
+       { :except => "minutes" },
        "1 year, 2 months, 3 days, 4 hours, and 6 seconds"],
       [Time.now,
         Time.now + 1.hour + 2.minutes + 3.seconds,
         { :highest_measure_only => true },
         "1 hour"],
+      [Time.now,
+       Time.now + 1.hours + 2.minutes + 3.seconds,
+       { :highest_measures => 1 },
+       "1 hour"],
       [Time.now,
        Time.now + 2.year + 3.months + 4.days + 5.hours + 6.minutes + 7.seconds,
-       { :singularize => :always },
-       "2 year, 3 month, 4 day, 5 hour, 6 minute, and 7 second"]
-    ].each do |start, finish, options, output|
+       { :highest_measures => 3 },
+       "2 years, 3 months, and 4 days"],
+      [Time.now,
+       Time.now + 2.year + 3.weeks + 4.days + 5.hours + 6.minutes + 7.seconds,
+       { :highest_measures => 2 },
+       "2 years and 25 days"],
+      [Time.now,
+       Time.now + 4.days + 6.minutes + 7.seconds,
+       { :highest_measures => 3 },
+       "4 days, 6 minutes, and 7 seconds"],
+      [Time.now,
+       Time.now + 1.year + 2.weeks,
+       { :highest_measures => 3 },
+       "1 year and 14 days"]
+    ]
+    fragments.each do |start, finish, options, output|
       it "should be #{output}" do
-        distance_of_time_in_words(start, finish, true, options).should eql(output)
+        expect(distance_of_time_in_words(start, finish, true, options)).to eq(output)
       end
     end
 
     describe "include_seconds" do
       it "is ignored if only seconds have passed" do
-        distance_of_time_in_words(Time.now, Time.now + 1.second, false).should eql("1 second")
+        expect(distance_of_time_in_words(Time.now, Time.now + 1.second, false)).to eq("1 second")
       end
 
       it "removes seconds in all other cases" do
-        distance_of_time_in_words(Time.now,
+        expect(distance_of_time_in_words(Time.now,
                                   Time.now + 1.year + 2.months + 3.days + 4.hours + 5.minutes + 6.seconds,
-                                  false).should eql("1 year, 2 months, 3 days, 4 hours, and 5 minutes")
+                                  false)).to eq("1 year, 2 months, 3 days, 4 hours, and 5 minutes")
       end
     end # include_seconds
   end
@@ -232,11 +252,11 @@ describe "A better distance_of_time_in_words" do
     end
 
     it "calculates 15%" do
-      time_in_percent.should eql("15%")
+      expect(time_in_percent).to eq("15%")
     end
 
     it "calculates 15.3%" do
-      time_in_percent(:precision => 1).should eql("15.3%")
+      expect(time_in_percent(:precision => 1)).to eq("15.3%")
     end
   end
 

data/spec/spec_helper.rb

@@ -7,13 +7,11 @@ $:.unshift ROOT_PATH unless $:.include? ROOT_PATH
 require 'erb'
 
 require 'active_support/all'
+require 'action_view'
 
-require 'action_view/context'
-require 'action_view/helpers'
-
-require 'init' # require dotiw through init (like a plugin would)
+require 'dotiw'
 
 Time.zone = 'UTC'
-I18n.load_path.clear
-I18n.load_path << Dir[File.join(File.dirname(__FILE__), "translations", "*")]
+
+I18n.load_path << Dir[File.join(File.dirname(__FILE__), 'translations', '*')]
 I18n.locale = :en

data/spec/translations/es.yml

@@ -1,9 +1,24 @@
 es:
-  seconds: segundos
-  minutes: minutos
-  hours: horas
-  days: días
-  weeks: semanas
-  months: meses
-  years: años
-  
+  datetime:
+    dotiw:
+      seconds:
+        one: uno segundo
+        other: "%{count} segundos"
+      minutes:
+        one: uno minuto
+        other: "%{count} minutos"
+      hours:
+        one: una hora
+        other: "%{count} horas"
+      days:
+        one: un día
+        other: "%{count} días"
+      weeks:
+        one: una semana
+        other: "%{count} semanas"
+      months:
+        one: un mes
+        other: "%{count} meses"
+      years:
+        one: un año
+        other: "%{count} años"

metadata

@@ -1,103 +1,144 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: dotiw
-version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 1.1.1
+version: !ruby/object:Gem::Version
+  version: '2.0'
 platform: ruby
-authors: 
+authors:
 - Ryan Bigg
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-12-23 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2010-12-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: "3"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: bundler
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: 1.0.0
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
   name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: "2.0"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: tzinfo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id003
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Better distance_of_time_in_words for Rails
 email: radarlistener@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- .gitignore
+files:
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - MIT-LICENSE
 - README.markdown
 - Rakefile
 - dotiw.gemspec
-- init.rb
 - lib/dotiw.rb
+- lib/dotiw/action_view_ext/helpers/date_helper.rb
+- lib/dotiw/locale/en.yml
 - lib/dotiw/time_hash.rb
 - lib/dotiw/version.rb
-- rails/init.rb
 - spec/lib/dotiw_spec.rb
 - spec/spec_helper.rb
-- spec/translations/en.yml
 - spec/translations/es.yml
 homepage: 
 licenses: []
-
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: 1.3.6
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.8
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Better distance_of_time_in_words for Rails
-test_files: 
+test_files:
 - spec/lib/dotiw_spec.rb
 - spec/spec_helper.rb
-- spec/translations/en.yml
 - spec/translations/es.yml

data/init.rb

@@ -1,3 +0,0 @@
-# encoding: utf-8
-
-require 'rails/init'

data/rails/init.rb

@@ -1 +0,0 @@
-require 'dotiw'

data/spec/translations/en.yml

@@ -1,24 +0,0 @@
-en:
-  seconds: seconds
-  minutes: minutes
-  hours: hours
-  days: days
-  weeks: weeks
-  months: months
-  years: years
-  
-  support:
-    array:
-      two_words_connector: " and "
-      words_connector: ", "
-      last_word_connector: ", and "
-      
-  datetime:
-    distance_in_words:
-      about_x_years:
-        one: "about 1 year"
-        many: "about %{count} years"
-        
-  number:
-      format:
-        separator: "."