activesupport 5.2.4 → 6.0.2.1

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

@@ -110,7 +110,7 @@ class DateTime
   # instance time. Do not use this method in combination with x.months, use
   # months_since instead!
   def since(seconds)
-    self + Rational(seconds.round, 86400)
+    self + Rational(seconds, 86400)
   end
   alias :in :since
 

data/lib/active_support/core_ext/enumerable.rb

@@ -1,64 +1,54 @@
 # frozen_string_literal: true
 
 module Enumerable
+  INDEX_WITH_DEFAULT = Object.new
+  private_constant :INDEX_WITH_DEFAULT
+
   # Enumerable#sum was added in Ruby 2.4, but it only works with Numeric elements
   # when we omit an identity.
+
+  # :stopdoc:
+
+  # We can't use Refinements here because Refinements with Module which will be prepended
+  # doesn't work well https://bugs.ruby-lang.org/issues/13446
+  alias :_original_sum_with_required_identity :sum
+  private :_original_sum_with_required_identity
+
+  # :startdoc:
+
+  # Calculates a sum from the 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 Enumerable.instance_methods(false).include?(:sum) && !((?a..?b).sum rescue false)
-    # :stopdoc:
-
-    # We can't use Refinements here because Refinements with Module which will be prepended
-    # doesn't work well https://bugs.ruby-lang.org/issues/13446
-    alias :_original_sum_with_required_identity :sum
-    private :_original_sum_with_required_identity
-
-    # :startdoc:
-
-    # Calculates a sum from the elements.
-    #
-    #  payments.sum { |p| p.price * p.tax_rate }
-    #  payments.sum(&:price)
-    #
-    # The latter is a shortcut for:
-    #
-    #  payments.inject(0) { |sum, p| sum + p.price }
-    #
-    # It can also calculate the sum without the use of a block.
-    #
-    #  [5, 15, 10].sum # => 30
-    #  ['foo', 'bar'].sum # => "foobar"
-    #  [[1, 2], [3, 1, 5]].sum # => [1, 2, 3, 1, 5]
-    #
-    # The default sum of an empty list is zero. You can override this default:
-    #
-    #  [].sum(Payment.new(0)) { |i| i.amount } # => Payment.new(0)
-    def sum(identity = nil, &block)
-      if identity
-        _original_sum_with_required_identity(identity, &block)
-      elsif block_given?
-        map(&block).sum(identity)
-      else
-        inject(:+) || 0
-      end
-    end
-  else
-    def sum(identity = nil, &block)
-      if block_given?
-        map(&block).sum(identity)
-      else
-        sum = identity ? inject(identity, :+) : inject(:+)
-        sum || identity || 0
-      end
+  #  payments.sum { |p| p.price * p.tax_rate }
+  #  payments.sum(&:price)
+  #
+  # The latter is a shortcut for:
+  #
+  #  payments.inject(0) { |sum, p| sum + p.price }
+  #
+  # It can also calculate the sum without the use of a block.
+  #
+  #  [5, 15, 10].sum # => 30
+  #  ['foo', 'bar'].sum # => "foobar"
+  #  [[1, 2], [3, 1, 5]].sum # => [1, 2, 3, 1, 5]
+  #
+  # The default sum of an empty list is zero. You can override this default:
+  #
+  #  [].sum(Payment.new(0)) { |i| i.amount } # => Payment.new(0)
+  def sum(identity = nil, &block)
+    if identity
+      _original_sum_with_required_identity(identity, &block)
+    elsif block_given?
+      map(&block).sum(identity)
+    else
+      inject(:+) || 0
     end
   end
 
-  # Convert an enumerable to a hash.
+  # Convert an enumerable to a hash keying it by the block return value.
   #
   #   people.index_by(&:login)
   #   # => { "nextangle" => <Person ...>, "chade-" => <Person ...>, ...}
+  #
   #   people.index_by { |person| "#{person.first_name} #{person.last_name}" }
   #   # => { "Chade- Fowlersburg-e" => <Person ...>, "David Heinemeier Hansson" => <Person ...>, ...}
   def index_by
@@ -71,6 +61,26 @@ module Enumerable
     end
   end
 
+  # Convert an enumerable to a hash keying it with the enumerable items and with the values returned in the block.
+  #
+  #   post = Post.new(title: "hey there", body: "what's up?")
+  #
+  #   %i( title body ).index_with { |attr_name| post.public_send(attr_name) }
+  #   # => { title: "hey there", body: "what's up?" }
+  def index_with(default = INDEX_WITH_DEFAULT)
+    if block_given?
+      result = {}
+      each { |elem| result[elem] = yield(elem) }
+      result
+    elsif default != INDEX_WITH_DEFAULT
+      result = {}
+      each { |elem| result[elem] = default }
+      result
+    else
+      to_enum(:index_with) { size if respond_to?(:size) }
+    end
+  end
+
   # Returns +true+ if the enumerable has more than 1 element. Functionally
   # equivalent to <tt>enum.to_a.size > 1</tt>. Can be called with a block too,
   # much like any?, so <tt>people.many? { |p| p.age > 26 }</tt> returns +true+
@@ -87,23 +97,43 @@ module Enumerable
     end
   end
 
+  # Returns a new array that includes the passed elements.
+  #
+  #   [ 1, 2, 3 ].including(4, 5)
+  #   # => [ 1, 2, 3, 4, 5 ]
+  #
+  #   ["David", "Rafael"].including %w[ Aaron Todd ]
+  #   # => ["David", "Rafael", "Aaron", "Todd"]
+  def including(*elements)
+    to_a.including(*elements)
+  end
+
   # The negative of the <tt>Enumerable#include?</tt>. Returns +true+ if the
   # collection does not include the object.
   def exclude?(object)
     !include?(object)
   end
 
-  # Returns a copy of the enumerable without the specified elements.
+  # Returns a copy of the enumerable excluding the specified elements.
+  #
+  #   ["David", "Rafael", "Aaron", "Todd"].excluding "Aaron", "Todd"
+  #   # => ["David", "Rafael"]
   #
-  #   ["David", "Rafael", "Aaron", "Todd"].without "Aaron", "Todd"
+  #   ["David", "Rafael", "Aaron", "Todd"].excluding %w[ Aaron Todd ]
   #   # => ["David", "Rafael"]
   #
-  #   {foo: 1, bar: 2, baz: 3}.without :bar
+  #   {foo: 1, bar: 2, baz: 3}.excluding :bar
   #   # => {foo: 1, baz: 3}
-  def without(*elements)
+  def excluding(*elements)
+    elements.flatten!(1)
     reject { |element| elements.include?(element) }
   end
 
+  # Alias for #excluding.
+  def without(*elements)
+    excluding(*elements)
+  end
+
   # Convert an enumerable to an array based on the given key.
   #
   #   [{ name: "David" }, { name: "Rafael" }, { name: "Aaron" }].pluck(:name)
@@ -138,27 +168,21 @@ class Range #:nodoc:
   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)
-  # Using Refinements here in order not to expose our internal method
-  using Module.new {
-    refine Array do
-      alias :orig_sum :sum
-    end
-  }
+# Using Refinements here in order not to expose our internal method
+using Module.new {
+  refine Array do
+    alias :orig_sum :sum
+  end
+}
 
-  class Array
-    def sum(init = nil, &block) #:nodoc:
-      if init.is_a?(Numeric) || first.is_a?(Numeric)
-        init ||= 0
-        orig_sum(init, &block)
-      else
-        super
-      end
+class Array #:nodoc:
+  # Array#sum was added in Ruby 2.4 but it only works with Numeric elements.
+  def sum(init = nil, &block)
+    if init.is_a?(Numeric) || first.is_a?(Numeric)
+      init ||= 0
+      orig_sum(init, &block)
+    else
+      super
     end
   end
 end

data/lib/active_support/core_ext/hash.rb

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/hash/compact"
 require "active_support/core_ext/hash/conversions"
 require "active_support/core_ext/hash/deep_merge"
+require "active_support/core_ext/hash/deep_transform_values"
 require "active_support/core_ext/hash/except"
 require "active_support/core_ext/hash/indifferent_access"
 require "active_support/core_ext/hash/keys"
 require "active_support/core_ext/hash/reverse_merge"
 require "active_support/core_ext/hash/slice"
-require "active_support/core_ext/hash/transform_values"

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

@@ -1,29 +1,5 @@
 # frozen_string_literal: true
 
-class Hash
-  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  # => {}
-    #   { c: true }.compact # => { c: true }
-    def compact
-      select { |_, value| !value.nil? }
-    end
-  end
+require "active_support/deprecation"
 
-  unless Hash.instance_methods(false).include?(:compact!)
-    # Replaces current hash with non +nil+ values.
-    # Returns +nil+ if no changes were made, otherwise returns the hash.
-    #
-    #   hash = { a: true, b: false, c: nil }
-    #   hash.compact!        # => { a: true, b: false }
-    #   hash                 # => { a: true, b: false }
-    #   { c: true }.compact! # => nil
-    def compact!
-      reject! { |_, value| value.nil? }
-    end
-  end
-end
+ActiveSupport::Deprecation.warn "Ruby 2.5+ (required by Rails 6) provides Hash#compact and Hash#compact! natively, so requiring active_support/core_ext/hash/compact is no longer necessary. Requiring it will raise LoadError in Rails 6.1."

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class Hash
+  # Returns a new hash with all values converted by the block operation.
+  # This includes the values from the root hash and from all
+  # nested hashes and arrays.
+  #
+  #  hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #  hash.deep_transform_values{ |value| value.to_s.upcase }
+  #  # => {person: {name: "ROB", age: "28"}}
+  def deep_transform_values(&block)
+    _deep_transform_values_in_object(self, &block)
+  end
+
+  # Destructively converts all values by using the block operation.
+  # This includes the values from the root hash and from all
+  # nested hashes and arrays.
+  def deep_transform_values!(&block)
+    _deep_transform_values_in_object!(self, &block)
+  end
+
+  private
+    # support methods for deep transforming nested hashes and arrays
+    def _deep_transform_values_in_object(object, &block)
+      case object
+      when Hash
+        object.transform_values { |value| _deep_transform_values_in_object(value, &block) }
+      when Array
+        object.map { |e| _deep_transform_values_in_object(e, &block) }
+      else
+        yield(object)
+      end
+    end
+
+    def _deep_transform_values_in_object!(object, &block)
+      case object
+      when Hash
+        object.transform_values! { |value| _deep_transform_values_in_object!(value, &block) }
+      when Array
+        object.map! { |e| _deep_transform_values_in_object!(e, &block) }
+      else
+        yield(object)
+      end
+    end
+end

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

@@ -10,7 +10,7 @@ class Hash
   # This is useful for limiting a set of parameters to everything but a few known toggles:
   #   @person.update(params[:person].except(:admin))
   def except(*keys)
-    dup.except!(*keys)
+    slice(*self.keys - keys)
   end
 
   # Removes the given keys from hash and returns it.

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

@@ -1,35 +1,6 @@
 # frozen_string_literal: true
 
 class Hash
-  # Returns a new hash with all keys converted using the +block+ operation.
-  #
-  #  hash = { name: 'Rob', age: '28' }
-  #
-  #  hash.transform_keys { |key| key.to_s.upcase } # => {"NAME"=>"Rob", "AGE"=>"28"}
-  #
-  # If you do not provide a +block+, it will return an Enumerator
-  # for chaining with other methods:
-  #
-  #  hash.transform_keys.with_index { |k, i| [k, i].join } # => {"name0"=>"Rob", "age1"=>"28"}
-  def transform_keys
-    return enum_for(:transform_keys) { size } unless block_given?
-    result = {}
-    each_key do |key|
-      result[yield(key)] = self[key]
-    end
-    result
-  end unless method_defined? :transform_keys
-
-  # Destructively converts all keys using the +block+ operations.
-  # Same as +transform_keys+ but modifies +self+.
-  def transform_keys!
-    return enum_for(:transform_keys!) { size } unless block_given?
-    keys.each do |key|
-      self[yield(key)] = delete(key)
-    end
-    self
-  end unless method_defined? :transform_keys!
-
   # Returns a new hash with all keys converted to strings.
   #
   #   hash = { name: 'Rob', age: '28' }

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

@@ -1,34 +1,12 @@
 # frozen_string_literal: true
 
 class Hash
-  # Slices a hash to include only the given keys. Returns a hash containing
-  # the given keys.
-  #
-  #   { a: 1, b: 2, c: 3, d: 4 }.slice(:a, :b)
-  #   # => {:a=>1, :b=>2}
-  #
-  # This is useful for limiting an options hash to valid keys before
-  # passing to a method:
-  #
-  #   def search(criteria = {})
-  #     criteria.assert_valid_keys(:mass, :velocity, :time)
-  #   end
-  #
-  #   search(options.slice(:mass, :velocity, :time))
-  #
-  # If you have an array of keys you want to limit to, you should splat them:
-  #
-  #   valid_keys = [:mass, :velocity, :time]
-  #   search(options.slice(*valid_keys))
-  def slice(*keys)
-    keys.each_with_object(Hash.new) { |k, hash| hash[k] = self[k] if has_key?(k) }
-  end unless method_defined?(:slice)
-
   # Replaces the hash with only the given keys.
   # Returns a hash containing the removed key/value pairs.
   #
-  #   { a: 1, b: 2, c: 3, d: 4 }.slice!(:a, :b)
-  #   # => {:c=>3, :d=>4}
+  #   hash = { a: 1, b: 2, c: 3, d: 4 }
+  #   hash.slice!(:a, :b)  # => {:c=>3, :d=>4}
+  #   hash                 # => {:a=>1, :b=>2}
   def slice!(*keys)
     omit = slice(*self.keys - keys)
     hash = slice(*keys)

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

@@ -1,32 +1,5 @@
 # frozen_string_literal: true
 
-class Hash
-  # Returns a new hash with the results of running +block+ once for every value.
-  # The keys are unchanged.
-  #
-  #   { a: 1, b: 2, c: 3 }.transform_values { |x| x * 2 } # => { a: 2, b: 4, c: 6 }
-  #
-  # If you do not provide a +block+, it will return an Enumerator
-  # for chaining with other methods:
-  #
-  #   { a: 1, b: 2 }.transform_values.with_index { |v, i| [v, i].join.to_i } # => { a: 10, b: 21 }
-  def transform_values
-    return enum_for(:transform_values) { size } unless block_given?
-    return {} if empty?
-    result = self.class.new
-    each do |key, value|
-      result[key] = yield(value)
-    end
-    result
-  end unless method_defined? :transform_values
+require "active_support/deprecation"
 
-  # Destructively converts all values using the +block+ operations.
-  # Same as +transform_values+ but modifies +self+.
-  def transform_values!
-    return enum_for(:transform_values!) { size } unless block_given?
-    each do |key, value|
-      self[key] = yield(value)
-    end
-  end unless method_defined? :transform_values!
-  # TODO: Remove this file when supporting only Ruby 2.4+.
-end
+ActiveSupport::Deprecation.warn "Ruby 2.5+ (required by Rails 6) provides Hash#transform_values natively, so requiring active_support/core_ext/hash/transform_values is no longer necessary. Requiring it will raise LoadError in Rails 6.1."

data/lib/active_support/core_ext/integer/multiple.rb

@@ -7,6 +7,6 @@ class Integer
   #   6.multiple_of?(5)  # => false
   #   10.multiple_of?(2) # => true
   def multiple_of?(number)
-    number != 0 ? self % number == 0 : zero?
+    number == 0 ? self == 0 : self % number == 0
   end
 end