actionpack 7.0.8 → 7.2.0

data/lib/abstract_controller/callbacks.rb

@@ -1,46 +1,68 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 module AbstractController
-  # = 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:
+  # # Abstract Controller Callbacks
   #
-  # * <tt>after_action</tt>
-  # * <tt>append_after_action</tt>
-  # * <tt>append_around_action</tt>
-  # * <tt>append_before_action</tt>
-  # * <tt>around_action</tt>
-  # * <tt>before_action</tt>
-  # * <tt>prepend_after_action</tt>
-  # * <tt>prepend_around_action</tt>
-  # * <tt>prepend_before_action</tt>
-  # * <tt>skip_after_action</tt>
-  # * <tt>skip_around_action</tt>
-  # * <tt>skip_before_action</tt>
-  #
-  # NOTE: Calling the same callback multiple times will overwrite previous callback definitions.
+  # Abstract Controller provides hooks during the life cycle of a controller
+  # action. Callbacks allow you to trigger logic during this cycle. Available
+  # callbacks are:
   #
+  # *   `after_action`
+  # *   `append_after_action`
+  # *   `append_around_action`
+  # *   `append_before_action`
+  # *   `around_action`
+  # *   `before_action`
+  # *   `prepend_after_action`
+  # *   `prepend_around_action`
+  # *   `prepend_before_action`
+  # *   `skip_after_action`
+  # *   `skip_around_action`
+  # *   `skip_before_action`
   module Callbacks
     extend ActiveSupport::Concern
 
-    # Uses ActiveSupport::Callbacks as the base functionality. For
-    # more details on the whole callback system, read the documentation
-    # for ActiveSupport::Callbacks.
+    # Uses ActiveSupport::Callbacks as the base functionality. For more details on
+    # the whole callback system, read the documentation for
+    # ActiveSupport::Callbacks.
     include ActiveSupport::Callbacks
 
     included do
       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
 
     class ActionFilter # :nodoc:
-      def initialize(actions)
+      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
 
@@ -50,53 +72,57 @@ module AbstractController
     end
 
     module ClassMethods
-      # If +:only+ or +:except+ are used, convert the options into the
-      # +:if+ and +:unless+ options of ActiveSupport::Callbacks.
+      # If `:only` or `:except` are used, convert the options into the `:if` and
+      # `:unless` options of ActiveSupport::Callbacks.
+      #
+      # The basic idea is that `:only => :index` gets converted to `:if => proc {|c|
+      # c.action_name == "index" }`.
       #
-      # The basic idea is that <tt>:only => :index</tt> gets converted to
-      # <tt>:if => proc {|c| c.action_name == "index" }</tt>.
+      # Note that `:only` has priority over `:if` in case they are used together.
       #
-      # Note that <tt>:only</tt> has priority over <tt>:if</tt> in case they
-      # are used together.
+      #     only: :index, if: -> { true } # the :if option will be ignored.
       #
-      #   only: :index, if: -> { true } # the :if option will be ignored.
+      # Note that `:if` has priority over `:except` in case they are used together.
       #
-      # Note that <tt>:if</tt> has priority over <tt>:except</tt> in case they
-      # are used together.
+      #     except: :index, if: -> { true } # the :except option will be ignored.
       #
-      #   except: :index, if: -> { true } # the :except option will be ignored.
+      # #### Options
+      # *   `only`   - The callback should be run only for this action.
+      # *   `except`  - The callback should be run for all actions except this action.
       #
-      # ==== Options
-      # * <tt>only</tt>   - The callback should be run only for this action.
-      # * <tt>except</tt>  - The callback should be run for all actions except this action.
       def _normalize_callback_options(options)
         _normalize_callback_option(options, :only, :if)
         _normalize_callback_option(options, :except, :unless)
       end
 
       def _normalize_callback_option(options, from, to) # :nodoc:
-        if from = options.delete(from)
-          from = ActionFilter.new(from)
-          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
 
-      # Take callback names and an optional callback proc, normalize them,
-      # then call the block with each callback. This allows us to abstract
-      # the normalization across several methods that use it.
+      # Take callback names and an optional callback proc, normalize them, then call
+      # the block with each callback. This allows us to abstract the normalization
+      # across several methods that use it.
+      #
+      # #### Parameters
+      # *   `callbacks` - An array of callbacks, with an optional options hash as the
+      #     last parameter.
+      # *   `block`    - A proc that should be added to the callbacks.
+      #
       #
-      # ==== Parameters
-      # * <tt>callbacks</tt> - An array of callbacks, with an optional
-      #   options hash as the last parameter.
-      # * <tt>block</tt>    - A proc that should be added to the callbacks.
+      # #### Block Parameters
+      # *   `name`     - The callback to be added.
+      # *   `options`  - A hash of options to be used when adding the callback.
       #
-      # ==== Block Parameters
-      # * <tt>name</tt>     - The callback to be added.
-      # * <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
@@ -109,20 +135,21 @@ module AbstractController
       #
       # Append a callback before actions. See _insert_callbacks for parameter details.
       #
-      # If the callback renders or redirects, the action will not run. If there
-      # are additional callbacks scheduled to run after that callback, they are
-      # also cancelled.
+      # If the callback renders or redirects, the action will not run. If there are
+      # additional callbacks scheduled to run after that callback, they are also
+      # cancelled.
 
       ##
       # :method: prepend_before_action
       #
       # :call-seq: prepend_before_action(names, block)
       #
-      # Prepend a callback before actions. See _insert_callbacks for parameter details.
+      # Prepend a callback before actions. See _insert_callbacks for parameter
+      # details.
       #
-      # If the callback renders or redirects, the action will not run. If there
-      # are additional callbacks scheduled to run after that callback, they are
-      # also cancelled.
+      # If the callback renders or redirects, the action will not run. If there are
+      # additional callbacks scheduled to run after that callback, they are also
+      # cancelled.
 
       ##
       # :method: skip_before_action
@@ -138,9 +165,9 @@ module AbstractController
       #
       # Append a callback before actions. See _insert_callbacks for parameter details.
       #
-      # If the callback renders or redirects, the action will not run. If there
-      # are additional callbacks scheduled to run after that callback, they are
-      # also cancelled.
+      # If the callback renders or redirects, the action will not run. If there are
+      # additional callbacks scheduled to run after that callback, they are also
+      # cancelled.
 
       ##
       # :method: after_action
@@ -182,7 +209,8 @@ module AbstractController
       #
       # :call-seq: prepend_around_action(names, block)
       #
-      # Prepend a callback around actions. See _insert_callbacks for parameter details.
+      # Prepend a callback around actions. See _insert_callbacks for parameter
+      # details.
 
       ##
       # :method: skip_around_action
@@ -197,9 +225,8 @@ module AbstractController
       # :call-seq: append_around_action(names, block)
       #
       # Append a callback around actions. See _insert_callbacks for parameter details.
-
-      # set up before_action, prepend_before_action, skip_before_action, etc.
-      # for each of before, after, and around.
+      # set up before_action, prepend_before_action, skip_before_action, etc. for each
+      # of before, after, and around.
       [:before, :after, :around].each do |callback|
         define_method "#{callback}_action" do |*names, &blk|
           _insert_callbacks(names, blk) do |name, options|
@@ -213,8 +240,8 @@ module AbstractController
           end
         end
 
-        # Skip a before, after or around callback. See _insert_callbacks
-        # for details on the allowed parameters.
+        # Skip a before, after or around callback. See _insert_callbacks for details on
+        # the allowed parameters.
         define_method "skip_#{callback}_action" do |*names|
           _insert_callbacks(names) do |name, options|
             skip_callback(:process_action, callback, name, options)
@@ -227,8 +254,8 @@ module AbstractController
     end
 
     private
-      # Override <tt>AbstractController::Base#process_action</tt> to run the
-      # <tt>process_action</tt> callbacks around the normal behavior.
+      # Override `AbstractController::Base#process_action` to run the `process_action`
+      # callbacks around the normal behavior.
       def process_action(...)
         run_callbacks(:process_action) do
           super

data/lib/abstract_controller/collector.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 require "action_dispatch/http/mime_type"
 
 module AbstractController
@@ -7,10 +9,9 @@ module AbstractController
     def self.generate_method_for_mime(mime)
       sym = mime.is_a?(Symbol) ? mime : mime.to_sym
       class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def #{sym}(*args, &block)
-          custom(Mime[:#{sym}], *args, &block)
+        def #{sym}(...)
+          custom(Mime[:#{sym}], ...)
         end
-        ruby2_keywords(:#{sym})
       RUBY
     end
 
@@ -23,7 +24,7 @@ module AbstractController
     end
 
   private
-    def method_missing(symbol, *args, &block)
+    def method_missing(symbol, ...)
       unless mime_constant = Mime[symbol]
         raise NoMethodError, "To respond to a custom format, register it as a MIME type first: " \
           "https://guides.rubyonrails.org/action_controller_overview.html#restful-downloads. " \
@@ -34,11 +35,10 @@ module AbstractController
 
       if Mime::SET.include?(mime_constant)
         AbstractController::Collector.generate_method_for_mime(mime_constant)
-        public_send(symbol, *args, &block)
+        public_send(symbol, ...)
       else
         super
       end
     end
-    ruby2_keywords(:method_missing)
   end
 end

data/lib/abstract_controller/deprecator.rb

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

data/lib/abstract_controller/error.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 module AbstractController
   class Error < StandardError # :nodoc:
   end

data/lib/abstract_controller/helpers.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 require "active_support/dependencies"
 require "active_support/core_ext/name_error"
 
@@ -10,8 +12,8 @@ module AbstractController
     included do
       class_attribute :_helper_methods, default: Array.new
 
-      # This is here so that it is always higher in the inheritance chain than
-      # the definition in lib/action_view/rendering.rb
+      # This is here so that it is always higher in the inheritance chain than the
+      # definition in lib/action_view/rendering.rb
       redefine_singleton_method(:_helpers) do
         if @_helpers ||= nil
           @_helpers
@@ -23,28 +25,46 @@ module AbstractController
       self._helpers = define_helpers_module(self)
     end
 
-    class MissingHelperError < LoadError
-      def initialize(error, path)
-        @error = error
-        @path  = "helpers/#{path}.rb"
-        set_backtrace error.backtrace
+    def _helpers
+      self.class._helpers
+    end
 
-        if /^#{path}(\.rb)?$/.match?(error.path)
-          super("Missing helper file helpers/%s.rb" % path)
-        else
-          raise error
+    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
-    end
 
-    def _helpers
-      self.class._helpers
+      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
-      # independently of the child class's.
+      # When a class is inherited, wrap its helper module in a new module. This
+      # ensures that the parent class's module can be changed independently of the
+      # child class's.
       def inherited(klass)
         # Inherited from parent by default
         klass._helpers = nil
@@ -55,28 +75,54 @@ 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.
+      #
+      #     ActionController::Base.modules_for_helpers(["application", "chart", "rubygems"])
+      #     # => [ApplicationHelper, ChartHelper, RubygemsHelper]
+      #
+      #--
+      # 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
+      # makes the `current_user` and `logged_in?` controller methods available
       # to the view:
-      #   class ApplicationController < ActionController::Base
-      #     helper_method :current_user, :logged_in?
+      #     class ApplicationController < ActionController::Base
+      #       helper_method :current_user, :logged_in?
       #
-      #     private
-      #       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
-      #   end
+      #         def logged_in?
+      #           current_user != nil
+      #         end
+      #     end
       #
       # In a view:
-      #  <% if logged_in? -%>Welcome, <%= current_user.name %><% end -%>
+      #     <% if logged_in? -%>Welcome, <%= current_user.name %><% end -%>
       #
-      # ==== Parameters
-      # * <tt>method[, method]</tt> - A name or names of a method on the controller
-      #   to be made available on the view.
+      # #### Parameters
+      # *   `method[, method]` - A name or names of a method on the controller to be
+      #     made available on the view.
       def helper_method(*methods)
         methods.flatten!
         self._helper_methods += methods
@@ -85,68 +131,67 @@ module AbstractController
         file, line = location.path, location.lineno
 
         methods.each do |method|
-          # def current_user(*args, &block)
-          #   controller.send(:'current_user', *args, &block)
+          # def current_user(...)
+          #   controller.send(:'current_user', ...)
           # end
           _helpers_for_modification.class_eval <<~ruby_eval.lines.map(&:strip).join(";"), file, line
-            def #{method}(*args, &block)
-              controller.send(:'#{method}', *args, &block)
+            def #{method}(...)
+              controller.send(:'#{method}', ...)
             end
-            ruby2_keywords(:'#{method}')
           ruby_eval
         end
       end
 
       # Includes the given modules in the template class.
       #
-      # Modules can be specified in different ways. All of the following calls
-      # include +FooHelper+:
+      # Modules can be specified in different ways. All of the following calls include
+      # `FooHelper`:
       #
-      #   # Module, recommended.
-      #   helper FooHelper
+      #     # Module, recommended.
+      #     helper FooHelper
       #
-      #   # String/symbol without the "helper" suffix, camel or snake case.
-      #   helper "Foo"
-      #   helper :Foo
-      #   helper "foo"
-      #   helper :foo
+      #     # String/symbol without the "helper" suffix, camel or snake case.
+      #     helper "Foo"
+      #     helper :Foo
+      #     helper "foo"
+      #     helper :foo
       #
-      # The last two assume that <tt>"foo".camelize</tt> returns "Foo".
+      # The last two assume that `"foo".camelize` 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
-      # yet loaded, it has to be autoloadable, which is normally the case.
+      # When strings or symbols are passed, the method finds the actual module 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+:
+      # Namespaces are supported. The following calls include `Foo::BarHelper`:
       #
-      #   # Module, recommended.
-      #   helper Foo::BarHelper
+      #     # Module, recommended.
+      #     helper Foo::BarHelper
       #
-      #   # String/symbol without the "helper" suffix, camel or snake case.
-      #   helper "Foo::Bar"
-      #   helper :"Foo::Bar"
-      #   helper "foo/bar"
-      #   helper :"foo/bar"
+      #     # String/symbol without the "helper" suffix, camel or snake case.
+      #     helper "Foo::Bar"
+      #     helper :"Foo::Bar"
+      #     helper "foo/bar"
+      #     helper :"foo/bar"
       #
-      # The last two assume that <tt>"foo/bar".camelize</tt> returns "Foo::Bar".
+      # The last two assume that `"foo/bar".camelize` returns "Foo::Bar".
       #
-      # The method accepts a block too. If present, the block is evaluated in
-      # the context of the controller helper module. This simple call makes the
-      # +wadus+ method available in templates of the enclosing controller:
+      # The method accepts a block too. If present, the block is evaluated in the
+      # context of the controller helper module. This simple call makes the `wadus`
+      # method available in templates of the enclosing controller:
       #
-      #   helper do
-      #     def wadus
-      #       "wadus"
+      #     helper do
+      #       def wadus
+      #         "wadus"
+      #       end
       #     end
-      #   end
       #
       # Furthermore, all the above styles can be mixed together:
       #
-      #   helper FooHelper, "woo", "bar/baz" do
-      #     def wadus
-      #       "wadus"
+      #     helper FooHelper, "woo", "bar/baz" do
+      #       def wadus
+      #         "wadus"
+      #       end
       #     end
-      #   end
       #
       def helper(*args, &block)
         modules_for_helpers(args).each do |mod|
@@ -157,8 +202,8 @@ module AbstractController
         _helpers_for_modification.module_eval(&block) if block_given?
       end
 
-      # Clears up all existing helpers in this class, only keeping the helper
-      # with the same name as this class.
+      # Clears up all existing helpers in this class, only keeping the helper with the
+      # same name as this class.
       def clear_helpers
         inherited_helper_methods = _helper_methods
         self._helpers = Module.new
@@ -168,23 +213,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)
@@ -194,8 +222,8 @@ module AbstractController
 
       private
         def define_helpers_module(klass, helpers = nil)
-          # In some tests inherited is called explicitly. In that case, just
-          # return the module from the first time it was defined
+          # In some tests inherited is called explicitly. In that case, just return the
+          # module from the first time it was defined
           return klass.const_get(:HelperMethods) if klass.const_defined?(:HelperMethods, false)
 
           mod = Module.new

data/lib/abstract_controller/logger.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 require "active_support/benchmarkable"
 
 module AbstractController

data/lib/abstract_controller/railties/routes_helpers.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 require "active_support/core_ext/module/introspection"
 
 module AbstractController
@@ -10,26 +12,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