dotiw 5.5.0 → 5.6.1

data/lib/dotiw/time_hash.rb

@@ -11,17 +11,9 @@ module DOTIW
       @options    = options.dup
       @distance   = distance
       @from_time  = from_time || Time.current
-      @to_time    = to_time   || (@to_time_not_given = true && @from_time + distance.seconds)
+      @to_time    = to_time || (@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 smallest.dst? && !largest.dst?
-        d += 1.hour if !smallest.dst? && largest.dst?
-        d
-      end
+      @distance ||= largest - smallest
 
       build_time_hash
     end
@@ -40,8 +32,64 @@ module DOTIW
     ONE_WEEK = 7.days.freeze
     FOUR_WEEKS = 28.days.freeze
 
+    # The distance between two Time objects computed via subtraction already
+    # reflects any change in UTC offset between them (whether from a DST
+    # transition or a permanent tzdata rule change, e.g. Pacific/Norfolk's
+    # 2015 UTC offset change), which is what we want when reporting a raw
+    # elapsed duration - this is why we never touch the top-level @distance
+    # used to pick which build_* branch to use. However, once we've split
+    # that distance into calendar fields (years/months/weeks/days, #153),
+    # we want the offset difference folded out of the *sub-day leftover*
+    # only, so it reflects actual elapsed wall-clock time rather than an
+    # artifact of an offset shift, without risking flipping the sign of the
+    # much larger top-level distance the way applying this correction
+    # globally used to (#165).
+    #
+    # This only makes sense when both times are the same clock (the same
+    # location/zone before and after a transition). If they're simply
+    # expressed with different, unrelated UTC offsets (e.g. one in UTC and
+    # one with an explicit "-08:00" offset), any difference between their
+    # offsets is an artifact of how each was represented, not a transition,
+    # and folding it in would double count what subtraction already got
+    # right (#160).
+    def offset_delta(smallest, largest)
+      return 0 unless same_clock?(smallest, largest)
+
+      largest.utc_offset - smallest.utc_offset
+    end
+
+    # Whether smallest and largest are readings of the same underlying
+    # clock, as opposed to two independently fixed offsets that simply
+    # happen to differ (e.g. one in UTC, one with an explicit "-08:00").
+    # Only in the former case does a UTC offset difference represent a
+    # real transition (DST, or a historical tzdata rule change) rather
+    # than an artifact of how each time happens to be represented.
+    #
+    # An ActiveSupport::TimeWithZone carries its zone explicitly, so two
+    # of them share a clock when their +time_zone+ matches. A plain Ruby
+    # Time normally reports its zone as a String abbreviation (e.g. "PST")
+    # or +nil+ (fixed numeric offset, which can never transition, so two
+    # such times can't share a clock). Depending on the Ruby/ActiveSupport
+    # version, however, converting an ActiveSupport::TimeWithZone via
+    # +#to_time+ can instead produce a plain Time whose +#zone+ is the
+    # ActiveSupport::TimeZone object itself (#162) - in that case we
+    # compare the zone objects directly rather than assuming any two
+    # non-String zones both refer to the process's system zone.
+    def same_clock?(smallest, largest)
+      if smallest.respond_to?(:time_zone) || largest.respond_to?(:time_zone)
+        smallest.respond_to?(:time_zone) && largest.respond_to?(:time_zone) &&
+          smallest.time_zone == largest.time_zone
+      elsif !smallest.zone.is_a?(String) || !largest.zone.is_a?(String)
+        !smallest.zone.nil? && smallest.zone == largest.zone
+      else
+        !smallest.zone.nil? && !smallest.utc? && !largest.zone.nil? && !largest.utc?
+      end
+    end
+
     def build_time_hash
-      if accumulate_on = options[:accumulate_on]
+      if (max_unit = options[:max_unit])
+        build_max_unit(max_unit.to_sym)
+      elsif accumulate_on = options[:accumulate_on]
         accumulate_on = accumulate_on.to_sym
         TIME_FRACTIONS.index(accumulate_on).downto(0) { |i| send("build_#{TIME_FRACTIONS[i]}") }
       else
@@ -86,6 +134,44 @@ module DOTIW
       output[:weeks], @distance = distance.divmod(ONE_WEEK.to_i) unless output[:weeks]
     end
 
+    # Expresses the entire distance as a single number in the given unit, discarding
+    # (flooring) any remainder smaller than that unit, unlike +accumulate_on+ which keeps
+    # showing the smaller units below the target.
+    def build_max_unit(unit)
+      case unit
+      when :seconds
+        output[:seconds] = distance.to_i
+      when :minutes
+        output[:minutes] = (distance / ONE_MINUTE).floor
+      when :hours
+        output[:hours] = (distance / ONE_HOUR).floor
+      when :days
+        output[:days] = (distance / ONE_DAY).floor
+      when :weeks
+        output[:weeks] = (distance / ONE_WEEK).floor
+      when :months
+        output[:months] = whole_months_between(smallest, largest)
+      when :years
+        output[:years] = whole_years_between(smallest, largest)
+      else
+        raise ArgumentError, "unrecognized max_unit #{unit.inspect}"
+      end
+
+      @distance = 0
+    end
+
+    def whole_months_between(from, to)
+      months = (to.year - from.year) * 12 + (to.month - from.month)
+      months -= 1 if to.advance(months: -months) < from
+      months
+    end
+
+    def whole_years_between(from, to)
+      years = to.year - from.year
+      years -= 1 if to.advance(years: -years) < from
+      years
+    end
+
     def build_months
       build_years_months_weeks_days
 
@@ -145,9 +231,28 @@ module DOTIW
       output[:weeks]   = weeks
       output[:days]    = days
 
-      total_days, @distance = distance.abs.divmod(ONE_DAY.to_i)
-
-      [total_days, @distance]
+      # total_days is discarded: years/months/weeks/days above are derived
+      # from calendar components (largest/smallest year/month/day), an
+      # entirely separate calculation from @distance. All we need from here
+      # on is the leftover below the day boundary, which is just @distance
+      # mod one day - decoupled like this (rather than reconstructed by
+      # advancing smallest by years/months/weeks/days and diffing against
+      # largest) so a calendar edge case where that reconstruction doesn't
+      # land exactly on largest (e.g. Jan 31 -> Mar 2) can never leave a
+      # leftover large enough to loop back into this same branch forever.
+      # We do fold in any UTC offset change between smallest and largest
+      # (#153) exactly once - guarded, since build_years and build_months
+      # both call this method unconditionally, and accumulate_on: :years
+      # ends up invoking it twice (once via build_years, once via
+      # build_months) - but only here, not in the top-level @distance used
+      # to pick which build_* branch to use in the first place, so a real
+      # elapsed time much smaller than the offset change (#165) still gets
+      # bucketed correctly.
+      unless @offset_applied
+        @offset_applied = true
+        @distance = distance.abs + offset_delta(smallest, largest)
+      end
+      _total_days, @distance = distance.abs.divmod(ONE_DAY.to_i)
     end
   end
 end

data/lib/dotiw/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DOTIW
-  VERSION = '5.5.0'
+  VERSION = '5.6.1'
 end

data/lib/dotiw.rb

@@ -1,45 +1,6 @@
 # frozen_string_literal: true
 
-require 'i18n'
-require 'logger'
-require 'active_support'
-require 'active_support/core_ext'
-
-module DOTIW
-  extend ActiveSupport::Autoload
-
-  eager_autoload do
-    autoload :VERSION, 'dotiw/version'
-    autoload :TimeHash, 'dotiw/time_hash'
-    autoload :Methods, 'dotiw/methods'
-  end
-
-  extend self
-
-  DEFAULT_I18N_SCOPE = :'datetime.dotiw'
-  DEFAULT_I18N_SCOPE_COMPACT = :'datetime.dotiw_compact'
-
-  def init_i18n!
-    I18n.load_path.unshift(*locale_files)
-    I18n.reload!
-  end
-
-  def languages
-    @languages ||= (locale_files.map { |path| path.split(%r{[/.]})[-2].to_sym })
-  end
-
-  def locale_files
-    files 'dotiw/locale', '*.yml'
-  end
-
-  protected
-
-  def files(directory, ext)
-    Dir[File.join File.dirname(__FILE__), directory, ext]
-  end
-end
-
-DOTIW.init_i18n!
+require_relative 'dotiw/core'
 
 begin
   require 'action_view'

data/spec/lib/dotiw_module_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DOTIW do
+  START_TIME_MODULE = '01-08-2009'.to_time(:utc)
+
+  before do
+    I18n.locale = :en
+  end
+
+  describe '.distance_of_time_in_words' do
+    it 'returns the exact distance' do
+      expect(
+        described_class.distance_of_time_in_words(START_TIME_MODULE, START_TIME_MODULE + 1.hour + 30.minutes)
+      ).to eq('1 hour and 30 minutes')
+    end
+
+    it 'accepts options' do
+      expect(
+        described_class.distance_of_time_in_words(
+          START_TIME_MODULE, START_TIME_MODULE + 1.hour + 30.minutes, highest_measures: 1
+        )
+      ).to eq('1 hour')
+    end
+  end
+
+  describe '.time_ago_in_words' do
+    it 'returns the distance to now' do
+      allow(Time).to receive(:now).and_return(START_TIME_MODULE)
+      allow(Time.zone).to receive(:now).and_return(START_TIME_MODULE)
+
+      expect(
+        described_class.time_ago_in_words(START_TIME_MODULE - 90, include_seconds: true)
+      ).to eq('1 minute and 30 seconds')
+    end
+  end
+
+  describe '.distance_of_time' do
+    it 'returns the distance for a number of seconds' do
+      expect(described_class.distance_of_time(90)).to eq('1 minute and 30 seconds')
+    end
+  end
+
+  describe '.distance_of_time_in_words_hash' do
+    it 'returns the distance as a hash' do
+      expect(
+        described_class.distance_of_time_in_words_hash(START_TIME_MODULE, START_TIME_MODULE + 1.hour + 30.minutes)
+      ).to include(hours: 1, minutes: 30)
+    end
+  end
+end

data/spec/lib/dotiw_spec.rb

@@ -17,7 +17,11 @@ describe 'A better distance_of_time_in_words' do
 
   before do
     I18n.locale = :en
-    ActiveSupport.to_time_preserves_timezone = :zone
+    # This config is deprecated as of Rails 8.1 (it becomes the permanent,
+    # non-configurable behavior) and is removed entirely in Rails 8.2.
+    if Gem::Version.new(ActiveSupport::VERSION::STRING) < Gem::Version.new('8.1')
+      ActiveSupport.to_time_preserves_timezone = :zone
+    end
 
     allow(Time).to receive(:now).and_return(START_TIME)
     allow(Time.zone).to receive(:now).and_return(START_TIME)
@@ -193,6 +197,167 @@ describe 'A better distance_of_time_in_words' do
       end
     end
 
+    context 'in timezones with an inverted DST scheme (#63)' do
+      # Real, non-mocked reproduction from #63: running the suite under
+      # certain timezones (e.g. Europe/Dublin, where IST is "standard" time
+      # and GMT is technically the DST offset) previously failed because
+      # Time#dst? disagreed between a Time built via Time.at(datetime) and
+      # one built via datetime.to_time for the exact same instant, even
+      # though their utc_offset was identical. This caused a spurious +/-1
+      # hour "DST correction" to be applied.
+      around do |example|
+        original_tz = ENV.fetch('TZ', nil)
+        ENV['TZ'] = tz
+        example.run
+        ENV['TZ'] = original_tz
+      end
+
+      %w[
+        Europe/Dublin
+        Africa/Casablanca
+        Asia/Tehran
+        Europe/Moscow
+        Asia/Gaza
+      ].each do |timezone|
+        context "TZ=#{timezone}" do
+          let(:tz) { timezone }
+
+          it 'is 1 minute' do
+            start = Time.at(DateTime.now)
+            finish = DateTime.now + 1.minute
+
+            expect(distance_of_time_in_words(start, finish)).to eq('1 minute')
+          end
+        end
+      end
+    end
+
+    context 'across a historical UTC offset change (#153)' do
+      # Real, non-mocked reproduction from #153: Pacific/Norfolk permanently
+      # changed its UTC offset from +11:30 to +11:00 on 2015-10-04 (a
+      # tzdata rule change, not a recurring DST transition - both endpoints
+      # report dst? == false). The calendar distance (years/months/weeks/
+      # days) was correct, but the leftover hours/minutes leaked the 30
+      # minute offset difference as a spurious "23 hours and 30 minutes".
+      around do |example|
+        original_tz = ENV.fetch('TZ', nil)
+        ENV['TZ'] = 'Pacific/Norfolk'
+        example.run
+        ENV['TZ'] = original_tz
+      end
+
+      it 'is 1 year and 2 months, not 1 year, 2 months, 23 hours, and 30 minutes' do
+        start = '2015-1-15'.to_time
+        finish = '2016-3-15'.to_time
+
+        expect(distance_of_time_in_words(start, finish, true)).to eq('1 year and 2 months')
+      end
+    end
+
+    context 'with different UTC offsets that are not the same clock (#160)' do
+      # Real, non-mocked reproduction from #160: comparing two timestamps
+      # expressed with different, unrelated UTC offsets (not the same
+      # location before/after a real transition) incorrectly folded the
+      # full offset difference between them into the reported distance.
+      # Neither endpoint here crosses any DST or historical offset
+      # transition; only their representation differs.
+      it 'is 1 hour, not 9 hours' do
+        from = Time.new(2026, 1, 15, 11, 0, 0, '-08:00')
+        to = Time.utc(2026, 1, 15, 20)
+
+        expect(to - from).to eq(3600.0)
+        expect(distance_of_time_in_words(from, to)).to eq('1 hour')
+      end
+
+      it 'is still 1 hour when both timestamps are in UTC' do
+        from = Time.new(2026, 1, 15, 11, 0, 0, '-08:00').getutc
+        to = Time.utc(2026, 1, 15, 20)
+
+        expect(distance_of_time_in_words(from, to)).to eq('1 hour')
+      end
+    end
+
+    context 'with Time values using different zone objects (#162)' do
+      # #to_time on an ActiveSupport::TimeWithZone (with to_time_preserves_timezone
+      # set, the default since Rails 7.1) returns a plain Time whose #zone is the
+      # ActiveSupport::TimeZone object itself, not a String abbreviation. Building
+      # these directly via TimeZone#local/#to_time, rather than Ruby's Time.new(in:)
+      # keyword (only available on Ruby 3.2+), reproduces the same shape of object
+      # portably across the whole supported Ruby/Rails matrix.
+      it 'treats different TimeZone-object zones as different clocks, without folding in any offset' do
+        tokyo_time = ActiveSupport::TimeZone['Asia/Tokyo'].local(2026, 1, 16, 4, 0, 0).to_time
+        la_time = ActiveSupport::TimeZone['America/Los_Angeles'].local(2026, 1, 15, 12, 0, 0).to_time
+
+        expect(la_time - tokyo_time).to eq(3600.0)
+        expect(distance_of_time_in_words(tokyo_time, la_time)).to eq('1 hour')
+      end
+
+      # Same TimeZone-object shape as above, but far enough apart to be split
+      # into calendar fields (years/months/weeks/days, #153/#165), which is
+      # the only place same_clock? is invoked (see #165). Tokyo and LA are
+      # unrelated zones (not the same clock before/after a transition), so
+      # this exercises same_clock?'s "not a String zone" comparison finding
+      # the two TimeZone objects unequal, exactly like the #160 case does
+      # for String zones.
+      it 'treats TimeZone-object zones far enough apart to span calendar fields as different clocks' do
+        tokyo_time = ActiveSupport::TimeZone['Asia/Tokyo'].local(2025, 1, 16, 4, 0, 0).to_time
+        la_time = ActiveSupport::TimeZone['America/Los_Angeles'].local(2026, 3, 15, 12, 0, 0).to_time
+
+        expect(distance_of_time_in_words(tokyo_time, la_time, true)).to eq('1 year, 1 month, 3 weeks, and 6 days')
+      end
+    end
+
+    context 'with explicit named zones' do
+      # https://github.com/moment/luxon/blob/3.7.2/test/datetime/diff.test.js#L317-L330
+      it 'preserves the elapsed time between UTC and CEST' do
+        from = Time.utc(2022, 5, 5, 23, 0, 0)
+        to = Time.new(2022, 5, 10, 0, 0, 0, '+02:00')
+
+        expect(to - from).to eq(3.days + 23.hours)
+        expect(distance_of_time_in_words(from, to, true)).to eq('3 days and 23 hours')
+      end
+
+      # https://github.com/bitwalker/timex/blob/3.7.11/test/format_duration_humanized_test.exs
+      it 'preserves one minute across the Europe/Dublin DST fall-back (#165)' do
+        # Passing an ActiveSupport::TimeWithZone straight through (rather than
+        # calling #to_time on it, as in the #162 example above) exercises the
+        # same_clock? branch that compares #time_zone directly. Prior to the
+        # #165 fix, dotiw unconditionally called #to_time on any TimeWithZone
+        # argument, which discarded the real zone entirely on Rails < 8.0 (see
+        # DOTIW::Methods#coerce_to_time, #170) - so this was only reproducible
+        # on Rails >= 8.0, and passed for the wrong reason everywhere else. Now
+        # that #coerce_to_time no longer makes that unforced conversion, and
+        # offset_delta is only ever applied to the sub-day leftover rather
+        # than the top-level distance, this passes for the right reason on
+        # every supported Rails version.
+        dublin = ActiveSupport::TimeZone['Europe/Dublin']
+        from = Time.utc(2024, 10, 27, 0, 59, 30).in_time_zone(dublin)
+        to = from + 1.minute
+
+        expect(from.utc_offset).to eq(1.hour)
+        expect(to.utc_offset).to eq(0)
+        expect(to - from).to eq(1.minute)
+        expect(distance_of_time_in_words(from, to)).to eq('1 minute')
+      end
+
+      # https://github.com/dblock/tz_test/blob/master/ruby/test.rb
+      it 'folds the Pacific/Norfolk historical offset change into the calendar distance' do
+        # As with the Dublin example above, from/to are passed through as
+        # ActiveSupport::TimeWithZone rather than being converted with
+        # #to_time, so their real zone is preserved on every Rails version
+        # (see DOTIW::Methods#coerce_to_time, #170) and same_clock? can
+        # correctly recognize this as the same clock across Pacific/Norfolk's
+        # 2015 historical UTC offset change.
+        norfolk = ActiveSupport::TimeZone['Pacific/Norfolk']
+        from = norfolk.local(2015, 1, 15)
+        to = norfolk.local(2016, 3, 15)
+
+        expect(from.utc_offset).to eq(11.hours + 30.minutes)
+        expect(to.utc_offset).to eq(11.hours)
+        expect(distance_of_time_in_words(from, to, true)).to eq('1 year and 2 months')
+      end
+    end
+
     describe 'accumulate_on:' do
       [
         [START_TIME,
@@ -228,6 +393,55 @@ describe 'A better distance_of_time_in_words' do
       end
     end
 
+    describe 'max_unit:' do
+      [
+        [START_TIME,
+         START_TIME + 10.minute,
+         :seconds,
+         { seconds: 600 },
+         '600 seconds'],
+        [START_TIME,
+         START_TIME + 10.hour + 10.minute + 1.second,
+         :minutes,
+         { minutes: 610 },
+         '610 minutes'],
+        [START_TIME,
+         START_TIME + 2.day + 10_000.hour + 10.second,
+         :hours,
+         { hours: 10_048 },
+         '10048 hours'],
+        [START_TIME,
+         START_TIME + 2.day + 10_000.hour + 10.second,
+         :days,
+         { days: 418 },
+         '418 days'],
+        [START_TIME,
+         START_TIME + 2.day + 10_000.hour + 10.second,
+         :weeks,
+         { weeks: 59 },
+         '59 weeks'],
+        ['2015-1-15'.to_time, '2016-3-15'.to_time, :months, { months: 14 }, '14 months'],
+        ['2015-1-15'.to_time, '2016-3-15'.to_time, :years, { years: 1 }, '1 year']
+      ].each do |start, finish, unit, hash, output|
+        it "should be #{output}" do
+          expect(distance_of_time_in_words_hash(start, finish, max_unit: unit)).to eq(hash)
+          expect(distance_of_time_in_words(start, finish, true, max_unit: unit)).to eq(output)
+        end
+      end
+
+      it 'floors and discards any remainder smaller than the unit' do
+        expect(
+          distance_of_time_in_words_hash(START_TIME, START_TIME + 1.year - 1.day, max_unit: :years)
+        ).to eq(years: 0)
+      end
+
+      it 'raises for an unrecognized unit' do
+        expect do
+          distance_of_time_in_words_hash(START_TIME, START_TIME + 1.day, max_unit: :fortnights)
+        end.to raise_error(ArgumentError, /unrecognized max_unit/)
+      end
+    end
+
     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
@@ -297,22 +511,28 @@ describe 'A better distance_of_time_in_words' do
       [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'],
+       # 5 excluded minutes are folded into seconds (5 * 60 + 6 = 306) instead of being discarded.
+       '1 year, 2 months, 3 days, 4 hours, and 306 seconds'],
       [START_TIME,
        START_TIME + 1.hour + 1.minute,
-       { except: 'minutes' }, '1 hour'],
+       { except: 'minutes' },
+       # The excluded minute is folded into seconds (1 * 60 = 60) instead of being discarded.
+       '1 hour and 60 seconds'],
       [START_TIME,
        START_TIME + 1.hour + 1.day + 1.minute,
        { except: %w[minutes hours] },
-       '1 day'],
+       # The excluded hour and minute cascade down into seconds (1 * 24 * 60 * 60 + 1 * 60 = 3660).
+       '1 day and 3660 seconds'],
       [START_TIME,
        START_TIME + 1.hour + 1.day + 1.minute,
        { only: %w[minutes hours] },
-       '1 hour and 1 minute'],
+       # The excluded day is folded into hours (1 * 24 + 1 = 25) instead of being discarded.
+       '25 hours and 1 minute'],
       [START_TIME,
        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'],
+       # 6 excluded minutes are folded into seconds (6 * 60 + 7 = 367) instead of being discarded.
+       '1 year, 2 months, 3 weeks, 4 days, 5 hours, and 367 seconds'],
       [START_TIME,
        START_TIME + 1.hour + 2.minutes + 3.seconds,
        { highest_measure_only: true },
@@ -395,6 +615,34 @@ describe 'A better distance_of_time_in_words' do
       end.to raise_error(ArgumentError)
     end
 
+    describe 'folding excluded fractions into included ones (regression for #77 and #120)' do
+      it 'folds excluded weeks into days rather than discarding them' do
+        from = '2019-01-02'.to_time
+        to = '2020-12-28'.to_time
+        expect(distance_of_time_in_words(from, to, false, only: %i[years months days]))
+          .to eq('1 year, 11 months, and 26 days')
+      end
+
+      it 'folds excluded weeks into days when using except' do
+        from = '2019-01-02'.to_time
+        to = '2020-12-28'.to_time
+        expect(distance_of_time_in_words(from, to, false, except: :weeks))
+          .to eq('1 year, 11 months, and 26 days')
+      end
+
+      it 'folds an excluded month into days' do
+        expect(distance_of_time_in_words(START_TIME, START_TIME + 1.month + 9.days, false, only: %i[months days]))
+          .to eq('1 month and 9 days')
+      end
+
+      it 'converts a negative day count into a week when the day-of-month matches but the hour rolls back' do
+        from = Time.new(2024, 5, 1, 10, 0, 0)
+        to = Time.new(2024, 6, 1, 9, 0, 0)
+        expect(distance_of_time_in_words(from, to, false, only: %i[months weeks days]))
+          .to eq('4 weeks and 2 days')
+      end
+    end
+
     if defined?(ActionView)
       describe 'ActionView without include seconds argument' do
         [
@@ -440,13 +688,31 @@ describe 'A better distance_of_time_in_words' do
           [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']
+           '1 year, 2 months, 3 weeks, 4 days, 5 hours, 6 minutes, and 7 seconds'],
+          [START_TIME,
+           START_TIME + 1.year + 2.months,
+           { vague: true, locale: :en },
+           'about 1 year']
         ].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
 
+        # requires the rails-i18n gem for non-English datetime.distance_in_words translations, see #44
+        if defined?(RailsI18n)
+          it 'should be rundt 1 år for vague: true, locale: :nb' do
+            finish = START_TIME + 1.year + 2.months
+            expect(distance_of_time_in_words(START_TIME, finish, true, vague: true, locale: :nb)).to eq('rundt 1 år')
+          end
+        else
+          it 'returns a translation missing message for vague: true, locale: :nb without the rails-i18n gem' do
+            finish = START_TIME + 1.year + 2.months
+            expect(distance_of_time_in_words(START_TIME, finish, true, vague: true, locale: :nb))
+              .to eq('Translation missing: nb.datetime.distance_in_words.about_x_years')
+          end
+        end
+
         context 'via ActionController::Base.helpers' do
           it '#distance_of_time_in_words' do
             end_time = START_TIME + 1.year + 2.months + 3.weeks + 4.days + 5.hours + 6.minutes + 7.seconds

data/spec/spec_helper.rb

@@ -3,8 +3,27 @@
 ROOT_PATH = File.join(File.dirname(__FILE__), '..')
 $LOAD_PATH.unshift ROOT_PATH unless $LOAD_PATH.include? ROOT_PATH
 
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/spec/'
+end
+
+# Ruby 3.4 dropped concurrent-ruby's implicit require of logger, which older
+# Rails versions rely on being already loaded, see https://github.com/rails/rails/issues/54271.
+require 'logger'
+require 'bundler'
+Bundler.require
+
 require 'dotiw'
 
+# Loads Rails' own datetime.distance_in_words translations for non-English
+# locales, needed by the vague: true option, which falls back to Rails'
+# native distance_of_time_in_words instead of dotiw's own translations, see #44.
+# Only present when the rails-i18n gem is in the Gemfile (see gemfiles/rails_8.1_i18n.gemfile).
+if defined?(RailsI18n)
+  I18n.load_path += Dir[File.join(Gem.loaded_specs['rails-i18n'].gem_dir, 'rails', 'locale', '*.yml')]
+end
+
 Time.zone = 'UTC'
 
 I18n.locale = :en