actionpack 4.2.10 → 7.2.0.rc1

data/lib/abstract_controller/helpers.rb

@@ -1,119 +1,209 @@
-require 'active_support/dependencies'
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/dependencies"
+require "active_support/core_ext/name_error"
 
 module AbstractController
   module Helpers
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :_helpers
-      self._helpers = Module.new
+      class_attribute :_helper_methods, default: Array.new
 
-      class_attribute :_helper_methods
-      self._helper_methods = Array.new
+      # 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
+        else
+          superclass._helpers
+        end
+      end
+
+      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 error.path =~ /^#{path}(\.rb)?$/
-          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
+
+      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)
-        helpers = _helpers
-        klass._helpers = Module.new { include helpers }
+        # Inherited from parent by default
+        klass._helpers = nil
+
         klass.class_eval { default_helper_module! } unless klass.anonymous?
         super
       end
 
-      # Declare a controller method as a helper. For example, the following
-      # makes the +current_user+ controller method available to the view:
-      #   class ApplicationController < ActionController::Base
-      #     helper_method :current_user, :logged_in?
+      attr_writer :_helpers
+
+      include Resolution
+
+      ##
+      # :method: modules_for_helpers
+      # :call-seq: modules_for_helpers(modules_or_helper_prefixes)
       #
-      #     def current_user
-      #       @current_user ||= User.find_by(id: session[:user])
-      #     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.
+      #
+      #     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.
       #
-      #     def logged_in?
-      #       current_user != nil
+      #     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?
+      #
+      #       private
+      #         def current_user
+      #           @current_user ||= User.find_by(id: session[:user])
+      #         end
+      #
+      #         def logged_in?
+      #           current_user != nil
+      #         end
       #     end
-      #   end
       #
       # In a view:
-      #  <% 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.
-      def helper_method(*meths)
-        meths.flatten!
-        self._helper_methods += meths
-
-        meths.each do |meth|
-          _helpers.class_eval <<-ruby_eval, __FILE__, __LINE__ + 1
-            def #{meth}(*args, &blk)                               # def current_user(*args, &blk)
-              controller.send(%(#{meth}), *args, &blk)             #   controller.send(:current_user, *args, &blk)
-            end                                                    # end
+      #     <% if logged_in? -%>Welcome, <%= current_user.name %><% end -%>
+      #
+      # #### 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
+
+        location = caller_locations(1, 1).first
+        file, line = location.path, location.lineno
+
+        methods.each do |method|
+          # def current_user(...)
+          #   controller.send(:'current_user', ...)
+          # end
+          _helpers_for_modification.class_eval <<~ruby_eval.lines.map(&:strip).join(";"), file, line
+            def #{method}(...)
+              controller.send(:'#{method}', ...)
+            end
           ruby_eval
         end
       end
 
-      # The +helper+ class method can take a series of helper module names, a block, or both.
+      # Includes the given modules in the template class.
+      #
+      # Modules can be specified in different ways. All of the following calls include
+      # `FooHelper`:
+      #
+      #     # Module, recommended.
+      #     helper FooHelper
+      #
+      #     # String/symbol without the "helper" suffix, camel or snake case.
+      #     helper "Foo"
+      #     helper :Foo
+      #     helper "foo"
+      #     helper :foo
       #
-      # ==== Options
-      # * <tt>*args</tt> - Module, Symbol, String
-      # * <tt>block</tt> - A block defining helper methods
+      # The last two assume that `"foo".camelize` returns "Foo".
       #
-      # When the argument is a module it will be included directly in the template class.
-      #   helper FooHelper # => includes FooHelper
+      # 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 the argument is a string or symbol, the method will provide the "_helper" suffix, require the file
-      # and include the module in the template class. The second form illustrates how to include custom helpers
-      # when working with namespaced controllers, or other cases where the file containing the helper definition is not
-      # in one of Rails' standard load paths:
-      #   helper :foo             # => requires 'foo_helper' and includes FooHelper
-      #   helper 'resources/foo'  # => requires 'resources/foo_helper' and includes Resources::FooHelper
+      # Namespaces are supported. The following calls include `Foo::BarHelper`:
       #
-      # Additionally, the +helper+ class method can receive and evaluate a block, making the methods defined available
-      # to the template.
+      #     # Module, recommended.
+      #     helper Foo::BarHelper
       #
-      #   # One line
-      #   helper { def hello() "Hello, world!" end }
+      #     # String/symbol without the "helper" suffix, camel or snake case.
+      #     helper "Foo::Bar"
+      #     helper :"Foo::Bar"
+      #     helper "foo/bar"
+      #     helper :"foo/bar"
       #
-      #   # Multi-line
-      #   helper do
-      #     def foo(bar)
-      #       "#{bar} is the very best"
+      # 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:
+      #
+      #     helper do
+      #       def wadus
+      #         "wadus"
+      #       end
       #     end
-      #   end
       #
-      # Finally, all the above styles can be mixed together, and the +helper+ method can be invoked with a mix of
-      # +symbols+, +strings+, +modules+ and blocks.
+      # Furthermore, all the above styles can be mixed together:
       #
-      #   helper(:three, BlindHelper) { def mice() 'mice' end }
+      #     helper FooHelper, "woo", "bar/baz" do
+      #       def wadus
+      #         "wadus"
+      #       end
+      #     end
       #
       def helper(*args, &block)
         modules_for_helpers(args).each do |mod|
-          add_template_helper(mod)
+          next if _helpers.include?(mod)
+          _helpers_for_modification.include(mod)
         end
 
-        _helpers.module_eval(&block) if block_given?
+        _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
@@ -123,72 +213,31 @@ module AbstractController
         default_helper_module! unless anonymous?
       end
 
-      # Returns a list of modules, normalized from the acceptable kinds of
-      # helpers with the following behavior:
-      #
-      # String or Symbol:: :FooBar or "FooBar" becomes "foo_bar_helper",
-      # and "foo_bar_helper.rb" is loaded using require_dependency.
-      #
-      # Module:: No further processing
-      #
-      # After loading the appropriate files, the corresponding modules
-      # are returned.
-      #
-      # ==== Parameters
-      # * <tt>args</tt> - An array of helpers
-      #
-      # ==== Returns
-      # * <tt>Array</tt> - A normalized list of modules for the list of
-      #   helpers provided.
-      def modules_for_helpers(args)
-        args.flatten.map! do |arg|
-          case arg
-          when String, Symbol
-            file_name = "#{arg.to_s.underscore}_helper"
-            begin
-              require_dependency(file_name)
-            rescue LoadError => e
-              raise AbstractController::Helpers::MissingHelperError.new(e, file_name)
-            end
-
-            mod_name = file_name.camelize
-            begin
-              mod_name.constantize
-            rescue LoadError
-              # dependencies.rb gives a similar error message but its wording is
-              # not as clear because it mentions autoloading. To the user all it
-              # matters is that a helper module couldn't be loaded, autoloading
-              # is an internal mechanism that should not leak.
-              raise NameError, "Couldn't find #{mod_name}, expected it to be defined in helpers/#{file_name}.rb"
-            end
-          when Module
-            arg
-          else
-            raise ArgumentError, "helper must be a String, Symbol, or Module"
-          end
+      def _helpers_for_modification
+        unless @_helpers
+          self._helpers = define_helpers_module(self, superclass._helpers)
         end
+        _helpers
       end
 
       private
-      # Makes all the (instance) methods in the helper module available to templates
-      # rendered through this controller.
-      #
-      # ==== Parameters
-      # * <tt>module</tt> - The module to include into the current helper module
-      #   for the class
-      def add_template_helper(mod)
-        _helpers.module_eval { include mod }
-      end
+        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
+          return klass.const_get(:HelperMethods) if klass.const_defined?(:HelperMethods, false)
+
+          mod = Module.new
+          klass.const_set(:HelperMethods, mod)
+          mod.include(helpers) if helpers
+          mod
+        end
 
-      def default_helper_module!
-        module_name = name.sub(/Controller$/, '')
-        module_path = module_name.underscore
-        helper module_path
-      rescue MissingSourceFile => e
-        raise e unless e.is_missing? "helpers/#{module_path}_helper"
-      rescue NameError => e
-        raise e unless e.missing_name? "#{module_name}Helper"
-      end
+        def default_helper_module!
+          helper_prefix = name.delete_suffix("Controller")
+          helper(helper_prefix)
+        rescue NameError => e
+          raise unless e.missing_name?("#{helper_prefix}Helper")
+        end
     end
   end
 end

data/lib/abstract_controller/logger.rb

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
 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,3 +1,9 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/core_ext/module/introspection"
+
 module AbstractController
   module Railties
     module RoutesHelpers
@@ -5,10 +11,11 @@ module AbstractController
         Module.new do
           define_method(:inherited) do |klass|
             super(klass)
-            if namespace = klass.parents.detect { |m| m.respond_to?(:railtie_routes_url_helpers) }
-              klass.send(:include, namespace.railtie_routes_url_helpers(include_path_helpers))
+
+            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.send(:include, routes.url_helpers(include_path_helpers))
+              klass.include(routes.url_helpers(include_path_helpers))
             end
           end
         end

data/lib/abstract_controller/rendering.rb

@@ -1,12 +1,15 @@
-require 'active_support/concern'
-require 'active_support/core_ext/class/attribute'
-require 'action_view'
-require 'action_view/view_paths'
-require 'set'
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "abstract_controller/error"
+require "action_view"
+require "action_view/view_paths"
+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)
@@ -17,66 +20,58 @@ module AbstractController
     extend ActiveSupport::Concern
     include ActionView::ViewPaths
 
-    # Normalize arguments, options and then delegates render_to_body and
-    # sticks the result in self.response_body.
-    # :api: public
+    # Normalizes arguments and options, and then delegates to render_to_body and
+    # sticks the result in `self.response_body`.
+    #
+    # Supported options depend on the underlying `render_to_body` implementation.
     def render(*args, &block)
       options = _normalize_render(*args, &block)
-      self.response_body = render_to_body(options)
-      _process_format(rendered_format, options) if rendered_format
-      self.response_body
+      rendered_body = render_to_body(options)
+      if options[:html]
+        _set_html_content_type
+      else
+        _set_rendered_content_type rendered_format
+      end
+      _set_vary_header
+      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 Action Controller extends it to be anything that
-    # responds to the method each), this method needs to be
-    # overridden in order to still return a string.
-    # :api: plugin
+    # 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)
     end
 
     # Performs the actual template rendering.
-    # :api: public
     def render_to_body(options = {})
     end
 
-    # Returns Content-Type of rendered content
-    # :api: public
+    # Returns `Content-Type` of rendered content.
     def rendered_format
-      Mime::TEXT
+      Mime[:text]
     end
 
-    DEFAULT_PROTECTED_INSTANCE_VARIABLES = Set.new %w(
-      @_action_name @_response_body @_formats @_prefixes @_config
-      @_view_context_class @_view_renderer @_lookup_context
-      @_routes @_db_runtime
-    ).map(&:to_sym)
+    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.
-    # :api: public
+    # This method should return a hash with assigns. You can overwrite this
+    # configuration per controller.
     def view_assigns
-      protected_vars = _protected_ivars
-      variables      = instance_variables
+      variables = instance_variables - _protected_ivars
 
-      variables.reject! { |s| protected_vars.include? s }
-      variables.each_with_object({}) { |name, hash|
+      variables.each_with_object({}) do |name, hash|
         hash[name.slice(1, name.length)] = instance_variable_get(name)
-      }
+      end
     end
 
-    # Normalize args by converting render "foo" to render :action => "foo" and
-    # render "foo/bar" to render :file => "foo/bar".
-    # :api: plugin
-    def _normalize_args(action=nil, options={})
+  private
+    # 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?
           action
@@ -91,35 +86,40 @@ module AbstractController
     end
 
     # Normalize options.
-    # :api: plugin
-    def _normalize_options(options)
+    def _normalize_options(options) # :doc:
       options
     end
 
     # Process extra options.
-    # :api: plugin
-    def _process_options(options)
+    def _process_options(options) # :doc:
       options
     end
 
     # Process the rendered format.
-    # :api: private
-    def _process_format(format, options = {})
+    def _process_format(format) # :nodoc:
+    end
+
+    def _process_variant(options)
+    end
+
+    def _set_html_content_type # :nodoc:
+    end
+
+    def _set_vary_header # :nodoc:
+    end
+
+    def _set_rendered_content_type(format) # :nodoc:
     end
 
     # Normalize args and options.
-    # :api: private
-    def _normalize_render(*args, &block)
+    def _normalize_render(*args, &block) # :nodoc:
       options = _normalize_args(*args, &block)
-      #TODO: remove defined? when we restore AP <=> AV dependency
-      if defined?(request) && request && request.variant.present?
-        options[:variant] = request.variant
-      end
+      _process_variant(options)
       _normalize_options(options)
       options
     end
 
-    def _protected_ivars # :nodoc:
+    def _protected_ivars
       DEFAULT_PROTECTED_INSTANCE_VARIABLES
     end
   end

data/lib/abstract_controller/translation.rb

@@ -1,27 +1,41 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/html_safe_translation"
+
 module AbstractController
   module Translation
-    # Delegates to <tt>I18n.translate</tt>. Also aliased as <tt>t</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.
-    def translate(*args)
-      key = args.first
-      if key.is_a?(String) && (key[0] == '.')
-        key = "#{ controller_path.tr('/', '.') }.#{ action_name }#{ key }"
-        args[0] = key
+    # 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("/", ".")
+        defaults = [:"#{path}#{key}"]
+        defaults << options[:default] if options[:default]
+        options[:default] = defaults.flatten
+        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
 
-      I18n.translate(*args)
+      ActiveSupport::HtmlSafeTranslation.translate(key, **options)
     end
     alias :t :translate
 
-    # Delegates to <tt>I18n.localize</tt>. Also aliased as <tt>l</tt>.
-    def localize(*args)
-      I18n.localize(*args)
+    # Delegates to `I18n.localize`.
+    def localize(object, **options)
+      I18n.localize(object, **options)
     end
     alias :l :localize
   end