actionpack 6.1.7.5 → 7.1.3.1

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2004-2022 David Heinemeier Hansson
+Copyright (c) David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -18,3 +18,4 @@ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.rdoc

@@ -2,9 +2,8 @@
 
 Action Pack is a framework for handling and responding to web requests. It
 provides mechanisms for *routing* (mapping request URLs to actions), defining
-*controllers* that implement actions, and generating responses by rendering
-*views*, which are templates of various formats. In short, Action Pack
-provides the view and controller layers in the MVC paradigm.
+*controllers* that implement actions, and generating responses. In short, Action Pack
+provides the controller layer in the MVC paradigm.
 
 It consists of several modules:
 
@@ -17,11 +16,11 @@ It consists of several modules:
   subclassed to implement filters and actions to handle requests. The result
   of an action is typically content generated from views.
 
-With the Ruby on Rails framework, users only directly interface with the
+With the Ruby on \Rails framework, users only directly interface with the
 Action Controller module. Necessary Action Dispatch functionality is activated
 by default and Action View rendering is implicitly triggered by Action
 Controller. However, these modules are designed to function on their own and
-can be used outside of Rails.
+can be used outside of \Rails.
 
 You can read more about Action Pack in the {Action Controller Overview}[https://guides.rubyonrails.org/action_controller_overview.html] guide.
 
@@ -31,7 +30,7 @@ The latest version of Action Pack can be installed with RubyGems:
 
   $ gem install actionpack
 
-Source code can be downloaded as part of the Rails project on GitHub:
+Source code can be downloaded as part of the \Rails project on GitHub:
 
 * https://github.com/rails/rails/tree/main/actionpack
 
@@ -49,7 +48,7 @@ API documentation is at:
 
 * https://api.rubyonrails.org
 
-Bug reports for the Ruby on Rails project can be filed here:
+Bug reports for the Ruby on \Rails project can be filed here:
 
 * https://github.com/rails/rails/issues
 

data/lib/abstract_controller/asset_paths.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module AbstractController
-  module AssetPaths #:nodoc:
+  module AssetPaths # :nodoc:
     extend ActiveSupport::Concern
 
     included do

data/lib/abstract_controller/base.rb

@@ -9,37 +9,25 @@ require "active_support/core_ext/module/attr_internal"
 module AbstractController
   # Raised when a non-existing controller action is triggered.
   class ActionNotFound < StandardError
-    attr_reader :controller, :action
-    def initialize(message = nil, controller = nil, action = nil)
+    attr_reader :controller, :action # :nodoc:
+
+    def initialize(message = nil, controller = nil, action = nil) # :nodoc:
       @controller = controller
       @action = action
       super(message)
     end
 
-    class Correction
-      def initialize(error)
-        @error = error
-      end
-
-      def corrections
-        if @error.action
-          maybe_these = @error.controller.class.action_methods
+    if defined?(DidYouMean::Correctable) && defined?(DidYouMean::SpellChecker)
+      include DidYouMean::Correctable # :nodoc:
 
-          maybe_these.sort_by { |n|
-            DidYouMean::Jaro.distance(@error.action.to_s, n)
-          }.reverse.first(4)
-        else
-          []
-        end
+      def corrections # :nodoc:
+        @corrections ||= DidYouMean::SpellChecker.new(dictionary: controller.class.action_methods).correct(action)
       end
     end
-
-    # We may not have DYM, and DYM might not let us register error handlers
-    if defined?(DidYouMean) && DidYouMean.respond_to?(:correct_error)
-      DidYouMean.correct_error(self, Correction)
-    end
   end
 
+  # = 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
@@ -84,12 +72,17 @@ module AbstractController
       # 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.
-      # (<tt>ActionController::Metal</tt> and ActionController::Base are defined as abstract)
+      # (ActionController::Metal and ActionController::Base are defined as abstract)
       def internal_methods
         controller = self
+        methods = []
 
-        controller = controller.superclass until controller.abstract?
-        controller.public_instance_methods(true)
+        until controller.abstract?
+          methods += controller.public_instance_methods(false)
+          controller = controller.superclass
+        end
+
+        controller.public_instance_methods(true) - methods
       end
 
       # A list of method names that should be considered actions. This
@@ -103,14 +96,11 @@ module AbstractController
       def action_methods
         @action_methods ||= begin
           # All public instance methods of this class, including ancestors
-          methods = (public_instance_methods(true) -
-            # Except for public instance methods of Base and its ancestors
-            internal_methods +
-            # Be sure to include shadowed public instance methods of this class
-            public_instance_methods(false))
-
+          # 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.to_set
         end
       end
@@ -141,11 +131,16 @@ module AbstractController
         super
         clear_action_methods!
       end
+
+      def eager_load! # :nodoc:
+        action_methods
+        nil
+      end
     end
 
     abstract!
 
-    # Calls the action going through the entire action dispatch stack.
+    # 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
@@ -164,13 +159,14 @@ module AbstractController
 
       process_action(action_name, *args)
     end
+    ruby2_keywords(:process)
 
-    # Delegates to the class' ::controller_path
+    # Delegates to the class's ::controller_path.
     def controller_path
       self.class.controller_path
     end
 
-    # Delegates to the class' ::action_methods
+    # Delegates to the class's ::action_methods.
     def action_methods
       self.class.action_methods
     end
@@ -191,7 +187,7 @@ module AbstractController
 
     # Tests if a response body is set. Used to determine if the
     # +process_action+ callback needs to be terminated in
-    # +AbstractController::Callbacks+.
+    # AbstractController::Callbacks.
     def performed?
       response_body
     end
@@ -224,8 +220,8 @@ module AbstractController
       #
       # Notice that the first argument is the method to be dispatched
       # which is *not* necessarily the same as the action name.
-      def process_action(method_name, *args)
-        send_action(method_name, *args)
+      def process_action(...)
+        send_action(...)
       end
 
       # Actually call the method associated with the action. Override

data/lib/abstract_controller/caching/fragments.rb

@@ -2,6 +2,8 @@
 
 module AbstractController
   module Caching
+    # = 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
@@ -142,8 +144,8 @@ module AbstractController
         end
       end
 
-      def instrument_fragment_cache(name, key) # :nodoc:
-        ActiveSupport::Notifications.instrument("#{name}.#{instrument_name}", instrument_payload(key)) { yield }
+      def instrument_fragment_cache(name, key, &block) # :nodoc:
+        ActiveSupport::Notifications.instrument("#{name}.#{instrument_name}", instrument_payload(key), &block)
       end
     end
   end

data/lib/abstract_controller/caching.rb

@@ -50,7 +50,7 @@ module AbstractController
     end
 
     def view_cache_dependencies
-      self.class._view_cache_dependencies.map { |dep| instance_exec(&dep) }.compact
+      self.class._view_cache_dependencies.filter_map { |dep| instance_exec(&dep) }
     end
 
     private

data/lib/abstract_controller/callbacks.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module AbstractController
-  # = Abstract Controller Callbacks
+  # = Abstract Controller \Callbacks
   #
   # Abstract Controller provides hooks during the life cycle of a controller action.
   # Callbacks allow you to trigger logic during this cycle. Available callbacks are:
@@ -33,14 +33,42 @@ module AbstractController
       define_callbacks :process_action,
                        terminator: ->(controller, result_lambda) { result_lambda.call; controller.performed? },
                        skip_after_callbacks_if_terminated: true
+      mattr_accessor :raise_on_missing_callback_actions, default: false
     end
 
-    # Override <tt>AbstractController::Base#process_action</tt> to run the
-    # <tt>process_action</tt> callbacks around the normal behavior.
-    def process_action(*)
-      run_callbacks(:process_action) do
-        super
+    class ActionFilter # :nodoc:
+      def initialize(filters, conditional_key, actions)
+        @filters = filters.to_a
+        @conditional_key = conditional_key
+        @actions = Array(actions).map(&:to_s).to_set
       end
+
+      def match?(controller)
+        if controller.raise_on_missing_callback_actions
+          missing_action = @actions.find { |action| !controller.available_action?(action) }
+          if missing_action
+            filter_names = @filters.length == 1 ? @filters.first.inspect : @filters.inspect
+
+            message = <<~MSG
+              The #{missing_action} action could not be found for the #{filter_names}
+              callback on #{controller.class.name}, but it is listed in the controller's
+              #{@conditional_key.inspect} option.
+
+              Raising for missing callback actions is a new default in Rails 7.1, if you'd
+              like to turn this off you can delete the option from the environment configurations
+              or set `config.action_controller.raise_on_missing_callback_actions` to `false`.
+            MSG
+
+            raise ActionNotFound.new(message, controller, missing_action)
+          end
+        end
+
+        @actions.include?(controller.action_name)
+      end
+
+      alias after  match?
+      alias before match?
+      alias around match?
     end
 
     module ClassMethods
@@ -69,10 +97,10 @@ module AbstractController
       end
 
       def _normalize_callback_option(options, from, to) # :nodoc:
-        if from = options.delete(from)
-          _from = Array(from).map(&:to_s).to_set
-          from = proc { |c| _from.include? c.action_name }
-          options[to] = Array(options[to]).unshift(from)
+        if from_value = options.delete(from)
+          filters = options[:filters]
+          from_value = ActionFilter.new(filters, from, from_value)
+          options[to] = Array(options[to]).unshift(from_value)
         end
       end
 
@@ -90,8 +118,10 @@ module AbstractController
       # * <tt>options</tt>  - A hash of options to be used when adding the callback.
       def _insert_callbacks(callbacks, block = nil)
         options = callbacks.extract_options!
-        _normalize_callback_options(options)
         callbacks.push(block) if block
+        options[:filters] = callbacks
+        _normalize_callback_options(options)
+        options.delete(:filters)
         callbacks.each do |callback|
           yield callback, options
         end
@@ -220,5 +250,14 @@ module AbstractController
         alias_method :"append_#{callback}_action", :"#{callback}_action"
       end
     end
+
+    private
+      # Override <tt>AbstractController::Base#process_action</tt> to run the
+      # <tt>process_action</tt> callbacks around the normal behavior.
+      def process_action(...)
+        run_callbacks(:process_action) do
+          super
+        end
+      end
   end
 end

data/lib/abstract_controller/collector.rb

@@ -10,7 +10,7 @@ module AbstractController
         def #{sym}(*args, &block)
           custom(Mime[:#{sym}], *args, &block)
         end
-        ruby2_keywords(:#{sym}) if respond_to?(:ruby2_keywords, true)
+        ruby2_keywords(:#{sym})
       RUBY
     end
 
@@ -39,6 +39,6 @@ module AbstractController
         super
       end
     end
-    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+    ruby2_keywords(:method_missing)
   end
 end

data/lib/abstract_controller/deprecator.rb

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

data/lib/abstract_controller/error.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module AbstractController
-  class Error < StandardError #:nodoc:
+  class Error < StandardError # :nodoc:
   end
 end

data/lib/abstract_controller/helpers.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 require "active_support/dependencies"
+require "active_support/core_ext/name_error"
 
 module AbstractController
   module Helpers
+    include ActiveSupport::Deprecation::DeprecatedConstantAccessor
     extend ActiveSupport::Concern
 
     included do
@@ -22,7 +24,7 @@ module AbstractController
       self._helpers = define_helpers_module(self)
     end
 
-    class MissingHelperError < LoadError
+    class DeprecatedMissingHelperError < LoadError
       def initialize(error, path)
         @error = error
         @path  = "helpers/#{path}.rb"
@@ -35,11 +37,46 @@ module AbstractController
         end
       end
     end
+    deprecate_constant "MissingHelperError", "AbstractController::Helpers::DeprecatedMissingHelperError",
+      message: "AbstractController::Helpers::MissingHelperError has been deprecated. If a Helper is not present, a NameError will be raised instead.",
+      deprecator: AbstractController.deprecator
 
     def _helpers
       self.class._helpers
     end
 
+    module Resolution # :nodoc:
+      def modules_for_helpers(modules_or_helper_prefixes)
+        modules_or_helper_prefixes.flatten.map! do |module_or_helper_prefix|
+          case module_or_helper_prefix
+          when Module
+            module_or_helper_prefix
+          when String, Symbol
+            helper_prefix = module_or_helper_prefix.to_s
+            helper_prefix = helper_prefix.camelize unless helper_prefix.start_with?(/[A-Z]/)
+            "#{helper_prefix}Helper".constantize
+          else
+            raise ArgumentError, "helper must be a String, Symbol, or Module"
+          end
+        end
+      end
+
+      def all_helpers_from_path(path)
+        helpers = Array(path).flat_map do |_path|
+          names = Dir["#{_path}/**/*_helper.rb"].map { |file| file[_path.to_s.size + 1..-"_helper.rb".size - 1] }
+          names.sort!
+        end
+        helpers.uniq!
+        helpers
+      end
+
+      def helper_modules_from_paths(paths)
+        modules_for_helpers(all_helpers_from_path(paths))
+      end
+    end
+
+    extend Resolution
+
     module ClassMethods
       # When a class is inherited, wrap its helper module in a new module.
       # This ensures that the parent class's module can be changed
@@ -54,19 +91,44 @@ module AbstractController
 
       attr_writer :_helpers
 
+      include Resolution
+
+      ##
+      # :method: modules_for_helpers
+      # :call-seq: modules_for_helpers(modules_or_helper_prefixes)
+      #
+      # Given an array of values like the ones accepted by +helper+, this method
+      # returns an array with the corresponding modules, in the same order.
+      #
+      #--
+      # Implemented by Resolution#modules_for_helpers.
+
+      ##
+      # :method: all_helpers_from_path
+      # :call-seq: all_helpers_from_path(path)
+      #
+      # Returns a list of helper names in a given path.
+      #
+      #   ActionController::Base.all_helpers_from_path 'app/helpers'
+      #   # => ["application", "chart", "rubygems"]
+      #
+      #--
+      # Implemented by Resolution#all_helpers_from_path.
+
       # Declare a controller method as a helper. For example, the following
       # makes the +current_user+ and +logged_in?+ controller methods available
       # to the view:
       #   class ApplicationController < ActionController::Base
       #     helper_method :current_user, :logged_in?
       #
-      #     def current_user
-      #       @current_user ||= User.find_by(id: session[:user])
-      #     end
+      #     private
+      #       def current_user
+      #         @current_user ||= User.find_by(id: session[:user])
+      #       end
       #
-      #     def logged_in?
-      #       current_user != nil
-      #     end
+      #       def logged_in?
+      #         current_user != nil
+      #       end
       #   end
       #
       # In a view:
@@ -83,11 +145,14 @@ module AbstractController
         file, line = location.path, location.lineno
 
         methods.each do |method|
-          _helpers_for_modification.class_eval <<-ruby_eval, file, line
-            def #{method}(*args, &block)                    # def current_user(*args, &block)
-              controller.send(:'#{method}', *args, &block)  #   controller.send(:'current_user', *args, &block)
-            end                                             # end
-            ruby2_keywords(:'#{method}') if respond_to?(:ruby2_keywords, true)
+          # def current_user(*args, &block)
+          #   controller.send(:'current_user', *args, &block)
+          # end
+          _helpers_for_modification.class_eval <<~ruby_eval.lines.map(&:strip).join(";"), file, line
+            def #{method}(*args, &block)
+              controller.send(:'#{method}', *args, &block)
+            end
+            ruby2_keywords(:'#{method}')
           ruby_eval
         end
       end
@@ -109,7 +174,7 @@ module AbstractController
       # The last two assume that <tt>"foo".camelize</tt> returns "Foo".
       #
       # When strings or symbols are passed, the method finds the actual module
-      # object using +String#constantize+. Therefore, if the module has not been
+      # object using String#constantize. Therefore, if the module has not been
       # yet loaded, it has to be autoloadable, which is normally the case.
       #
       # Namespaces are supported. The following calls include +Foo::BarHelper+:
@@ -163,23 +228,6 @@ module AbstractController
         default_helper_module! unless anonymous?
       end
 
-      # Given an array of values like the ones accepted by +helper+, this method
-      # returns an array with the corresponding modules, in the same order.
-      def modules_for_helpers(modules_or_helper_prefixes)
-        modules_or_helper_prefixes.flatten.map! do |module_or_helper_prefix|
-          case module_or_helper_prefix
-          when Module
-            module_or_helper_prefix
-          when String, Symbol
-            helper_prefix = module_or_helper_prefix.to_s
-            helper_prefix = helper_prefix.camelize unless helper_prefix.start_with?(/[A-Z]/)
-            "#{helper_prefix}Helper".constantize
-          else
-            raise ArgumentError, "helper must be a String, Symbol, or Module"
-          end
-        end
-      end
-
       def _helpers_for_modification
         unless @_helpers
           self._helpers = define_helpers_module(self, superclass._helpers)

data/lib/abstract_controller/logger.rb

@@ -3,7 +3,7 @@
 require "active_support/benchmarkable"
 
 module AbstractController
-  module Logger #:nodoc:
+  module Logger # :nodoc:
     extend ActiveSupport::Concern
 
     included do

data/lib/abstract_controller/railties/routes_helpers.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/module/introspection"
+
 module AbstractController
   module Railties
     module RoutesHelpers
@@ -8,26 +10,11 @@ module AbstractController
           define_method(:inherited) do |klass|
             super(klass)
 
-            namespace = klass.module_parents.detect { |m| m.respond_to?(:railtie_routes_url_helpers) }
-            actual_routes = namespace ? namespace.railtie_routes_url_helpers._routes : routes
-
-            if namespace
+            if namespace = klass.module_parents.detect { |m| m.respond_to?(:railtie_routes_url_helpers) }
               klass.include(namespace.railtie_routes_url_helpers(include_path_helpers))
             else
               klass.include(routes.url_helpers(include_path_helpers))
             end
-
-            # In the case that we have ex.
-            #   class A::Foo < ApplicationController
-            #   class Bar < A::Foo
-            # We will need to redefine _routes because it will not be correct
-            # via inheritance.
-            unless klass._routes.equal?(actual_routes)
-              klass.redefine_singleton_method(:_routes) { actual_routes }
-              klass.include(Module.new do
-                define_method(:_routes) { @_routes || actual_routes }
-              end)
-            end
           end
         end
       end

data/lib/abstract_controller/rendering.rb

@@ -7,7 +7,7 @@ require "set"
 
 module AbstractController
   class DoubleRenderError < Error
-    DEFAULT_MESSAGE = "Render and/or redirect were called multiple times in this action. Please note that you may only call render OR redirect, and at most once per action. Also note that neither redirect nor render terminate execution of the action, so if you want to exit an action after redirecting, you need to do something like \"redirect_to(...) and return\"."
+    DEFAULT_MESSAGE = "Render and/or redirect were called multiple times in this action. Please note that you may only call render OR redirect, and at most once per action. Also note that neither redirect nor render terminate execution of the action, so if you want to exit an action after redirecting, you need to do something like \"redirect_to(...); return\"."
 
     def initialize(message = nil)
       super(message || DEFAULT_MESSAGE)
@@ -18,8 +18,10 @@ module AbstractController
     extend ActiveSupport::Concern
     include ActionView::ViewPaths
 
-    # Normalizes arguments, options and then delegates render_to_body and
+    # Normalizes arguments and options, and then delegates to render_to_body and
     # sticks the result in <tt>self.response_body</tt>.
+    #
+    # Supported options depend on the underlying +render_to_body+ implementation.
     def render(*args, &block)
       options = _normalize_render(*args, &block)
       rendered_body = render_to_body(options)
@@ -32,16 +34,12 @@ module AbstractController
       self.response_body = rendered_body
     end
 
-    # Raw rendering of a template to a string.
-    #
-    # It is similar to render, except that it does not
-    # set the +response_body+ and it should be guaranteed
-    # to always return a string.
+    # Similar to #render, but only returns the rendered template as a string,
+    # instead of setting +self.response_body+.
     #
-    # If a component extends the semantics of +response_body+
-    # (as ActionController extends it to be anything that
-    # responds to the method each), this method needs to be
-    # overridden in order to still return a string.
+    # If a component extends the semantics of +response_body+ (as ActionController
+    # extends it to be anything that responds to the method each), this method
+    # needs to be overridden in order to still return a string.
     def render_to_string(*args, &block)
       options = _normalize_render(*args, &block)
       render_to_body(options)
@@ -51,7 +49,7 @@ module AbstractController
     def render_to_body(options = {})
     end
 
-    # Returns Content-Type of rendered content.
+    # Returns +Content-Type+ of rendered content.
     def rendered_format
       Mime[:text]
     end
@@ -70,8 +68,8 @@ module AbstractController
 
   private
     # Normalize args by converting <tt>render "foo"</tt> to
-    # <tt>render :action => "foo"</tt> and <tt>render "foo/bar"</tt> to
-    # <tt>render :file => "foo/bar"</tt>.
+    # <tt>render action: "foo"</tt> and <tt>render "foo/bar"</tt> to
+    # <tt>render file: "foo/bar"</tt>.
     def _normalize_args(action = nil, options = {}) # :doc:
       if action.respond_to?(:permitted?)
         if action.permitted?