activesupport 6.0.3.6 → 6.1.1

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

@@ -1,10 +1,10 @@
 # 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/object/try"
 require "active_support/core_ext/array/wrap"
 require "active_support/core_ext/hash/reverse_merge"
 require "active_support/core_ext/string/inflections"
@@ -208,7 +208,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_transform_values.rb

@@ -21,7 +21,7 @@ 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_values_in_object(object, &block)
       case object
       when Hash

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

@@ -11,7 +11,7 @@ class Hash
   #   @person.update(params[:person].except(:admin))
   def except(*keys)
     slice(*self.keys - keys)
-  end
+  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/keys.rb

@@ -112,7 +112,7 @@ 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

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

@@ -18,8 +18,9 @@ class Hash
 
   # Removes and returns the key/value pairs matching the given keys.
   #
-  #   { a: 1, b: 2, c: 3, d: 4 }.extract!(:a, :b) # => {:a=>1, :b=>2}
-  #   { a: 1, b: 2 }.extract!(:a, :x)             # => {:a=>1}
+  #   hash = { a: 1, b: 2, c: 3, d: 4 }
+  #   hash.extract!(:a, :b) # => {:a=>1, :b=>2}
+  #   hash                  # => {:c=>3, :d=>4}
   def extract!(*keys)
     keys.each_with_object(self.class.new) { |key, result| result[key] = delete(key) if has_key?(key) }
   end

data/lib/active_support/core_ext/load_error.rb

@@ -4,6 +4,6 @@ class LoadError
   # Returns true if the given path name (except perhaps for the ".rb"
   # extension) is the missing file which caused the exception to be raised.
   def is_missing?(location)
-    location.sub(/\.rb$/, "") == path.to_s.sub(/\.rb$/, "")
+    location.delete_suffix(".rb") == path.to_s.delete_suffix(".rb")
   end
 end

data/lib/active_support/core_ext/marshal.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/string/inflections"
+
 module ActiveSupport
   module MarshalWithAutoloading # :nodoc:
     def load(source, proc = nil)

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

@@ -28,9 +28,9 @@ class Module
     end
 
     def attr_internal_define(attr_name, type)
-      internal_name = attr_internal_ivar_name(attr_name).sub(/\A@/, "")
+      internal_name = attr_internal_ivar_name(attr_name).delete_prefix("@")
       # use native attr_* methods as they are faster on some Ruby implementations
-      send("attr_#{type}", internal_name)
+      public_send("attr_#{type}", internal_name)
       attr_name, internal_name = "#{attr_name}=", "#{internal_name}=" if type == :writer
       alias_method attr_name, internal_name
       remove_method internal_name

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

@@ -48,28 +48,25 @@ class Module
   #   end
   #
   #   Person.new.hair_colors # => [:brown, :black, :blonde, :red]
-  def mattr_reader(*syms, instance_reader: true, instance_accessor: true, default: nil)
+  def mattr_reader(*syms, instance_reader: true, instance_accessor: true, default: nil, location: nil)
+    raise TypeError, "module attributes should be defined directly on class, not singleton" if singleton_class?
+    location ||= caller_locations(1, 1).first
+
+    definition = []
     syms.each do |sym|
       raise NameError.new("invalid attribute name: #{sym}") unless /\A[_A-Za-z]\w*\z/.match?(sym)
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        @@#{sym} = nil unless defined? @@#{sym}
 
-        def self.#{sym}
-          @@#{sym}
-        end
-      EOS
+      definition << "def self.#{sym}; @@#{sym}; end"
 
       if instance_reader && instance_accessor
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-          def #{sym}
-            @@#{sym}
-          end
-        EOS
+        definition << "def #{sym}; @@#{sym}; end"
       end
 
       sym_default_value = (block_given? && default.nil?) ? yield : default
-      class_variable_set("@@#{sym}", sym_default_value) unless sym_default_value.nil?
+      class_variable_set("@@#{sym}", sym_default_value) unless sym_default_value.nil? && class_variable_defined?("@@#{sym}")
     end
+
+    module_eval(definition.join(";"), location.path, location.lineno)
   end
   alias :cattr_reader :mattr_reader
 
@@ -115,28 +112,24 @@ class Module
   #   end
   #
   #   Person.class_variable_get("@@hair_colors") # => [:brown, :black, :blonde, :red]
-  def mattr_writer(*syms, instance_writer: true, instance_accessor: true, default: nil)
+  def mattr_writer(*syms, instance_writer: true, instance_accessor: true, default: nil, location: nil)
+    raise TypeError, "module attributes should be defined directly on class, not singleton" if singleton_class?
+    location ||= caller_locations(1, 1).first
+
+    definition = []
     syms.each do |sym|
       raise NameError.new("invalid attribute name: #{sym}") unless /\A[_A-Za-z]\w*\z/.match?(sym)
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        @@#{sym} = nil unless defined? @@#{sym}
-
-        def self.#{sym}=(obj)
-          @@#{sym} = obj
-        end
-      EOS
+      definition << "def self.#{sym}=(val); @@#{sym} = val; end"
 
       if instance_writer && instance_accessor
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-          def #{sym}=(obj)
-            @@#{sym} = obj
-          end
-        EOS
+        definition << "def #{sym}=(val); @@#{sym} = val; end"
       end
 
       sym_default_value = (block_given? && default.nil?) ? yield : default
-      send("#{sym}=", sym_default_value) unless sym_default_value.nil?
+      class_variable_set("@@#{sym}", sym_default_value) unless sym_default_value.nil? && class_variable_defined?("@@#{sym}")
     end
+
+    module_eval(definition.join(";"), location.path, location.lineno)
   end
   alias :cattr_writer :mattr_writer
 
@@ -205,8 +198,9 @@ class Module
   #
   #   Person.class_variable_get("@@hair_colors") # => [:brown, :black, :blonde, :red]
   def mattr_accessor(*syms, instance_reader: true, instance_writer: true, instance_accessor: true, default: nil, &blk)
-    mattr_reader(*syms, instance_reader: instance_reader, instance_accessor: instance_accessor, default: default, &blk)
-    mattr_writer(*syms, instance_writer: instance_writer, instance_accessor: instance_accessor, default: default)
+    location = caller_locations(1, 1).first
+    mattr_reader(*syms, instance_reader: instance_reader, instance_accessor: instance_accessor, default: default, location: location, &blk)
+    mattr_writer(*syms, instance_writer: instance_writer, instance_accessor: instance_accessor, default: default, location: location)
   end
   alias :cattr_accessor :mattr_accessor
 end

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

@@ -33,7 +33,7 @@ class Module
   #   end
   #
   #   Current.new.user # => NoMethodError
-  def thread_mattr_reader(*syms, instance_reader: true, instance_accessor: true) # :nodoc:
+  def thread_mattr_reader(*syms, instance_reader: true, instance_accessor: true, default: nil) # :nodoc:
     syms.each do |sym|
       raise NameError.new("invalid attribute name: #{sym}") unless /^[_A-Za-z]\w*$/.match?(sym)
 
@@ -52,6 +52,8 @@ class Module
           end
         EOS
       end
+
+      Thread.current["attr_" + name + "_#{sym}"] = default unless default.nil?
     end
   end
   alias :thread_cattr_reader :thread_mattr_reader
@@ -74,7 +76,7 @@ class Module
   #   end
   #
   #   Current.new.user = "DHH" # => NoMethodError
-  def thread_mattr_writer(*syms, instance_writer: true, instance_accessor: true) # :nodoc:
+  def thread_mattr_writer(*syms, instance_writer: true, instance_accessor: true, default: nil) # :nodoc:
     syms.each do |sym|
       raise NameError.new("invalid attribute name: #{sym}") unless /^[_A-Za-z]\w*$/.match?(sym)
 
@@ -93,6 +95,8 @@ class Module
           end
         EOS
       end
+
+      public_send("#{sym}=", default) unless default.nil?
     end
   end
   alias :thread_cattr_writer :thread_mattr_writer
@@ -136,8 +140,8 @@ class Module
   #
   #   Current.new.user = "DHH"  # => NoMethodError
   #   Current.new.user          # => NoMethodError
-  def thread_mattr_accessor(*syms, instance_reader: true, instance_writer: true, instance_accessor: true)
-    thread_mattr_reader(*syms, instance_reader: instance_reader, instance_accessor: instance_accessor)
+  def thread_mattr_accessor(*syms, instance_reader: true, instance_writer: true, instance_accessor: true, default: nil)
+    thread_mattr_reader(*syms, instance_reader: instance_reader, instance_accessor: instance_accessor, default: default)
     thread_mattr_writer(*syms, instance_writer: instance_writer, instance_accessor: instance_accessor)
   end
   alias :thread_cattr_accessor :thread_mattr_accessor

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

@@ -104,10 +104,16 @@ class Module
   # * grok the behavior of our class in one glance,
   # * clean up monolithic junk-drawer classes by separating their concerns, and
   # * stop leaning on protected/private for crude "this is internal stuff" modularity.
+  #
+  # === Prepending concerning
+  #
+  # <tt>concerning</tt> supports a <tt>prepend: true</tt> argument which will <tt>prepend</tt> the
+  # concern instead of using <tt>include</tt> for it.
   module Concerning
     # Define a new concern and mix it in.
-    def concerning(topic, &block)
-      include concern(topic, &block)
+    def concerning(topic, prepend: false, &block)
+      method = prepend ? :prepend : :include
+      __send__(method, concern(topic, &block))
     end
 
     # A low-cruft shortcut to define a concern.

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

@@ -170,7 +170,7 @@ class Module
   # The target method must be public, otherwise it will raise +NoMethodError+.
   def delegate(*methods, to: nil, prefix: nil, allow_nil: nil, private: nil)
     unless to
-      raise ArgumentError, "Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, to: :greeter)."
+      raise ArgumentError, "Delegation needs a target. Supply a keyword argument 'to' (e.g. delegate :hello, to: :greeter)."
     end
 
     if prefix == true && /^[^a-z_]/.match?(to)
@@ -190,7 +190,13 @@ class Module
     to = to.to_s
     to = "self.#{to}" if DELEGATION_RESERVED_METHOD_NAMES.include?(to)
 
-    method_names = methods.map do |method|
+    method_def = []
+    method_names = []
+
+    methods.map do |method|
+      method_name = prefix ? "#{method_prefix}#{method}" : method
+      method_names << method_name.to_sym
+
       # Attribute writer methods only accept one argument. Makes sure []=
       # methods still accept two arguments.
       definition = if /[^\]]=$/.match?(method)
@@ -209,34 +215,33 @@ class Module
       # whereas conceptually, from the user point of view, the delegator should
       # be doing one call.
       if allow_nil
-        method_def = [
-          "def #{method_prefix}#{method}(#{definition})",
-          "_ = #{to}",
-          "if !_.nil? || nil.respond_to?(:#{method})",
-          "  _.#{method}(#{definition})",
-          "end",
-        "end"
-        ].join ";"
+        method = method.to_s
+
+        method_def <<
+          "def #{method_name}(#{definition})" <<
+          "  _ = #{to}" <<
+          "  if !_.nil? || nil.respond_to?(:#{method})" <<
+          "    _.#{method}(#{definition})" <<
+          "  end" <<
+          "end"
       else
-        exception = %(raise DelegationError, "#{self}##{method_prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
+        method = method.to_s
+        method_name = method_name.to_s
 
-        method_def = [
-          "def #{method_prefix}#{method}(#{definition})",
-          " _ = #{to}",
-          "  _.#{method}(#{definition})",
-          "rescue NoMethodError => e",
-          "  if _.nil? && e.name == :#{method}",
-          "    #{exception}",
-          "  else",
-          "    raise",
-          "  end",
+        method_def <<
+          "def #{method_name}(#{definition})" <<
+          "  _ = #{to}" <<
+          "  _.#{method}(#{definition})" <<
+          "rescue NoMethodError => e" <<
+          "  if _.nil? && e.name == :#{method}" <<
+          %(   raise DelegationError, "#{self}##{method_name} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}") <<
+          "  else" <<
+          "    raise" <<
+          "  end" <<
           "end"
-        ].join ";"
       end
-
-      module_eval(method_def, file, line)
     end
-
+    module_eval(method_def.join(";"), file, line)
     private(*method_names) if private
     method_names
   end
@@ -280,13 +285,14 @@ class Module
   # variables, methods, constants, etc.
   #
   # The delegated method must be public on the target, otherwise it will
-  # raise +NoMethodError+.
+  # raise +DelegationError+. If you wish to instead return +nil+,
+  # use the <tt>:allow_nil</tt> option.
   #
   # The <tt>marshal_dump</tt> and <tt>_dump</tt> methods are exempt from
   # delegation due to possible interference when calling
   # <tt>Marshal.dump(object)</tt>, should the delegation target method
   # of <tt>object</tt> add or remove instance variables.
-  def delegate_missing_to(target)
+  def delegate_missing_to(target, allow_nil: nil)
     target = target.to_s
     target = "self.#{target}" if DELEGATION_RESERVED_METHOD_NAMES.include?(target)
 
@@ -307,7 +313,11 @@ class Module
             super
           rescue NoMethodError
             if #{target}.nil?
-              raise DelegationError, "\#{method} delegated to #{target}, but #{target} is nil"
+              if #{allow_nil == true}
+                nil
+              else
+                raise DelegationError, "\#{method} delegated to #{target}, but #{target} is nil"
+              end
             else
               raise
             end

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

@@ -11,20 +11,12 @@ class Module
     if defined?(@parent_name)
       @parent_name
     else
-      parent_name = name =~ /::[^:]+\Z/ ? $`.freeze : nil
+      parent_name = name =~ /::[^:]+\z/ ? -$` : nil
       @parent_name = parent_name unless frozen?
       parent_name
     end
   end
 
-  def parent_name
-    ActiveSupport::Deprecation.warn(<<-MSG.squish)
-      `Module#parent_name` has been renamed to `module_parent_name`.
-      `parent_name` is deprecated and will be removed in Rails 6.1.
-    MSG
-    module_parent_name
-  end
-
   # Returns the module which contains this one according to its name.
   #
   #   module M
@@ -44,14 +36,6 @@ class Module
     module_parent_name ? ActiveSupport::Inflector.constantize(module_parent_name) : Object
   end
 
-  def parent
-    ActiveSupport::Deprecation.warn(<<-MSG.squish)
-      `Module#parent` has been renamed to `module_parent`.
-      `parent` is deprecated and will be removed in Rails 6.1.
-    MSG
-    module_parent
-  end
-
   # Returns all the parents of this module according to its name, ordered from
   # nested outwards. The receiver is not contained within the result.
   #
@@ -76,12 +60,4 @@ class Module
     parents << Object unless parents.include? Object
     parents
   end
-
-  def parents
-    ActiveSupport::Deprecation.warn(<<-MSG.squish)
-      `Module#parents` has been renamed to `module_parents`.
-      `parents` is deprecated and will be removed in Rails 6.1.
-    MSG
-    module_parents
-  end
 end

data/lib/active_support/core_ext/name_error.rb

@@ -14,9 +14,22 @@ class NameError
     # It extends NameError#message with spell corrections which are SLOW.
     # We should use original_message message instead.
     message = respond_to?(:original_message) ? original_message : self.message
+    return unless message.start_with?("uninitialized constant ")
 
-    if /undefined local variable or method/ !~ message
-      $1 if /((::)?([A-Z]\w*)(::[A-Z]\w*)*)$/ =~ message
+    receiver = begin
+      self.receiver
+    rescue ArgumentError
+      nil
+    end
+
+    if receiver == Object
+      name.to_s
+    elsif receiver
+      "#{real_mod_name(receiver)}::#{self.name}"
+    else
+      if match = message.match(/((::)?([A-Z]\w*)(::[A-Z]\w*)*)$/)
+        match[1]
+      end
     end
   end
 
@@ -35,4 +48,18 @@ class NameError
       missing_name == name.to_s
     end
   end
+
+  private
+    UNBOUND_METHOD_MODULE_NAME = Module.instance_method(:name)
+    private_constant :UNBOUND_METHOD_MODULE_NAME
+
+    if UnboundMethod.method_defined?(:bind_call)
+      def real_mod_name(mod)
+        UNBOUND_METHOD_MODULE_NAME.bind_call(mod)
+      end
+    else
+      def real_mod_name(mod)
+        UNBOUND_METHOD_MODULE_NAME.bind(mod).call
+      end
+    end
 end