actionpack 7.1.3 → 7.2.1.1

data/lib/abstract_controller/callbacks.rb

@@ -1,32 +1,32 @@
 # 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:
-  #
-  # * <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>
+  # # Abstract Controller Callbacks
   #
-  # 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
@@ -72,25 +72,24 @@ 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 <tt>:only => :index</tt> gets converted to
-      # <tt>:if => proc {|c| c.action_name == "index" }</tt>.
+      # The basic idea is that `:only => :index` gets converted to `:if => proc {|c|
+      # c.action_name == "index" }`.
       #
-      # Note that <tt>:only</tt> has priority over <tt>:if</tt> in case they
-      # are used together.
+      # Note that `:only` has priority over `:if` 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 <tt>:if</tt> has priority over <tt>:except</tt> in case they
-      # are used together.
+      # Note that `:if` has priority over `:except` 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)
@@ -104,18 +103,20 @@ module AbstractController
         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.
-      #
-      # ==== 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
-      # * <tt>name</tt>     - The callback to be added.
-      # * <tt>options</tt>  - A hash of options to be used when adding the callback.
+      # 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.
+      #
+      #
+      # #### Block Parameters
+      # *   `name`     - The callback to be added.
+      # *   `options`  - A hash of options to be used when adding the callback.
+      #
       def _insert_callbacks(callbacks, block = nil)
         options = callbacks.extract_options!
         callbacks.push(block) if block
@@ -134,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
@@ -163,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
@@ -207,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
@@ -222,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|
@@ -238,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)
@@ -252,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

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

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,18 +1,19 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 require "active_support/dependencies"
 require "active_support/core_ext/name_error"
 
 module AbstractController
   module Helpers
-    include ActiveSupport::Deprecation::DeprecatedConstantAccessor
     extend ActiveSupport::Concern
 
     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
@@ -24,23 +25,6 @@ module AbstractController
       self._helpers = define_helpers_module(self)
     end
 
-    class DeprecatedMissingHelperError < LoadError
-      def initialize(error, path)
-        @error = error
-        @path  = "helpers/#{path}.rb"
-        set_backtrace error.backtrace
-
-        if /^#{path}(\.rb)?$/.match?(error.path)
-          super("Missing helper file helpers/%s.rb" % path)
-        else
-          raise error
-        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
@@ -78,9 +62,9 @@ module AbstractController
     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
@@ -97,46 +81,48 @@ module AbstractController
       # :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
+      # 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
+      # :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"]
+      #     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
@@ -145,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|
@@ -217,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
@@ -237,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

data/lib/abstract_controller/rendering.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 require "abstract_controller/error"
 require "action_view"
 require "action_view/view_paths"
@@ -19,9 +21,9 @@ module AbstractController
     include ActionView::ViewPaths
 
     # Normalizes arguments and options, and then delegates to render_to_body and
-    # sticks the result in <tt>self.response_body</tt>.
+    # sticks the result in `self.response_body`.
     #
-    # Supported options depend on the underlying +render_to_body+ implementation.
+    # 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)
@@ -35,11 +37,11 @@ module AbstractController
     end
 
     # Similar to #render, but only returns the rendered template as a string,
-    # instead of setting +self.response_body+.
+    # 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)
@@ -49,15 +51,15 @@ 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
 
     DEFAULT_PROTECTED_INSTANCE_VARIABLES = %i(@_action_name @_response_body @_formats @_prefixes)
 
-    # This method should return a hash with assigns.
-    # You can overwrite this configuration per controller.
+    # This method should return a hash with assigns. You can overwrite this
+    # configuration per controller.
     def view_assigns
       variables = instance_variables - _protected_ivars
 
@@ -67,9 +69,8 @@ module AbstractController
     end
 
   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>.
+    # Normalize args by converting `render "foo"` to `render action: "foo"` and
+    # `render "foo/bar"` to `render file: "foo/bar"`.
     def _normalize_args(action = nil, options = {}) # :doc:
       if action.respond_to?(:permitted?)
         if action.permitted?

data/lib/abstract_controller/translation.rb

@@ -1,17 +1,19 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 require "active_support/html_safe_translation"
 
 module AbstractController
   module Translation
-    # Delegates to <tt>I18n.translate</tt>.
+    # Delegates to `I18n.translate`.
     #
     # When the given key starts with a period, it will be scoped by the current
-    # controller and action. So if you call <tt>translate(".foo")</tt> from
-    # <tt>PeopleController#index</tt>, it will convert the call to
-    # <tt>I18n.translate("people.index.foo")</tt>. This makes it less repetitive
-    # to translate many keys within the same controller / action and gives you a
-    # simple framework for scoping them consistently.
+    # controller and action. So if you call `translate(".foo")` from
+    # `PeopleController#index`, it will convert the call to
+    # `I18n.translate("people.index.foo")`. This makes it less repetitive to
+    # translate many keys within the same controller / action and gives you a simple
+    # framework for scoping them consistently.
     def translate(key, **options)
       if key&.start_with?(".")
         path = controller_path.tr("/", ".")
@@ -21,11 +23,17 @@ module AbstractController
         key = "#{path}.#{action_name}#{key}"
       end
 
+      if options[:default] && ActiveSupport::HtmlSafeTranslation.html_safe_translation_key?(key)
+        options[:default] = Array(options[:default]).map do |value|
+          value.is_a?(String) ? ERB::Util.html_escape(value) : value
+        end
+      end
+
       ActiveSupport::HtmlSafeTranslation.translate(key, **options)
     end
     alias :t :translate
 
-    # Delegates to <tt>I18n.localize</tt>.
+    # Delegates to `I18n.localize`.
     def localize(object, **options)
       I18n.localize(object, **options)
     end