dotiw 3.0 → 5.0.0

data/lib/dotiw/methods.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module DOTIW
+  module Methods
+    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(nil, 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
+
+      hash = distance_of_time_in_words_hash(from_time, to_time, options)
+      _display_time_in_words(hash, options)
+    end
+
+    def time_ago_in_words(from_time, include_seconds_or_options = {})
+      distance_of_time_in_words(from_time, Time.current, 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_sym) if options[:except]
+      options[:only] = Array.wrap(options[:only]).map!(&:to_sym) 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]&.include?(key) ||
+          (options[:only] && !options[:only].include?(key))
+      end
+
+      i18n_scope = options.delete(:scope) || DOTIW::DEFAULT_I18N_SCOPE
+      if hash.empty?
+        fractions = DOTIW::TimeHash::TIME_FRACTIONS
+        fractions &= options[:only] if options[:only]
+        fractions -= options[:except] if options[:except]
+
+        I18n.with_options locale: options[:locale], scope: i18n_scope do |locale|
+          # e.g. try to format 'less than 1 days', fallback to '0 days'
+          return locale.translate :less_than_x,
+                                  distance: locale.translate(fractions.first, count: 1),
+                                  default: locale.translate(fractions.first, count: 0)
+        end
+      end
+
+      output = []
+      I18n.with_options locale: options[:locale], scope: i18n_scope do |locale|
+        output = hash.map { |key, value| locale.t(key, count: value) }
+      end
+
+      options.delete(:except)
+      options.delete(:only)
+      highest_measures = options.delete(:highest_measures)
+      highest_measures = 1 if options.delete(:highest_measure_only)
+      output = output[0...highest_measures] if highest_measures
+
+      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
+end # DOTIW

data/lib/dotiw/time_hash.rb

@@ -1,25 +1,25 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module DOTIW
   class TimeHash
-    TIME_FRACTIONS = [:seconds, :minutes, :hours, :days, :months, :years]
-
-    attr_accessor :distance, :smallest, :largest, :from_time, :to_time
-
-    def initialize(distance, from_time = nil, to_time = nil, options = {})
-      self.output     = ActiveSupport::OrderedHash.new
-      self.options    = options
-      self.distance   = distance
-      self.from_time  = from_time || Time.now
-      self.to_time    = to_time   || (@to_time_not_given = true && self.from_time + self.distance.seconds)
-      self.smallest, self.largest = [self.from_time, self.to_time].minmax
-      self.to_time   += 1.hour if @to_time_not_given && self.smallest.dst? && !self.largest.dst?
-      self.to_time   -= 1.hour if @to_time_not_given && !self.smallest.dst? && self.largest.dst?
-      self.smallest, self.largest = [self.from_time, self.to_time].minmax
-      self.distance ||= begin
+    TIME_FRACTIONS = %i[seconds minutes hours days weeks months years].freeze
+
+    attr_reader :distance, :smallest, :largest, :from_time, :to_time
+
+    def initialize(distance, from_time, to_time = nil, options = {})
+      @output     = {}
+      @options    = options
+      @distance   = distance
+      @from_time  = from_time || Time.current
+      @to_time    = to_time   || (@to_time_not_given = true && @from_time + distance.seconds)
+      @smallest, @largest = [@from_time, @to_time].minmax
+      @to_time   += 1.hour if @to_time_not_given && smallest.dst? && !largest.dst?
+      @to_time   -= 1.hour if @to_time_not_given && !smallest.dst? && largest.dst?
+      @smallest, @largest = [@from_time, @to_time].minmax
+      @distance ||= begin
         d = largest - smallest
-        d -= 1.hour if self.smallest.dst? && !self.largest.dst?
-        d += 1.hour if !self.smallest.dst? && self.largest.dst?
+        d -= 1.hour if smallest.dst? && !largest.dst?
+        d += 1.hour if !smallest.dst? && largest.dst?
         d
       end
 
@@ -30,16 +30,16 @@ module DOTIW
       output
     end
 
-  private
-    attr_accessor :options, :output
+    private
+
+    attr_reader :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]}") }
+        return build_time_hash if accumulate_on == :years
+
+        TIME_FRACTIONS.index(accumulate_on).downto(0) { |i| send("build_#{TIME_FRACTIONS[i]}") }
       else
         while distance > 0
           if distance < 1.minute
@@ -48,10 +48,12 @@ module DOTIW
             build_minutes
           elsif distance < 1.day
             build_hours
-          elsif distance < 28.days
+          elsif distance < 7.days
             build_days
-          else # greater than a month
-            build_years_months_days
+          elsif distance < 28.days
+            build_weeks
+          else # greater than a week
+            build_years_months_weeks_days
           end
         end
       end
@@ -61,43 +63,67 @@ module DOTIW
 
     def build_seconds
       output[:seconds] = distance.to_i
-      self.distance = 0
+      @distance = 0
     end
 
     def build_minutes
-      output[:minutes], self.distance = distance.divmod(1.minute)
+      output[:minutes], @distance = distance.divmod(1.minute.to_i)
     end
 
     def build_hours
-      output[:hours], self.distance = distance.divmod(1.hour)
+      output[:hours], @distance = distance.divmod(1.hour.to_i)
     end
 
     def build_days
-      output[:days], self.distance = distance.divmod(1.day) if output[:days].nil?
+      output[:days], @distance = distance.divmod(1.day.to_i) unless output[:days]
+    end
+
+    def build_weeks
+      output[:weeks], @distance = distance.divmod(1.week.to_i) unless output[:weeks]
     end
 
     def build_months
-      build_years_months_days
+      build_years_months_weeks_days
 
       if (years = output.delete(:years)) > 0
         output[:months] += (years * 12)
       end
     end
 
-    def build_years_months_days
+    def build_years_months_weeks_days
       months = (largest.year - smallest.year) * 12 + (largest.month - smallest.month)
       years, months = months.divmod(12)
 
       days = largest.day - smallest.day
 
+      weeks, days = days.divmod(7)
+
       # 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
+        # Convert a week to days and add to total
+        weeks -= 1
+        days += 7
+      end
+
+      if weeks < 0
+        # Convert the last month to a week and add to total
         months -= 1
-        last_month = largest.advance(:months => -1)
-        days += Time.days_in_month(last_month.month, last_month.year)
+        last_month = largest.advance(months: -1)
+        days_in_month = Time.days_in_month(last_month.month, last_month.year)
+        weeks += days_in_month / 7
+        days += days_in_month % 7
+        if days >= 7
+          days -= 7
+          weeks += 1
+        end
+
+        if weeks == -1
+          months -= 1
+          weeks = 4
+          days -= 4
+        end
       end
 
       if months < 0
@@ -108,11 +134,12 @@ module DOTIW
 
       output[:years]   = years
       output[:months]  = months
+      output[:weeks]   = weeks
       output[:days]    = days
 
-      total_days, self.distance = distance.abs.divmod(1.day)
+      total_days, @distance = distance.abs.divmod(1.day.to_i)
 
-      [total_days, self.distance]
+      [total_days, @distance]
     end
   end # TimeHash
 end # DOTIW

data/lib/dotiw/version.rb

@@ -1,5 +1,5 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module DOTIW
-  VERSION = "3.0"
+  VERSION = '5.0.0'
 end

data/spec/lib/dotiw_spec.rb

@@ -1,13 +1,17 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 require 'spec_helper'
 
-describe "A better distance_of_time_in_words" do
-  include ActionView::Helpers::DateHelper
-  include ActionView::Helpers::TextHelper
-  include ActionView::Helpers::NumberHelper
+describe 'A better distance_of_time_in_words' do
+  if defined?(ActionView)
+    include ActionView::Helpers::DateHelper
+    include ActionView::Helpers::TextHelper
+    include ActionView::Helpers::NumberHelper
+  else
+    include DOTIW::Methods
+  end
 
-  START_TIME = "01-08-2009".to_time
+  START_TIME = '01-08-2009'.to_time
 
   before do
     I18n.locale = :en
@@ -15,269 +19,314 @@ describe "A better distance_of_time_in_words" do
     allow(Time.zone).to receive(:now).and_return(START_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"]
-    ]
-    fragments.each do |number, result|
+  describe 'distance of time' do
+    [
+      [0.5.minutes, '30 seconds'],
+      [4.5.minutes, '4 minutes and 30 seconds'],
+      [5.minutes, '5 minutes'],
+      [10.minutes, '10 minutes'],
+      [1.hour, '1 hour'],
+      [1.hour + 30.seconds, '1 hour and 30 seconds'],
+      [4.weeks, '4 weeks'],
+      [4.weeks + 2.days, '4 weeks and 2 days'],
+      [24.weeks, '5 months, 2 weeks, and 1 day']
+    ].each do |number, result|
       it "#{number} == #{result}" do
         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")
+    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
+      it 'except:seconds has higher precedence 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
-    describe "giving correct numbers of" do
-
-      [:years, :months, :days, :minutes, :seconds].each do |name|
+  describe 'hash version' do
+    describe 'giving correct numbers of' do
+      %i[years months weeks days minutes seconds].each do |name|
         describe name do
-          it "exactly" do
+          it 'exactly' do
             hash = distance_of_time_in_words_hash(START_TIME, START_TIME + 1.send(name))
             expect(hash[name]).to eq(1)
           end
 
-          it "two" do
+          it 'two' do
             hash = distance_of_time_in_words_hash(START_TIME, START_TIME + 2.send(name))
             expect(hash[name]).to eq(2)
           end
         end
       end
 
-      it "should be happy with lots of measurements" do
-        hash = distance_of_time_in_words_hash(START_TIME,
-                                              START_TIME + 1.year + 2.months + 3.days + 4.hours + 5.minutes + 6.seconds)
+      it 'should be happy with lots of measurements' do
+        hash = distance_of_time_in_words_hash(
+          START_TIME,
+          START_TIME + 1.year + 2.months + 3.weeks + 4.days + 5.hours + 6.minutes + 7.seconds
+        )
         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)
+        expect(hash[:weeks]).to eq(3)
+        expect(hash[:days]).to eq(4)
+        expect(hash[:hours]).to eq(5)
+        expect(hash[:minutes]).to eq(6)
+        expect(hash[:seconds]).to eq(7)
       end
     end
   end
 
-  describe "real version" do
-    it "debe hablar español" do
-      expect(distance_of_time_in_words(START_TIME, START_TIME + 1.days, :locale => :es)).to eq("un día")
-      expect(distance_of_time_in_words(START_TIME, START_TIME + 5.days, :locale => :es)).to eq("5 días")
+  describe 'real version' do
+    it 'debe hablar español' do
+      expect(distance_of_time_in_words(START_TIME, START_TIME + 1.days, locale: :es)).to eq('un día')
+      expect(distance_of_time_in_words(START_TIME, START_TIME + 5.days, locale: :es)).to eq('5 días')
     end
 
     it "deve parlare l'italiano" do
-      expect(distance_of_time_in_words(START_TIME, START_TIME + 1.days, true, :locale => :it)).to eq("un giorno")
-      expect(distance_of_time_in_words(START_TIME, START_TIME + 5.days, true, :locale => :it)).to eq("5 giorni")
+      expect(distance_of_time_in_words(START_TIME, START_TIME + 1.days, true, locale: :it)).to eq('un giorno')
+      expect(distance_of_time_in_words(START_TIME, START_TIME + 5.days, true, locale: :it)).to eq('5 giorni')
     end
 
-    fragments = [
-      [START_TIME, START_TIME + 5.days + 3.minutes, "5 days and 3 minutes"],
-      [START_TIME, START_TIME + 1.minute, "1 minute"],
-      [START_TIME, START_TIME + 3.years, "3 years"],
-      [START_TIME, START_TIME + 10.years, "10 years"],
-      [START_TIME, START_TIME + 10.years, "10 years"],
-      [START_TIME, START_TIME + 3.hour, "3 hours"],
-      [START_TIME, START_TIME + 13.months, "1 year and 1 month"],
+    [
+      [START_TIME, START_TIME + 5.days + 3.minutes, '5 days and 3 minutes'],
+      [START_TIME, START_TIME + 1.minute, '1 minute'],
+      [START_TIME, START_TIME + 3.years, '3 years'],
+      [START_TIME, START_TIME + 10.years, '10 years'],
+      [START_TIME, START_TIME + 8.months, '8 months'],
+      [START_TIME, START_TIME + 3.hour, '3 hours'],
+      [START_TIME, START_TIME + 13.months, '1 year and 1 month'],
       # Any numeric sequence is merely coincidental.
-      [START_TIME, START_TIME + 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"],
-      ["2009-3-16".to_time, "2008-4-14".to_time, "11 months and 2 days"],
-      ["2009-3-16".to_time + 1.minute, "2008-4-14".to_time, "11 months, 2 days, and 1 minute"],
-      ["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"]
-    ]
-    fragments.each do |start, finish, output|
+      [START_TIME, START_TIME + 1.year + 2.months + 3.weeks + 4.days + 5.hours + 6.minutes + 7.seconds, '1 year, 2 months, 3 weeks, 4 days, 5 hours, 6 minutes, and 7 seconds'],
+      ['2009-3-16'.to_time, '2008-4-14'.to_time, '11 months and 2 days'],
+      ['2009-3-16'.to_time + 1.minute, '2008-4-14'.to_time, '11 months, 2 days, and 1 minute'],
+      ['2009-4-14'.to_time, '2008-3-16'.to_time, '1 year, 4 weeks, and 1 day'],
+      ['2009-2-01'.to_time, '2009-3-01'.to_time, '1 month'],
+      ['2008-2-01'.to_time, '2008-3-01'.to_time, '1 month'],
+      [Date.parse('31.03.2015').to_time, Time.parse('01.03.2016'), '10 months, 4 weeks, and 2 days'],
+      [Date.new(2014, 1, 31), Date.new(2014, 3, 1), '4 weeks and 1 day'],
+      ['2008-2-01'.to_time, '2008-3-01'.to_time, '1 month'],
+      ['2014-1-31'.to_time, '2014-3-01'.to_time, '4 weeks and 1 day'],
+      ['2014-1-31'.to_time, '2014-3-02'.to_time, '4 weeks and 2 days'],
+      ['2016-1-31'.to_time, '2016-3-01'.to_time, '4 weeks and 2 days'],
+      ['2016-1-31'.to_time, '2016-3-02'.to_time, '1 month']
+    ].each do |start, finish, output|
       it "should be #{output}" do
         expect(distance_of_time_in_words(start, finish, true)).to eq(output)
+        expect(distance_of_time_in_words(finish, start, true)).to eq(output)
+      end
+    end
+
+    [
+      [Time.zone.now, Time.zone.now + 1.day - 1.minute, '23 hours and 59 minutes'],
+      [Time.zone.now, Time.zone.now + 15.days - 1.minute, '14 days, 23 hours, and 59 minutes'],
+      [Time.zone.now, Time.zone.now + 29.days - 1.minute, '28 days, 23 hours, and 59 minutes'],
+      [Time.zone.now, Time.zone.now + 30.days - 1.minute, '29 days, 23 hours, and 59 minutes'],
+      [Time.zone.now, Time.zone.now + 31.days - 1.minute, '30 days, 23 hours, and 59 minutes'],
+      [Time.zone.now, Time.zone.now + 32.days - 1.minute, '31 days, 23 hours, and 59 minutes'],
+      [Time.zone.now, Time.zone.now + 33.days - 1.minute, '32 days, 23 hours, and 59 minutes']
+    ].each do |start, finish, output|
+      it "should be #{output}" do
+        expect(distance_of_time_in_words(start, finish, accumulate_on: 'days')).to eq(output)
+      end
+    end
+
+    [
+      [Time.at(1), Time.at(100), '1 minute'],
+      [DateTime.now, DateTime.now + 1.minute, '1 minute'],
+      [Date.new(2000, 1, 2), Date.new(2000, 1, 3), '1 day'],
+      [Time.at(DateTime.now), DateTime.now + 1.minute, '1 minute']
+    ].each do |start, finish, output|
+      it "should be #{output}" do
+        expect(distance_of_time_in_words(start, finish)).to eq(output)
       end
     end
 
-    describe "accumulate on" do
-      fragments = [
+    describe 'accumulate on' do
+      [
         [START_TIME,
          START_TIME + 10.minute,
          :seconds,
-         "600 seconds"],
+         '600 seconds'],
         [START_TIME,
          START_TIME + 10.hour + 10.minute + 1.second,
          :minutes,
-         "610 minutes and 1 second"],
+         '610 minutes and 1 second'],
         [START_TIME,
-         START_TIME + 2.day + 10000.hour + 10.second,
+         START_TIME + 2.day + 10_000.hour + 10.second,
          :hours,
-         "10048 hours and 10 seconds"],
+         '10048 hours and 10 seconds'],
         [START_TIME,
-         START_TIME + 2.day + 10000.hour + 10.second,
+         START_TIME + 2.day + 10_000.hour + 10.second,
          :days,
-         "418 days, 16 hours, and 10 seconds"],
+         '418 days, 16 hours, and 10 seconds'],
+        [START_TIME,
+         START_TIME + 2.day + 10_000.hour + 10.second,
+         :weeks,
+         '59 weeks, 5 days, 16 hours, and 10 seconds'],
         [START_TIME,
-         START_TIME + 2.day + 10000.hour + 10.second,
+         START_TIME + 2.day + 10_000.hour + 10.second,
          :months,
-         "13 months, 22 days, 16 hours, and 10 seconds"],
-        ["2015-1-15".to_time, "2016-3-15".to_time, :months, "14 months"]
-
-      ]
-      fragments.each do |start, finish, accumulator, output|
+         '13 months, 3 weeks, 1 day, 16 hours, and 10 seconds'],
+        ['2015-1-15'.to_time, '2016-3-15'.to_time, :months, '14 months']
+      ].each do |start, finish, accumulator, output|
         it "should be #{output}" do
-          expect(distance_of_time_in_words(start, finish, true, :accumulate_on => accumulator)).to eq(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
+    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|
+      [
+        [5.minutes.to_i, '5 minutes'],
+        [10.minutes.to_i, '10 minutes'],
+        [1.hour.to_i, '1 hour'],
+        [6.days.to_i, '6 days'],
+        [4.weeks.to_i, '4 weeks'],
+        [24.weeks.to_i, '5 months, 2 weeks, and 1 day']
+      ].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 = [
+  describe 'with output options' do
+    [
       # Any numeric sequence is merely coincidental.
       [START_TIME,
-       START_TIME + 1.year + 2.months + 3.days + 4.hours + 5.minutes + 6.seconds,
-       { :words_connector => " - " },
-       "1 year - 2 months - 3 days - 4 hours - 5 minutes, and 6 seconds"],
+       START_TIME + 1.year + 2.months + 3.weeks + 4.days + 5.hours + 6.minutes + 7.seconds,
+       { words_connector: ' - ' },
+       '1 year - 2 months - 3 weeks - 4 days - 5 hours - 6 minutes, and 7 seconds'],
       [START_TIME,
        START_TIME + 5.minutes + 6.seconds,
-       { :two_words_connector => " - " },
-       "5 minutes - 6 seconds"],
+       { two_words_connector: ' - ' },
+       '5 minutes - 6 seconds'],
       [START_TIME,
-       START_TIME + 4.hours +  5.minutes + 6.seconds,
-       { :last_word_connector => " - " },
-       "4 hours, 5 minutes - 6 seconds"],
+       START_TIME + 4.hours + 5.minutes + 6.seconds,
+       { last_word_connector: ' - ' },
+       '4 hours, 5 minutes - 6 seconds'],
       [START_TIME,
        START_TIME + 1.year + 2.months + 3.days + 4.hours + 5.minutes + 6.seconds,
-       { :except => "minutes" },
-       "1 year, 2 months, 3 days, 4 hours, and 6 seconds"],
+       { except: 'minutes' },
+       '1 year, 2 months, 3 days, 4 hours, and 6 seconds'],
       [START_TIME,
        START_TIME + 1.hour + 1.minute,
-       { :except => "minutes"}, "1 hour"],
+       { except: 'minutes' }, '1 hour'],
       [START_TIME,
        START_TIME + 1.hour + 1.day + 1.minute,
-       { :except => ["minutes", "hours"]},
-       "1 day"],
+       { except: %w[minutes hours] },
+       '1 day'],
       [START_TIME,
        START_TIME + 1.hour + 1.day + 1.minute,
-       { :only => ["minutes", "hours"]},
-       "1 hour and 1 minute"],
+       { only: %w[minutes hours] },
+       '1 hour and 1 minute'],
       [START_TIME,
-       START_TIME + 1.year + 2.months + 3.days + 4.hours + 5.minutes + 6.seconds,
-       { :vague => true },
-       "about 1 year"],
+       START_TIME + 1.year + 2.months + 3.weeks + 4.days + 5.hours + 6.minutes + 7.seconds,
+       { except: 'minutes' },
+       '1 year, 2 months, 3 weeks, 4 days, 5 hours, and 7 seconds'],
       [START_TIME,
-       START_TIME + 1.year + 2.months + 3.days + 4.hours + 5.minutes + 6.seconds,
-       { :vague => "Yes please" },
-       "about 1 year"],
-      [START_TIME,
-       START_TIME + 1.year + 2.months + 3.days + 4.hours + 5.minutes + 6.seconds,
-       { :vague => false },
-       "1 year, 2 months, 3 days, 4 hours, 5 minutes, and 6 seconds"],
-      [START_TIME,
-       START_TIME + 1.year + 2.months + 3.days + 4.hours + 5.minutes + 6.seconds,
-       { :vague => nil },
-       "1 year, 2 months, 3 days, 4 hours, 5 minutes, and 6 seconds"],
-      [START_TIME,
-       START_TIME + 1.year + 2.months + 3.days + 4.hours + 5.minutes + 6.seconds,
-       { :except => "minutes" },
-       "1 year, 2 months, 3 days, 4 hours, and 6 seconds"],
-      [START_TIME,
-        START_TIME + 1.hour + 2.minutes + 3.seconds,
-        { :highest_measure_only => true },
-        "1 hour"],
+       START_TIME + 1.hour + 2.minutes + 3.seconds,
+       { highest_measure_only: true },
+       '1 hour'],
       [START_TIME,
        START_TIME + 1.hours + 2.minutes + 3.seconds,
-       { :highest_measures => 1 },
-       "1 hour"],
+       { highest_measures: 1 },
+       '1 hour'],
       [START_TIME,
        START_TIME + 2.year + 3.months + 4.days + 5.hours + 6.minutes + 7.seconds,
-       { :highest_measures => 3 },
-       "2 years, 3 months, and 4 days"],
+       { highest_measures: 3 },
+       '2 years, 3 months, and 4 days'],
       [START_TIME,
        START_TIME + 2.year + 3.weeks + 4.days + 5.hours + 6.minutes + 7.seconds,
-       { :highest_measures => 2 },
-       "2 years and 25 days"],
+       { highest_measures: 2 },
+       '2 years and 3 weeks'],
       [START_TIME,
        START_TIME + 4.days + 6.minutes + 7.seconds,
-       { :highest_measures => 3 },
-       "4 days, 6 minutes, and 7 seconds"],
+       { highest_measures: 3 },
+       '4 days, 6 minutes, and 7 seconds'],
       [START_TIME,
        START_TIME + 1.year + 2.weeks,
-       { :highest_measures => 3 },
-       "1 year and 14 days"],
+       { highest_measures: 3 },
+       '1 year and 2 weeks'],
       [START_TIME,
        START_TIME + 1.days,
-       { :only => [:years, :months] },
-       "less than 1 month"],
+       { only: %i[years months] },
+       'less than 1 month'],
       [START_TIME,
        START_TIME + 5.minutes,
-       { :except => [:hours, :minutes, :seconds] },
-       "less than 1 day"],
+       { except: %i[hours minutes seconds] },
+       'less than 1 day'],
       [START_TIME,
        START_TIME + 1.days,
-       { :highest_measures => 1, :only => [:years, :months] },
-       "less than 1 month"]
-    ]
-    fragments.each do |start, finish, options, output|
+       { highest_measures: 1, only: %i[years months] },
+       'less than 1 month']
+    ].each do |start, finish, options, output|
       it "should be #{output}" do
         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
-        expect(distance_of_time_in_words(START_TIME, START_TIME + 1.second, false)).to eq("1 second")
+    if defined?(ActionView)
+      describe 'ActionView' do
+        [
+          [START_TIME,
+           START_TIME + 1.year + 2.months + 3.weeks + 4.days + 5.hours + 6.minutes + 7.seconds,
+           { vague: true },
+           'about 1 year'],
+          [START_TIME,
+           START_TIME + 1.year + 2.months + 3.weeks + 4.days + 5.hours + 6.minutes + 7.seconds,
+           { vague: 'Yes please' },
+           'about 1 year'],
+          [START_TIME,
+           START_TIME + 1.year + 2.months + 3.weeks + 4.days + 5.hours + 6.minutes + 7.seconds,
+           { vague: false },
+           '1 year, 2 months, 3 weeks, 4 days, 5 hours, 6 minutes, and 7 seconds'],
+          [START_TIME,
+           START_TIME + 1.year + 2.months + 3.weeks + 4.days + 5.hours + 6.minutes + 7.seconds,
+           { vague: nil },
+           '1 year, 2 months, 3 weeks, 4 days, 5 hours, 6 minutes, and 7 seconds']
+        ].each do |start, finish, options, output|
+          it "should be #{output}" do
+            expect(distance_of_time_in_words(start, finish, true, options)).to eq(output)
+          end
+        end
       end
+    end
 
-      it "removes seconds in all other cases" do
+    describe 'include_seconds' do
+      it 'is ignored if only seconds have passed' do
+        expect(distance_of_time_in_words(START_TIME, START_TIME + 1.second, false)).to eq('1 second')
+      end
+
+      it 'removes seconds in all other cases' do
         expect(distance_of_time_in_words(START_TIME,
-                                  START_TIME + 1.year + 2.months + 3.days + 4.hours + 5.minutes + 6.seconds,
-                                  false)).to eq("1 year, 2 months, 3 days, 4 hours, and 5 minutes")
+                                         START_TIME + 1.year + 2.months + 3.weeks + 4.days + 5.hours + 6.minutes + 7.seconds,
+                                         false)).to eq('1 year, 2 months, 3 weeks, 4 days, 5 hours, and 6 minutes')
       end
     end # include_seconds
   end
 
-  describe "percentage of time" do
-    def time_in_percent(options = {})
-      distance_of_time_in_percent("04-12-2009".to_time, "29-01-2010".to_time, "04-12-2010".to_time, options)
-    end
+  if defined?(ActionView)
+    describe 'percentage of time' do
+      def time_in_percent(options = {})
+        distance_of_time_in_percent('04-12-2009'.to_time, '29-01-2010'.to_time, '04-12-2010'.to_time, options)
+      end
 
-    it "calculates 15%" do
-      expect(time_in_percent).to eq("15%")
-    end
+      it 'calculates 15%' do
+        expect(time_in_percent).to eq('15%')
+      end
 
-    it "calculates 15.3%" do
-      expect(time_in_percent(:precision => 1)).to eq("15.3%")
+      it 'calculates 15.3%' do
+        expect(time_in_percent(precision: 1)).to eq('15.3%')
+      end
     end
   end
-
 end