activesupport 4.2.11.1 → 5.2.4

data/lib/active_support/core_ext/date_time.rb

@@ -1,5 +1,7 @@
-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'
+# frozen_string_literal: true
+
+require "active_support/core_ext/date_time/acts_like"
+require "active_support/core_ext/date_time/blank"
+require "active_support/core_ext/date_time/calculations"
+require "active_support/core_ext/date_time/compatibility"
+require "active_support/core_ext/date_time/conversions"

data/lib/active_support/core_ext/digest/uuid.rb

@@ -1,4 +1,6 @@
-require 'securerandom'
+# frozen_string_literal: true
+
+require "securerandom"
 
 module Digest
   module UUID
@@ -12,7 +14,7 @@ module Digest
     # Using Digest::MD5 generates version 3 UUIDs; Digest::SHA1 generates version 5 UUIDs.
     # uuid_from_hash always generates the same UUID for a given name and namespace combination.
     #
-    # See RFC 4122 for details of UUID at: http://www.ietf.org/rfc/rfc4122.txt
+    # See RFC 4122 for details of UUID at: https://www.ietf.org/rfc/rfc4122.txt
     def self.uuid_from_hash(hash_class, uuid_namespace, name)
       if hash_class == Digest::MD5
         version = 3
@@ -26,7 +28,7 @@ module Digest
       hash.update(uuid_namespace)
       hash.update(name)
 
-      ary = hash.digest.unpack('NnnnnN')
+      ary = hash.digest.unpack("NnnnnN")
       ary[2] = (ary[2] & 0x0FFF) | (version << 12)
       ary[3] = (ary[3] & 0x3FFF) | 0x8000
 
@@ -35,12 +37,12 @@ module Digest
 
     # Convenience method for uuid_from_hash using Digest::MD5.
     def self.uuid_v3(uuid_namespace, name)
-      self.uuid_from_hash(Digest::MD5, uuid_namespace, name)
+      uuid_from_hash(Digest::MD5, uuid_namespace, name)
     end
 
     # Convenience method for uuid_from_hash using Digest::SHA1.
     def self.uuid_v5(uuid_namespace, name)
-      self.uuid_from_hash(Digest::SHA1, uuid_namespace, name)
+      uuid_from_hash(Digest::SHA1, uuid_namespace, name)
     end
 
     # Convenience method for SecureRandom.uuid.

data/lib/active_support/core_ext/digest.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/digest/uuid"

data/lib/active_support/core_ext/enumerable.rb

@@ -1,39 +1,71 @@
+# frozen_string_literal: true
+
 module Enumerable
-  # 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.
+  # Enumerable#sum was added in Ruby 2.4, but it only works with Numeric elements
+  # when we omit an identity.
   #
-  #  [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 = 0, &block)
-    if block_given?
-      map(&block).sum(identity)
-    else
-      inject { |sum, element| sum + element } || identity
+  # 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
     end
   end
 
   # Convert an enumerable to a hash.
   #
   #   people.index_by(&:login)
-  #     => { "nextangle" => <Person ...>, "chade-" => <Person ...>, ...}
+  #   # => { "nextangle" => <Person ...>, "chade-" => <Person ...>, ...}
   #   people.index_by { |person| "#{person.first_name} #{person.last_name}" }
-  #     => { "Chade- Fowlersburg-e" => <Person ...>, "David Heinemeier Hansson" => <Person ...>, ...}
+  #   # => { "Chade- Fowlersburg-e" => <Person ...>, "David Heinemeier Hansson" => <Person ...>, ...}
   def index_by
     if block_given?
-      Hash[map { |elem| [yield(elem), elem] }]
+      result = {}
+      each { |elem| result[yield(elem)] = elem }
+      result
     else
       to_enum(:index_by) { size if respond_to?(:size) }
     end
@@ -60,20 +92,47 @@ module Enumerable
   def exclude?(object)
     !include?(object)
   end
+
+  # Returns a copy of the enumerable without the specified elements.
+  #
+  #   ["David", "Rafael", "Aaron", "Todd"].without "Aaron", "Todd"
+  #   # => ["David", "Rafael"]
+  #
+  #   {foo: 1, bar: 2, baz: 3}.without :bar
+  #   # => {foo: 1, baz: 3}
+  def without(*elements)
+    reject { |element| elements.include?(element) }
+  end
+
+  # Convert an enumerable to an array based on the given key.
+  #
+  #   [{ name: "David" }, { name: "Rafael" }, { name: "Aaron" }].pluck(:name)
+  #   # => ["David", "Rafael", "Aaron"]
+  #
+  #   [{ id: 1, name: "David" }, { id: 2, name: "Rafael" }].pluck(:id, :name)
+  #   # => [[1, "David"], [2, "Rafael"]]
+  def pluck(*keys)
+    if keys.many?
+      map { |element| keys.map { |key| element[key] } }
+    else
+      map { |element| element[keys.first] }
+    end
+  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 = 0)
+  def sum(identity = nil)
     if block_given? || !(first.is_a?(Integer) && last.is_a?(Integer))
       super
     else
       actual_last = exclude_end? ? (last - 1) : last
       if actual_last >= first
-        (actual_last - first + 1) * (actual_last + first) / 2
+        sum = identity || 0
+        sum + (actual_last - first + 1) * (actual_last + first) / 2
       else
-        identity
+        identity || 0
       end
     end
   end
@@ -85,12 +144,21 @@ end
 # 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
+  # Using Refinements here in order not to expose our internal method
+  using Module.new {
+    refine Array do
+      alias :orig_sum :sum
+    end
+  }
 
-    def sum(*args) #:nodoc:
-      # Use Enumerable#sum instead.
-      super
+  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
     end
   end
 end

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

@@ -1,4 +1,6 @@
-require 'fileutils'
+# frozen_string_literal: true
+
+require "fileutils"
 
 class File
   # Write to a file atomically. Useful for situations where you don't
@@ -8,51 +10,56 @@ class File
   #     file.write('hello')
   #   end
   #
-  # If your temp directory is not on the same filesystem as the file you're
-  # trying to write, you can provide a different temporary directory.
+  # This method needs to create a temporary file. By default it will create it
+  # in the same directory as the destination file. If you don't like this
+  # behavior you can provide a different directory but it must be on the
+  # same physical filesystem as the file you're trying to write.
   #
   #   File.atomic_write('/data/something.important', '/data/tmp') do |file|
   #     file.write('hello')
   #   end
-  def self.atomic_write(file_name, temp_dir = Dir.tmpdir)
-    require 'tempfile' unless defined?(Tempfile)
-    require 'fileutils' unless defined?(FileUtils)
-
-    temp_file = Tempfile.new(basename(file_name), temp_dir)
-    temp_file.binmode
-    yield temp_file
-    temp_file.close
-
-    if File.exist?(file_name)
-      # Get original file permissions
-      old_stat = stat(file_name)
-    else
-      # If not possible, probe which are the default permissions in the
-      # destination directory.
-      old_stat = probe_stat_in(dirname(file_name))
-    end
+  def self.atomic_write(file_name, temp_dir = dirname(file_name))
+    require "tempfile" unless defined?(Tempfile)
+
+    Tempfile.open(".#{basename(file_name)}", temp_dir) do |temp_file|
+      temp_file.binmode
+      return_val = yield temp_file
+      temp_file.close
+
+      old_stat = if exist?(file_name)
+        # Get original file permissions
+        stat(file_name)
+      else
+        # If not possible, probe which are the default permissions in the
+        # destination directory.
+        probe_stat_in(dirname(file_name))
+      end
 
-    # Overwrite original file with temp file
-    FileUtils.mv(temp_file.path, file_name)
+      if old_stat
+        # Set correct permissions on new file
+        begin
+          chown(old_stat.uid, old_stat.gid, temp_file.path)
+          # This operation will affect filesystem ACL's
+          chmod(old_stat.mode, temp_file.path)
+        rescue Errno::EPERM, Errno::EACCES
+          # Changing file ownership failed, moving on.
+        end
+      end
 
-    # Set correct permissions on new file
-    begin
-      chown(old_stat.uid, old_stat.gid, file_name)
-      # This operation will affect filesystem ACL's
-      chmod(old_stat.mode, file_name)
-    rescue Errno::EPERM, Errno::EACCES
-      # Changing file ownership failed, moving on.
+      # Overwrite original file with temp file
+      rename(temp_file.path, file_name)
+      return_val
     end
   end
 
   # Private utility method.
   def self.probe_stat_in(dir) #:nodoc:
     basename = [
-      '.permissions_check',
+      ".permissions_check",
       Thread.current.object_id,
       Process.pid,
       rand(1000000)
-    ].join('.')
+    ].join(".")
 
     file_name = join(dir, basename)
     FileUtils.touch(file_name)

data/lib/active_support/core_ext/file.rb

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

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

@@ -1,24 +1,29 @@
+# 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 # => {}
+    #   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
-      self.select { |_, value| !value.nil? }
+      select { |_, value| !value.nil? }
     end
   end
 
   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}
+    #   hash = { a: true, b: false, c: nil }
+    #   hash.compact!        # => { a: true, b: false }
+    #   hash                 # => { a: true, b: false }
+    #   { c: true }.compact! # => nil
     def compact!
-      self.reject! { |_, value| value.nil? }
+      reject! { |_, value| value.nil? }
     end
   end
 end

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

@@ -1,11 +1,13 @@
-require 'active_support/xml_mini'
-require 'active_support/time'
-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/array/wrap'
-require 'active_support/core_ext/hash/reverse_merge'
-require 'active_support/core_ext/string/inflections'
+# frozen_string_literal: true
+
+require "active_support/xml_mini"
+require "active_support/time"
+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/array/wrap"
+require "active_support/core_ext/hash/reverse_merge"
+require "active_support/core_ext/string/inflections"
 
 class Hash
   # Returns a string containing an XML representation of its receiver:
@@ -31,7 +33,7 @@ class Hash
   #   with +key+ as <tt>:root</tt>, and +key+ singularized as second argument. The
   #   callable can add nodes by using <tt>options[:builder]</tt>.
   #
-  #     'foo'.to_xml(lambda { |options, key| options[:builder].b(key) })
+  #     {foo: lambda { |options, key| options[:builder].b(key) }}.to_xml
   #     # => "<b>foo</b>"
   #
   # * If +value+ responds to +to_xml+ the method is invoked with +key+ as <tt>:root</tt>.
@@ -71,11 +73,11 @@ 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)
 
     options = options.dup
     options[:indent]  ||= 2
-    options[:root]    ||= 'hash'
+    options[:root]    ||= "hash"
     options[:builder] ||= Builder::XmlMarkup.new(indent: options[:indent])
 
     builder = options[:builder]
@@ -105,7 +107,25 @@ class Hash
     #   # => {"hash"=>{"foo"=>1, "bar"=>2}}
     #
     # +DisallowedType+ is raised if the XML contains attributes with <tt>type="yaml"</tt> or
-    # <tt>type="symbol"</tt>. Use <tt>Hash.from_trusted_xml</tt> to parse this XML.
+    # <tt>type="symbol"</tt>. Use <tt>Hash.from_trusted_xml</tt> to
+    # parse this XML.
+    #
+    # Custom +disallowed_types+ can also be passed in the form of an
+    # array.
+    #
+    #   xml = <<-XML
+    #     <?xml version="1.0" encoding="UTF-8"?>
+    #       <hash>
+    #         <foo type="integer">1</foo>
+    #         <bar type="string">"David"</bar>
+    #       </hash>
+    #   XML
+    #
+    #   hash = Hash.from_xml(xml, ['integer'])
+    #   # => ActiveSupport::XMLConverter::DisallowedType: Disallowed type attribute: "integer"
+    #
+    # Note that passing custom disallowed types will override the default types,
+    # which are Symbol and YAML.
     def from_xml(xml, disallowed_types = nil)
       ActiveSupport::XMLConverter.new(xml, disallowed_types).to_h
     end
@@ -119,6 +139,8 @@ end
 
 module ActiveSupport
   class XMLConverter # :nodoc:
+    # Raised if the XML contains attributes with type="yaml" or
+    # type="symbol". Read Hash#from_xml for more details.
     class DisallowedType < StandardError
       def initialize(type)
         super "Disallowed type attribute: #{type.inspect}"
@@ -139,36 +161,36 @@ module ActiveSupport
     private
       def normalize_keys(params)
         case params
-          when Hash
-            Hash[params.map { |k,v| [k.to_s.tr('-', '_'), normalize_keys(v)] } ]
-          when Array
-            params.map { |v| normalize_keys(v) }
-          else
-            params
+        when Hash
+          Hash[params.map { |k, v| [k.to_s.tr("-", "_"), normalize_keys(v)] } ]
+        when Array
+          params.map { |v| normalize_keys(v) }
+        else
+          params
         end
       end
 
       def deep_to_h(value)
         case value
-          when Hash
-            process_hash(value)
-          when Array
-            process_array(value)
-          when String
-            value
-          else
-            raise "can't typecast #{value.class.name} - #{value.inspect}"
+        when Hash
+          process_hash(value)
+        when Array
+          process_array(value)
+        when String
+          value
+        else
+          raise "can't typecast #{value.class.name} - #{value.inspect}"
         end
       end
 
       def process_hash(value)
-        if value.include?('type') && !value['type'].is_a?(Hash) && @disallowed_types.include?(value['type'])
-          raise DisallowedType, value['type']
+        if value.include?("type") && !value["type"].is_a?(Hash) && @disallowed_types.include?(value["type"])
+          raise DisallowedType, value["type"]
         end
 
         if become_array?(value)
-          _, entries = Array.wrap(value.detect { |k,v| not v.is_a?(String) })
-          if entries.nil? || value['__content__'].try(:empty?)
+          _, entries = Array.wrap(value.detect { |k, v| not v.is_a?(String) })
+          if entries.nil? || value["__content__"].try(:empty?)
             []
           else
             case entries
@@ -184,28 +206,28 @@ module ActiveSupport
           process_content(value)
 
         elsif become_empty_string?(value)
-          ''
+          ""
         elsif become_hash?(value)
-          xml_value = Hash[value.map { |k,v| [k, deep_to_h(v)] }]
+          xml_value = Hash[value.map { |k, v| [k, deep_to_h(v)] }]
 
           # Turn { files: { file: #<StringIO> } } into { files: #<StringIO> } so it is compatible with
           # how multipart uploaded files from HTML appear
-          xml_value['file'].is_a?(StringIO) ? xml_value['file'] : xml_value
+          xml_value["file"].is_a?(StringIO) ? xml_value["file"] : xml_value
         end
       end
 
       def become_content?(value)
-        value['type'] == 'file' || (value['__content__'] && (value.keys.size == 1 || value['__content__'].present?))
+        value["type"] == "file" || (value["__content__"] && (value.keys.size == 1 || value["__content__"].present?))
       end
 
       def become_array?(value)
-        value['type'] == 'array'
+        value["type"] == "array"
       end
 
       def become_empty_string?(value)
         # { "string" => true }
         # No tests fail when the second term is removed.
-        value['type'] == 'string' && value['nil'] != 'true'
+        value["type"] == "string" && value["nil"] != "true"
       end
 
       def become_hash?(value)
@@ -214,19 +236,19 @@ module ActiveSupport
 
       def nothing?(value)
         # blank or nil parsed values are represented by nil
-        value.blank? || value['nil'] == 'true'
+        value.blank? || value["nil"] == "true"
       end
 
       def garbage?(value)
         # If the type is the only element which makes it then
         # this still makes the value nil, except if type is
         # an XML node(where type['value'] is a Hash)
-        value['type'] && !value['type'].is_a?(::Hash) && value.size == 1
+        value["type"] && !value["type"].is_a?(::Hash) && value.size == 1
       end
 
       def process_content(value)
-        content = value['__content__']
-        if parser = ActiveSupport::XmlMini::PARSING[value['type']]
+        content = value["__content__"]
+        if parser = ActiveSupport::XmlMini::PARSING[value["type"]]
           parser.arity == 1 ? parser.call(content) : parser.call(content, value)
         else
           content
@@ -237,6 +259,5 @@ module ActiveSupport
         value.map! { |i| deep_to_h(i) }
         value.length > 1 ? value : value.first
       end
-
   end
 end

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 class Hash
   # Returns a new hash with +self+ and +other_hash+ merged recursively.
   #
   #   h1 = { a: true, b: { c: [1, 2, 3] } }
   #   h2 = { a: false, b: { x: [3, 4, 5] } }
   #
-  #   h1.deep_merge(h2) #=> { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
+  #   h1.deep_merge(h2) # => { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
   #
   # Like with Hash#merge in the standard library, a block can be provided
   # to merge values:
@@ -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/except.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 class Hash
-  # Returns a hash that includes everything but the given keys.
-  #   hash = { a: true, b: false, c: nil}
-  #   hash.except(:c) # => { a: true, b: false}
-  #   hash # => { a: true, b: false, c: nil}
+  # Returns a hash that includes everything except given keys.
+  #   hash = { a: true, b: false, c: nil }
+  #   hash.except(:c)     # => { a: true, b: false }
+  #   hash.except(:a, :b) # => { c: nil }
+  #   hash                # => { a: true, b: false, c: nil }
   #
   # This is useful for limiting a set of parameters to everything but a few known toggles:
   #   @person.update(params[:person].except(:admin))
@@ -10,10 +13,10 @@ class Hash
     dup.except!(*keys)
   end
 
-  # Replaces the hash without the given keys.
-  #   hash = { a: true, b: false, c: nil}
-  #   hash.except!(:c) # => { a: true, b: false}
-  #   hash # => { a: true, b: false }
+  # Removes the given keys from hash and returns it.
+  #   hash = { a: true, b: false, c: nil }
+  #   hash.except!(:c) # => { a: true, b: false }
+  #   hash             # => { a: true, b: false }
   def except!(*keys)
     keys.each { |key| delete(key) }
     self

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

@@ -1,12 +1,13 @@
-require 'active_support/hash_with_indifferent_access'
+# frozen_string_literal: true
 
-class Hash
+require "active_support/hash_with_indifferent_access"
 
+class Hash
   # Returns an <tt>ActiveSupport::HashWithIndifferentAccess</tt> out of its receiver:
   #
   #   { a: 1 }.with_indifferent_access['a'] # => 1
   def with_indifferent_access
-    ActiveSupport::HashWithIndifferentAccess.new_from_hash_copying_default(self)
+    ActiveSupport::HashWithIndifferentAccess.new(self)
   end
 
   # Called when object is nested under an object that receives