activesupport 7.0.8.1 → 7.1.0.beta1

data/lib/active_support/encrypted_configuration.rb

@@ -4,9 +4,12 @@ require "yaml"
 require "active_support/encrypted_file"
 require "active_support/ordered_options"
 require "active_support/core_ext/object/inclusion"
+require "active_support/core_ext/hash/keys"
 require "active_support/core_ext/module/delegation"
 
 module ActiveSupport
+  # = Encrypted Configuration
+  #
   # Provides convenience methods on top of EncryptedFile to access values stored
   # as encrypted YAML.
   #
@@ -30,12 +33,23 @@ module ActiveSupport
   #   # => KeyError
   #
   class EncryptedConfiguration < EncryptedFile
-    delegate :[], :fetch, to: :config
+    class InvalidContentError < RuntimeError
+      def initialize(content_path)
+        super "Invalid YAML in '#{content_path}'."
+      end
+
+      def message
+        cause.is_a?(Psych::SyntaxError) ? "#{super}\n\n  #{cause.message}" : super
+      end
+    end
+
     delegate_missing_to :options
 
     def initialize(config_path:, key_path:, env_key:, raise_if_missing_key:)
       super content_path: config_path, key_path: key_path,
         env_key: env_key, raise_if_missing_key: raise_if_missing_key
+      @config = nil
+      @options = nil
     end
 
     # Reads the file and returns the decrypted content. See EncryptedFile#read.
@@ -46,10 +60,8 @@ module ActiveSupport
       ""
     end
 
-    def write(contents)
-      deserialize(contents)
-
-      super
+    def validate! # :nodoc:
+      deserialize(read)
     end
 
     # Returns the decrypted content as a Hash with symbolized keys.
@@ -64,11 +76,15 @@ module ActiveSupport
       @config ||= deserialize(read).deep_symbolize_keys
     end
 
+    def inspect # :nodoc:
+      "#<#{self.class.name}:#{'%#016x' % (object_id << 1)}>"
+    end
+
     private
       def deep_transform(hash)
         return hash unless hash.is_a?(Hash)
 
-        h = ActiveSupport::InheritableOptions.new
+        h = ActiveSupport::OrderedOptions.new
         hash.each do |k, v|
           h[k] = deep_transform(v)
         end
@@ -79,9 +95,14 @@ module ActiveSupport
         @options ||= deep_transform(config)
       end
 
-      def deserialize(config)
-        doc = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(config) : YAML.load(config)
-        doc.presence || {}
+      def deserialize(content)
+        config = YAML.respond_to?(:unsafe_load) ?
+          YAML.unsafe_load(content, filename: content_path) :
+          YAML.load(content, filename: content_path)
+
+        config.presence || {}
+      rescue Psych::SyntaxError
+        raise InvalidContentError.new(content_path)
       end
   end
 end

data/lib/active_support/encrypted_file.rb

@@ -53,6 +53,12 @@ module ActiveSupport
       read_env_key || read_key_file || handle_missing_key
     end
 
+    # Returns truthy if #key is truthy. Returns falsy otherwise. Unlike #key,
+    # does not raise MissingKeyError when +raise_if_missing_key+ is true.
+    def key?
+      read_env_key || read_key_file
+    end
+
     # Reads the file and returns the decrypted content.
     #
     # Raises:
@@ -104,7 +110,7 @@ module ActiveSupport
       end
 
       def encryptor
-        @encryptor ||= ActiveSupport::MessageEncryptor.new([ key ].pack("H*"), cipher: CIPHER)
+        @encryptor ||= ActiveSupport::MessageEncryptor.new([ key ].pack("H*"), cipher: CIPHER, serializer: Marshal)
       end
 
 
@@ -113,8 +119,7 @@ module ActiveSupport
       end
 
       def read_key_file
-        return @key_file_contents if defined?(@key_file_contents)
-        @key_file_contents = (key_path.binread.strip if key_path.exist?)
+        @key_file_contents ||= (key_path.binread.strip if key_path.exist?)
       end
 
       def handle_missing_key

data/lib/active_support/environment_inquirer.rb

@@ -1,20 +1,40 @@
 # frozen_string_literal: true
 
 require "active_support/string_inquirer"
+require "active_support/core_ext/object/inclusion"
 
 module ActiveSupport
   class EnvironmentInquirer < StringInquirer # :nodoc:
-    DEFAULT_ENVIRONMENTS = ["development", "test", "production"]
+    # Optimization for the three default environments, so this inquirer doesn't need to rely on
+    # the slower delegation through method_missing that StringInquirer would normally entail.
+    DEFAULT_ENVIRONMENTS = %w[ development test production ]
+
+    # Environments that'll respond true for #local?
+    LOCAL_ENVIRONMENTS = %w[ development test ]
+
     def initialize(env)
+      raise(ArgumentError, "'local' is a reserved environment name") if env == "local"
+
       super(env)
 
       DEFAULT_ENVIRONMENTS.each do |default|
         instance_variable_set :"@#{default}", env == default
       end
+
+      @local = in? LOCAL_ENVIRONMENTS
     end
 
     DEFAULT_ENVIRONMENTS.each do |env|
-      class_eval "def #{env}?; @#{env}; end"
+      class_eval <<~RUBY, __FILE__, __LINE__ + 1
+        def #{env}?
+          @#{env}
+        end
+      RUBY
+    end
+
+    # Returns true if we're in the development or test environment.
+    def local?
+      @local
     end
   end
 end

data/lib/active_support/error_reporter/test_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveSupport::ErrorReporter::TestHelper # :nodoc:
+  class ErrorSubscriber
+    attr_reader :events
+
+    def initialize
+      @events = []
+    end
+
+    def report(error, handled:, severity:, source:, context:)
+      @events << [error, handled, severity, source, context]
+    end
+  end
+end

data/lib/active_support/error_reporter.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 module ActiveSupport
+  # = Active Support \Error Reporter
+  #
   # +ActiveSupport::ErrorReporter+ is a common interface for error reporting services.
   #
-  # To rescue and report any unhandled error, you can use the +handle+ method:
+  # To rescue and report any unhandled error, you can use the #handle method:
   #
   #   Rails.error.handle do
   #     do_something!
@@ -11,35 +13,19 @@ module ActiveSupport
   #
   # If an error is raised, it will be reported and swallowed.
   #
-  # Alternatively if you want to report the error but not swallow it, you can use +record+
+  # Alternatively, if you want to report the error but not swallow it, you can use #record:
   #
   #   Rails.error.record do
   #     do_something!
   #   end
   #
-  # Both methods can be restricted to only handle a specific exception class
+  # Both methods can be restricted to handle only a specific error class:
   #
   #   maybe_tags = Rails.error.handle(Redis::BaseError) { redis.get("tags") }
   #
-  # You can also pass some extra context information that may be used by the error subscribers:
-  #
-  #   Rails.error.handle(context: { section: "admin" }) do
-  #     # ...
-  #   end
-  #
-  # Additionally a +severity+ can be passed along to communicate how important the error report is.
-  # +severity+ can be one of +:error+, +:warning+, or +:info+. Handled errors default to the +:warning+
-  # severity, and unhandled ones to +:error+.
-  #
-  # Both +handle+ and +record+ pass through the return value from the block. In the case of +handle+
-  # rescuing an error, a fallback can be provided. The fallback must be a callable whose result will
-  # be returned when the block raises and is handled:
-  #
-  #   user = Rails.error.handle(fallback: -> { User.anonymous }) do
-  #     User.find_by(params)
-  #   end
   class ErrorReporter
     SEVERITIES = %i(error warning info)
+    DEFAULT_SOURCE = "application"
 
     attr_accessor :logger
 
@@ -48,31 +34,92 @@ module ActiveSupport
       @logger = logger
     end
 
-    # Report any unhandled exception, and swallow it.
+    # Evaluates the given block, reporting and swallowing any unhandled error.
+    # If no error is raised, returns the return value of the block. Otherwise,
+    # returns the result of +fallback.call+, or +nil+ if +fallback+ is not
+    # specified.
     #
+    #   # Will report a TypeError to all subscribers and return nil.
     #   Rails.error.handle do
     #     1 + '1'
     #   end
     #
-    def handle(error_class = StandardError, severity: :warning, context: {}, fallback: nil)
+    # Can be restricted to handle only specific error classes:
+    #
+    #   maybe_tags = Rails.error.handle(Redis::BaseError) { redis.get("tags") }
+    #
+    # ==== Options
+    #
+    # * +:severity+ - This value is passed along to subscribers to indicate how
+    #   important the error report is. Can be +:error+, +:warning+, or +:info+.
+    #   Defaults to +:warning+.
+    #
+    # * +:context+ - Extra information that is passed along to subscribers. For
+    #   example:
+    #
+    #     Rails.error.handle(context: { section: "admin" }) do
+    #       # ...
+    #     end
+    #
+    # * +:fallback+ - A callable that provides +handle+'s return value when an
+    #   unhandled error is raised. For example:
+    #
+    #     user = Rails.error.handle(fallback: -> { User.anonymous }) do
+    #       User.find_by(params)
+    #     end
+    #
+    # * +:source+ - This value is passed along to subscribers to indicate the
+    #   source of the error. Subscribers can use this value to ignore certain
+    #   errors. Defaults to <tt>"application"</tt>.
+    def handle(*error_classes, severity: :warning, context: {}, fallback: nil, source: DEFAULT_SOURCE)
+      error_classes = [StandardError] if error_classes.blank?
       yield
-    rescue error_class => error
-      report(error, handled: true, severity: severity, context: context)
+    rescue *error_classes => error
+      report(error, handled: true, severity: severity, context: context, source: source)
       fallback.call if fallback
     end
 
-    def record(error_class = StandardError, severity: :error, context: {})
+    # Evaluates the given block, reporting and re-raising any unhandled error.
+    # If no error is raised, returns the return value of the block.
+    #
+    #   # Will report a TypeError to all subscribers and re-raise it.
+    #   Rails.error.record do
+    #     1 + '1'
+    #   end
+    #
+    # Can be restricted to handle only specific error classes:
+    #
+    #   tags = Rails.error.record(Redis::BaseError) { redis.get("tags") }
+    #
+    # ==== Options
+    #
+    # * +:severity+ - This value is passed along to subscribers to indicate how
+    #   important the error report is. Can be +:error+, +:warning+, or +:info+.
+    #   Defaults to +:error+.
+    #
+    # * +:context+ - Extra information that is passed along to subscribers. For
+    #   example:
+    #
+    #     Rails.error.record(context: { section: "admin" }) do
+    #       # ...
+    #     end
+    #
+    # * +:source+ - This value is passed along to subscribers to indicate the
+    #   source of the error. Subscribers can use this value to ignore certain
+    #   errors. Defaults to <tt>"application"</tt>.
+    def record(*error_classes, severity: :error, context: {}, source: DEFAULT_SOURCE)
+      error_classes = [StandardError] if error_classes.blank?
       yield
-    rescue error_class => error
-      report(error, handled: false, severity: severity, context: context)
+    rescue *error_classes => error
+      report(error, handled: false, severity: severity, context: context, source: source)
       raise
     end
 
     # Register a new error subscriber. The subscriber must respond to
     #
-    #   report(Exception, handled: Boolean, context: Hash)
+    #   report(Exception, handled: Boolean, severity: (:error OR :warning OR :info), context: Hash, source: String)
     #
-    # The +report+ method +should+ never raise an error.
+    # The +report+ method <b>should never</b> raise an error.
     def subscribe(subscriber)
       unless subscriber.respond_to?(:report)
         raise ArgumentError, "Error subscribers must respond to #report"
@@ -80,26 +127,61 @@ module ActiveSupport
       @subscribers << subscriber
     end
 
-    # Update the execution context that is accessible to error subscribers
+    # Unregister an error subscriber. Accepts either a subscriber or a class.
+    #
+    #   subscriber = MyErrorSubscriber.new
+    #   Rails.error.subscribe(subscriber)
+    #
+    #   Rails.error.unsubscribe(subscriber)
+    #   # or
+    #   Rails.error.unsubscribe(MyErrorSubscriber)
+    def unsubscribe(subscriber)
+      @subscribers.delete_if { |s| subscriber === s }
+    end
+
+    # Prevent a subscriber from being notified of errors for the
+    # duration of the block. You may pass in the subscriber itself, or its class.
+    #
+    # This can be helpful for error reporting service integrations, when they wish
+    # to handle any errors higher in the stack.
+    def disable(subscriber)
+      disabled_subscribers = (ActiveSupport::IsolatedExecutionState[self] ||= [])
+      disabled_subscribers << subscriber
+      begin
+        yield
+      ensure
+        disabled_subscribers.delete(subscriber)
+      end
+    end
+
+    # Update the execution context that is accessible to error subscribers. Any
+    # context passed to #handle, #record, or #report will be merged with the
+    # context set here.
     #
     #   Rails.error.set_context(section: "checkout", user_id: @user.id)
     #
-    # See +ActiveSupport::ExecutionContext.set+
     def set_context(...)
       ActiveSupport::ExecutionContext.set(...)
     end
 
-    # When the block based +handle+ and +record+ methods are not suitable, you can directly use +report+
+    # Report an error directly to subscribers. You can use this method when the
+    # block-based #handle and #record methods are not suitable.
+    #
+    #   Rails.error.report(error)
     #
-    #   Rails.error.report(error, handled: true)
-    def report(error, handled:, severity: handled ? :warning : :error, context: {})
+    def report(error, handled: true, severity: handled ? :warning : :error, context: {}, source: DEFAULT_SOURCE)
+      return if error.instance_variable_defined?(:@__rails_error_reported)
+
       unless SEVERITIES.include?(severity)
         raise ArgumentError, "severity must be one of #{SEVERITIES.map(&:inspect).join(", ")}, got: #{severity.inspect}"
       end
 
       full_context = ActiveSupport::ExecutionContext.to_h.merge(context)
+      disabled_subscribers = ActiveSupport::IsolatedExecutionState[self]
       @subscribers.each do |subscriber|
-        subscriber.report(error, handled: handled, severity: severity, context: full_context)
+        unless disabled_subscribers&.any? { |s| s === subscriber }
+          subscriber.report(error, handled: handled, severity: severity, context: full_context, source: source)
+        end
       rescue => subscriber_error
         if logger
           logger.fatal(
@@ -111,6 +193,10 @@ module ActiveSupport
         end
       end
 
+      unless error.frozen?
+        error.instance_variable_set(:@__rails_error_reported, true)
+      end
+
       nil
     end
   end

data/lib/active_support/execution_wrapper.rb

@@ -84,14 +84,14 @@ module ActiveSupport
     end
 
     # Perform the work in the supplied block as an execution.
-    def self.wrap
+    def self.wrap(source: "application.active_support")
       return yield if active?
 
       instance = run!
       begin
         yield
       rescue => error
-        error_reporter.report(error, handled: false)
+        error_reporter&.report(error, handled: false, source: source)
         raise
       ensure
         instance.complete!
@@ -108,8 +108,8 @@ module ActiveSupport
       end
     end
 
-    def self.error_reporter
-      @error_reporter ||= ActiveSupport::ErrorReporter.new
+    def self.error_reporter # :nodoc:
+      ActiveSupport.error_reporter
     end
 
     def self.active_key # :nodoc:

data/lib/active_support/file_update_checker.rb

@@ -3,7 +3,9 @@
 require "active_support/core_ext/time/calculations"
 
 module ActiveSupport
-  # FileUpdateChecker specifies the API used by Rails to watch files
+  # = \File Update Checker
+  #
+  # FileUpdateChecker specifies the API used by \Rails to watch files
   # and control reloading. The API depends on four methods:
   #
   # * +initialize+ which expects two parameters and one block as
@@ -20,7 +22,7 @@ module ActiveSupport
   # After initialization, a call to +execute_if_updated+ must execute
   # the block only if there was really a change in the filesystem.
   #
-  # This class is used by Rails to reload the I18n framework whenever
+  # This class is used by \Rails to reload the I18n framework whenever
   # they are changed upon a new request.
   #
   #   i18n_reloader = ActiveSupport::FileUpdateChecker.new(paths) do

data/lib/active_support/fork_tracker.rb

@@ -6,7 +6,7 @@ module ActiveSupport
       def _fork
         pid = super
         if pid == 0
-          ForkTracker.check!
+          ForkTracker.after_fork_callback
         end
         pid
       end
@@ -37,7 +37,7 @@ module ActiveSupport
     @callbacks = []
 
     class << self
-      def check!
+      def after_fork_callback
         new_pid = Process.pid
         if @pid != new_pid
           @callbacks.each(&:call)
@@ -45,6 +45,14 @@ module ActiveSupport
         end
       end
 
+      if Process.respond_to?(:_fork) # Ruby 3.1+
+        def check!
+          # We trust the `_fork` callback
+        end
+      else
+        alias_method :check!, :after_fork_callback
+      end
+
       def hook!
         if Process.respond_to?(:_fork) # Ruby 3.1+
           ::Process.singleton_class.prepend(ModernCoreExt)

data/lib/active_support/gem_version.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
 module ActiveSupport
-  # Returns the currently loaded version of Active Support as a <tt>Gem::Version</tt>.
+  # Returns the currently loaded version of Active Support as a +Gem::Version+.
   def self.gem_version
     Gem::Version.new VERSION::STRING
   end
 
   module VERSION
     MAJOR = 7
-    MINOR = 0
-    TINY  = 8
-    PRE   = "1"
+    MINOR = 1
+    TINY  = 0
+    PRE   = "beta1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_support/gzip.rb

@@ -4,6 +4,8 @@ require "zlib"
 require "stringio"
 
 module ActiveSupport
+  # = Active Support \Gzip
+  #
   # A convenient wrapper for the zlib standard library that allows
   # compression/decompression of strings with gzip.
   #

data/lib/active_support/hash_with_indifferent_access.rb

@@ -6,6 +6,8 @@ require "active_support/core_ext/hash/except"
 require "active_support/core_ext/hash/slice"
 
 module ActiveSupport
+  # = \Hash With Indifferent Access
+  #
   # Implements a hash where keys <tt>:foo</tt> and <tt>"foo"</tt> are considered
   # to be the same.
   #
@@ -37,7 +39,7 @@ module ActiveSupport
   #
   # but this class is intended for use cases where strings or symbols are the
   # expected keys and it is convenient to understand both as the same. For
-  # example the +params+ hash in Ruby on Rails.
+  # example the +params+ hash in Ruby on \Rails.
   #
   # Note that core extensions define <tt>Hash#with_indifferent_access</tt>:
   #
@@ -45,7 +47,7 @@ module ActiveSupport
   #
   # which may be handy.
   #
-  # To access this class outside of Rails, require the core extension with:
+  # To access this class outside of \Rails, require the core extension with:
   #
   #   require "active_support/core_ext/hash/indifferent_access"
   #
@@ -113,7 +115,7 @@ module ActiveSupport
     #   hash.update({ "a" => 1 }, { "b" => 2 }) # => { "a" => 1, "b" => 2 }
     #
     # The arguments can be either an
-    # <tt>ActiveSupport::HashWithIndifferentAccess</tt> or a regular +Hash+.
+    # +ActiveSupport::HashWithIndifferentAccess+ or a regular +Hash+.
     # In either case the merge respects the semantics of indifferent access.
     #
     # If the argument is a regular hash with keys +:key+ and <tt>"key"</tt> only one
@@ -218,8 +220,12 @@ module ActiveSupport
     #   hash.default                   # => nil
     #   hash.default('foo')            # => 'foo'
     #   hash.default(:foo)             # => 'foo'
-    def default(*args)
-      super(*args.map { |arg| convert_key(arg) })
+    def default(key = (no_key = true))
+      if no_key
+        super()
+      else
+        super(convert_key(key))
+      end
     end
 
     # Returns an array of the values at the specified indices:
@@ -229,7 +235,8 @@ module ActiveSupport
     #   hash[:b] = 'y'
     #   hash.values_at('a', 'b') # => ["x", "y"]
     def values_at(*keys)
-      super(*keys.map { |key| convert_key(key) })
+      keys.map! { |key| convert_key(key) }
+      super
     end
 
     # Returns an array of the values at the specified indices, but also
@@ -242,7 +249,8 @@ module ActiveSupport
     #   hash.fetch_values('a', 'c') { |key| 'z' } # => ["x", "z"]
     #   hash.fetch_values('a', 'c') # => KeyError: key not found: "c"
     def fetch_values(*indices, &block)
-      super(*indices.map { |key| convert_key(key) }, &block)
+      indices.map! { |key| convert_key(key) }
+      super
     end
 
     # Returns a shallow copy of the hash.
@@ -301,7 +309,7 @@ module ActiveSupport
     #   hash.except(:a, "b") # => {c: 10}.with_indifferent_access
     #   hash                 # => { a: "x", b: "y", c: 10 }.with_indifferent_access
     def except(*keys)
-      slice(*self.keys - keys.map { |key| convert_key(key) })
+      dup.except!(*keys)
     end
     alias_method :without, :except
 
@@ -326,21 +334,31 @@ module ActiveSupport
       dup.tap { |hash| hash.reject!(*args, &block) }
     end
 
-    def transform_values(*args, &block)
+    def transform_values(&block)
       return to_enum(:transform_values) unless block_given?
-      dup.tap { |hash| hash.transform_values!(*args, &block) }
+      dup.tap { |hash| hash.transform_values!(&block) }
     end
 
-    def transform_keys(*args, &block)
-      return to_enum(:transform_keys) unless block_given?
-      dup.tap { |hash| hash.transform_keys!(*args, &block) }
+    NOT_GIVEN = Object.new # :nodoc:
+
+    def transform_keys(hash = NOT_GIVEN, &block)
+      return to_enum(:transform_keys) if NOT_GIVEN.equal?(hash) && !block_given?
+      dup.tap { |h| h.transform_keys!(hash, &block) }
     end
 
-    def transform_keys!
-      return enum_for(:transform_keys!) { size } unless block_given?
-      keys.each do |key|
-        self[yield(key)] = delete(key)
+    def transform_keys!(hash = NOT_GIVEN, &block)
+      return to_enum(:transform_keys!) if NOT_GIVEN.equal?(hash) && !block_given?
+
+      if hash.nil?
+        super
+      elsif NOT_GIVEN.equal?(hash)
+        keys.each { |key| self[yield(key)] = delete(key) }
+      elsif block_given?
+        keys.each { |key| self[hash[key] || yield(key)] = delete(key) }
+      else
+        keys.each { |key| self[hash[key] || key] = delete(key) }
       end
+
       self
     end
 

data/lib/active_support/i18n.rb

@@ -7,7 +7,7 @@ begin
   require "i18n"
   require "i18n/backend/fallbacks"
 rescue LoadError => e
-  $stderr.puts "The i18n gem is not available. Please add it to your Gemfile and run bundle install"
+  warn "The i18n gem is not available. Please add it to your Gemfile and run bundle install"
   raise e
 end
 require "active_support/lazy_load_hooks"