activesupport 4.0.13 → 4.2.11.3

data/lib/active_support/core_ext/time/calculations.rb

@@ -3,7 +3,7 @@ require 'active_support/core_ext/time/conversions'
 require 'active_support/time_with_zone'
 require 'active_support/core_ext/time/zones'
 require 'active_support/core_ext/date_and_time/calculations'
-require 'active_support/deprecation'
+require 'active_support/core_ext/date/calculations'
 
 class Time
   include DateAndTime::Calculations
@@ -26,41 +26,6 @@ class Time
       end
     end
 
-    # *DEPRECATED*: Use +Time#utc+ or +Time#local+ instead.
-    #
-    # Returns a new Time if requested year can be accommodated by Ruby's Time class
-    # (i.e., if year is within either 1970..2038 or 1902..2038, depending on system architecture);
-    # otherwise returns a DateTime.
-    def time_with_datetime_fallback(utc_or_local, year, month=1, day=1, hour=0, min=0, sec=0, usec=0)
-      ActiveSupport::Deprecation.warn 'time_with_datetime_fallback is deprecated. Use Time#utc or Time#local instead', caller
-      time = ::Time.send(utc_or_local, year, month, day, hour, min, sec, usec)
-
-      # This check is needed because Time.utc(y) returns a time object in the 2000s for 0 <= y <= 138.
-      if time.year == year
-        time
-      else
-        ::DateTime.civil_from_format(utc_or_local, year, month, day, hour, min, sec)
-      end
-    rescue
-      ::DateTime.civil_from_format(utc_or_local, year, month, day, hour, min, sec)
-    end
-
-    # *DEPRECATED*: Use +Time#utc+ instead.
-    #
-    # Wraps class method +time_with_datetime_fallback+ with +utc_or_local+ set to <tt>:utc</tt>.
-    def utc_time(*args)
-      ActiveSupport::Deprecation.warn 'utc_time is deprecated. Use Time#utc instead', caller
-      time_with_datetime_fallback(:utc, *args)
-    end
-
-    # *DEPRECATED*: Use +Time#local+ instead.
-    #
-    # Wraps class method +time_with_datetime_fallback+ with +utc_or_local+ set to <tt>:local</tt>.
-    def local_time(*args)
-      ActiveSupport::Deprecation.warn 'local_time is deprecated. Use Time#local instead', caller
-      time_with_datetime_fallback(:local, *args)
-    end
-
     # Returns <tt>Time.zone.now</tt> when <tt>Time.zone</tt> or <tt>config.time_zone</tt> are set, otherwise just returns <tt>Time.now</tt>.
     def current
       ::Time.zone ? ::Time.zone.now : ::Time.now
@@ -98,13 +63,21 @@ class Time
     end_of_day.to_i - to_i
   end
 
+  # Returns the fraction of a second as a +Rational+
+  #
+  #   Time.new(2012, 8, 29, 0, 0, 0.5).sec_fraction # => (1/2)
+  def sec_fraction
+    subsec
+  end
+
   # Returns a new Time where one or more of the elements have been changed according
   # to the +options+ parameter. The time options (<tt>:hour</tt>, <tt>:min</tt>,
-  # <tt>:sec</tt>, <tt>:usec</tt>) reset cascadingly, so if only the hour is passed,
-  # then minute, sec, and usec is set to 0. If the hour and minute is passed, then
-  # sec and usec is set to 0.  The +options+ parameter takes a hash with any of these
-  # keys: <tt>:year</tt>, <tt>:month</tt>, <tt>:day</tt>, <tt>:hour</tt>, <tt>:min</tt>,
-  # <tt>:sec</tt>, <tt>:usec</tt>.
+  # <tt>:sec</tt>, <tt>:usec</tt>, <tt>:nsec</tt>) reset cascadingly, so if only
+  # the hour is passed, then minute, sec, usec and nsec is set to 0. If the hour
+  # and minute is passed, then sec, usec and nsec is set to 0. The +options+
+  # parameter takes a hash with any of these keys: <tt>:year</tt>, <tt>:month</tt>,
+  # <tt>:day</tt>, <tt>:hour</tt>, <tt>:min</tt>, <tt>:sec</tt>, <tt>:usec</tt>
+  # <tt>:nsec</tt>. Path either <tt>:usec</tt> or <tt>:nsec</tt>, not both.
   #
   #   Time.new(2012, 8, 29, 22, 35, 0).change(day: 1)              # => Time.new(2012, 8, 1, 22, 35, 0)
   #   Time.new(2012, 8, 29, 22, 35, 0).change(year: 1981, day: 1)  # => Time.new(1981, 8, 1, 22, 35, 0)
@@ -116,21 +89,35 @@ class Time
     new_hour  = options.fetch(:hour, hour)
     new_min   = options.fetch(:min, options[:hour] ? 0 : min)
     new_sec   = options.fetch(:sec, (options[:hour] || options[:min]) ? 0 : sec)
-    new_usec  = options.fetch(:usec, (options[:hour] || options[:min] || options[:sec]) ? 0 : Rational(nsec, 1000))
+
+    if new_nsec = options[:nsec]
+      raise ArgumentError, "Can't change both :nsec and :usec at the same time: #{options.inspect}" if options[:usec]
+      new_usec = Rational(new_nsec, 1000)
+    else
+      new_usec  = options.fetch(:usec, (options[:hour] || options[:min] || options[:sec]) ? 0 : Rational(nsec, 1000))
+    end
 
     if utc?
       ::Time.utc(new_year, new_month, new_day, new_hour, new_min, new_sec, new_usec)
     elsif zone
       ::Time.local(new_year, new_month, new_day, new_hour, new_min, new_sec, new_usec)
     else
+      raise ArgumentError, 'argument out of range' if new_usec >= 1000000
       ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec + (new_usec.to_r / 1000000), utc_offset)
     end
   end
 
-  # Uses Date to provide precise Time calculations for years, months, and days.
-  # The +options+ parameter takes a hash with any of these keys: <tt>:years</tt>,
-  # <tt>:months</tt>, <tt>:weeks</tt>, <tt>:days</tt>, <tt>:hours</tt>,
-  # <tt>:minutes</tt>, <tt>:seconds</tt>.
+  # Uses Date to provide precise Time calculations for years, months, and days
+  # according to the proleptic Gregorian calendar. The +options+ parameter
+  # takes a hash with any of these keys: <tt>:years</tt>, <tt>:months</tt>,
+  # <tt>:weeks</tt>, <tt>:days</tt>, <tt>:hours</tt>, <tt>:minutes</tt>,
+  # <tt>:seconds</tt>.
+  #
+  #   Time.new(2015, 8, 1, 14, 35, 0).advance(seconds: 1) # => 2015-08-01 14:35:01 -0700
+  #   Time.new(2015, 8, 1, 14, 35, 0).advance(minutes: 1) # => 2015-08-01 14:36:00 -0700
+  #   Time.new(2015, 8, 1, 14, 35, 0).advance(hours: 1)   # => 2015-08-01 15:35:00 -0700
+  #   Time.new(2015, 8, 1, 14, 35, 0).advance(days: 1)    # => 2015-08-02 14:35:00 -0700
+  #   Time.new(2015, 8, 1, 14, 35, 0).advance(weeks: 1)   # => 2015-08-08 14:35:00 -0700
   def advance(options)
     unless options[:weeks].nil?
       options[:weeks], partial_weeks = options[:weeks].divmod(1)
@@ -143,6 +130,7 @@ class Time
     end
 
     d = to_date.advance(options)
+    d = d.gregorian if d.julian?
     time_advanced_by_date = change(:year => d.year, :month => d.month, :day => d.day)
     seconds_to_advance = \
       options.fetch(:seconds, 0) +
@@ -178,6 +166,16 @@ class Time
   alias :at_midnight :beginning_of_day
   alias :at_beginning_of_day :beginning_of_day
 
+  # Returns a new Time representing the middle of the day (12:00)
+  def middle_of_day
+    change(:hour => 12)
+  end
+  alias :midday :middle_of_day
+  alias :noon :middle_of_day
+  alias :at_midday :middle_of_day
+  alias :at_noon :middle_of_day
+  alias :at_middle_of_day :middle_of_day
+
   # Returns a new Time representing the end of the day, 23:59:59.999999 (.999999999 in ruby1.9)
   def end_of_day
     change(
@@ -225,27 +223,6 @@ class Time
     beginning_of_day..end_of_day
   end
 
-  # Returns a Range representing the whole week of the current time.
-  # Week starts on start_day, default is <tt>Date.week_start</tt> or <tt>config.week_start</tt> when set.
-  def all_week(start_day = Date.beginning_of_week)
-    beginning_of_week(start_day)..end_of_week(start_day)
-  end
-
-  # Returns a Range representing the whole month of the current time.
-  def all_month
-    beginning_of_month..end_of_month
-  end
-
-  # Returns a Range representing the whole quarter of the current time.
-  def all_quarter
-    beginning_of_quarter..end_of_quarter
-  end
-
-  # Returns a Range representing the whole year of the current time.
-  def all_year
-    beginning_of_year..end_of_year
-  end
-
   def plus_with_duration(other) #:nodoc:
     if ActiveSupport::Duration === other
       other.since(self)
@@ -280,7 +257,9 @@ class Time
   # can be chronologically compared with a Time
   def compare_with_coercion(other)
     # we're avoiding Time#to_datetime cause it's expensive
-    if other.is_a?(Time)
+    if other.class == Time
+      compare_without_coercion(other)
+    elsif other.is_a?(Time)
       compare_without_coercion(other.to_time)
     else
       to_datetime <=> other

data/lib/active_support/core_ext/time/compatibility.rb

@@ -0,0 +1,14 @@
+require "active_support/core_ext/date_and_time/compatibility"
+require "active_support/core_ext/module/remove_method"
+
+class Time
+  include DateAndTime::Compatibility
+
+  remove_possible_method :to_time
+
+  # Either return +self+ or the time in the local system timezone depending
+  # on the setting of +ActiveSupport.to_time_preserves_timezone+.
+  def to_time
+    preserve_timezone ? self : getlocal
+  end
+end

data/lib/active_support/core_ext/time/conversions.rb

@@ -16,10 +16,11 @@ class Time
     :rfc822       => lambda { |time|
       offset_format = time.formatted_offset(false)
       time.strftime("%a, %d %b %Y %H:%M:%S #{offset_format}")
-    }
+    },
+    :iso8601      => lambda { |time| time.iso8601 }
   }
 
-  # Converts to a formatted string. See DATE_FORMATS for builtin formats.
+  # Converts to a formatted string. See DATE_FORMATS for built-in formats.
   #
   # This method is aliased to <tt>to_s</tt>.
   #
@@ -34,6 +35,7 @@ class Time
   #   time.to_formatted_s(:long)         # => "January 18, 2007 06:10"
   #   time.to_formatted_s(:long_ordinal) # => "January 18th, 2007 06:10"
   #   time.to_formatted_s(:rfc822)       # => "Thu, 18 Jan 2007 06:10:17 -0600"
+  #   time.to_formatted_s(:iso8601)      # => "2007-01-18T06:10:17-06:00"
   #
   # == Adding your own time formats to +to_formatted_s+
   # You can add your own formats to the Time::DATE_FORMATS hash.

data/lib/active_support/core_ext/time/zones.rb

@@ -1,7 +1,9 @@
 require 'active_support/time_with_zone'
 require 'active_support/core_ext/time/acts_like'
+require 'active_support/core_ext/date_and_time/zones'
 
 class Time
+  include DateAndTime::Zones
   class << self
     attr_accessor :zone_default
 
@@ -74,24 +76,4 @@ class Time
       find_zone!(time_zone) rescue nil
     end
   end
-
-  # Returns the simultaneous time in <tt>Time.zone</tt>.
-  #
-  #   Time.zone = 'Hawaii'        # => 'Hawaii'
-  #   Time.utc(2000).in_time_zone # => Fri, 31 Dec 1999 14:00:00 HST -10:00
-  #
-  # This method is similar to Time#localtime, except that it uses <tt>Time.zone</tt> as the local zone
-  # instead of the operating system's time zone.
-  #
-  # You can also pass in a TimeZone instance or string that identifies a TimeZone as an argument,
-  # and the conversion will be based on that zone instead of <tt>Time.zone</tt>.
-  #
-  #   Time.utc(2000).in_time_zone('Alaska') # => Fri, 31 Dec 1999 15:00:00 AKST -09:00
-  def in_time_zone(zone = ::Time.zone)
-    if zone
-      ActiveSupport::TimeWithZone.new(utc? ? self : getutc, ::Time.find_zone!(zone))
-    else
-      self
-    end
-  end
 end

data/lib/active_support/core_ext/time.rb

@@ -1,5 +1,6 @@
 require 'active_support/core_ext/time/acts_like'
 require 'active_support/core_ext/time/calculations'
+require 'active_support/core_ext/time/compatibility'
 require 'active_support/core_ext/time/conversions'
 require 'active_support/core_ext/time/marshal'
 require 'active_support/core_ext/time/zones'

data/lib/active_support/core_ext.rb

@@ -1,4 +1,3 @@
 Dir["#{File.dirname(__FILE__)}/core_ext/*.rb"].each do |path|
-  next if File.basename(path, '.rb') == 'logger'
   require path
 end

data/lib/active_support/dependencies/autoload.rb

@@ -67,7 +67,7 @@ module ActiveSupport
     end
 
     def eager_load!
-      @_autoloads.values.each { |file| require file }
+      @_autoloads.each_value { |file| require file }
     end
 
     def autoloads

data/lib/active_support/dependencies.rb

@@ -30,6 +30,10 @@ module ActiveSupport #:nodoc:
     mattr_accessor :loaded
     self.loaded = Set.new
 
+    # Stack of files being loaded.
+    mattr_accessor :loading
+    self.loading = []
+
     # Should we load files or require them?
     mattr_accessor :mechanism
     self.mechanism = ENV['NO_RELOAD'] ? :require : :load
@@ -176,14 +180,23 @@ module ActiveSupport #:nodoc:
       end
 
       def const_missing(const_name)
-        # The interpreter does not pass nesting information, and in the
-        # case of anonymous modules we cannot even make the trade-off of
-        # assuming their name reflects the nesting. Resort to Object as
-        # the only meaningful guess we can make.
-        from_mod = anonymous? ? ::Object : self
+        from_mod = anonymous? ? guess_for_anonymous(const_name) : self
         Dependencies.load_missing_constant(from_mod, const_name)
       end
 
+      # We assume that the name of the module reflects the nesting
+      # (unless it can be proven that is not the case) and the path to the file
+      # that defines the constant. Anonymous modules cannot follow these
+      # conventions and therefore we assume that the user wants to refer to a
+      # top-level constant.
+      def guess_for_anonymous(const_name)
+        if Object.const_defined?(const_name)
+          raise NameError.new "#{const_name} cannot be autoloaded from an anonymous class or module", const_name
+        else
+          Object
+        end
+      end
+
       def unloadable(const_desc = self)
         super(const_desc)
       end
@@ -192,16 +205,29 @@ module ActiveSupport #:nodoc:
     # Object includes this module.
     module Loadable #:nodoc:
       def self.exclude_from(base)
-        base.class_eval { define_method(:load, Kernel.instance_method(:load)) }
+        base.class_eval do
+          define_method(:load, Kernel.instance_method(:load))
+          private :load
+        end
       end
 
       def require_or_load(file_name)
         Dependencies.require_or_load(file_name)
       end
 
+      # Interprets a file using <tt>mechanism</tt> and marks its defined
+      # constants as autoloaded. <tt>file_name</tt> can be either a string or
+      # respond to <tt>to_path</tt>.
+      #
+      # Use this method in code that absolutely needs a certain constant to be
+      # defined at that point. A typical use case is to make constant name
+      # resolution deterministic for constants with the same relative name in
+      # different namespaces whose evaluation would depend on load order
+      # otherwise.
       def require_dependency(file_name, message = "No such file to load -- %s")
+        file_name = file_name.to_path if file_name.respond_to?(:to_path)
         unless file_name.is_a?(String)
-          raise ArgumentError, "the file name must be a String -- you passed #{file_name.inspect}"
+          raise ArgumentError, "the file name must either be a String or implement #to_path -- you passed #{file_name.inspect}"
         end
 
         Dependencies.depend_on(file_name, message)
@@ -218,18 +244,6 @@ module ActiveSupport #:nodoc:
         raise
       end
 
-      def load(file, wrap = false)
-        result = false
-        load_dependency(file) { result = super }
-        result
-      end
-
-      def require(file)
-        result = false
-        load_dependency(file) { result = super }
-        result
-      end
-
       # Mark the given constant as unloadable. Unloadable constants are removed
       # each time dependencies are cleared.
       #
@@ -246,6 +260,20 @@ module ActiveSupport #:nodoc:
       def unloadable(const_desc)
         Dependencies.mark_for_unload const_desc
       end
+
+      private
+
+      def load(file, wrap = false)
+        result = false
+        load_dependency(file) { result = super }
+        result
+      end
+
+      def require(file)
+        result = false
+        load_dependency(file) { result = super }
+        result
+      end
     end
 
     # Exception file-blaming.
@@ -298,6 +326,7 @@ module ActiveSupport #:nodoc:
     def clear
       log_call
       loaded.clear
+      loading.clear
       remove_unloadable_constants!
     end
 
@@ -310,6 +339,7 @@ module ActiveSupport #:nodoc:
       # Record that we've seen this file *before* loading it to avoid an
       # infinite loop with mutual dependencies.
       loaded << expanded
+      loading << expanded
 
       begin
         if load?
@@ -332,6 +362,8 @@ module ActiveSupport #:nodoc:
       rescue Exception
         loaded.delete expanded
         raise
+      ensure
+        loading.pop
       end
 
       # Record history *after* loading so first load gets warnings.
@@ -389,7 +421,8 @@ module ActiveSupport #:nodoc:
     end
 
     def load_once_path?(path)
-      # to_s works around a ruby1.9 issue where #starts_with?(Pathname) will always return false
+      # to_s works around a ruby1.9 issue where String#starts_with?(Pathname)
+      # will raise a TypeError: no implicit conversion of Pathname into String
       autoload_once_paths.any? { |base| path.starts_with? base.to_s }
     end
 
@@ -417,7 +450,7 @@ module ActiveSupport #:nodoc:
     def load_file(path, const_paths = loadable_constants_for_path(path))
       log_call path, const_paths
       const_paths = [const_paths].compact unless const_paths.is_a? Array
-      parent_paths = const_paths.collect { |const_path| const_path[/.*(?=::)/] || :Object }
+      parent_paths = const_paths.collect { |const_path| const_path[/.*(?=::)/] || ::Object }
 
       result = nil
       newly_defined_paths = new_constants_in(*parent_paths) do
@@ -446,8 +479,6 @@ module ActiveSupport #:nodoc:
         raise ArgumentError, "A copy of #{from_mod} has been removed from the module tree but is still active!"
       end
 
-      raise NameError.new("#{from_mod} is not missing constant #{const_name}!", const_name) if from_mod.const_defined?(const_name, false)
-
       qualified_name = qualified_name_for from_mod, const_name
       path_suffix = qualified_name.underscore
 
@@ -457,7 +488,7 @@ module ActiveSupport #:nodoc:
         expanded = File.expand_path(file_path)
         expanded.sub!(/\.rb\z/, '')
 
-        if loaded.include?(expanded)
+        if loading.include?(expanded)
           raise "Circular dependency detected while autoloading constant #{qualified_name}"
         else
           require_or_load(expanded, qualified_name)
@@ -635,7 +666,7 @@ module ActiveSupport #:nodoc:
         when String then desc.sub(/^::/, '')
         when Symbol then desc.to_s
         when Module
-          desc.name.presence ||
+          desc.name ||
             raise(ArgumentError, "Anonymous modules have no name to be referenced by")
         else raise TypeError, "Not a valid constant descriptor: #{desc.inspect}"
       end
@@ -649,6 +680,14 @@ module ActiveSupport #:nodoc:
       constants = normalized.split('::')
       to_remove = constants.pop
 
+      # Remove the file path from the loaded list.
+      file_path = search_for_file(const.underscore)
+      if file_path
+        expanded = File.expand_path(file_path)
+        expanded.sub!(/\.rb\z/, '')
+        self.loaded.delete(expanded)
+      end
+
       if constants.empty?
         parent = Object
       else

data/lib/active_support/deprecation/behaviors.rb

@@ -17,10 +17,10 @@ module ActiveSupport
         $stderr.puts(message)
         $stderr.puts callstack.join("\n  ") if debug
       },
-      
+
       log: ->(message, callstack) {
         logger =
-            if defined?(Rails) && Rails.logger
+            if defined?(Rails.logger) && Rails.logger
               Rails.logger
             else
               require 'active_support/logger'
@@ -29,12 +29,12 @@ module ActiveSupport
         logger.warn message
         logger.debug callstack.join("\n  ") if debug
       },
-      
+
       notify: ->(message, callstack) {
         ActiveSupport::Notifications.instrument("deprecation.rails",
                                                 :message => message, :callstack => callstack)
       },
-      
+
       silence: ->(message, callstack) {},
     }
 

data/lib/active_support/deprecation.rb

@@ -25,14 +25,14 @@ module ActiveSupport
     include Reporting
     include MethodWrapper
 
-    # The version the deprecated behavior will be removed, by default.
+    # The version number in which the deprecated behavior will be removed, by default.
     attr_accessor :deprecation_horizon
 
-    # It accepts two parameters on initialization. The first is an version of library
-    # and the second is an library name
+    # It accepts two parameters on initialization. The first is a version of library
+    # and the second is a library name
     #
     #   ActiveSupport::Deprecation.new('2.0', 'MyLibrary')
-    def initialize(deprecation_horizon = '4.1', gem_name = 'Rails')
+    def initialize(deprecation_horizon = '5.0', gem_name = 'Rails')
       self.gem_name = gem_name
       self.deprecation_horizon = deprecation_horizon
       # By default, warnings are not silenced and debugging is off.

data/lib/active_support/duration.rb

@@ -1,4 +1,3 @@
-require 'active_support/proxy_object'
 require 'active_support/core_ext/array/conversions'
 require 'active_support/core_ext/object/acts_like'
 
@@ -7,7 +6,7 @@ module ActiveSupport
   # Time#advance, respectively. It mainly supports the methods on Numeric.
   #
   #   1.month.ago       # equivalent to Time.now.advance(months: -1)
-  class Duration < ProxyObject
+  class Duration
     attr_accessor :value, :parts
 
     def initialize(value, parts) #:nodoc:
@@ -39,6 +38,10 @@ module ActiveSupport
     end
     alias :kind_of? :is_a?
 
+    def instance_of?(klass) # :nodoc:
+      Duration == klass || value.instance_of?(klass)
+    end
+
     # Returns +true+ if +other+ is also a Duration instance with the
     # same +value+, or if <tt>other == value</tt>.
     def ==(other)
@@ -49,6 +52,44 @@ module ActiveSupport
       end
     end
 
+    def to_s
+      @value.to_s
+    end
+
+    # Returns the number of seconds that this Duration represents.
+    #
+    #   1.minute.to_i   # => 60
+    #   1.hour.to_i     # => 3600
+    #   1.day.to_i      # => 86400
+    #
+    # Note that this conversion makes some assumptions about the
+    # duration of some periods, e.g. months are always 30 days
+    # and years are 365.25 days:
+    #
+    #   # equivalent to 30.days.to_i
+    #   1.month.to_i    # => 2592000
+    #
+    #   # equivalent to 365.25.days.to_i
+    #   1.year.to_i     # => 31557600
+    #
+    # In such cases, Ruby's core
+    # Date[http://ruby-doc.org/stdlib/libdoc/date/rdoc/Date.html] and
+    # Time[http://ruby-doc.org/stdlib/libdoc/time/rdoc/Time.html] should be used for precision
+    # date and time arithmetic.
+    def to_i
+      @value.to_i
+    end
+
+    # Returns +true+ if +other+ is also a Duration instance, which has the
+    # same parts as this one.
+    def eql?(other)
+      Duration === other && other.value.eql?(value)
+    end
+
+    def hash
+      @value.hash
+    end
+
     def self.===(other) #:nodoc:
       other.is_a?(Duration)
     rescue ::NoMethodError
@@ -70,19 +111,23 @@ module ActiveSupport
     alias :until :ago
 
     def inspect #:nodoc:
-      consolidated = parts.inject(::Hash.new(0)) { |h,(l,r)| h[l] += r; h }
-      parts = [:years, :months, :days, :minutes, :seconds].map do |length|
-        n = consolidated[length]
-        "#{n} #{n == 1 ? length.to_s.singularize : length.to_s}" if n.nonzero?
-      end.compact
-      parts = ["0 seconds"] if parts.empty?
-      parts.to_sentence(:locale => :en)
+      parts.
+        reduce(::Hash.new(0)) { |h,(l,r)| h[l] += r; h }.
+        sort_by {|unit,  _ | [:years, :months, :days, :minutes, :seconds].index(unit)}.
+        map     {|unit, val| "#{val} #{val == 1 ? unit.to_s.chop : unit.to_s}"}.
+        to_sentence(locale: ::I18n.default_locale)
     end
 
     def as_json(options = nil) #:nodoc:
       to_i
     end
 
+    def respond_to_missing?(method, include_private=false) #:nodoc
+      @value.respond_to?(method, include_private)
+    end
+
+    delegate :<=>, to: :value
+
     protected
 
       def sum(sign, time = ::Time.current) #:nodoc:
@@ -103,8 +148,7 @@ module ActiveSupport
 
       # We define it as a workaround to Ruby 2.0.0-p353 bug.
       # For more information, check rails/rails#13055.
-      # It should be dropped once a new Ruby patch-level
-      # release after 2.0.0-p353 happens.
+      # Remove it when we drop support for 2.0.0-p353.
       def ===(other) #:nodoc:
         value === other
       end

data/lib/active_support/file_update_checker.rb

@@ -115,7 +115,7 @@ module ActiveSupport
     end
 
     def compile_glob(hash)
-      hash.freeze # Freeze so changes aren't accidently pushed
+      hash.freeze # Freeze so changes aren't accidentally pushed
       return if hash.empty?
 
       globs = hash.map do |key, value|

data/lib/active_support/gem_version.rb

@@ -0,0 +1,15 @@
+module ActiveSupport
+  # Returns the version of the currently loaded Active Support as a <tt>Gem::Version</tt>
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 4
+    MINOR = 2
+    TINY  = 11
+    PRE   = "3"
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end