omg-activesupport 8.0.0.alpha1

data/lib/active_support/ordered_hash.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+YAML.add_builtin_type("omap") do |type, val|
+  ActiveSupport::OrderedHash[val.map { |v| v.to_a.first }]
+end
+
+module ActiveSupport
+  # DEPRECATED: +ActiveSupport::OrderedHash+ implements a hash that preserves
+  # insertion order.
+  #
+  #   oh = ActiveSupport::OrderedHash.new
+  #   oh[:a] = 1
+  #   oh[:b] = 2
+  #   oh.keys # => [:a, :b], this order is guaranteed
+  #
+  # Also, maps the +omap+ feature for YAML files
+  # (See https://yaml.org/type/omap.html) to support ordered items
+  # when loading from YAML.
+  #
+  # +ActiveSupport::OrderedHash+ is namespaced to prevent conflicts
+  # with other implementations.
+  class OrderedHash < ::Hash # :nodoc:
+    def to_yaml_type
+      "!tag:yaml.org,2002:omap"
+    end
+
+    def encode_with(coder)
+      coder.represent_seq "!omap", map { |k, v| { k => v } }
+    end
+
+    def select(*args, &block)
+      dup.tap { |hash| hash.select!(*args, &block) }
+    end
+
+    def reject(*args, &block)
+      dup.tap { |hash| hash.reject!(*args, &block) }
+    end
+
+    def nested_under_indifferent_access
+      self
+    end
+
+    # Returns true to make sure that this hash is extractable via <tt>Array#extract_options!</tt>
+    def extractable_options?
+      true
+    end
+  end
+end

data/lib/active_support/ordered_options.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/blank"
+
+module ActiveSupport
+  # = Ordered Options
+  #
+  # +OrderedOptions+ inherits from +Hash+ and provides dynamic accessor methods.
+  #
+  # With a +Hash+, key-value pairs are typically managed like this:
+  #
+  #   h = {}
+  #   h[:boy] = 'John'
+  #   h[:girl] = 'Mary'
+  #   h[:boy]  # => 'John'
+  #   h[:girl] # => 'Mary'
+  #   h[:dog]  # => nil
+  #
+  # Using +OrderedOptions+, the above code can be written as:
+  #
+  #   h = ActiveSupport::OrderedOptions.new
+  #   h.boy = 'John'
+  #   h.girl = 'Mary'
+  #   h.boy  # => 'John'
+  #   h.girl # => 'Mary'
+  #   h.dog  # => nil
+  #
+  # To raise an exception when the value is blank, append a
+  # bang to the key name, like:
+  #
+  #   h.dog! # => raises KeyError: :dog is blank
+  #
+  class OrderedOptions < Hash
+    alias_method :_get, :[] # preserve the original #[] method
+    protected :_get # make it protected
+
+    def []=(key, value)
+      super(key.to_sym, value)
+    end
+
+    def [](key)
+      super(key.to_sym)
+    end
+
+    def dig(key, *identifiers)
+      super(key.to_sym, *identifiers)
+    end
+
+    def method_missing(method, *args)
+      if method.end_with?("=")
+        self[method.name.chomp("=")] = args.first
+      elsif method.end_with?("!")
+        name_string = method.name.chomp("!")
+        self[name_string].presence || raise(KeyError.new(":#{name_string} is blank"))
+      else
+        self[method.name]
+      end
+    end
+
+    def respond_to_missing?(name, include_private)
+      true
+    end
+
+    def extractable_options?
+      true
+    end
+
+    def inspect
+      "#<#{self.class.name} #{super}>"
+    end
+  end
+
+  # = Inheritable Options
+  #
+  # +InheritableOptions+ provides a constructor to build an OrderedOptions
+  # hash inherited from another hash.
+  #
+  # Use this if you already have some hash and you want to create a new one based on it.
+  #
+  #   h = ActiveSupport::InheritableOptions.new({ girl: 'Mary', boy: 'John' })
+  #   h.girl # => 'Mary'
+  #   h.boy  # => 'John'
+  #
+  # If the existing hash has string keys, call Hash#symbolize_keys on it.
+  #
+  #   h = ActiveSupport::InheritableOptions.new({ 'girl' => 'Mary', 'boy' => 'John' }.symbolize_keys)
+  #   h.girl # => 'Mary'
+  #   h.boy  # => 'John'
+  class InheritableOptions < OrderedOptions
+    def initialize(parent = nil)
+      @parent = parent
+      if @parent.kind_of?(OrderedOptions)
+        # use the faster _get when dealing with OrderedOptions
+        super() { |h, k| @parent._get(k) }
+      elsif @parent
+        super() { |h, k| @parent[k] }
+      else
+        super()
+        @parent = {}
+      end
+    end
+
+    def to_h
+      @parent.merge(self)
+    end
+
+    def ==(other)
+      to_h == other.to_h
+    end
+
+    def inspect
+      "#<#{self.class.name} #{to_h.inspect}>"
+    end
+
+    def to_s
+      to_h.to_s
+    end
+
+    def pretty_print(pp)
+      pp.pp_hash(to_h)
+    end
+
+    alias_method :own_key?, :key?
+    private :own_key?
+
+    def key?(key)
+      super || @parent.key?(key)
+    end
+
+    def overridden?(key)
+      !!(@parent && @parent.key?(key) && own_key?(key.to_sym))
+    end
+
+    def inheritable_copy
+      self.class.new(self)
+    end
+
+    def to_a
+      entries
+    end
+
+    def each(&block)
+      to_h.each(&block)
+      self
+    end
+  end
+end

data/lib/active_support/parameter_filter.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/duplicable"
+require "active_support/core_ext/array/extract"
+
+module ActiveSupport
+  # = Active Support Parameter Filter
+  #
+  # +ParameterFilter+ replaces values in a <tt>Hash</tt>-like object if their
+  # keys match one of the specified filters.
+  #
+  # Matching based on nested keys is possible by using dot notation, e.g.
+  # <tt>"credit_card.number"</tt>.
+  #
+  # If a proc is given as a filter, each key and value of the <tt>Hash</tt>-like
+  # and of any nested <tt>Hash</tt>es will be passed to it. The value or key can
+  # then be mutated as desired using methods such as <tt>String#replace</tt>.
+  #
+  #   # Replaces values with "[FILTERED]" for keys that match /password/i.
+  #   ActiveSupport::ParameterFilter.new([:password])
+  #
+  #   # Replaces values with "[FILTERED]" for keys that match /foo|bar/i.
+  #   ActiveSupport::ParameterFilter.new([:foo, "bar"])
+  #
+  #   # Replaces values for the exact key "pin" and for keys that begin with
+  #   # "pin_". Does not match keys that otherwise include "pin" as a
+  #   # substring, such as "shipping_id".
+  #   ActiveSupport::ParameterFilter.new([/\Apin\z/, /\Apin_/])
+  #
+  #   # Replaces the value for :code in `{ credit_card: { code: "xxxx" } }`.
+  #   # Does not change `{ file: { code: "xxxx" } }`.
+  #   ActiveSupport::ParameterFilter.new(["credit_card.code"])
+  #
+  #   # Reverses values for keys that match /secret/i.
+  #   ActiveSupport::ParameterFilter.new([-> (k, v) do
+  #     v.reverse! if /secret/i.match?(k)
+  #   end])
+  #
+  class ParameterFilter
+    FILTERED = "[FILTERED]" # :nodoc:
+
+    # Precompiles an array of filters that otherwise would be passed directly to
+    # #initialize. Depending on the quantity and types of filters,
+    # precompilation can improve filtering performance, especially in the case
+    # where the ParameterFilter instance itself cannot be retained (but the
+    # precompiled filters can be retained).
+    #
+    #   filters = [/foo/, :bar, "nested.baz", /nested\.qux/]
+    #
+    #   precompiled = ActiveSupport::ParameterFilter.precompile_filters(filters)
+    #   # => [/(?-mix:foo)|(?i:bar)/, /(?i:nested\.baz)|(?-mix:nested\.qux)/]
+    #
+    #   ActiveSupport::ParameterFilter.new(precompiled)
+    #
+    def self.precompile_filters(filters)
+      filters, patterns = filters.partition { |filter| filter.is_a?(Proc) }
+
+      patterns.map! do |pattern|
+        pattern.is_a?(Regexp) ? pattern : "(?i:#{Regexp.escape pattern.to_s})"
+      end
+
+      deep_patterns = patterns.extract! { |pattern| pattern.to_s.include?("\\.") }
+
+      filters << Regexp.new(patterns.join("|")) if patterns.any?
+      filters << Regexp.new(deep_patterns.join("|")) if deep_patterns.any?
+
+      filters
+    end
+
+    # Create instance with given filters. Supported type of filters are +String+, +Regexp+, and +Proc+.
+    # Other types of filters are treated as +String+ using +to_s+.
+    # For +Proc+ filters, key, value, and optional original hash is passed to block arguments.
+    #
+    # ==== Options
+    #
+    # * <tt>:mask</tt> - A replaced object when filtered. Defaults to <tt>"[FILTERED]"</tt>.
+    def initialize(filters = [], mask: FILTERED)
+      @mask = mask
+      compile_filters!(filters)
+    end
+
+    # Mask value of +params+ if key matches one of filters.
+    def filter(params)
+      @no_filters ? params.dup : call(params)
+    end
+
+    # Returns filtered value for given key. For +Proc+ filters, third block argument is not populated.
+    def filter_param(key, value)
+      @no_filters ? value : value_for_key(key, value)
+    end
+
+  private
+    def compile_filters!(filters)
+      @no_filters = filters.empty?
+      return if @no_filters
+
+      @regexps, strings = [], []
+      @deep_regexps, deep_strings = nil, nil
+      @blocks = nil
+
+      filters.each do |item|
+        case item
+        when Proc
+          (@blocks ||= []) << item
+        when Regexp
+          if item.to_s.include?("\\.")
+            (@deep_regexps ||= []) << item
+          else
+            @regexps << item
+          end
+        else
+          s = Regexp.escape(item.to_s)
+          if s.include?("\\.")
+            (deep_strings ||= []) << s
+          else
+            strings << s
+          end
+        end
+      end
+
+      @regexps << Regexp.new(strings.join("|"), true) unless strings.empty?
+      (@deep_regexps ||= []) << Regexp.new(deep_strings.join("|"), true) if deep_strings
+    end
+
+    def call(params, full_parent_key = nil, original_params = params)
+      filtered_params = params.class.new
+
+      params.each do |key, value|
+        filtered_params[key] = value_for_key(key, value, full_parent_key, original_params)
+      end
+
+      filtered_params
+    end
+
+    def value_for_key(key, value, full_parent_key = nil, original_params = nil)
+      if @deep_regexps
+        full_key = full_parent_key ? "#{full_parent_key}.#{key}" : key.to_s
+      end
+
+      if @regexps.any? { |r| r.match?(key.to_s) }
+        value = @mask
+      elsif @deep_regexps&.any? { |r| r.match?(full_key) }
+        value = @mask
+      elsif value.is_a?(Hash)
+        value = call(value, full_key, original_params)
+      elsif value.is_a?(Array)
+        value = value.map { |v| value_for_key(key, v, full_parent_key, original_params) }
+      elsif @blocks
+        key = key.dup if key.duplicable?
+        value = value.dup if value.duplicable?
+        @blocks.each { |b| b.arity == 2 ? b.call(key, value) : b.call(key, value, original_params) }
+      end
+
+      value
+    end
+  end
+end

data/lib/active_support/proxy_object.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  class ProxyObject < ::BasicObject # :nodoc:
+    undef_method :==
+    undef_method :equal?
+
+    # Let ActiveSupport::ProxyObject at least raise exceptions.
+    def raise(*args)
+      ::Object.send(:raise, *args)
+    end
+
+    def self.inherited(_subclass)
+      ::ActiveSupport.deprecator.warn(<<~MSG)
+        ActiveSupport::ProxyObject is deprecated and will be removed in Rails 8.0.
+        Use Ruby's built-in BasicObject instead.
+      MSG
+    end
+  end
+end

data/lib/active_support/rails.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# This is a private interface.
+#
+# Rails components cherry pick from Active Support as needed, but there are a
+# few features that are used for sure in some way or another and it is not worth
+# putting individual requires absolutely everywhere. Think blank? for example.
+#
+# This file is loaded by every Rails component except Active Support itself,
+# but it does not belong to the Rails public interface. It is internal to
+# Rails and can change anytime.
+
+# Defines Object#blank? and Object#present?.
+require "active_support/core_ext/object/blank"
+
+# Support for ClassMethods and the included macro.
+require "active_support/concern"
+
+# Defines Class#class_attribute.
+require "active_support/core_ext/class/attribute"
+
+# Defines Module#delegate.
+require "active_support/core_ext/module/delegation"
+
+# Defines ActiveSupport::Deprecation.
+require "active_support/deprecation"

data/lib/active_support/railtie.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/i18n_railtie"
+
+module ActiveSupport
+  class Railtie < Rails::Railtie # :nodoc:
+    config.active_support = ActiveSupport::OrderedOptions.new
+
+    config.eager_load_namespaces << ActiveSupport
+
+    initializer "active_support.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:active_support] = ActiveSupport.deprecator
+    end
+
+    initializer "active_support.isolation_level" do |app|
+      config.after_initialize do
+        if level = app.config.active_support.delete(:isolation_level)
+          ActiveSupport::IsolatedExecutionState.isolation_level = level
+        end
+      end
+    end
+
+    initializer "active_support.raise_on_invalid_cache_expiration_time" do |app|
+      config.after_initialize do
+        if app.config.active_support.raise_on_invalid_cache_expiration_time
+          ActiveSupport::Cache::Store.raise_on_invalid_cache_expiration_time = true
+        end
+      end
+    end
+
+    initializer "active_support.set_authenticated_message_encryption" do |app|
+      config.after_initialize do
+        unless app.config.active_support.use_authenticated_message_encryption.nil?
+          ActiveSupport::MessageEncryptor.use_authenticated_message_encryption =
+            app.config.active_support.use_authenticated_message_encryption
+        end
+      end
+    end
+
+    initializer "active_support.reset_execution_context" do |app|
+      app.reloader.before_class_unload { ActiveSupport::ExecutionContext.clear }
+      app.executor.to_run              { ActiveSupport::ExecutionContext.clear }
+      app.executor.to_complete         { ActiveSupport::ExecutionContext.clear }
+    end
+
+    initializer "active_support.reset_all_current_attributes_instances" do |app|
+      app.reloader.before_class_unload { ActiveSupport::CurrentAttributes.clear_all }
+      app.executor.to_run              { ActiveSupport::CurrentAttributes.reset_all }
+      app.executor.to_complete         { ActiveSupport::CurrentAttributes.reset_all }
+
+      ActiveSupport.on_load(:active_support_test_case) do
+        if app.config.active_support.executor_around_test_case
+          require "active_support/executor/test_helper"
+          include ActiveSupport::Executor::TestHelper
+        else
+          require "active_support/current_attributes/test_helper"
+          include ActiveSupport::CurrentAttributes::TestHelper
+
+          require "active_support/execution_context/test_helper"
+          include ActiveSupport::ExecutionContext::TestHelper
+        end
+      end
+    end
+
+    initializer "active_support.deprecation_behavior" do |app|
+      if app.config.active_support.report_deprecations == false
+        app.deprecators.silenced = true
+        app.deprecators.behavior = :silence
+        app.deprecators.disallowed_behavior = :silence
+      else
+        if deprecation = app.config.active_support.deprecation
+          app.deprecators.behavior = deprecation
+        end
+
+        if disallowed_deprecation = app.config.active_support.disallowed_deprecation
+          app.deprecators.disallowed_behavior = disallowed_deprecation
+        end
+
+        if disallowed_warnings = app.config.active_support.disallowed_deprecation_warnings
+          app.deprecators.disallowed_warnings = disallowed_warnings
+        end
+      end
+    end
+
+    # Sets the default value for Time.zone
+    # If assigned value cannot be matched to a TimeZone, an exception will be raised.
+    initializer "active_support.initialize_time_zone" do |app|
+      begin
+        TZInfo::DataSource.get
+      rescue TZInfo::DataSourceNotFound => e
+        raise e.exception('tzinfo-data is not present. Please add gem "tzinfo-data" to your Gemfile and run bundle install')
+      end
+      require "active_support/core_ext/time/zones"
+      Time.zone_default = Time.find_zone!(app.config.time_zone)
+      config.eager_load_namespaces << TZInfo
+    end
+
+    initializer "active_support.to_time_preserves_timezone" do |app|
+      ActiveSupport.to_time_preserves_timezone = app.config.active_support.to_time_preserves_timezone
+    end
+
+    # Sets the default week start
+    # If assigned value is not a valid day symbol (e.g. :sunday, :monday, ...), an exception will be raised.
+    initializer "active_support.initialize_beginning_of_week" do |app|
+      require "active_support/core_ext/date/calculations"
+      beginning_of_week_default = Date.find_beginning_of_week!(app.config.beginning_of_week)
+
+      Date.beginning_of_week_default = beginning_of_week_default
+    end
+
+    initializer "active_support.require_master_key" do |app|
+      if app.config.respond_to?(:require_master_key) && app.config.require_master_key
+        begin
+          app.credentials.key
+        rescue ActiveSupport::EncryptedFile::MissingKeyError => error
+          $stderr.puts error.message
+          exit 1
+        end
+      end
+    end
+
+    initializer "active_support.set_configs" do |app|
+      app.config.active_support.each do |k, v|
+        k = "#{k}="
+        ActiveSupport.public_send(k, v) if ActiveSupport.respond_to? k
+      end
+    end
+
+    initializer "active_support.set_hash_digest_class" do |app|
+      config.after_initialize do
+        if klass = app.config.active_support.hash_digest_class
+          ActiveSupport::Digest.hash_digest_class = klass
+        end
+      end
+    end
+
+    initializer "active_support.set_key_generator_hash_digest_class" do |app|
+      config.after_initialize do
+        if klass = app.config.active_support.key_generator_hash_digest_class
+          ActiveSupport::KeyGenerator.hash_digest_class = klass
+        end
+      end
+    end
+
+    initializer "active_support.set_default_message_serializer" do |app|
+      config.after_initialize do
+        if message_serializer = app.config.active_support.message_serializer
+          ActiveSupport::Messages::Codec.default_serializer = message_serializer
+        end
+      end
+    end
+
+    initializer "active_support.set_use_message_serializer_for_metadata" do |app|
+      config.after_initialize do
+        ActiveSupport::Messages::Metadata.use_message_serializer_for_metadata =
+          app.config.active_support.use_message_serializer_for_metadata
+      end
+    end
+  end
+end

data/lib/active_support/reloader.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "active_support/execution_wrapper"
+require "active_support/executor"
+
+module ActiveSupport
+  # = Active Support \Reloader
+  #
+  # This class defines several callbacks:
+  #
+  #   to_prepare -- Run once at application startup, and also from
+  #   +to_run+.
+  #
+  #   to_run -- Run before a work run that is reloading. If
+  #   +reload_classes_only_on_change+ is true (the default), the class
+  #   unload will have already occurred.
+  #
+  #   to_complete -- Run after a work run that has reloaded. If
+  #   +reload_classes_only_on_change+ is false, the class unload will
+  #   have occurred after the work run, but before this callback.
+  #
+  #   before_class_unload -- Run immediately before the classes are
+  #   unloaded.
+  #
+  #   after_class_unload -- Run immediately after the classes are
+  #   unloaded.
+  #
+  class Reloader < ExecutionWrapper
+    define_callbacks :prepare
+
+    define_callbacks :class_unload
+
+    # Registers a callback that will run once at application startup and every time the code is reloaded.
+    def self.to_prepare(*args, &block)
+      set_callback(:prepare, *args, &block)
+    end
+
+    # Registers a callback that will run immediately before the classes are unloaded.
+    def self.before_class_unload(*args, &block)
+      set_callback(:class_unload, *args, &block)
+    end
+
+    # Registers a callback that will run immediately after the classes are unloaded.
+    def self.after_class_unload(*args, &block)
+      set_callback(:class_unload, :after, *args, &block)
+    end
+
+    to_run(:after) { self.class.prepare! }
+
+    # Initiate a manual reload
+    def self.reload!
+      executor.wrap do
+        new.tap do |instance|
+          instance.run!
+        ensure
+          instance.complete!
+        end
+      end
+      prepare!
+    end
+
+    def self.run!(reset: false) # :nodoc:
+      if check!
+        super
+      else
+        Null
+      end
+    end
+
+    # Run the supplied block as a work unit, reloading code as needed
+    def self.wrap(**kwargs)
+      return yield if active?
+
+      executor.wrap(**kwargs) do
+        instance = run!
+        begin
+          yield
+        ensure
+          instance.complete!
+        end
+      end
+    end
+
+    class_attribute :executor, default: Executor
+    class_attribute :check, default: lambda { false }
+
+    def self.check! # :nodoc:
+      @should_reload ||= check.call
+    end
+
+    def self.reloaded! # :nodoc:
+      @should_reload = false
+    end
+
+    def self.prepare! # :nodoc:
+      new.run_callbacks(:prepare)
+    end
+
+    def initialize
+      super
+      @locked = false
+    end
+
+    # Acquire the ActiveSupport::Dependencies::Interlock unload lock,
+    # ensuring it will be released automatically
+    def require_unload_lock!
+      unless @locked
+        ActiveSupport::Dependencies.interlock.start_unloading
+        @locked = true
+      end
+    end
+
+    # Release the unload lock if it has been previously obtained
+    def release_unload_lock!
+      if @locked
+        @locked = false
+        ActiveSupport::Dependencies.interlock.done_unloading
+      end
+    end
+
+    def run! # :nodoc:
+      super
+      release_unload_lock!
+    end
+
+    def class_unload!(&block) # :nodoc:
+      require_unload_lock!
+      run_callbacks(:class_unload, &block)
+    end
+
+    def complete! # :nodoc:
+      super
+      self.class.reloaded!
+    ensure
+      release_unload_lock!
+    end
+  end
+end