activesupport 4.2.5 → 4.2.11.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 61b8d3f7b7567155481d04cb842d4ffafa441abe
-  data.tar.gz: cadd0882bd760c4b0cb206a9abde82791e304413
+SHA256:
+  metadata.gz: e5927887f8de9d6b13175ee528ab4606a7975d7b4eb27c7365c3ed5bbc620183
+  data.tar.gz: 1f4c3a900e5f84241a557376ecb5850a5c9c6b86be17f6929397871a9ae5f925
 SHA512:
-  metadata.gz: 8b7f68146497c8b513710e3e5bee0782e6dc01039f78a910d1226ab9caf19b524feafa1df9dd859492f43dcdc78389d8d0ae7c248f013fbb1abc6768a0d999c8
-  data.tar.gz: c747288209536e557565cdf470f2e12c5f786f1137388548af3fabfdbd523260bdf68b0c5b37adf0b0ddb4fdb3ea749e84d16f78eb9abb5bdee671971750c7d8
+  metadata.gz: d4bf38be75e38c3e9fdabdac8220b0ec283a7828778c9d1aaa6c084eed3a31ad677d12ef23d59aeb83188f258f6436d2ac50a6f1240e0dbbcdd01d7476694b5a
+  data.tar.gz: 6fd1b23cf9c7d1600ddf239616dbc86253de33a2b1ee73a82892f22cef0af1010920582a76ef5e1995d1188e451980700427cc932b261fdc99fcba9c0ba79914

data/CHANGELOG.md

@@ -1,3 +1,203 @@
+## Rails 4.2.11.3 (May 15, 2020) ##
+
+*   No changes.
+
+
+## Rails 4.2.11.2 (May 15, 2020) ##
+
+*   No changes.
+
+
+## Rails 4.2.11.1 (March 11, 2019) ##
+
+*   No changes.
+
+
+## Rails 4.2.11 (November 27, 2018) ##
+
+*   No changes.
+
+
+## Rails 4.2.10 (September 27, 2017) ##
+
+*   No changes.
+
+
+## Rails 4.2.9 (June 26, 2017) ##
+
+*   Fixed bug in `DateAndTime::Compatibility#to_time` that caused it to
+    raise `RuntimeError: can't modify frozen Time` when called on any frozen `Time`.
+    Properly pass through the frozen `Time` or `ActiveSupport::TimeWithZone` object
+    when calling `#to_time`.
+
+    *Kevin McPhillips* & *Andrew White*
+
+*   Restore the return type of `DateTime#utc`
+
+    In Rails 5.0 the return type of `DateTime#utc` was changed to `Time` to be
+    consistent with the new `DateTime#localtime` method. When these changes were
+    backported in #27553 this inadvertently changed the return type in a patcn
+    release. Since `DateTime#localtime` was new in Rails 4.2.8 it's okay to
+    restore the return type of `DateTime#utc` but keep `DateTime#localtime` as
+    returning `Time` without breaking backwards compatibility.
+
+    *Andrew White*
+
+*   In Core Extensions, make `MarshalWithAutoloading#load` pass through the second, optional
+    argument for `Marshal#load( source [, proc] )`. This way we don't have to do
+    `Marshal.method(:load).super_method.call(sourse, proc)` just to be able to pass a proc.
+
+    *Jeff Latz*
+
+*   Cache `ActiveSupport::TimeWithZone#to_datetime` before freezing.
+
+    *Adam Rice*
+
+*   `AS::Testing::TimeHelpers#travel_to` now changes `DateTime.now` as well as
+    `Time.now` and `Date.today`.
+
+    *Yuki Nishijima*
+
+
+## Rails 4.2.8 (February 21, 2017) ##
+
+*   Make `getlocal` and `getutc` always return instances of `Time` for
+    `ActiveSupport::TimeWithZone` and `DateTime`. This eliminates a possible
+    stack level too deep error in `to_time` where `ActiveSupport::TimeWithZone`
+    was wrapping a `DateTime` instance. As a consequence of this the internal
+    time value in `ActiveSupport::TimeWithZone` is now always an instance of
+    `Time` in the UTC timezone, whether that's as the UTC time directly or
+    a representation of the local time in the timezone. There should be no
+    consequences of this internal change and if there are it's a bug due to
+    leaky abstractions.
+
+    *Andrew White*
+
+*   Add `DateTime#subsec` to return the fraction of a second as a `Rational`.
+
+    *Andrew White*
+
+*   Add additional aliases for `DateTime#utc` to mirror the ones on
+    `ActiveSupport::TimeWithZone` and `Time`.
+
+    *Andrew White*
+
+*   Add `DateTime#localtime` to return an instance of `Time` in the system's
+    local timezone. Also aliased to `getlocal`.
+
+    *Andrew White*, *Yuichiro Kaneko*
+
+*   Add `Time#sec_fraction` to return the fraction of a second as a `Rational`.
+
+    *Andrew White*
+
+*   Add `ActiveSupport.to_time_preserves_timezone` config option to control
+    how `to_time` handles timezones. In Ruby 2.4+ the behavior will change
+    from converting to the local system timezone, to preserving the timezone
+    of the receiver. This config option defaults to false so that apps made
+    with earlier versions of Rails are not affected when upgrading, e.g:
+
+        >> ENV['TZ'] = 'US/Eastern'
+
+        >> "2016-04-23T10:23:12.000Z".to_time
+        => "2016-04-23T06:23:12.000-04:00"
+
+        >> ActiveSupport.to_time_preserves_timezone = true
+
+        >> "2016-04-23T10:23:12.000Z".to_time
+        => "2016-04-23T10:23:12.000Z"
+
+    Fixes #24617.
+
+    *Andrew White*
+
+*   Add `init_with` to `ActiveSupport::TimeWithZone` and `ActiveSupport::TimeZone`
+
+    It is helpful to be able to run apps concurrently written in successive
+    versions of Rails to aid migration, e.g. run Rails 4.2 and 5.0 variants
+    of your application at the same time to carry out A/B testing.
+
+    To do this serialization formats need to be cross compatible and the
+    change in 3aa26cf didn't meet this criteria because the Psych loader
+    checks for the existence of `init_with` before setting the instance
+    variables and the wrapping behavior of `ActiveSupport::TimeWithZone`
+    tries to see if the `Time` instance responds to `init_with` before the
+    `@time` variable is set.
+
+    To fix this we backported just the `init_with` behavior from the change
+    in 3aa26cf. If the revived instance is then written out to YAML again
+    it will revert to the default Rails 4.2 behavior of converting it to
+    a UTC timestamp string.
+
+    Fixes #26296.
+
+    *Andrew White*
+
+*   Fix `ActiveSupport::TimeWithZone#in` across DST boundaries.
+
+    Previously calls to `in` were being sent to the non-DST aware
+    method `Time#since` via `method_missing`. It is now aliased to
+    the DST aware `ActiveSupport::TimeWithZone#since` which handles
+    transitions across DST boundaries, e.g:
+
+        Time.zone = "US/Eastern"
+
+        t = Time.zone.local(2016,11,6,1)
+        # => Sun, 06 Nov 2016 01:00:00 EDT -05:00
+
+        t.in(1.hour)
+        # => Sun, 06 Nov 2016 01:00:00 EST -05:00
+
+    Fixes #26580.
+
+    *Thomas Balthazar*
+
+
+## Rails 4.2.7 (July 12, 2016) ##
+
+*   Fixed `ActiveSupport::Logger.broadcast` so that calls to `#silence` now
+    properly delegate to all loggers. Silencing now properly suppresses logging
+    to both the log and the console.
+
+    *Kevin McPhillips*
+
+*   Backported `ActiveSupport::LoggerThreadSafeLevel`. Assigning the
+    `Rails.logger.level` is now thread safe.
+
+    *Kevin McPhillips*
+
+*   Fixed a problem with ActiveSupport::SafeBuffer.titleize calling capitalize
+    on nil.
+
+    *Brian McManus*
+
+*   Time zones: Ensure that the UTC offset reflects DST changes that occurred
+    since the app started. Removes UTC offset caching, reducing performance,
+    but this is still relatively quick and isn't in any hot paths.
+
+    *Alexey Shein*
+
+*   Prevent `Marshal.load` from looping infinitely when trying to autoload a constant
+    which resolves to a different name.
+
+    *Olek Janiszewski*
+
+
+## Rails 4.2.6 (March 07, 2016) ##
+
+*   No changes.
+
+
+## Rails 4.2.5.2 (February 26, 2016) ##
+
+*   No changes.
+
+
+## Rails 4.2.5.1 (January 25, 2015) ##
+
+*   No changes.
+
+
 ## Rails 4.2.5 (November 12, 2015) ##
 
 *   Fix `TimeWithZone#eql?` to properly handle `TimeWithZone` created from `DateTime`:

data/lib/active_support/cache/mem_cache_store.rb

@@ -67,7 +67,7 @@ module ActiveSupport
         options = names.extract_options!
         options = merged_options(options)
         keys_to_names = Hash[names.map{|name| [escape_key(namespaced_key(name, options)), name]}]
-        raw_values = @data.get_multi(keys_to_names.keys, :raw => true)
+        raw_values = @data.get_multi(keys_to_names.keys)
         values = {}
         raw_values.each do |key, value|
           entry = deserialize_entry(value)

data/lib/active_support/callbacks.rb

@@ -770,7 +770,7 @@ module ActiveSupport
         options = names.extract_options!
 
         names.each do |name|
-          class_attribute "_#{name}_callbacks"
+          class_attribute "_#{name}_callbacks", instance_writer: false
           set_callbacks name, CallbackChain.new(name, options)
 
           module_eval <<-RUBY, __FILE__, __LINE__ + 1

data/lib/active_support/core_ext/class/subclasses.rb

@@ -25,8 +25,6 @@ class Class
 
   # Returns an array with the direct children of +self+.
   #
-  #   Integer.subclasses # => [Fixnum, Bignum]
-  #
   #   class Foo; end
   #   class Bar < Foo; end
   #   class Baz < Bar; end

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

@@ -0,0 +1,15 @@
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/module/remove_method'
+
+module DateAndTime
+  module Compatibility
+    # If true, +to_time+ preserves the timezone offset of receiver.
+    #
+    # NOTE: With Ruby 2.4+ the default for +to_time+ changed from
+    # converting to the local system time, to preserving the offset
+    # of the receiver. For backwards compatibility we're overriding
+    # this behavior, but new apps will have an initializer that sets
+    # this to true, because the new behavior is preferred.
+    mattr_accessor(:preserve_timezone, instance_writer: false) { false }
+  end
+end

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

@@ -24,6 +24,13 @@ class DateTime
     end_of_day.to_i - to_i
   end
 
+  # Returns the fraction of a second as a +Rational+
+  #
+  #   DateTime.new(2012, 8, 29, 0, 0, 0.5).subsec # => (1/2)
+  def subsec
+    sec_fraction
+  end
+
   # Returns a new DateTime 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>) reset cascadingly, so if only the hour is
@@ -139,14 +146,27 @@ class DateTime
   end
   alias :at_end_of_minute :end_of_minute
 
-  # Adjusts DateTime to UTC by adding its offset value; offset is set to 0.
+  # Returns a <tt>Time</tt> instance of the simultaneous time in the system timezone.
+  def localtime(utc_offset = nil)
+    utc = new_offset(0)
+
+    Time.utc(
+      utc.year, utc.month, utc.day,
+      utc.hour, utc.min, utc.sec + utc.sec_fraction
+    ).getlocal(utc_offset)
+  end
+  alias_method :getlocal, :localtime
+
+  # Returns a <tt>DateTime</tt> instance of the simultaneous time in the UTC timezone.
   #
   #   DateTime.civil(2005, 2, 21, 10, 11, 12, Rational(-6, 24))     # => Mon, 21 Feb 2005 10:11:12 -0600
-  #   DateTime.civil(2005, 2, 21, 10, 11, 12, Rational(-6, 24)).utc # => Mon, 21 Feb 2005 16:11:12 +0000
+  #   DateTime.civil(2005, 2, 21, 10, 11, 12, Rational(-6, 24)).utc # => Mon, 21 Feb 2005 16:11:12 UTC
   def utc
     new_offset(0)
   end
+  alias_method :getgm, :utc
   alias_method :getutc, :utc
+  alias_method :gmtime, :utc
 
   # Returns +true+ if <tt>offset == 0</tt>.
   def utc?

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

@@ -0,0 +1,16 @@
+require 'active_support/core_ext/date_and_time/compatibility'
+require 'active_support/core_ext/module/remove_method'
+
+class DateTime
+  include DateAndTime::Compatibility
+
+  remove_possible_method :to_time
+
+  # Either return an instance of `Time` with the same UTC offset
+  # as +self+ or an instance of `Time` representing the same time
+  # in the the local system timezone depending on the setting of
+  # on the setting of +ActiveSupport.to_time_preserves_timezone+.
+  def to_time
+    preserve_timezone ? getlocal(utc_offset) : getlocal
+  end
+end

data/lib/active_support/core_ext/date_time.rb

@@ -1,4 +1,5 @@
 require 'active_support/core_ext/date_time/acts_like'
 require 'active_support/core_ext/date_time/calculations'
+require 'active_support/core_ext/date_time/compatibility'
 require 'active_support/core_ext/date_time/conversions'
 require 'active_support/core_ext/date_time/zones'

data/lib/active_support/core_ext/enumerable.rb

@@ -78,3 +78,19 @@ class Range #:nodoc:
     end
   end
 end
+
+# Array#sum was added in Ruby 2.4 but it only works with Numeric elements.
+#
+# We tried shimming it to attempt the fast native method, rescue TypeError,
+# and fall back to the compatible implementation, but that's much slower than
+# just calling the compat method in the first place.
+if Array.instance_methods(false).include?(:sum) && !(%w[a].sum rescue false)
+  class Array
+    remove_method :sum
+
+    def sum(*args) #:nodoc:
+      # Use Enumerable#sum instead.
+      super
+    end
+  end
+end

data/lib/active_support/core_ext/hash/compact.rb

@@ -1,20 +1,24 @@
 class Hash
-  # Returns a hash with non +nil+ values.
-  #
-  #   hash = { a: true, b: false, c: nil}
-  #   hash.compact # => { a: true, b: false}
-  #   hash # => { a: true, b: false, c: nil}
-  #   { c: nil }.compact # => {}
-  def compact
-    self.select { |_, value| !value.nil? }
+  unless Hash.instance_methods(false).include?(:compact)
+    # Returns a hash with non +nil+ values.
+    #
+    #   hash = { a: true, b: false, c: nil}
+    #   hash.compact # => { a: true, b: false}
+    #   hash # => { a: true, b: false, c: nil}
+    #   { c: nil }.compact # => {}
+    def compact
+      self.select { |_, value| !value.nil? }
+    end
   end
 
-  # Replaces current hash with non +nil+ values.
-  #
-  #   hash = { a: true, b: false, c: nil}
-  #   hash.compact! # => { a: true, b: false}
-  #   hash # => { a: true, b: false}
-  def compact!
-    self.reject! { |_, value| value.nil? }
+  unless Hash.instance_methods(false).include?(:compact!)
+    # Replaces current hash with non +nil+ values.
+    #
+    #   hash = { a: true, b: false, c: nil}
+    #   hash.compact! # => { a: true, b: false}
+    #   hash # => { a: true, b: false}
+    def compact!
+      self.reject! { |_, value| value.nil? }
+    end
   end
 end

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

@@ -55,8 +55,7 @@ class Hash
   #
   #     XML_TYPE_NAMES = {
   #       "Symbol"     => "symbol",
-  #       "Fixnum"     => "integer",
-  #       "Bignum"     => "integer",
+  #       "Integer"    => "integer",
   #       "BigDecimal" => "decimal",
   #       "Float"      => "float",
   #       "TrueClass"  => "boolean",

data/lib/active_support/core_ext/hash/transform_values.rb

@@ -11,7 +11,7 @@ class Hash
       result[key] = yield(value)
     end
     result
-  end
+  end unless method_defined? :transform_values
 
   # Destructive +transform_values+
   def transform_values!
@@ -19,5 +19,5 @@ class Hash
     each do |key, value|
       self[key] = yield(value)
     end
-  end
+  end unless method_defined? :transform_values!
 end

data/lib/active_support/core_ext/marshal.rb

@@ -2,13 +2,16 @@ require 'active_support/core_ext/module/aliasing'
 
 module Marshal
   class << self
-    def load_with_autoloading(source)
-      load_without_autoloading(source)
+    def load_with_autoloading(source, proc = nil)
+      load_without_autoloading(source, proc)
     rescue ArgumentError, NameError => exc
-      if exc.message.match(%r|undefined class/module (.+)|)
+      if exc.message.match(%r|undefined class/module (.+?)(::)?\z|)
         # try loading the class/module
-        $1.constantize
-        # if it is a IO we need to go back to read the object
+        loaded = $1.constantize
+
+        raise unless $1 == loaded.name
+
+        # if it is an IO we need to go back to read the object
         source.rewind if source.respond_to?(:rewind)
         retry
       else

data/lib/active_support/core_ext/module/delegation.rb

@@ -11,6 +11,14 @@ class Module
        return self super then true undef unless until when while yield)
   ).freeze
 
+  DELEGATION_RESERVED_KEYWORDS = Set.new(
+    %w(_ arg args block)
+  )
+
+  DELEGATION_RESERVED_METHOD_NAMES = Set.new(
+    RUBY_RESERVED_WORDS + DELEGATION_RESERVED_KEYWORDS
+  ).freeze
+
   # Provides a +delegate+ class method to easily expose contained objects'
   # public methods as your own.
   #

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

@@ -118,7 +118,15 @@ class Numeric
     end
   end
 
-  [Float, Fixnum, Bignum, BigDecimal].each do |klass|
+  klasses = [Float, BigDecimal]
+  # Ruby 2.4+ unifies Fixnum & Bignum into Integer.
+  if 0.class == Integer
+    klasses << Integer
+  else
+    klasses << Fixnum << Bignum
+  end
+
+  klasses.each do |klass|
     klass.send(:alias_method, :to_default_s, :to_s)
 
     klass.send(:define_method, :to_s) do |*args|

data/lib/active_support/core_ext/object/duplicable.rb

@@ -1,7 +1,7 @@
 #--
-# Most objects are cloneable, but not all. For example you can't dup +nil+:
+# Most objects are cloneable, but not all. For example you can't dup methods:
 #
-#   nil.dup # => TypeError: can't dup NilClass
+#   method(:puts).dup # => TypeError: allocator undefined for Method
 #
 # Classes may signal their instances are not duplicable removing +dup+/+clone+
 # or raising exceptions from them. So, to dup an arbitrary object you normally
@@ -27,52 +27,78 @@ class Object
 end
 
 class NilClass
-  # +nil+ is not duplicable:
-  #
-  #   nil.duplicable? # => false
-  #   nil.dup         # => TypeError: can't dup NilClass
-  def duplicable?
-    false
+  begin
+    nil.dup
+  rescue TypeError
+
+    # +nil+ is not duplicable:
+    #
+    #   nil.duplicable? # => false
+    #   nil.dup         # => TypeError: can't dup NilClass
+    def duplicable?
+      false
+    end
   end
 end
 
 class FalseClass
-  # +false+ is not duplicable:
-  #
-  #   false.duplicable? # => false
-  #   false.dup         # => TypeError: can't dup FalseClass
-  def duplicable?
-    false
+  begin
+    false.dup
+  rescue TypeError
+
+    # +false+ is not duplicable:
+    #
+    #   false.duplicable? # => false
+    #   false.dup         # => TypeError: can't dup FalseClass
+    def duplicable?
+      false
+    end
   end
 end
 
 class TrueClass
-  # +true+ is not duplicable:
-  #
-  #   true.duplicable? # => false
-  #   true.dup         # => TypeError: can't dup TrueClass
-  def duplicable?
-    false
+  begin
+    true.dup
+  rescue TypeError
+
+    # +true+ is not duplicable:
+    #
+    #   true.duplicable? # => false
+    #   true.dup         # => TypeError: can't dup TrueClass
+    def duplicable?
+      false
+    end
   end
 end
 
 class Symbol
-  # Symbols are not duplicable:
-  #
-  #   :my_symbol.duplicable? # => false
-  #   :my_symbol.dup         # => TypeError: can't dup Symbol
-  def duplicable?
-    false
+  begin
+    :symbol.dup # Ruby 2.4.x.
+    'symbol_from_string'.to_sym.dup # Some symbols can't `dup` in Ruby 2.4.0.
+  rescue TypeError
+
+    # Symbols are not duplicable:
+    #
+    #   :my_symbol.duplicable? # => false
+    #   :my_symbol.dup         # => TypeError: can't dup Symbol
+    def duplicable?
+      false
+    end
   end
 end
 
 class Numeric
-  # Numbers are not duplicable:
-  #
-  #  3.duplicable? # => false
-  #  3.dup         # => TypeError: can't dup Fixnum
-  def duplicable?
-    false
+  begin
+    1.dup
+  rescue TypeError
+
+    # Numbers are not duplicable:
+    #
+    #  3.duplicable? # => false
+    #  3.dup         # => TypeError: can't dup Integer
+    def duplicable?
+      false
+    end
   end
 end
 

data/lib/active_support/core_ext/string/access.rb

@@ -1,5 +1,5 @@
 class String
-  # If you pass a single Fixnum, returns a substring of one character at that
+  # If you pass a single integer, returns a substring of one character at that
   # position. The first character of the string is at position 0, the next at
   # position 1, and so on. If a range is supplied, a substring containing
   # characters at offsets given by the range is returned. In both cases, if an

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

@@ -31,7 +31,7 @@ class String
       parts.fetch(:offset, form == :utc ? 0 : nil)
     )
 
-    form == :utc ? time.utc : time.getlocal
+    form == :utc ? time.utc : time.to_time
   end
 
   # Converts a string to a Date value.

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

@@ -63,6 +63,13 @@ 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>, <tt>:nsec</tt>) reset cascadingly, so if only
@@ -250,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.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'