activesupport 5.0.0 → 6.1.0

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

@@ -1,9 +1,9 @@
-require 'active_support/core_ext/array/extract_options'
+# frozen_string_literal: true
 
 # Extends the module object with class/module and instance accessors for
 # class/module attributes, just like the native attr* accessors for instance
 # attributes, but does so on a per-thread basis.
-# 
+#
 # So the values are scoped within the Thread.current space under the class name
 # of the module.
 class Module
@@ -25,7 +25,7 @@ class Module
   #   end
   #   # => NameError: invalid attribute name: 1_Badname
   #
-  # If you want to opt out the creation on the instance reader method, pass
+  # To omit the instance reader method, pass
   # <tt>instance_reader: false</tt> or <tt>instance_accessor: false</tt>.
   #
   #   class Current
@@ -33,24 +33,27 @@ class Module
   #   end
   #
   #   Current.new.user # => NoMethodError
-  def thread_mattr_reader(*syms)
-    options = syms.extract_options!
-
+  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 sym =~ /^[_A-Za-z]\w*$/
+      raise NameError.new("invalid attribute name: #{sym}") unless /^[_A-Za-z]\w*$/.match?(sym)
+
+      # The following generated method concatenates `name` because we want it
+      # to work with inheritance via polymorphism.
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
         def self.#{sym}
-          Thread.current[:"attr_#{name}_#{sym}"]
+          Thread.current["attr_" + name + "_#{sym}"]
         end
       EOS
 
-      unless options[:instance_reader] == false || options[:instance_accessor] == false
+      if instance_reader && instance_accessor
         class_eval(<<-EOS, __FILE__, __LINE__ + 1)
           def #{sym}
-            Thread.current[:"attr_#{name}_#{sym}"]
+            self.class.#{sym}
           end
         EOS
       end
+
+      Thread.current["attr_" + name + "_#{sym}"] = default unless default.nil?
     end
   end
   alias :thread_cattr_reader :thread_mattr_reader
@@ -65,7 +68,7 @@ class Module
   #   Current.user = "DHH"
   #   Thread.current[:attr_Current_user] # => "DHH"
   #
-  # If you want to opt out the instance writer method, pass
+  # To omit the instance writer method, pass
   # <tt>instance_writer: false</tt> or <tt>instance_accessor: false</tt>.
   #
   #   class Current
@@ -73,23 +76,27 @@ class Module
   #   end
   #
   #   Current.new.user = "DHH" # => NoMethodError
-  def thread_mattr_writer(*syms)
-    options = syms.extract_options!
+  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 sym =~ /^[_A-Za-z]\w*$/
+      raise NameError.new("invalid attribute name: #{sym}") unless /^[_A-Za-z]\w*$/.match?(sym)
+
+      # The following generated method concatenates `name` because we want it
+      # to work with inheritance via polymorphism.
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
         def self.#{sym}=(obj)
-          Thread.current[:"attr_#{name}_#{sym}"] = obj
+          Thread.current["attr_" + name + "_#{sym}"] = obj
         end
       EOS
 
-      unless options[:instance_writer] == false || options[:instance_accessor] == false
+      if instance_writer && instance_accessor
         class_eval(<<-EOS, __FILE__, __LINE__ + 1)
           def #{sym}=(obj)
-            Thread.current[:"attr_#{name}_#{sym}"] = obj
+            self.class.#{sym} = obj
           end
         EOS
       end
+
+      public_send("#{sym}=", default) unless default.nil?
     end
   end
   alias :thread_cattr_writer :thread_mattr_writer
@@ -115,8 +122,8 @@ class Module
   #   Customer.user # => "Rafael"
   #   Account.user  # => "DHH"
   #
-  # To opt out of the instance writer method, pass <tt>instance_writer: false</tt>.
-  # To opt out of the instance reader method, pass <tt>instance_reader: false</tt>.
+  # To omit the instance writer method, pass <tt>instance_writer: false</tt>.
+  # To omit the instance reader method, pass <tt>instance_reader: false</tt>.
   #
   #   class Current
   #     thread_mattr_accessor :user, instance_writer: false, instance_reader: false
@@ -125,17 +132,17 @@ class Module
   #   Current.new.user = "DHH"  # => NoMethodError
   #   Current.new.user          # => NoMethodError
   #
-  # Or pass <tt>instance_accessor: false</tt>, to opt out both instance methods.
+  # Or pass <tt>instance_accessor: false</tt>, to omit both instance methods.
   #
   #   class Current
-  #     mattr_accessor :user, instance_accessor: false
+  #     thread_mattr_accessor :user, instance_accessor: false
   #   end
   #
   #   Current.new.user = "DHH"  # => NoMethodError
   #   Current.new.user          # => NoMethodError
-  def thread_mattr_accessor(*syms, &blk)
-    thread_mattr_reader(*syms, &blk)
-    thread_mattr_writer(*syms, &blk)
+  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
 end

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

@@ -1,4 +1,6 @@
-require 'active_support/concern'
+# frozen_string_literal: true
+
+require "active_support/concern"
 
 class Module
   # = Bite-sized separation of concerns
@@ -20,7 +22,7 @@ class Module
   #
   # == Using comments:
   #
-  #   class Todo
+  #   class Todo < ApplicationRecord
   #     # Other todo implementation
   #     # ...
   #
@@ -28,7 +30,6 @@ class Module
   #     has_many :events
   #
   #     before_create :track_creation
-  #     after_destroy :track_deletion
   #
   #     private
   #       def track_creation
@@ -40,7 +41,7 @@ class Module
   #
   # Noisy syntax.
   #
-  #   class Todo
+  #   class Todo < ApplicationRecord
   #     # Other todo implementation
   #     # ...
   #
@@ -50,7 +51,6 @@ class Module
   #       included do
   #         has_many :events
   #         before_create :track_creation
-  #         after_destroy :track_deletion
   #       end
   #
   #       private
@@ -68,7 +68,7 @@ class Module
   # increased overhead can be a reasonable tradeoff even if it reduces our
   # at-a-glance perception of how things work.
   #
-  #   class Todo
+  #   class Todo < ApplicationRecord
   #     # Other todo implementation
   #     # ...
   #
@@ -80,7 +80,7 @@ class Module
   # By quieting the mix-in noise, we arrive at a natural, low-ceremony way to
   # separate bite-sized concerns.
   #
-  #   class Todo
+  #   class Todo < ApplicationRecord
   #     # Other todo implementation
   #     # ...
   #
@@ -88,7 +88,6 @@ class Module
   #       included do
   #         has_many :events
   #         before_create :track_creation
-  #         after_destroy :track_deletion
   #       end
   #
   #       private
@@ -99,16 +98,22 @@ class Module
   #   end
   #
   #   Todo.ancestors
-  #   # => [Todo, Todo::EventTracking, Object]
+  #   # => [Todo, Todo::EventTracking, ApplicationRecord, Object]
   #
   # This small step has some wonderful ripple effects. We can
   # * 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

@@ -1,24 +1,29 @@
-require 'set'
+# frozen_string_literal: true
+
+require "set"
 
 class Module
   # Error generated by +delegate+ when a method is called on +nil+ and +allow_nil+
   # option is not used.
   class DelegationError < NoMethodError; end
 
+  RUBY_RESERVED_KEYWORDS = %w(alias and BEGIN begin break case class def defined? do
+  else elsif END end ensure false for if in module next nil not or redo rescue retry
+  return self super then true undef unless until when while yield)
+  DELEGATION_RESERVED_KEYWORDS = %w(_ arg args block)
   DELEGATION_RESERVED_METHOD_NAMES = Set.new(
-    %w(_ arg args alias and BEGIN begin block break case class def defined? do
-       else elsif END end ensure false for if in module next nil not or redo
-       rescue retry return self super then true undef unless until when while
-       yield)
+    RUBY_RESERVED_KEYWORDS + DELEGATION_RESERVED_KEYWORDS
   ).freeze
 
   # Provides a +delegate+ class method to easily expose contained objects'
   # public methods as your own.
   #
   # ==== Options
-  # * <tt>:to</tt> - Specifies the target object
+  # * <tt>:to</tt> - Specifies the target object name as a symbol or string
   # * <tt>:prefix</tt> - Prefixes the new method with the target name or a custom prefix
-  # * <tt>:allow_nil</tt> - if set to true, prevents a +NoMethodError+ from being raised
+  # * <tt>:allow_nil</tt> - If set to true, prevents a +Module::DelegationError+
+  #   from being raised
+  # * <tt>:private</tt> - If set to true, changes method visibility to private
   #
   # The macro receives one or more method names (specified as symbols or
   # strings) and the name of the target object via the <tt>:to</tt> option
@@ -109,19 +114,34 @@ class Module
   #   invoice.customer_name    # => 'John Doe'
   #   invoice.customer_address # => 'Vimmersvej 13'
   #
+  # The delegated methods are public by default.
+  # Pass <tt>private: true</tt> to change that.
+  #
+  #   class User < ActiveRecord::Base
+  #     has_one :profile
+  #     delegate :first_name, to: :profile
+  #     delegate :date_of_birth, to: :profile, private: true
+  #
+  #     def age
+  #       Date.today.year - date_of_birth.year
+  #     end
+  #   end
+  #
+  #   User.new.first_name # => "Tomas"
+  #   User.new.date_of_birth # => NoMethodError: private method `date_of_birth' called for #<User:0x00000008221340>
+  #   User.new.age # => 2
+  #
   # If the target is +nil+ and does not respond to the delegated method a
-  # +NoMethodError+ is raised, as with any other value. Sometimes, however, it
-  # makes sense to be robust to that situation and that is the purpose of the
-  # <tt>:allow_nil</tt> option: If the target is not +nil+, or it is and
-  # responds to the method, everything works as usual. But if it is +nil+ and
-  # does not respond to the delegated method, +nil+ is returned.
+  # +Module::DelegationError+ is raised. If you wish to instead return +nil+,
+  # use the <tt>:allow_nil</tt> option.
   #
   #   class User < ActiveRecord::Base
   #     has_one :profile
   #     delegate :age, to: :profile
   #   end
   #
-  #   User.new.age # raises NoMethodError: undefined method `age'
+  #   User.new.age
+  #   # => Module::DelegationError: User#age delegated to profile.age, but profile is nil
   #
   # But if not having a profile yet is fine and should not be an error
   # condition:
@@ -148,21 +168,20 @@ class Module
   #   Foo.new("Bar").name # raises NoMethodError: undefined method `name'
   #
   # The target method must be public, otherwise it will raise +NoMethodError+.
-  #
-  def delegate(*methods, to: nil, prefix: nil, allow_nil: nil)
+  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 && to =~ /^[^a-z_]/
-      raise ArgumentError, 'Can only automatically set the delegation prefix when delegating to a method.'
+    if prefix == true && /^[^a-z_]/.match?(to)
+      raise ArgumentError, "Can only automatically set the delegation prefix when delegating to a method."
     end
 
     method_prefix = \
       if prefix
         "#{prefix == true ? to : prefix}_"
       else
-        ''
+        ""
       end
 
     location = caller_locations(1, 1).first
@@ -171,10 +190,22 @@ class Module
     to = to.to_s
     to = "self.#{to}" if DELEGATION_RESERVED_METHOD_NAMES.include?(to)
 
-    methods.each 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 = (method =~ /[^\]]=$/) ? 'arg' : '*args, &block'
+      definition = if /[^\]]=$/.match?(method)
+        "arg"
+      elsif RUBY_VERSION >= "2.7"
+        "..."
+      else
+        "*args, &block"
+      end
 
       # The following generated method calls the target exactly once, storing
       # the returned value in a dummy variable.
@@ -184,32 +215,116 @@ 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_def = [
-          "def #{method_prefix}#{method}(#{definition})",
-          " _ = #{to}",
-          "  _.#{method}(#{definition})",
-          "rescue NoMethodError => e",
-          "  if _.nil? && e.name == :#{method}",
-          "    #{exception}",
-          "  else",
-          "    raise",
-          "  end",
+        method = method.to_s
+        method_name = method_name.to_s
+
+        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
+
+  # When building decorators, a common pattern may emerge:
+  #
+  #   class Partition
+  #     def initialize(event)
+  #       @event = event
+  #     end
+  #
+  #     def person
+  #       detail.person || creator
+  #     end
+  #
+  #     private
+  #       def respond_to_missing?(name, include_private = false)
+  #         @event.respond_to?(name, include_private)
+  #       end
+  #
+  #       def method_missing(method, *args, &block)
+  #         @event.send(method, *args, &block)
+  #       end
+  #   end
+  #
+  # With <tt>Module#delegate_missing_to</tt>, the above is condensed to:
+  #
+  #   class Partition
+  #     delegate_missing_to :@event
+  #
+  #     def initialize(event)
+  #       @event = event
+  #     end
+  #
+  #     def person
+  #       detail.person || creator
+  #     end
+  #   end
+  #
+  # The target can be anything callable within the object, e.g. instance
+  # variables, methods, constants, etc.
+  #
+  # The delegated method must be public on the target, otherwise it will
+  # 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, allow_nil: nil)
+    target = target.to_s
+    target = "self.#{target}" if DELEGATION_RESERVED_METHOD_NAMES.include?(target)
+
+    module_eval <<-RUBY, __FILE__, __LINE__ + 1
+      def respond_to_missing?(name, include_private = false)
+        # It may look like an oversight, but we deliberately do not pass
+        # +include_private+, because they do not get delegated.
+
+        return false if name == :marshal_dump || name == :_dump
+        #{target}.respond_to?(name) || super
+      end
+
+      def method_missing(method, *args, &block)
+        if #{target}.respond_to?(method)
+          #{target}.public_send(method, *args, &block)
+        else
+          begin
+            super
+          rescue NoMethodError
+            if #{target}.nil?
+              if #{allow_nil == true}
+                nil
+              else
+                raise DelegationError, "\#{method} delegated to #{target}, but #{target} is nil"
+              end
+            else
+              raise
+            end
+          end
+        end
+      end
+      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+    RUBY
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Module
   #   deprecate :foo
   #   deprecate bar: 'message'

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

@@ -1,14 +1,19 @@
-require 'active_support/inflector'
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/filters"
+require "active_support/inflector"
 
 class Module
   # Returns the name of the module containing this one.
   #
-  #   M::N.parent_name # => "M"
-  def parent_name
-    if defined? @parent_name
+  #   M::N.module_parent_name # => "M"
+  def module_parent_name
+    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
 
@@ -20,15 +25,15 @@ class Module
   #   end
   #   X = M::N
   #
-  #   M::N.parent # => M
-  #   X.parent    # => M
+  #   M::N.module_parent # => M
+  #   X.module_parent    # => M
   #
   # The parent of top-level and anonymous modules is Object.
   #
-  #   M.parent          # => Object
-  #   Module.new.parent # => Object
-  def parent
-    parent_name ? ActiveSupport::Inflector.constantize(parent_name) : Object
+  #   M.module_parent          # => Object
+  #   Module.new.module_parent # => Object
+  def module_parent
+    module_parent_name ? ActiveSupport::Inflector.constantize(module_parent_name) : Object
   end
 
   # Returns all the parents of this module according to its name, ordered from
@@ -40,27 +45,19 @@ class Module
   #   end
   #   X = M::N
   #
-  #   M.parents    # => [Object]
-  #   M::N.parents # => [M, Object]
-  #   X.parents    # => [M, Object]
-  def parents
+  #   M.module_parents    # => [Object]
+  #   M::N.module_parents # => [M, Object]
+  #   X.module_parents    # => [M, Object]
+  def module_parents
     parents = []
-    if parent_name
-      parts = parent_name.split('::')
+    if module_parent_name
+      parts = module_parent_name.split("::")
       until parts.empty?
-        parents << ActiveSupport::Inflector.constantize(parts * '::')
+        parents << ActiveSupport::Inflector.constantize(parts * "::")
         parts.pop
       end
     end
     parents << Object unless parents.include? Object
     parents
   end
-
-  def local_constants #:nodoc:
-    ActiveSupport::Deprecation.warn(<<-MSG.squish)
-      Module#local_constants is deprecated and will be removed in Rails 5.1.
-      Use Module#constants(false) instead.
-    MSG
-    constants(false)
-  end
 end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class Module
+  # Marks the named method as intended to be redefined, if it exists.
+  # Suppresses the Ruby method redefinition warning. Prefer
+  # #redefine_method where possible.
+  def silence_redefinition_of_method(method)
+    if method_defined?(method) || private_method_defined?(method)
+      # This suppresses the "method redefined" warning; the self-alias
+      # looks odd, but means we don't need to generate a unique name
+      alias_method method, method
+    end
+  end
+
+  # Replaces the existing method definition, if there is one, with the passed
+  # block as its body.
+  def redefine_method(method, &block)
+    visibility = method_visibility(method)
+    silence_redefinition_of_method(method)
+    define_method(method, &block)
+    send(visibility, method)
+  end
+
+  # Replaces the existing singleton method definition, if there is one, with
+  # the passed block as its body.
+  def redefine_singleton_method(method, &block)
+    singleton_class.redefine_method(method, &block)
+  end
+
+  def method_visibility(method) # :nodoc:
+    case
+    when private_method_defined?(method)
+      :private
+    when protected_method_defined?(method)
+      :protected
+    else
+      :public
+    end
+  end
+end

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

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/redefine_method"
+
 class Module
   # Removes the named method, if it exists.
   def remove_possible_method(method)
@@ -8,28 +12,6 @@ class Module
 
   # Removes the named singleton method, if it exists.
   def remove_possible_singleton_method(method)
-    singleton_class.instance_eval do
-      remove_possible_method(method)
-    end
-  end
-
-  # Replaces the existing method definition, if there is one, with the passed
-  # block as its body.
-  def redefine_method(method, &block)
-    visibility = method_visibility(method)
-    remove_possible_method(method)
-    define_method(method, &block)
-    send(visibility, method)
-  end
-
-  def method_visibility(method) # :nodoc:
-    case
-    when private_method_defined?(method)
-      :private
-    when protected_method_defined?(method)
-      :protected
-    else
-      :public
-    end
+    singleton_class.remove_possible_method(method)
   end
 end