activesupport 7.0.8 → 7.1.0.beta1

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

@@ -160,9 +160,25 @@ class Time
     elsif utc?
       ::Time.utc(new_year, new_month, new_day, new_hour, new_min, new_sec)
     elsif zone&.respond_to?(:utc_to_local)
-      ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec, zone)
+      new_time = ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec, zone)
+
+      # When there are two occurrences of a nominal time due to DST ending,
+      # `Time.new` chooses the first chronological occurrence (the one with a
+      # larger UTC offset). However, for `change`, we want to choose the
+      # occurrence that matches this time's UTC offset.
+      #
+      # If the new time's UTC offset is larger than this time's UTC offset, the
+      # new time might be a first chronological occurrence. So we add the offset
+      # difference to fast-forward the new time, and check if the result has the
+      # desired UTC offset (i.e. is the second chronological occurrence).
+      offset_difference = new_time.utc_offset - utc_offset
+      if offset_difference > 0 && (new_time_2 = new_time + offset_difference).utc_offset == utc_offset
+        new_time_2
+      else
+        new_time
+      end
     elsif zone
-      ::Time.local(new_year, new_month, new_day, new_hour, new_min, new_sec)
+      ::Time.local(new_sec, new_min, new_hour, new_day, new_month, new_year, nil, nil, isdst, nil)
     else
       ::Time.new(new_year, new_month, new_day, new_hour, new_min, new_sec, utc_offset)
     end

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

@@ -54,12 +54,12 @@ class Time
     if formatter = DATE_FORMATS[format]
       formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
     else
-      # Change to `to_s` when deprecation is gone. Also deprecate `to_default_s`.
-      to_default_s
+      to_s
     end
   end
   alias_method :to_formatted_s, :to_fs
   alias_method :to_default_s, :to_s
+  deprecate to_default_s: :to_s, deprecator: ActiveSupport.deprecator
 
   # Returns a formatted string of the offset from UTC, or an alternative
   # string if the time zone is already UTC.

data/lib/active_support/core_ext/time/zones.rb

@@ -19,10 +19,10 @@ class Time
     #
     # This method accepts any of the following:
     #
-    # * A Rails TimeZone object.
-    # * An identifier for a Rails TimeZone object (e.g., "Eastern Time (US & Canada)", <tt>-5.hours</tt>).
-    # * A <tt>TZInfo::Timezone</tt> object.
-    # * An identifier for a <tt>TZInfo::Timezone</tt> object (e.g., "America/New_York").
+    # * A \Rails TimeZone object.
+    # * An identifier for a \Rails TimeZone object (e.g., "Eastern Time (US & Canada)", <tt>-5.hours</tt>).
+    # * A +TZInfo::Timezone+ object.
+    # * An identifier for a +TZInfo::Timezone+ object (e.g., "America/New_York").
     #
     # Here's an example of how you might set <tt>Time.zone</tt> on a per request basis and reset it when the request is done.
     # <tt>current_user.time_zone</tt> just needs to return a string identifying the user's preferred time zone:

data/lib/active_support/core_ext/time.rb

@@ -4,5 +4,4 @@ require "active_support/core_ext/time/acts_like"
 require "active_support/core_ext/time/calculations"
 require "active_support/core_ext/time/compatibility"
 require "active_support/core_ext/time/conversions"
-require "active_support/core_ext/time/deprecated_conversions" unless ENV["RAILS_DISABLE_DEPRECATED_TO_S_CONVERSION"]
 require "active_support/core_ext/time/zones"

data/lib/active_support/current_attributes.rb

@@ -5,6 +5,8 @@ require "active_support/core_ext/enumerable"
 require "active_support/core_ext/module/delegation"
 
 module ActiveSupport
+  # = Current Attributes
+  #
   # Abstract super class that provides a thread-isolated attributes singleton, which resets automatically
   # before and after each request. This allows you to keep all the per-request attributes easily
   # available to the whole system.
@@ -90,6 +92,8 @@ module ActiveSupport
     include ActiveSupport::Callbacks
     define_callbacks :reset
 
+    INVALID_ATTRIBUTE_NAMES = [:set, :reset, :resets, :instance, :before_reset, :after_reset, :reset_all, :clear_all] # :nodoc:
+
     class << self
       # Returns singleton instance for this class in this thread. If none exists, one is created.
       def instance
@@ -98,6 +102,11 @@ module ActiveSupport
 
       # Declares one or more attributes that will be given both class and instance accessor methods.
       def attribute(*names)
+        invalid_attribute_names = names.map(&:to_sym) & INVALID_ATTRIBUTE_NAMES
+        if invalid_attribute_names.any?
+          raise ArgumentError, "Restricted attribute names: #{invalid_attribute_names.join(", ")}"
+        end
+
         ActiveSupport::CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |owner|
           names.each do |name|
             owner.define_cached_method(name, namespace: :current_attributes) do |batch|
@@ -133,14 +142,14 @@ module ActiveSupport
         end
       end
 
-      # Calls this block before #reset is called on the instance. Used for resetting external collaborators that depend on current values.
-      def before_reset(&block)
-        set_callback :reset, :before, &block
+      # Calls this callback before #reset is called on the instance. Used for resetting external collaborators that depend on current values.
+      def before_reset(*methods, &block)
+        set_callback :reset, :before, *methods, &block
       end
 
-      # Calls this block after #reset is called on the instance. Used for resetting external collaborators, like Time.zone.
-      def resets(&block)
-        set_callback :reset, :after, &block
+      # Calls this callback after #reset is called on the instance. Used for resetting external collaborators, like Time.zone.
+      def resets(*methods, &block)
+        set_callback :reset, :after, *methods, &block
       end
       alias_method :after_reset, :resets
 

data/lib/active_support/dependencies/autoload.rb

@@ -3,10 +3,12 @@
 require "active_support/inflector/methods"
 
 module ActiveSupport
+  # = Active Support \Autoload
+  #
   # Autoload and eager load conveniences for your library.
   #
   # This module allows you to define autoloads based on
-  # Rails conventions (i.e. no need to define the path
+  # \Rails conventions (i.e. no need to define the path
   # it is automatically guessed based on the filename)
   # and also define a set of constants that needs to be
   # eager loaded:
@@ -26,11 +28,14 @@ module ActiveSupport
   #   MyLib.eager_load!
   module Autoload
     def self.extended(base) # :nodoc:
-      base.class_eval do
-        @_autoloads = {}
-        @_under_path = nil
-        @_at_path = nil
-        @_eager_autoload = false
+      if RUBY_VERSION < "3"
+        base.class_eval do
+          @_autoloads = nil
+          @_under_path = nil
+          @_at_path = nil
+          @_eager_autoload = false
+          @_eagerloaded_constants = nil
+        end
       end
     end
 
@@ -41,7 +46,8 @@ module ActiveSupport
       end
 
       if @_eager_autoload
-        @_autoloads[const_name] = path
+        @_eagerloaded_constants ||= []
+        @_eagerloaded_constants << const_name
       end
 
       super const_name, path
@@ -69,11 +75,10 @@ module ActiveSupport
     end
 
     def eager_load!
-      @_autoloads.each_value { |file| require file }
-    end
-
-    def autoloads
-      @_autoloads
+      if @_eagerloaded_constants
+        @_eagerloaded_constants.each { |const_name| const_get(const_name) }
+        @_eagerloaded_constants = nil
+      end
     end
   end
 end

data/lib/active_support/deprecation/behaviors.rb

@@ -11,18 +11,18 @@ module ActiveSupport
   class Deprecation
     # Default warning behaviors per Rails.env.
     DEFAULT_BEHAVIORS = {
-      raise: ->(message, callstack, deprecation_horizon, gem_name) {
+      raise: ->(message, callstack, deprecator) do
         e = DeprecationException.new(message)
         e.set_backtrace(callstack.map(&:to_s))
         raise e
-      },
+      end,
 
-      stderr: ->(message, callstack, deprecation_horizon, gem_name) {
+      stderr: ->(message, callstack, deprecator) do
         $stderr.puts(message)
-        $stderr.puts callstack.join("\n  ") if debug
-      },
+        $stderr.puts callstack.join("\n  ") if deprecator.debug
+      end,
 
-      log: ->(message, callstack, deprecation_horizon, gem_name) {
+      log: ->(message, callstack, deprecator) do
         logger =
             if defined?(Rails.logger) && Rails.logger
               Rails.logger
@@ -31,30 +31,38 @@ module ActiveSupport
               ActiveSupport::Logger.new($stderr)
             end
         logger.warn message
-        logger.debug callstack.join("\n  ") if debug
-      },
-
-      notify: ->(message, callstack, deprecation_horizon, gem_name) {
-        notification_name = "deprecation.#{gem_name.underscore.tr('/', '_')}"
-        ActiveSupport::Notifications.instrument(notification_name,
-                                                message: message,
-                                                callstack: callstack,
-                                                gem_name: gem_name,
-                                                deprecation_horizon: deprecation_horizon)
-      },
-
-      silence: ->(message, callstack, deprecation_horizon, gem_name) { },
+        logger.debug callstack.join("\n  ") if deprecator.debug
+      end,
+
+      notify: ->(message, callstack, deprecator) do
+        ActiveSupport::Notifications.instrument(
+          "deprecation.#{deprecator.gem_name.underscore.tr("/", "_")}",
+          message: message,
+          callstack: callstack,
+          gem_name: deprecator.gem_name,
+          deprecation_horizon: deprecator.deprecation_horizon,
+        )
+      end,
+
+      silence: ->(message, callstack, deprecator) { },
+
+      report: ->(message, callstack, deprecator) do
+        error = DeprecationException.new(message)
+        error.set_backtrace(callstack.map(&:to_s))
+        ActiveSupport.error_reporter.report(error)
+      end
     }
 
     # Behavior module allows to determine how to display deprecation messages.
     # You can create a custom behavior or set any from the +DEFAULT_BEHAVIORS+
     # constant. Available behaviors are:
     #
-    # [+raise+]   Raise <tt>ActiveSupport::DeprecationException</tt>.
+    # [+raise+]   Raise ActiveSupport::DeprecationException.
     # [+stderr+]  Log all deprecation warnings to <tt>$stderr</tt>.
     # [+log+]     Log all deprecation warnings to +Rails.logger+.
     # [+notify+]  Use +ActiveSupport::Notifications+ to notify +deprecation.rails+.
-    # [+silence+] Do nothing. On Rails, set <tt>config.active_support.report_deprecations = false</tt> to disable all behaviors.
+    # [+report+]  Use +ActiveSupport::ErrorReporter+ to report deprecations.
+    # [+silence+] Do nothing. On \Rails, set <tt>config.active_support.report_deprecations = false</tt> to disable all behaviors.
     #
     # Setting behaviors only affects deprecations that happen after boot time.
     # For more information you can read the documentation of the +behavior=+ method.
@@ -77,31 +85,33 @@ module ActiveSupport
       #
       # Available behaviors:
       #
-      # [+raise+]   Raise <tt>ActiveSupport::DeprecationException</tt>.
+      # [+raise+]   Raise ActiveSupport::DeprecationException.
       # [+stderr+]  Log all deprecation warnings to <tt>$stderr</tt>.
       # [+log+]     Log all deprecation warnings to +Rails.logger+.
       # [+notify+]  Use +ActiveSupport::Notifications+ to notify +deprecation.rails+.
+      # [+report+]  Use +ActiveSupport::ErrorReporter+ to report deprecations.
       # [+silence+] Do nothing.
       #
       # Setting behaviors only affects deprecations that happen after boot time.
       # Deprecation warnings raised by gems are not affected by this setting
-      # because they happen before Rails boots up.
+      # because they happen before \Rails boots up.
       #
-      #   ActiveSupport::Deprecation.behavior = :stderr
-      #   ActiveSupport::Deprecation.behavior = [:stderr, :log]
-      #   ActiveSupport::Deprecation.behavior = MyCustomHandler
-      #   ActiveSupport::Deprecation.behavior = ->(message, callstack, deprecation_horizon, gem_name) {
+      #   deprecator = ActiveSupport::Deprecation.new
+      #   deprecator.behavior = :stderr
+      #   deprecator.behavior = [:stderr, :log]
+      #   deprecator.behavior = MyCustomHandler
+      #   deprecator.behavior = ->(message, callstack, deprecation_horizon, gem_name) {
       #     # custom stuff
       #   }
       #
-      # If you are using Rails, you can set <tt>config.active_support.report_deprecations = false</tt> to disable
+      # If you are using \Rails, you can set <tt>config.active_support.report_deprecations = false</tt> to disable
       # all deprecation behaviors. This is similar to the +silence+ option but more performant.
       def behavior=(behavior)
         @behavior = Array(behavior).map { |b| DEFAULT_BEHAVIORS[b] || arity_coerce(b) }
       end
 
       # Sets the behavior for disallowed deprecations (those configured by
-      # ActiveSupport::Deprecation.disallowed_warnings=) to the specified
+      # ActiveSupport::Deprecation#disallowed_warnings=) to the specified
       # value. As with +behavior=+, this can be a single value, array, or an
       # object that responds to +call+.
       def disallowed_behavior=(behavior)
@@ -114,12 +124,23 @@ module ActiveSupport
             raise ArgumentError, "#{behavior.inspect} is not a valid deprecation behavior."
           end
 
-          if behavior.respond_to?(:arity) && behavior.arity == 2
-            -> message, callstack, _, _ { behavior.call(message, callstack) }
-          else
+          case arity_of_callable(behavior)
+          when 2
+            ->(message, callstack, deprecator) do
+              behavior.call(message, callstack)
+            end
+          when -2..3
             behavior
+          else
+            ->(message, callstack, deprecator) do
+              behavior.call(message, callstack, deprecator.deprecation_horizon, deprecator.gem_name)
+            end
           end
         end
+
+        def arity_of_callable(callable)
+          callable.respond_to?(:arity) ? callable.arity : callable.method(:call).arity
+        end
     end
   end
 end

data/lib/active_support/deprecation/constant_accessor.rb

@@ -6,8 +6,7 @@ module ActiveSupport
     # hooking +const_missing+.
     #
     # It takes the names of an old (deprecated) constant and of a new constant
-    # (both in string form) and optionally a deprecator. The deprecator defaults
-    # to +ActiveSupport::Deprecator+ if none is specified.
+    # (both in string form) and a deprecator.
     #
     # The deprecated constant now returns the same object as the new one rather
     # than a proxy object, so it can be used transparently in +rescue+ blocks
@@ -19,7 +18,7 @@ module ActiveSupport
     #
     #   PLANETS_POST_2006 = %w(mercury venus earth mars jupiter saturn uranus neptune)
     #   include ActiveSupport::Deprecation::DeprecatedConstantAccessor
-    #   deprecate_constant 'PLANETS', 'PLANETS_POST_2006'
+    #   deprecate_constant 'PLANETS', 'PLANETS_POST_2006', deprecator: ActiveSupport::Deprecation.new
     #
     #   PLANETS.map { |planet| planet.capitalize }
     #   # => DEPRECATION WARNING: PLANETS is deprecated! Use PLANETS_POST_2006 instead.
@@ -40,7 +39,9 @@ module ActiveSupport
             super
           end
 
-          def deprecate_constant(const_name, new_constant, message: nil, deprecator: ActiveSupport::Deprecation.instance)
+          def deprecate_constant(const_name, new_constant, message: nil, deprecator: nil)
+            ActiveSupport.deprecator.warn("DeprecatedConstantAccessor.deprecate_constant without a deprecator is deprecated") unless deprecator
+            deprecator ||= ActiveSupport::Deprecation._instance
             class_variable_set(:@@_deprecated_constants, {}) unless class_variable_defined?(:@@_deprecated_constants)
             class_variable_get(:@@_deprecated_constants)[const_name.to_s] = { new: new_constant, message: message, deprecator: deprecator }
           end

data/lib/active_support/deprecation/deprecators.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  class Deprecation
+    # A managed collection of deprecators. Configuration methods, such as
+    # #behavior=, affect all deprecators in the collection. Additionally, the
+    # #silence method silences all deprecators in the collection for the
+    # duration of a given block.
+    class Deprecators
+      def initialize
+        @options = {}
+        @deprecators = {}
+      end
+
+      # Returns a deprecator added to this collection via #[]=.
+      def [](name)
+        @deprecators[name]
+      end
+
+      # Adds a given +deprecator+ to this collection. The deprecator will be
+      # immediately configured with any options previously set on this
+      # collection.
+      #
+      #   deprecators = ActiveSupport::Deprecation::Deprecators.new
+      #   deprecators.debug = true
+      #
+      #   foo_deprecator = ActiveSupport::Deprecation.new("2.0", "Foo")
+      #   foo_deprecator.debug    # => false
+      #
+      #   deprecators[:foo] = foo_deprecator
+      #   deprecators[:foo].debug # => true
+      #   foo_deprecator.debug    # => true
+      #
+      def []=(name, deprecator)
+        apply_options(deprecator)
+        @deprecators[name] = deprecator
+      end
+
+      # Iterates over all deprecators in this collection. If no block is given,
+      # returns an +Enumerator+.
+      def each(&block)
+        return to_enum(__method__) unless block
+        @deprecators.each_value(&block)
+      end
+
+      # Sets the silenced flag for all deprecators in this collection.
+      def silenced=(silenced)
+        set_option(:silenced, silenced)
+      end
+
+      # Sets the debug flag for all deprecators in this collection.
+      def debug=(debug)
+        set_option(:debug, debug)
+      end
+
+      # Sets the deprecation warning behavior for all deprecators in this
+      # collection.
+      #
+      # See ActiveSupport::Deprecation#behavior=.
+      def behavior=(behavior)
+        set_option(:behavior, behavior)
+      end
+
+      # Sets the disallowed deprecation warning behavior for all deprecators in
+      # this collection.
+      #
+      # See ActiveSupport::Deprecation#disallowed_behavior=.
+      def disallowed_behavior=(disallowed_behavior)
+        set_option(:disallowed_behavior, disallowed_behavior)
+      end
+
+      # Sets the disallowed deprecation warnings for all deprecators in this
+      # collection.
+      #
+      # See ActiveSupport::Deprecation#disallowed_warnings=.
+      def disallowed_warnings=(disallowed_warnings)
+        set_option(:disallowed_warnings, disallowed_warnings)
+      end
+
+      # Silences all deprecators in this collection for the duration of the
+      # given block.
+      #
+      # See ActiveSupport::Deprecation#silence.
+      def silence(&block)
+        each { |deprecator| deprecator.begin_silence }
+        block.call
+      ensure
+        each { |deprecator| deprecator.end_silence }
+      end
+
+      private
+        def set_option(name, value)
+          @options[name] = value
+          each { |deprecator| deprecator.public_send("#{name}=", value) }
+        end
+
+        def apply_options(deprecator)
+          @options.each do |name, value|
+            deprecator.public_send("#{name}=", value)
+          end
+        end
+    end
+  end
+end

data/lib/active_support/deprecation/disallowed.rb

@@ -24,10 +24,9 @@ module ActiveSupport
 
       private
         def deprecation_disallowed?(message)
-          disallowed = ActiveSupport::Deprecation.disallowed_warnings
           return false if explicitly_allowed?(message)
-          return true if disallowed == :all
-          disallowed.any? do |rule|
+          return true if disallowed_warnings == :all
+          message && disallowed_warnings.any? do |rule|
             case rule
             when String, Symbol
               message.include?(rule.to_s)
@@ -41,8 +40,7 @@ module ActiveSupport
           allowances = @explicitly_allowed_warnings.value
           return false unless allowances
           return true if allowances == :all
-          allowances = [allowances] unless allowances.kind_of?(Array)
-          allowances.any? do |rule|
+          message && Array(allowances).any? do |rule|
             case rule
             when String, Symbol
               message.include?(rule.to_s)

data/lib/active_support/deprecation/instance_delegator.rb

@@ -1,24 +1,51 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/module/delegation"
-
 module ActiveSupport
   class Deprecation
     module InstanceDelegator # :nodoc:
       def self.included(base)
         base.extend(ClassMethods)
         base.singleton_class.prepend(OverrideDelegators)
-        base.public_class_method :new
       end
 
       module ClassMethods # :nodoc:
+        MUTEX = Mutex.new
+        private_constant :MUTEX
+
         def include(included_module)
           included_module.instance_methods.each { |m| method_added(m) }
           super
         end
 
         def method_added(method_name)
-          singleton_class.delegate(method_name, to: :instance)
+          use_instead =
+            case method_name
+            when :silence, :behavior=, :disallowed_behavior=, :disallowed_warnings=, :silenced=, :debug=
+              target = "(defined?(Rails.application.deprecators) ? Rails.application.deprecators : ActiveSupport::Deprecation._instance)"
+              "Rails.application.deprecators.#{method_name}"
+            when :warn, :deprecate_methods, :gem_name, :gem_name=, :deprecation_horizon, :deprecation_horizon=
+              "your own Deprecation object"
+            else
+              "Rails.application.deprecators[framework].#{method_name} where framework is for example :active_record"
+            end
+          args = /[^\]]=\z/.match?(method_name) ? "arg" : "..."
+          target ||= "ActiveSupport::Deprecation._instance"
+          singleton_class.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def #{method_name}(#{args})
+              #{target}.#{method_name}(#{args})
+            ensure
+              ActiveSupport.deprecator.warn("Calling #{method_name} on ActiveSupport::Deprecation is deprecated and will be removed from Rails (use #{use_instead} instead)")
+            end
+          RUBY
+        end
+
+        def instance
+          ActiveSupport.deprecator.warn("ActiveSupport::Deprecation.instance is deprecated (use your own Deprecation object)")
+          _instance
+        end
+
+        def _instance
+          @_instance ||= MUTEX.synchronize { @_instance ||= new }
         end
       end
 

data/lib/active_support/deprecation/method_wrappers.rb

@@ -16,38 +16,21 @@ module ActiveSupport
       #     def eee; end
       #   end
       #
-      # Using the default deprecator:
-      #   ActiveSupport::Deprecation.deprecate_methods(Fred, :aaa, bbb: :zzz, ccc: 'use Bar#ccc instead')
+      #   deprecator = ActiveSupport::Deprecation.new('next-release', 'MyGem')
+      #
+      #   deprecator.deprecate_methods(Fred, :aaa, bbb: :zzz, ccc: 'use Bar#ccc instead')
       #   # => Fred
       #
       #   Fred.new.aaa
-      #   # DEPRECATION WARNING: aaa is deprecated and will be removed from Rails 5.1. (called from irb_binding at (irb):10)
+      #   # DEPRECATION WARNING: aaa is deprecated and will be removed from MyGem next-release. (called from irb_binding at (irb):10)
       #   # => nil
       #
       #   Fred.new.bbb
-      #   # DEPRECATION WARNING: bbb is deprecated and will be removed from Rails 5.1 (use zzz instead). (called from irb_binding at (irb):11)
+      #   # DEPRECATION WARNING: bbb is deprecated and will be removed from MyGem next-release (use zzz instead). (called from irb_binding at (irb):11)
       #   # => nil
       #
       #   Fred.new.ccc
-      #   # DEPRECATION WARNING: ccc is deprecated and will be removed from Rails 5.1 (use Bar#ccc instead). (called from irb_binding at (irb):12)
-      #   # => nil
-      #
-      # Passing in a custom deprecator:
-      #   custom_deprecator = ActiveSupport::Deprecation.new('next-release', 'MyGem')
-      #   ActiveSupport::Deprecation.deprecate_methods(Fred, ddd: :zzz, deprecator: custom_deprecator)
-      #   # => [:ddd]
-      #
-      #   Fred.new.ddd
-      #   DEPRECATION WARNING: ddd is deprecated and will be removed from MyGem next-release (use zzz instead). (called from irb_binding at (irb):15)
-      #   # => nil
-      #
-      # Using a custom deprecator directly:
-      #   custom_deprecator = ActiveSupport::Deprecation.new('next-release', 'MyGem')
-      #   custom_deprecator.deprecate_methods(Fred, eee: :zzz)
-      #   # => [:eee]
-      #
-      #   Fred.new.eee
-      #   DEPRECATION WARNING: eee is deprecated and will be removed from MyGem next-release (use zzz instead). (called from irb_binding at (irb):18)
+      #   # DEPRECATION WARNING: ccc is deprecated and will be removed from MyGem next-release (use Bar#ccc instead). (called from irb_binding at (irb):12)
       #   # => nil
       def deprecate_methods(target_module, *method_names)
         options = method_names.extract_options!