activesupport 5.1.7 → 7.0.4.1

data/lib/active_support/core_ext/enumerable.rb

@@ -1,57 +1,103 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module EnumerableCoreExt # :nodoc:
+    module Constants
+      private
+        def const_missing(name)
+          if name == :SoleItemExpectedError
+            ::ActiveSupport::EnumerableCoreExt::SoleItemExpectedError
+          else
+            super
+          end
+        end
+    end
+  end
+end
+
 module Enumerable
-  # Enumerable#sum was added in Ruby 2.4 but it only works with Numeric elements
+  # Error generated by +sole+ when called on an enumerable that doesn't have
+  # exactly one item.
+  class SoleItemExpectedError < StandardError; end
+
+  # HACK: For performance reasons, Enumerable shouldn't have any constants of its own.
+  # So we move SoleItemExpectedError into ActiveSupport::EnumerableCoreExt.
+  ActiveSupport::EnumerableCoreExt::SoleItemExpectedError = remove_const(:SoleItemExpectedError)
+  singleton_class.prepend(ActiveSupport::EnumerableCoreExt::Constants)
+
+  # 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 the minimum from the extracted 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)
-    # 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
-    # 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 = [Payment.new(5), Payment.new(15), Payment.new(10)]
+  #   payments.minimum(:price) # => 5
+  def minimum(key)
+    map(&key).min
+  end
+
+  # Calculates the maximum from the extracted elements.
+  #
+  #   payments = [Payment.new(5), Payment.new(15), Payment.new(10)]
+  #   payments.maximum(:price) # => 15
+  def maximum(key)
+    map(&key).max
+  end
+
+  # 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
+    # we check `first(1) == []` to check if we have an
+    # empty Enumerable; checking `empty?` would return
+    # true for `[nil]`, which we want to deprecate to
+    # keep consistent with Ruby
+    elsif first.is_a?(Numeric) || first(1) == []
+      identity ||= 0
+      _original_sum_with_required_identity(identity, &block)
+    else
+      ActiveSupport::Deprecation.warn(<<-MSG.squish)
+        Rails 7.0 has deprecated Enumerable.sum in favor of Ruby's native implementation available since 2.4.
+        Sum of non-numeric elements requires an initial argument.
+      MSG
+      inject(:+) || 0
     end
   end
 
-  # Convert an enumerable to a hash.
+  # Convert an enumerable to a hash, using the block result as the key and the
+  # element as the 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
@@ -64,6 +110,33 @@ module Enumerable
     end
   end
 
+  # Convert an enumerable to a hash, using the element as the key and the block
+  # result as the value.
+  #
+  #   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?" }
+  #
+  # If an argument is passed instead of a block, it will be used as the value
+  # for all elements:
+  #
+  #   %i( created_at updated_at ).index_with(Time.now)
+  #   # => { created_at: 2020-03-09 22:31:47, updated_at: 2020-03-09 22:31:47 }
+  def index_with(default = (no_default = true))
+    if block_given?
+      result = {}
+      each { |elem| result[elem] = yield(elem) }
+      result
+    elsif no_default
+      to_enum(:index_with) { size if respond_to?(:size) }
+    else
+      result = {}
+      each { |elem| result[elem] = default }
+      result
+    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+
@@ -80,24 +153,40 @@ 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 :without :excluding
 
-  # Convert an enumerable to an array based on the given key.
+  # Extract the given key from each element in the enumerable.
   #
   #   [{ name: "David" }, { name: "Rafael" }, { name: "Aaron" }].pluck(:name)
   #   # => ["David", "Rafael", "Aaron"]
@@ -108,12 +197,91 @@ module Enumerable
     if keys.many?
       map { |element| keys.map { |key| element[key] } }
     else
-      map { |element| element[keys.first] }
+      key = keys.first
+      map { |element| element[key] }
+    end
+  end
+
+  # Extract the given key from the first element in the enumerable.
+  #
+  #   [{ name: "David" }, { name: "Rafael" }, { name: "Aaron" }].pick(:name)
+  #   # => "David"
+  #
+  #   [{ id: 1, name: "David" }, { id: 2, name: "Rafael" }].pick(:id, :name)
+  #   # => [1, "David"]
+  def pick(*keys)
+    return if none?
+
+    if keys.many?
+      keys.map { |key| first[key] }
+    else
+      first[keys.first]
+    end
+  end
+
+  # Returns a new +Array+ without the blank items.
+  # Uses Object#blank? for determining if an item is blank.
+  #
+  #   [1, "", nil, 2, " ", [], {}, false, true].compact_blank
+  #   # =>  [1, 2, true]
+  #
+  #   Set.new([nil, "", 1, 2])
+  #   # => [2, 1] (or [1, 2])
+  #
+  # When called on a +Hash+, returns a new +Hash+ without the blank values.
+  #
+  #   { a: "", b: 1, c: nil, d: [], e: false, f: true }.compact_blank
+  #   # => { b: 1, f: true }
+  def compact_blank
+    reject(&:blank?)
+  end
+
+  # Returns a new +Array+ where the order has been set to that provided in the +series+, based on the +key+ of the
+  # objects in the original enumerable.
+  #
+  #   [ Person.find(5), Person.find(3), Person.find(1) ].in_order_of(:id, [ 1, 5, 3 ])
+  #   # => [ Person.find(1), Person.find(5), Person.find(3) ]
+  #
+  # If the +series+ include keys that have no corresponding element in the Enumerable, these are ignored.
+  # If the Enumerable has additional elements that aren't named in the +series+, these are not included in the result.
+  def in_order_of(key, series)
+    index_by(&key).values_at(*series).compact
+  end
+
+  # Returns the sole item in the enumerable. If there are no items, or more
+  # than one item, raises +Enumerable::SoleItemExpectedError+.
+  #
+  #   ["x"].sole          # => "x"
+  #   Set.new.sole        # => Enumerable::SoleItemExpectedError: no item found
+  #   { a: 1, b: 2 }.sole # => Enumerable::SoleItemExpectedError: multiple items found
+  def sole
+    case count
+    when 1   then return first # rubocop:disable Style/RedundantReturn
+    when 0   then raise ActiveSupport::EnumerableCoreExt::SoleItemExpectedError, "no item found"
+    when 2.. then raise ActiveSupport::EnumerableCoreExt::SoleItemExpectedError, "multiple items found"
     end
   end
 end
 
-class Range #:nodoc:
+class Hash
+  # Hash#reject has its own definition, so this needs one too.
+  def compact_blank # :nodoc:
+    reject { |_k, v| v.blank? }
+  end
+
+  # Removes all blank values from the +Hash+ in place and returns self.
+  # Uses Object#blank? for determining if a value is blank.
+  #
+  #   h = { a: "", b: 1, c: nil, d: [], e: false, f: true }
+  #   h.compact_blank!
+  #   # => { b: 1, f: true }
+  def compact_blank!
+    # use delete_if rather than reject! because it always returns self even if nothing changed
+    delete_if { |_k, v| v.blank? }
+  end
+end
+
+class Range # :nodoc:
   # Optimize range sum to use arithmetic progression if a block is not given and
   # we have a range of numeric values.
   def sum(identity = nil)
@@ -131,27 +299,31 @@ 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:
+  def sum(init = nil, &block)
+    if init.is_a?(Numeric) || first.is_a?(Numeric)
+      init ||= 0
+      orig_sum(init, &block)
+    else
+      super
     end
   end
+
+  # Removes all blank elements from the +Array+ in place and returns self.
+  # Uses Object#blank? for determining if an item is blank.
+  #
+  #   a = [1, "", nil, 2, " ", [], {}, false, true]
+  #   a.compact_blank!
+  #   # =>  [1, 2, true]
+  def compact_blank!
+    # use delete_if rather than reject! because it always returns self even if nothing changed
+    delete_if(&:blank?)
+  end
 end

data/lib/active_support/core_ext/file/atomic.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "fileutils"
 
 class File
@@ -27,7 +29,7 @@ class File
       old_stat = if exist?(file_name)
         # Get original file permissions
         stat(file_name)
-      elsif temp_dir != dirname(file_name)
+      else
         # If not possible, probe which are the default permissions in the
         # destination directory.
         probe_stat_in(dirname(file_name))
@@ -51,7 +53,7 @@ class File
   end
 
   # Private utility method.
-  def self.probe_stat_in(dir) #:nodoc:
+  def self.probe_stat_in(dir) # :nodoc:
     basename = [
       ".permissions_check",
       Thread.current.object_id,
@@ -62,6 +64,8 @@ class File
     file_name = join(dir, basename)
     FileUtils.touch(file_name)
     stat(file_name)
+  rescue Errno::ENOENT
+    file_name = nil
   ensure
     FileUtils.rm_f(file_name) if file_name
   end

data/lib/active_support/core_ext/file.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/file/atomic"

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

@@ -1,8 +1,9 @@
-require "active_support/xml_mini"
-require "active_support/time"
+# frozen_string_literal: true
+
 require "active_support/core_ext/object/blank"
 require "active_support/core_ext/object/to_param"
 require "active_support/core_ext/object/to_query"
+require "active_support/core_ext/object/try"
 require "active_support/core_ext/array/wrap"
 require "active_support/core_ext/hash/reverse_merge"
 require "active_support/core_ext/string/inflections"
@@ -71,7 +72,7 @@ class Hash
   # configure your own builder with the <tt>:builder</tt> option. The method also accepts
   # options like <tt>:dasherize</tt> and friends, they are forwarded to the builder.
   def to_xml(options = {})
-    require "active_support/builder" unless defined?(Builder)
+    require "active_support/builder" unless defined?(Builder::XmlMarkup)
 
     options = options.dup
     options[:indent]  ||= 2
@@ -163,7 +164,7 @@ module ActiveSupport
           Hash[params.map { |k, v| [k.to_s.tr("-", "_"), normalize_keys(v)] } ]
         when Array
           params.map { |v| normalize_keys(v) }
-          else
+        else
           params
         end
       end
@@ -176,7 +177,7 @@ module ActiveSupport
           process_array(value)
         when String
           value
-          else
+        else
           raise "can't typecast #{value.class.name} - #{value.inspect}"
         end
       end
@@ -206,7 +207,7 @@ module ActiveSupport
         elsif become_empty_string?(value)
           ""
         elsif become_hash?(value)
-          xml_value = Hash[value.map { |k, v| [k, deep_to_h(v)] }]
+          xml_value = value.transform_values { |v| deep_to_h(v) }
 
           # Turn { files: { file: #<StringIO> } } into { files: #<StringIO> } so it is compatible with
           # how multipart uploaded files from HTML appear

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Hash
   # Returns a new hash with +self+ and +other_hash+ merged recursively.
   #
@@ -19,20 +21,14 @@ class Hash
 
   # Same as +deep_merge+, but modifies +self+.
   def deep_merge!(other_hash, &block)
-    other_hash.each_pair do |current_key, other_value|
-      this_value = self[current_key]
-
-      self[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
-        this_value.deep_merge(other_value, &block)
+    merge!(other_hash) do |key, this_val, other_val|
+      if this_val.is_a?(Hash) && other_val.is_a?(Hash)
+        this_val.deep_merge(other_val, &block)
+      elsif block_given?
+        block.call(key, this_val, other_val)
       else
-        if block_given? && key?(current_key)
-          block.call(current_key, this_value, other_value)
-        else
-          other_value
-        end
+        other_val
       end
     end
-
-    self
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Hash
   # Returns a hash that includes everything except given keys.
   #   hash = { a: true, b: false, c: nil }
@@ -8,8 +10,8 @@ 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)
-  end
+    slice(*self.keys - keys)
+  end unless method_defined?(:except)
 
   # Removes the given keys from hash and returns it.
   #   hash = { a: true, b: false, c: nil }

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

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require "active_support/hash_with_indifferent_access"
 
 class Hash
-  # Returns an <tt>ActiveSupport::HashWithIndifferentAccess</tt> out of its receiver:
+  # Returns an ActiveSupport::HashWithIndifferentAccess out of its receiver:
   #
   #   { a: 1 }.with_indifferent_access['a'] # => 1
   def with_indifferent_access
@@ -11,8 +13,8 @@ class Hash
   # Called when object is nested under an object that receives
   # #with_indifferent_access. This method will be called on the current object
   # by the enclosing object and is aliased to #with_indifferent_access by
-  # default. Subclasses of Hash may overwrite this method to return +self+ if
-  # converting to an <tt>ActiveSupport::HashWithIndifferentAccess</tt> would not be
+  # default. Subclasses of Hash may override this method to return +self+ if
+  # converting to an ActiveSupport::HashWithIndifferentAccess would not be
   # desirable.
   #
   #   b = { b: 1 }

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

@@ -1,33 +1,6 @@
-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!
+# frozen_string_literal: true
 
+class Hash
   # Returns a new hash with all keys converted to strings.
   #
   #   hash = { name: 'Rob', age: '28' }
@@ -139,11 +112,11 @@ class Hash
   end
 
   private
-    # support methods for deep transforming nested hashes and arrays
+    # Support methods for deep transforming nested hashes and arrays.
     def _deep_transform_keys_in_object(object, &block)
       case object
       when Hash
-        object.each_with_object({}) do |(key, value), result|
+        object.each_with_object(self.class.new) do |(key, value), result|
           result[yield(key)] = _deep_transform_keys_in_object(value, &block)
         end
       when Array

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Hash
   # Merges the caller into +other_hash+. For example,
   #
@@ -12,11 +14,12 @@ class Hash
   def reverse_merge(other_hash)
     other_hash.merge(self)
   end
+  alias_method :with_defaults, :reverse_merge
 
   # Destructive +reverse_merge+.
   def reverse_merge!(other_hash)
-    # right wins if there is no left
-    merge!(other_hash) { |key, left, right| left }
+    replace(reverse_merge(other_hash))
   end
   alias_method :reverse_update, :reverse_merge!
+  alias_method :with_defaults!, :reverse_merge!
 end