actionpack 6.0.0

data/lib/abstract_controller/error.rb

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

data/lib/abstract_controller/helpers.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require "active_support/dependencies"
+
+module AbstractController
+  module Helpers
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_helpers, default: Module.new
+      class_attribute :_helper_methods, default: Array.new
+    end
+
+    class MissingHelperError < 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
+
+    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.
+      def inherited(klass)
+        helpers = _helpers
+        klass._helpers = Module.new { include helpers }
+        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+ 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
+      #
+      #     def logged_in?
+      #       current_user != nil
+      #     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
+          ruby_eval
+        end
+      end
+
+      # The +helper+ class method can take a series of helper module names, a block, or both.
+      #
+      # ==== Options
+      # * <tt>*args</tt> - Module, Symbol, String
+      # * <tt>block</tt> - A block defining helper methods
+      #
+      # When the argument is a module it will be included directly in the template class.
+      #   helper FooHelper # => includes FooHelper
+      #
+      # 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
+      #
+      # Additionally, the +helper+ class method can receive and evaluate a block, making the methods defined available
+      # to the template.
+      #
+      #   # One line
+      #   helper { def hello() "Hello, world!" end }
+      #
+      #   # Multi-line
+      #   helper do
+      #     def foo(bar)
+      #       "#{bar} is the very best"
+      #     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.
+      #
+      #   helper(:three, BlindHelper) { def mice() 'mice' end }
+      #
+      def helper(*args, &block)
+        modules_for_helpers(args).each do |mod|
+          add_template_helper(mod)
+        end
+
+        _helpers.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.
+      def clear_helpers
+        inherited_helper_methods = _helper_methods
+        self._helpers = Module.new
+        self._helper_methods = Array.new
+
+        inherited_helper_methods.each { |meth| helper_method meth }
+        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
+        end
+      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 default_helper_module!
+          module_name = name.sub(/Controller$/, "")
+          module_path = module_name.underscore
+          helper module_path
+        rescue LoadError => e
+          raise e unless e.is_missing? "helpers/#{module_path}_helper"
+        rescue NameError => e
+          raise e unless e.missing_name? "#{module_name}Helper"
+        end
+    end
+  end
+end

data/lib/abstract_controller/logger.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "active_support/benchmarkable"
+
+module AbstractController
+  module Logger #:nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      config_accessor :logger
+      include ActiveSupport::Benchmarkable
+    end
+  end
+end

data/lib/abstract_controller/railties/routes_helpers.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module AbstractController
+  module Railties
+    module RoutesHelpers
+      def self.with(routes, include_path_helpers = true)
+        Module.new do
+          define_method(:inherited) do |klass|
+            super(klass)
+            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
+          end
+        end
+      end
+    end
+  end
+end

data/lib/abstract_controller/rendering.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+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\"."
+
+    def initialize(message = nil)
+      super(message || DEFAULT_MESSAGE)
+    end
+  end
+
+  module Rendering
+    extend ActiveSupport::Concern
+    include ActionView::ViewPaths
+
+    # Normalizes arguments, options and then delegates render_to_body and
+    # sticks the result in <tt>self.response_body</tt>.
+    def render(*args, &block)
+      options = _normalize_render(*args, &block)
+      rendered_body = render_to_body(options)
+      if options[:html]
+        _set_html_content_type
+      else
+        _set_rendered_content_type rendered_format
+      end
+      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.
+    #
+    # 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.
+    def render_to_body(options = {})
+    end
+
+    # Returns Content-Type of rendered content.
+    def rendered_format
+      Mime[:text]
+    end
+
+    DEFAULT_PROTECTED_INSTANCE_VARIABLES = Set.new %i(
+      @_action_name @_response_body @_formats @_prefixes
+    )
+
+    # 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.reject! { |s| protected_vars.include? s }
+      variables.each_with_object({}) { |name, hash|
+        hash[name.slice(1, name.length)] = instance_variable_get(name)
+      }
+    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>.
+    def _normalize_args(action = nil, options = {}) # :doc:
+      if action.respond_to?(:permitted?)
+        if action.permitted?
+          action
+        else
+          raise ArgumentError, "render parameters are not permitted"
+        end
+      elsif action.is_a?(Hash)
+        action
+      else
+        options
+      end
+    end
+
+    # Normalize options.
+    def _normalize_options(options) # :doc:
+      options
+    end
+
+    # Process extra options.
+    def _process_options(options) # :doc:
+      options
+    end
+
+    # Process the rendered format.
+    def _process_format(format) # :nodoc:
+    end
+
+    def _process_variant(options)
+    end
+
+    def _set_html_content_type # :nodoc:
+    end
+
+    def _set_rendered_content_type(format) # :nodoc:
+    end
+
+    # Normalize args and options.
+    def _normalize_render(*args, &block) # :nodoc:
+      options = _normalize_args(*args, &block)
+      _process_variant(options)
+      _normalize_options(options)
+      options
+    end
+
+    def _protected_ivars # :nodoc:
+      DEFAULT_PROTECTED_INSTANCE_VARIABLES
+    end
+  end
+end

data/lib/abstract_controller/translation.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module AbstractController
+  module Translation
+    # Delegates to <tt>I18n.translate</tt>. Also aliased as <tt>t</tt>.
+    #
+    # 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(key, options = {})
+      options = options.dup
+      if key.to_s.first == "."
+        path = controller_path.tr("/", ".")
+        defaults = [:"#{path}#{key}"]
+        defaults << options[:default] if options[:default]
+        options[:default] = defaults.flatten
+        key = "#{path}.#{action_name}#{key}"
+      end
+      I18n.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)
+    end
+    alias :l :localize
+  end
+end

data/lib/abstract_controller/url_for.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module AbstractController
+  # Includes +url_for+ into the host class (e.g. an abstract controller or mailer). The class
+  # has to provide a +RouteSet+ by implementing the <tt>_routes</tt> methods. Otherwise, an
+  # exception will be raised.
+  #
+  # Note that this module is completely decoupled from HTTP - the only requirement is a valid
+  # <tt>_routes</tt> implementation.
+  module UrlFor
+    extend ActiveSupport::Concern
+    include ActionDispatch::Routing::UrlFor
+
+    def _routes
+      raise "In order to use #url_for, you must include routing helpers explicitly. " \
+            "For instance, `include Rails.application.routes.url_helpers`."
+    end
+
+    module ClassMethods
+      def _routes
+        nil
+      end
+
+      def action_methods
+        @action_methods ||= begin
+          if _routes
+            super - _routes.named_routes.helper_names
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/action_controller.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "active_support/rails"
+require "abstract_controller"
+require "action_dispatch"
+require "action_controller/metal/live"
+require "action_controller/metal/strong_parameters"
+
+module ActionController
+  extend ActiveSupport::Autoload
+
+  autoload :API
+  autoload :Base
+  autoload :Metal
+  autoload :Middleware
+  autoload :Renderer
+  autoload :FormBuilder
+
+  eager_autoload do
+    autoload :Caching
+  end
+
+  autoload_under "metal" do
+    autoload :ConditionalGet
+    autoload :ContentSecurityPolicy
+    autoload :Cookies
+    autoload :DataStreaming
+    autoload :DefaultHeaders
+    autoload :EtagWithTemplateDigest
+    autoload :EtagWithFlash
+    autoload :Flash
+    autoload :ForceSSL
+    autoload :Head
+    autoload :Helpers
+    autoload :HttpAuthentication
+    autoload :BasicImplicitRender
+    autoload :ImplicitRender
+    autoload :Instrumentation
+    autoload :MimeResponds
+    autoload :ParamsWrapper
+    autoload :Redirecting
+    autoload :Renderers
+    autoload :Rendering
+    autoload :RequestForgeryProtection
+    autoload :Rescue
+    autoload :Streaming
+    autoload :StrongParameters
+    autoload :ParameterEncoding
+    autoload :Testing
+    autoload :UrlFor
+  end
+
+  autoload_under "api" do
+    autoload :ApiRendering
+  end
+
+  autoload :TestCase,           "action_controller/test_case"
+  autoload :TemplateAssertions, "action_controller/test_case"
+end
+
+# Common Active Support usage in Action Controller
+require "active_support/core_ext/module/attribute_accessors"
+require "active_support/core_ext/load_error"
+require "active_support/core_ext/module/attr_internal"
+require "active_support/core_ext/name_error"
+require "active_support/core_ext/uri"
+require "active_support/inflector"