omg-activesupport 8.0.0.alpha1

data/lib/active_support/deprecation/proxy_wrappers.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  class Deprecation
+    class DeprecationProxy # :nodoc:
+      def self.new(*args, **kwargs, &block)
+        object = args.first
+
+        return object unless object
+        super
+      end
+
+      instance_methods.each { |m| undef_method m unless /^__|^object_id$/.match?(m) }
+
+      # Don't give a deprecation warning on inspect since test/unit and error
+      # logs rely on it for diagnostics.
+      def inspect
+        target.inspect
+      end
+
+      private
+        def method_missing(called, *args, &block)
+          warn caller_locations, called, args
+          target.__send__(called, *args, &block)
+        end
+    end
+
+    # DeprecatedObjectProxy transforms an object into a deprecated one. It takes an object, a deprecation message, and
+    # a deprecator.
+    #
+    #   deprecated_object = ActiveSupport::Deprecation::DeprecatedObjectProxy.new(Object.new, "This object is now deprecated", ActiveSupport::Deprecation.new)
+    #   # => #<Object:0x007fb9b34c34b0>
+    #
+    #   deprecated_object.to_s
+    #   DEPRECATION WARNING: This object is now deprecated.
+    #   (Backtrace)
+    #   # => "#<Object:0x007fb9b34c34b0>"
+    class DeprecatedObjectProxy < DeprecationProxy
+      def initialize(object, message, deprecator)
+        @object = object
+        @message = message
+        @deprecator = deprecator
+      end
+
+      private
+        def target
+          @object
+        end
+
+        def warn(callstack, called, args)
+          @deprecator.warn(@message, callstack)
+        end
+    end
+
+    # DeprecatedInstanceVariableProxy transforms an instance variable into a deprecated one. It takes an instance of a
+    # class, a method on that class, an instance variable, and a deprecator as the last argument.
+    #
+    # Trying to use the deprecated instance variable will result in a deprecation warning, pointing to the method as a
+    # replacement.
+    #
+    #   class Example
+    #     def initialize
+    #       @request = ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new(self, :request, :@request, ActiveSupport::Deprecation.new)
+    #       @_request = :special_request
+    #     end
+    #
+    #     def request
+    #       @_request
+    #     end
+    #
+    #     def old_request
+    #       @request
+    #     end
+    #   end
+    #
+    #   example = Example.new
+    #   # => #<Example:0x007fb9b31090b8 @_request=:special_request, @request=:special_request>
+    #
+    #   example.old_request.to_s
+    #   # => DEPRECATION WARNING: @request is deprecated! Call request.to_s instead of
+    #      @request.to_s
+    #      (Backtrace information…)
+    #      "special_request"
+    #
+    #   example.request.to_s
+    #   # => "special_request"
+    class DeprecatedInstanceVariableProxy < DeprecationProxy
+      def initialize(instance, method, var = "@#{method}", deprecator:)
+        @instance = instance
+        @method = method
+        @var = var
+        @deprecator = deprecator
+      end
+
+      private
+        def target
+          @instance.__send__(@method)
+        end
+
+        def warn(callstack, called, args)
+          @deprecator.warn("#{@var} is deprecated! Call #{@method}.#{called} instead of #{@var}.#{called}. Args: #{args.inspect}", callstack)
+        end
+    end
+
+    # DeprecatedConstantProxy transforms a constant into a deprecated one. It takes the full names of an old
+    # (deprecated) constant and of a new constant (both in string form) and a deprecator. The deprecated constant now
+    # returns the value of the new one.
+    #
+    #   PLANETS = %w(mercury venus earth mars jupiter saturn uranus neptune pluto)
+    #
+    #   # (In a later update, the original implementation of `PLANETS` has been removed.)
+    #
+    #   PLANETS_POST_2006 = %w(mercury venus earth mars jupiter saturn uranus neptune)
+    #   PLANETS = ActiveSupport::Deprecation::DeprecatedConstantProxy.new("PLANETS", "PLANETS_POST_2006", ActiveSupport::Deprecation.new)
+    #
+    #   PLANETS.map { |planet| planet.capitalize }
+    #   # => DEPRECATION WARNING: PLANETS is deprecated! Use PLANETS_POST_2006 instead.
+    #        (Backtrace information…)
+    #        ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
+    class DeprecatedConstantProxy < Module
+      def self.new(*args, **options, &block)
+        object = args.first
+
+        return object unless object
+        super
+      end
+
+      def initialize(old_const, new_const, deprecator, message: "#{old_const} is deprecated! Use #{new_const} instead.")
+        Kernel.require "active_support/inflector/methods"
+
+        @old_const = old_const
+        @new_const = new_const
+        @deprecator = deprecator
+        @message = message
+      end
+
+      instance_methods.each { |m| undef_method m unless /^__|^object_id$/.match?(m) }
+
+      # Don't give a deprecation warning on inspect since test/unit and error
+      # logs rely on it for diagnostics.
+      def inspect
+        target.inspect
+      end
+
+      # Don't give a deprecation warning on methods that IRB may invoke
+      # during tab-completion.
+      delegate :hash, :instance_methods, :name, :respond_to?, to: :target
+
+      # Returns the class of the new constant.
+      #
+      #   PLANETS_POST_2006 = %w(mercury venus earth mars jupiter saturn uranus neptune)
+      #   PLANETS = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('PLANETS', 'PLANETS_POST_2006')
+      #   PLANETS.class # => Array
+      def class
+        target.class
+      end
+
+      def append_features(base)
+        @deprecator.warn(@message, caller_locations)
+        base.include(target)
+      end
+
+      def prepend_features(base)
+        @deprecator.warn(@message, caller_locations)
+        base.prepend(target)
+      end
+
+      def extended(base)
+        @deprecator.warn(@message, caller_locations)
+        base.extend(target)
+      end
+
+      private
+        def target
+          ActiveSupport::Inflector.constantize(@new_const.to_s)
+        end
+
+        def const_missing(name)
+          @deprecator.warn(@message, caller_locations)
+          target.const_get(name)
+        end
+
+        def method_missing(...)
+          @deprecator.warn(@message, caller_locations)
+          target.__send__(...)
+        end
+    end
+  end
+end

data/lib/active_support/deprecation/reporting.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module ActiveSupport
+  class Deprecation
+    module Reporting
+      # Whether to print a message (silent mode)
+      attr_writer :silenced
+      # Name of gem where method is deprecated
+      attr_accessor :gem_name
+
+      # Outputs a deprecation warning to the output configured by
+      # ActiveSupport::Deprecation#behavior.
+      #
+      #   ActiveSupport::Deprecation.new.warn('something broke!')
+      #   # => "DEPRECATION WARNING: something broke! (called from your_code.rb:1)"
+      def warn(message = nil, callstack = nil)
+        return if silenced
+
+        callstack ||= caller_locations(2)
+        deprecation_message(callstack, message).tap do |full_message|
+          if deprecation_disallowed?(message)
+            disallowed_behavior.each { |b| b.call(full_message, callstack, self) }
+          else
+            behavior.each { |b| b.call(full_message, callstack, self) }
+          end
+        end
+      end
+
+      # Silence deprecation warnings within the block.
+      #
+      #   deprecator = ActiveSupport::Deprecation.new
+      #   deprecator.warn('something broke!')
+      #   # => "DEPRECATION WARNING: something broke! (called from your_code.rb:1)"
+      #
+      #   deprecator.silence do
+      #     deprecator.warn('something broke!')
+      #   end
+      #   # => nil
+      def silence(&block)
+        begin_silence
+        block.call
+      ensure
+        end_silence
+      end
+
+      def begin_silence # :nodoc:
+        @silence_counter.value += 1
+      end
+
+      def end_silence # :nodoc:
+        @silence_counter.value -= 1
+      end
+
+      def silenced
+        @silenced || @silence_counter.value.nonzero?
+      end
+
+      # Allow previously disallowed deprecation warnings within the block.
+      # <tt>allowed_warnings</tt> can be an array containing strings, symbols, or regular
+      # expressions. (Symbols are treated as strings). These are compared against
+      # the text of deprecation warning messages generated within the block.
+      # Matching warnings will be exempt from the rules set by
+      # ActiveSupport::Deprecation#disallowed_warnings.
+      #
+      # The optional <tt>if:</tt> argument accepts a truthy/falsy value or an object that
+      # responds to <tt>.call</tt>. If truthy, then matching warnings will be allowed.
+      # If falsey then the method yields to the block without allowing the warning.
+      #
+      #   deprecator = ActiveSupport::Deprecation.new
+      #   deprecator.disallowed_behavior = :raise
+      #   deprecator.disallowed_warnings = [
+      #     "something broke"
+      #   ]
+      #
+      #   deprecator.warn('something broke!')
+      #   # => ActiveSupport::DeprecationException
+      #
+      #   deprecator.allow ['something broke'] do
+      #     deprecator.warn('something broke!')
+      #   end
+      #   # => nil
+      #
+      #   deprecator.allow ['something broke'], if: Rails.env.production? do
+      #     deprecator.warn('something broke!')
+      #   end
+      #   # => ActiveSupport::DeprecationException for dev/test, nil for production
+      def allow(allowed_warnings = :all, if: true, &block)
+        conditional = binding.local_variable_get(:if)
+        conditional = conditional.call if conditional.respond_to?(:call)
+        if conditional
+          @explicitly_allowed_warnings.bind(allowed_warnings, &block)
+        else
+          yield
+        end
+      end
+
+      def deprecation_warning(deprecated_method_name, message = nil, caller_backtrace = nil)
+        caller_backtrace ||= caller_locations(2)
+        deprecated_method_warning(deprecated_method_name, message).tap do |msg|
+          warn(msg, caller_backtrace)
+        end
+      end
+
+      private
+        # Outputs a deprecation warning message
+        #
+        #   deprecated_method_warning(:method_name)
+        #   # => "method_name is deprecated and will be removed from Rails #{deprecation_horizon}"
+        #   deprecated_method_warning(:method_name, :another_method)
+        #   # => "method_name is deprecated and will be removed from Rails #{deprecation_horizon} (use another_method instead)"
+        #   deprecated_method_warning(:method_name, "Optional message")
+        #   # => "method_name is deprecated and will be removed from Rails #{deprecation_horizon} (Optional message)"
+        def deprecated_method_warning(method_name, message = nil)
+          warning = "#{method_name} is deprecated and will be removed from #{gem_name} #{deprecation_horizon}"
+          case message
+          when Symbol then "#{warning} (use #{message} instead)"
+          when String then "#{warning} (#{message})"
+          else warning
+          end
+        end
+
+        def deprecation_message(callstack, message = nil)
+          message ||= "You are using deprecated behavior which will be removed from the next major or minor release."
+          "DEPRECATION WARNING: #{message} #{deprecation_caller_message(callstack)}"
+        end
+
+        def deprecation_caller_message(callstack)
+          file, line, method = extract_callstack(callstack)
+          if file
+            if line && method
+              "(called from #{method} at #{file}:#{line})"
+            else
+              "(called from #{file}:#{line})"
+            end
+          end
+        end
+
+        def extract_callstack(callstack)
+          return [] if callstack.empty?
+          return _extract_callstack(callstack) if callstack.first.is_a? String
+
+          offending_line = callstack.find { |frame|
+            # Code generated with `eval` doesn't have an `absolute_path`, e.g. templates.
+            path = frame.absolute_path || frame.path
+            path && !ignored_callstack?(path)
+          } || callstack.first
+
+          [offending_line.path, offending_line.lineno, offending_line.label]
+        end
+
+        def _extract_callstack(callstack)
+          ActiveSupport.deprecator.warn(<<~MESSAGE)
+            Passing the result of `caller` to ActiveSupport::Deprecation#warn is deprecated and will be removed in Rails 8.0.
+
+            Please pass the result of `caller_locations` instead.
+          MESSAGE
+
+          offending_line = callstack.find { |line| !ignored_callstack?(line) } || callstack.first
+
+          if offending_line
+            if md = offending_line.match(/^(.+?):(\d+)(?::in `(.*?)')?/)
+              md.captures
+            else
+              offending_line
+            end
+          end
+        end
+
+        RAILS_GEM_ROOT = File.expand_path("../../../..", __dir__) + "/" # :nodoc:
+        LIB_DIR = RbConfig::CONFIG["libdir"] # :nodoc:
+
+        def ignored_callstack?(path)
+          path.start_with?(RAILS_GEM_ROOT, LIB_DIR) || path.include?("<internal:")
+        end
+    end
+  end
+end

data/lib/active_support/deprecation.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  # = Active Support \Deprecation
+  #
+  # \Deprecation specifies the API used by \Rails to deprecate methods, instance variables, objects, and constants. It's
+  # also available for gems or applications.
+  #
+  # For a gem, use Deprecation.new to create a Deprecation object and store it in your module or class (in order for
+  # users to be able to configure it).
+  #
+  #   module MyLibrary
+  #     def self.deprecator
+  #       @deprecator ||= ActiveSupport::Deprecation.new("2.0", "MyLibrary")
+  #     end
+  #   end
+  #
+  # For a Railtie or Engine, you may also want to add it to the application's deprecators, so that the application's
+  # configuration can be applied to it.
+  #
+  #   module MyLibrary
+  #     class Railtie < Rails::Railtie
+  #       initializer "my_library.deprecator" do |app|
+  #         app.deprecators[:my_library] = MyLibrary.deprecator
+  #       end
+  #     end
+  #   end
+  #
+  # With the above initializer, configuration settings like the following will affect +MyLibrary.deprecator+:
+  #
+  #   # in config/environments/test.rb
+  #   config.active_support.deprecation = :raise
+  class Deprecation
+    # active_support.rb sets an autoload for ActiveSupport::Deprecation.
+    #
+    # If these requires were at the top of the file the constant would not be
+    # defined by the time their files were loaded. Since some of them reopen
+    # ActiveSupport::Deprecation its autoload would be triggered, resulting in
+    # a circular require warning for active_support/deprecation.rb.
+    #
+    # So, we define the constant first, and load dependencies later.
+    require "active_support/deprecation/behaviors"
+    require "active_support/deprecation/reporting"
+    require "active_support/deprecation/disallowed"
+    require "active_support/deprecation/constant_accessor"
+    require "active_support/deprecation/method_wrappers"
+    require "active_support/deprecation/proxy_wrappers"
+    require "active_support/deprecation/deprecators"
+    require "active_support/core_ext/module/deprecation"
+    require "concurrent/atomic/thread_local_var"
+
+    include Behavior
+    include Reporting
+    include Disallowed
+    include MethodWrapper
+
+    MUTEX = Mutex.new # :nodoc:
+    private_constant :MUTEX
+
+    def self._instance # :nodoc:
+      @_instance ||= MUTEX.synchronize { @_instance ||= new }
+    end
+
+    # The version number in which the deprecated behavior will be removed, by default.
+    attr_accessor :deprecation_horizon
+
+    # It accepts two parameters on initialization. The first is a version of library
+    # and the second is a library name.
+    #
+    #   ActiveSupport::Deprecation.new('2.0', 'MyLibrary')
+    def initialize(deprecation_horizon = "8.1", gem_name = "Rails")
+      self.gem_name = gem_name
+      self.deprecation_horizon = deprecation_horizon
+      # By default, warnings are not silenced and debugging is off.
+      self.silenced = false
+      self.debug = false
+      @silence_counter = Concurrent::ThreadLocalVar.new(0)
+      @explicitly_allowed_warnings = Concurrent::ThreadLocalVar.new(nil)
+    end
+  end
+end

data/lib/active_support/deprecator.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  def self.deprecator # :nodoc:
+    ActiveSupport::Deprecation._instance
+  end
+end

data/lib/active_support/descendants_tracker.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "weakref"
+
+module ActiveSupport
+  # = Active Support Descendants Tracker
+  #
+  # This module provides an internal implementation to track descendants
+  # which is faster than iterating through +ObjectSpace+.
+  #
+  # However Ruby 3.1 provide a fast native +Class#subclasses+ method,
+  # so if you know your code won't be executed on older rubies, including
+  # +ActiveSupport::DescendantsTracker+ does not provide any benefit.
+  module DescendantsTracker
+    @clear_disabled = false
+
+    if RUBY_ENGINE == "ruby"
+      # On MRI `ObjectSpace::WeakMap` keys are weak references.
+      # So we can simply use WeakMap as a `Set`.
+      class WeakSet < ObjectSpace::WeakMap # :nodoc:
+        alias_method :to_a, :keys
+
+        def <<(object)
+          self[object] = true
+        end
+      end
+    else
+      # On TruffleRuby `ObjectSpace::WeakMap` keys are strong references.
+      # So we use `object_id` as a key and the actual object as a value.
+      #
+      # JRuby for now doesn't have Class#descendant, but when it will, it will likely
+      # have the same WeakMap semantic than Truffle so we future proof this as much as possible.
+      class WeakSet # :nodoc:
+        def initialize
+          @map = ObjectSpace::WeakMap.new
+        end
+
+        def [](object)
+          @map.key?(object.object_id)
+        end
+        alias_method :include?, :[]
+
+        def []=(object, _present)
+          @map[object.object_id] = object
+        end
+
+        def to_a
+          @map.values
+        end
+
+        def <<(object)
+          self[object] = true
+        end
+      end
+    end
+    @excluded_descendants = WeakSet.new
+
+    module ReloadedClassesFiltering # :nodoc:
+      def subclasses
+        DescendantsTracker.reject!(super)
+      end
+
+      def descendants
+        DescendantsTracker.reject!(super)
+      end
+    end
+
+    class << self
+      def disable_clear! # :nodoc:
+        unless @clear_disabled
+          @clear_disabled = true
+          ReloadedClassesFiltering.remove_method(:subclasses)
+          ReloadedClassesFiltering.remove_method(:descendants)
+          @excluded_descendants = nil
+        end
+      end
+
+      def clear(classes) # :nodoc:
+        raise "DescendantsTracker.clear was disabled because config.enable_reloading is false" if @clear_disabled
+
+        classes.each do |klass|
+          @excluded_descendants << klass
+          klass.descendants.each do |descendant|
+            @excluded_descendants << descendant
+          end
+        end
+      end
+
+      def reject!(classes) # :nodoc:
+        if @excluded_descendants
+          classes.reject! { |d| @excluded_descendants.include?(d) }
+        end
+        classes
+      end
+    end
+
+    class << self
+      def subclasses(klass)
+        klass.subclasses
+      end
+
+      def descendants(klass)
+        klass.descendants
+      end
+    end
+
+    def descendants
+      subclasses = DescendantsTracker.reject!(self.subclasses)
+      subclasses.concat(subclasses.flat_map(&:descendants))
+    end
+  end
+end

data/lib/active_support/digest.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module ActiveSupport
+  class Digest # :nodoc:
+    class << self
+      def hash_digest_class
+        @hash_digest_class ||= OpenSSL::Digest::MD5
+      end
+
+      def hash_digest_class=(klass)
+        raise ArgumentError, "#{klass} is expected to implement hexdigest class method" unless klass.respond_to?(:hexdigest)
+        @hash_digest_class = klass
+      end
+
+      def hexdigest(arg)
+        hash_digest_class.hexdigest(arg)[0...32]
+      end
+    end
+  end
+end