actionpack 7.1.5.1 → 8.1.2

data/README.rdoc

@@ -52,6 +52,6 @@ Bug reports for the Ruby on \Rails project can be filed here:
 
 * https://github.com/rails/rails/issues
 
-Feature requests should be discussed on the rails-core mailing list here:
+Feature requests should be discussed on the rubyonrails-core forum here:
 
 * https://discuss.rubyonrails.org/c/rubyonrails-core

data/lib/abstract_controller/asset_paths.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 module AbstractController
   module AssetPaths # :nodoc:
     extend ActiveSupport::Concern
 
     included do
-      config_accessor :asset_host, :assets_dir, :javascripts_dir,
-        :stylesheets_dir, :default_asset_host_protocol, :relative_url_root
+      singleton_class.delegate :asset_host, :asset_host=, :assets_dir, :assets_dir=, :javascripts_dir, :javascripts_dir=,
+        :stylesheets_dir, :stylesheets_dir=, :default_asset_host_protocol, :default_asset_host_protocol=, :relative_url_root, :relative_url_root=, to: :config
+      delegate :asset_host, :asset_host=, :assets_dir, :assets_dir=, :javascripts_dir, :javascripts_dir=,
+        :stylesheets_dir, :stylesheets_dir=, :default_asset_host_protocol, :default_asset_host_protocol=, :relative_url_root, :relative_url_root=, to: :config
     end
   end
 end

data/lib/abstract_controller/base.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 require "abstract_controller/error"
-require "active_support/configurable"
 require "active_support/descendants_tracker"
 require "active_support/core_ext/module/anonymous"
 require "active_support/core_ext/module/attr_internal"
@@ -26,12 +27,12 @@ module AbstractController
     end
   end
 
-  # = Abstract Controller \Base
+  # # Abstract Controller Base
   #
-  # AbstractController::Base is a low-level API. Nobody should be
-  # using it directly, and subclasses (like ActionController::Base) are
-  # expected to provide their own +render+ method, since rendering means
-  # different things depending on the context.
+  # AbstractController::Base is a low-level API. Nobody should be using it
+  # directly, and subclasses (like ActionController::Base) are expected to provide
+  # their own `render` method, since rendering means different things depending on
+  # the context.
   class Base
     ##
     # Returns the body of the HTTP response sent by the controller.
@@ -45,34 +46,34 @@ module AbstractController
     # Returns the formats that can be processed by the controller.
     attr_internal :formats
 
-    include ActiveSupport::Configurable
+    class_attribute :config, instance_predicate: false, default: ActiveSupport::OrderedOptions.new
     extend ActiveSupport::DescendantsTracker
 
     class << self
       attr_reader :abstract
       alias_method :abstract?, :abstract
 
-      # Define a controller as abstract. See internal_methods for more
-      # details.
+      # Define a controller as abstract. See internal_methods for more details.
       def abstract!
         @abstract = true
       end
 
       def inherited(klass) # :nodoc:
-        # Define the abstract ivar on subclasses so that we don't get
-        # uninitialized ivar warnings
+        # Define the abstract ivar on subclasses so that we don't get uninitialized ivar
+        # warnings
         unless klass.instance_variable_defined?(:@abstract)
           klass.instance_variable_set(:@abstract, false)
         end
+        klass.config = ActiveSupport::InheritableOptions.new(config)
         super
       end
 
-      # A list of all internal methods for a controller. This finds the first
-      # abstract superclass of a controller, and gets a list of all public
-      # instance methods on that abstract class. Public instance methods of
-      # a controller would normally be considered action methods, so methods
-      # declared on abstract classes are being removed.
-      # (ActionController::Metal and ActionController::Base are defined as abstract)
+      # A list of all internal methods for a controller. This finds the first abstract
+      # superclass of a controller, and gets a list of all public instance methods on
+      # that abstract class. Public instance methods of a controller would normally be
+      # considered action methods, so methods declared on abstract classes are being
+      # removed. (ActionController::Metal and ActionController::Base are defined as
+      # abstract)
       def internal_methods
         controller = self
         methods = []
@@ -85,47 +86,43 @@ module AbstractController
         controller.public_instance_methods(true) - methods
       end
 
-      # A list of method names that should be considered actions. This
-      # includes all public instance methods on a controller, less
-      # any internal methods (see internal_methods), adding back in
-      # any methods that are internal, but still exist on the class
-      # itself.
-      #
-      # ==== Returns
-      # * <tt>Set</tt> - A set of all methods that should be considered actions.
+      # A `Set` of method names that should be considered actions. This includes all
+      # public instance methods on a controller, less any internal methods (see
+      # internal_methods), adding back in any methods that are internal, but still
+      # exist on the class itself.
       def action_methods
         @action_methods ||= begin
-          # All public instance methods of this class, including ancestors
-          # except for public instance methods of Base and its ancestors.
+          # All public instance methods of this class, including ancestors except for
+          # public instance methods of Base and its ancestors.
           methods = public_instance_methods(true) - internal_methods
-          # Be sure to include shadowed public instance methods of this class.
-          methods.concat(public_instance_methods(false))
-          methods.map!(&:to_s)
+          methods.map!(&:name)
           methods.to_set
         end
       end
 
-      # action_methods are cached and there is sometimes a need to refresh
-      # them. ::clear_action_methods! allows you to do that, so next time
-      # you run action_methods, they will be recalculated.
+      # action_methods are cached and there is sometimes a need to refresh them.
+      # ::clear_action_methods! allows you to do that, so next time you run
+      # action_methods, they will be recalculated.
       def clear_action_methods!
         @action_methods = nil
       end
 
       # Returns the full controller name, underscored, without the ending Controller.
       #
-      #   class MyApp::MyPostsController < AbstractController::Base
+      #     class MyApp::MyPostsController < AbstractController::Base
       #
-      #   end
+      #     end
       #
-      #   MyApp::MyPostsController.controller_path # => "my_app/my_posts"
+      #     MyApp::MyPostsController.controller_path # => "my_app/my_posts"
       #
-      # ==== Returns
-      # * <tt>String</tt>
       def controller_path
         @controller_path ||= name.delete_suffix("Controller").underscore unless anonymous?
       end
 
+      def configure # :nodoc:
+        yield config
+      end
+
       # Refresh the cached action_methods when a new action_method is added.
       def method_added(name)
         super
@@ -142,13 +139,10 @@ module AbstractController
 
     # Calls the action going through the entire Action Dispatch stack.
     #
-    # The actual method that is called is determined by calling
-    # #method_for_action. If no method can handle the action, then an
-    # AbstractController::ActionNotFound error is raised.
-    #
-    # ==== Returns
-    # * <tt>self</tt>
-    def process(action, *args)
+    # The actual method that is called is determined by calling #method_for_action.
+    # If no method can handle the action, then an AbstractController::ActionNotFound
+    # error is raised.
+    def process(action, ...)
       @_action_name = action.to_s
 
       unless action_name = _find_action_name(@_action_name)
@@ -157,9 +151,8 @@ module AbstractController
 
       @_response_body = nil
 
-      process_action(action_name, *args)
+      process_action(action_name, ...)
     end
-    ruby2_keywords(:process)
 
     # Delegates to the class's ::controller_path.
     def controller_path
@@ -171,114 +164,120 @@ module AbstractController
       self.class.action_methods
     end
 
-    # Returns true if a method for the action is available and
-    # can be dispatched, false otherwise.
+    # Returns true if a method for the action is available and can be dispatched,
+    # false otherwise.
+    #
+    # Notice that `action_methods.include?("foo")` may return false and
+    # `available_action?("foo")` returns true because this method considers actions
+    # that are also available through other means, for example, implicit render
+    # ones.
     #
-    # Notice that <tt>action_methods.include?("foo")</tt> may return
-    # false and <tt>available_action?("foo")</tt> returns true because
-    # this method considers actions that are also available
-    # through other means, for example, implicit render ones.
+    # #### Parameters
+    # *   `action_name` - The name of an action to be tested
     #
-    # ==== Parameters
-    # * <tt>action_name</tt> - The name of an action to be tested
     def available_action?(action_name)
       _find_action_name(action_name)
     end
 
-    # Tests if a response body is set. Used to determine if the
-    # +process_action+ callback needs to be terminated in
-    # AbstractController::Callbacks.
+    # Tests if a response body is set. Used to determine if the `process_action`
+    # callback needs to be terminated in AbstractController::Callbacks.
     def performed?
       response_body
     end
 
-    # Returns true if the given controller is capable of rendering
-    # a path. A subclass of +AbstractController::Base+
-    # may return false. An Email controller for example does not
-    # support paths, only full URLs.
+    # Returns true if the given controller is capable of rendering a path. A
+    # subclass of `AbstractController::Base` may return false. An Email controller
+    # for example does not support paths, only full URLs.
     def self.supports_path?
       true
     end
 
+    def config # :nodoc:
+      @_config ||= self.class.config.inheritable_copy
+    end
+
     def inspect # :nodoc:
       "#<#{self.class.name}:#{'%#016x' % (object_id << 1)}>"
     end
 
     private
-      # Returns true if the name can be considered an action because
-      # it has a method defined in the controller.
+      # Returns true if the name can be considered an action because it has a method
+      # defined in the controller.
+      #
+      # #### Parameters
+      # *   `name` - The name of an action to be tested
       #
-      # ==== Parameters
-      # * <tt>name</tt> - The name of an action to be tested
       def action_method?(name)
         self.class.action_methods.include?(name)
       end
 
-      # Call the action. Override this in a subclass to modify the
-      # behavior around processing an action. This, and not #process,
-      # is the intended way to override action dispatching.
+      # Call the action. Override this in a subclass to modify the behavior around
+      # processing an action. This, and not #process, is the intended way to override
+      # action dispatching.
       #
-      # Notice that the first argument is the method to be dispatched
-      # which is *not* necessarily the same as the action name.
+      # Notice that the first argument is the method to be dispatched which is **not**
+      # necessarily the same as the action name.
       def process_action(...)
         send_action(...)
       end
 
-      # Actually call the method associated with the action. Override
-      # this method if you wish to change how action methods are called,
-      # not to add additional behavior around it. For example, you would
-      # override #send_action if you want to inject arguments into the
-      # method.
+      # Actually call the method associated with the action. Override this method if
+      # you wish to change how action methods are called, not to add additional
+      # behavior around it. For example, you would override #send_action if you want
+      # to inject arguments into the method.
       alias send_action send
 
-      # If the action name was not found, but a method called "action_missing"
-      # was found, #method_for_action will return "_handle_action_missing".
-      # This method calls #action_missing with the current action name.
+      # If the action name was not found, but a method called "action_missing" was
+      # found, #method_for_action will return "_handle_action_missing". This method
+      # calls #action_missing with the current action name.
       def _handle_action_missing(*args)
         action_missing(@_action_name, *args)
       end
 
-      # Takes an action name and returns the name of the method that will
-      # handle the action.
+      # Takes an action name and returns the name of the method that will handle the
+      # action.
       #
       # It checks if the action name is valid and returns false otherwise.
       #
       # See method_for_action for more information.
       #
-      # ==== Parameters
-      # * <tt>action_name</tt> - An action name to find a method name for
+      # #### Parameters
+      # *   `action_name` - An action name to find a method name for
+      #
       #
-      # ==== Returns
-      # * <tt>string</tt> - The name of the method that handles the action
-      # * false           - No valid method name could be found.
-      # Raise +AbstractController::ActionNotFound+.
+      # #### Returns
+      # *   `string` - The name of the method that handles the action
+      # *   false           - No valid method name could be found.
+      #
+      # Raise `AbstractController::ActionNotFound`.
       def _find_action_name(action_name)
         _valid_action_name?(action_name) && method_for_action(action_name)
       end
 
-      # Takes an action name and returns the name of the method that will
-      # handle the action. In normal cases, this method returns the same
-      # name as it receives. By default, if #method_for_action receives
-      # a name that is not an action, it will look for an #action_missing
-      # method and return "_handle_action_missing" if one is found.
+      # Takes an action name and returns the name of the method that will handle the
+      # action. In normal cases, this method returns the same name as it receives. By
+      # default, if #method_for_action receives a name that is not an action, it will
+      # look for an #action_missing method and return "_handle_action_missing" if one
+      # is found.
+      #
+      # Subclasses may override this method to add additional conditions that should
+      # be considered an action. For instance, an HTTP controller with a template
+      # matching the action name is considered to exist.
+      #
+      # If you override this method to handle additional cases, you may also provide a
+      # method (like `_handle_method_missing`) to handle the case.
       #
-      # Subclasses may override this method to add additional conditions
-      # that should be considered an action. For instance, an HTTP controller
-      # with a template matching the action name is considered to exist.
+      # If none of these conditions are true, and `method_for_action` returns `nil`,
+      # an `AbstractController::ActionNotFound` exception will be raised.
       #
-      # If you override this method to handle additional cases, you may
-      # also provide a method (like +_handle_method_missing+) to handle
-      # the case.
+      # #### Parameters
+      # *   `action_name` - An action name to find a method name for
       #
-      # If none of these conditions are true, and +method_for_action+
-      # returns +nil+, an +AbstractController::ActionNotFound+ exception will be raised.
       #
-      # ==== Parameters
-      # * <tt>action_name</tt> - An action name to find a method name for
+      # #### Returns
+      # *   `string` - The name of the method that handles the action
+      # *   `nil`    - No method name could be found.
       #
-      # ==== Returns
-      # * <tt>string</tt> - The name of the method that handles the action
-      # * <tt>nil</tt>    - No method name could be found.
       def method_for_action(action_name)
         if action_method?(action_name)
           action_name

data/lib/abstract_controller/caching/fragments.rb

@@ -1,22 +1,23 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 module AbstractController
   module Caching
-    # = Abstract Controller Caching \Fragments
+    # # Abstract Controller Caching Fragments
     #
-    # Fragment caching is used for caching various blocks within
-    # views without caching the entire action as a whole. This is
-    # useful when certain elements of an action change frequently or
-    # depend on complicated state while other parts rarely change or
-    # can be shared amongst multiple parties. The caching is done using
-    # the +cache+ helper available in the Action View. See
+    # Fragment caching is used for caching various blocks within views without
+    # caching the entire action as a whole. This is useful when certain elements of
+    # an action change frequently or depend on complicated state while other parts
+    # rarely change or can be shared amongst multiple parties. The caching is done
+    # using the `cache` helper available in the Action View. See
     # ActionView::Helpers::CacheHelper for more information.
     #
-    # While it's strongly recommended that you use key-based cache
-    # expiration (see links in CacheHelper for more information),
-    # it is also possible to manually expire caches. For example:
+    # While it's strongly recommended that you use key-based cache expiration (see
+    # links in CacheHelper for more information), it is also possible to manually
+    # expire caches. For example:
     #
-    #   expire_fragment('name_of_cache')
+    #     expire_fragment('name_of_cache')
     module Fragments
       extend ActiveSupport::Concern
 
@@ -35,38 +36,35 @@ module AbstractController
       end
 
       module ClassMethods
-        # Allows you to specify controller-wide key prefixes for
-        # cache fragments. Pass either a constant +value+, or a block
-        # which computes a value each time a cache key is generated.
+        # Allows you to specify controller-wide key prefixes for cache fragments. Pass
+        # either a constant `value`, or a block which computes a value each time a cache
+        # key is generated.
         #
-        # For example, you may want to prefix all fragment cache keys
-        # with a global version identifier, so you can easily
-        # invalidate all caches.
+        # For example, you may want to prefix all fragment cache keys with a global
+        # version identifier, so you can easily invalidate all caches.
         #
-        #   class ApplicationController
-        #     fragment_cache_key "v1"
-        #   end
+        #     class ApplicationController
+        #       fragment_cache_key "v1"
+        #     end
         #
-        # When it's time to invalidate all fragments, simply change
-        # the string constant. Or, progressively roll out the cache
-        # invalidation using a computed value:
+        # When it's time to invalidate all fragments, simply change the string constant.
+        # Or, progressively roll out the cache invalidation using a computed value:
         #
-        #   class ApplicationController
-        #     fragment_cache_key do
-        #       @account.id.odd? ? "v1" : "v2"
+        #     class ApplicationController
+        #       fragment_cache_key do
+        #         @account.id.odd? ? "v1" : "v2"
+        #       end
         #     end
-        #   end
         def fragment_cache_key(value = nil, &key)
           self.fragment_cache_keys += [key || -> { value }]
         end
       end
 
-      # Given a key (as described in +expire_fragment+), returns
-      # a key array suitable for use in reading, writing, or expiring a
-      # cached fragment. All keys begin with <tt>:views</tt>,
-      # followed by <tt>ENV["RAILS_CACHE_ID"]</tt> or <tt>ENV["RAILS_APP_VERSION"]</tt> if set,
-      # followed by any controller-wide key prefix values, ending
-      # with the specified +key+ value.
+      # Given a key (as described in `expire_fragment`), returns a key array suitable
+      # for use in reading, writing, or expiring a cached fragment. All keys begin
+      # with `:views`, followed by `ENV["RAILS_CACHE_ID"]` or
+      # `ENV["RAILS_APP_VERSION"]` if set, followed by any controller-wide key prefix
+      # values, ending with the specified `key` value.
       def combined_fragment_cache_key(key)
         head = self.class.fragment_cache_keys.map { |k| instance_exec(&k) }
         tail = key.is_a?(Hash) ? url_for(key).split("://").last : key
@@ -77,8 +75,8 @@ module AbstractController
         cache_key
       end
 
-      # Writes +content+ to the location signified by
-      # +key+ (see +expire_fragment+ for acceptable formats).
+      # Writes `content` to the location signified by `key` (see `expire_fragment` for
+      # acceptable formats).
       def write_fragment(key, content, options = nil)
         return content unless cache_configured?
 
@@ -90,8 +88,8 @@ module AbstractController
         content
       end
 
-      # Reads a cached fragment from the location signified by +key+
-      # (see +expire_fragment+ for acceptable formats).
+      # Reads a cached fragment from the location signified by `key` (see
+      # `expire_fragment` for acceptable formats).
       def read_fragment(key, options = nil)
         return unless cache_configured?
 
@@ -102,8 +100,8 @@ module AbstractController
         end
       end
 
-      # Check if a cached fragment from the location signified by
-      # +key+ exists (see +expire_fragment+ for acceptable formats).
+      # Check if a cached fragment from the location signified by `key` exists (see
+      # `expire_fragment` for acceptable formats).
       def fragment_exist?(key, options = nil)
         return unless cache_configured?
         key = combined_fragment_cache_key(key)
@@ -115,22 +113,21 @@ module AbstractController
 
       # Removes fragments from the cache.
       #
-      # +key+ can take one of three forms:
+      # `key` can take one of three forms:
+      #
+      # *   String - This would normally take the form of a path, like
+      #     `pages/45/notes`.
+      # *   Hash - Treated as an implicit call to `url_for`, like `{ controller:
+      #     'pages', action: 'notes', id: 45}`
+      # *   Regexp - Will remove any fragment that matches, so `%r{pages/\d*/notes}`
+      #     might remove all notes. Make sure you don't use anchors in the regex (`^`
+      #     or `$`) because the actual filename matched looks like
+      #     `./cache/filename/path.cache`. Note: Regexp expiration is only supported
+      #     on caches that can iterate over all keys (unlike memcached).
       #
-      # * String - This would normally take the form of a path, like
-      #   <tt>pages/45/notes</tt>.
-      # * Hash - Treated as an implicit call to +url_for+, like
-      #   <tt>{ controller: 'pages', action: 'notes', id: 45}</tt>
-      # * Regexp - Will remove any fragment that matches, so
-      #   <tt>%r{pages/\d*/notes}</tt> might remove all notes. Make sure you
-      #   don't use anchors in the regex (<tt>^</tt> or <tt>$</tt>) because
-      #   the actual filename matched looks like
-      #   <tt>./cache/filename/path.cache</tt>. Note: Regexp expiration is
-      #   only supported on caches that can iterate over all keys (unlike
-      #   memcached).
       #
-      # +options+ is passed through to the cache store's +delete+
-      # method (or <tt>delete_matched</tt>, for Regexp keys).
+      # `options` is passed through to the cache store's `delete` method (or
+      # `delete_matched`, for Regexp keys).
       def expire_fragment(key, options = nil)
         return unless cache_configured?
         key = combined_fragment_cache_key(key) unless key.is_a?(Regexp)

data/lib/abstract_controller/caching.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 module AbstractController
   module Caching
     extend ActiveSupport::Concern
@@ -30,13 +32,16 @@ module AbstractController
     included do
       extend ConfigMethods
 
-      config_accessor :default_static_extension
+      singleton_class.delegate :default_static_extension, :default_static_extension=, to: :config
+      delegate :default_static_extension, :default_static_extension=, to: :config
       self.default_static_extension ||= ".html"
 
-      config_accessor :perform_caching
+      singleton_class.delegate :perform_caching, :perform_caching=, to: :config
+      delegate :perform_caching, :perform_caching=, to: :config
       self.perform_caching = true if perform_caching.nil?
 
-      config_accessor :enable_fragment_cache_logging
+      singleton_class.delegate :enable_fragment_cache_logging, :enable_fragment_cache_logging=, to: :config
+      delegate :enable_fragment_cache_logging, :enable_fragment_cache_logging=, to: :config
       self.enable_fragment_cache_logging = false
 
       class_attribute :_view_cache_dependencies, default: []