actionpack 5.2.3

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.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,31 @@
+# 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 = {})
+      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,66 @@
+# 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 :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"

data/lib/action_controller/api.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "action_view"
+require "action_controller"
+require "action_controller/log_subscriber"
+
+module ActionController
+  # API Controller is a lightweight version of <tt>ActionController::Base</tt>,
+  # created for applications that don't require all functionalities that a complete
+  # \Rails controller provides, allowing you to create controllers with just the
+  # features that you need for API only applications.
+  #
+  # An API Controller is different from a normal controller in the sense that
+  # by default it doesn't include a number of features that are usually required
+  # by browser access only: layouts and templates rendering, cookies, sessions,
+  # flash, assets, and so on. This makes the entire controller stack thinner,
+  # suitable for API applications. It doesn't mean you won't have such
+  # features if you need them: they're all available for you to include in
+  # your application, they're just not part of the default API controller stack.
+  #
+  # Normally, +ApplicationController+ is the only controller that inherits from
+  # <tt>ActionController::API</tt>. All other controllers in turn inherit from
+  # +ApplicationController+.
+  #
+  # A sample controller could look like this:
+  #
+  #   class PostsController < ApplicationController
+  #     def index
+  #       posts = Post.all
+  #       render json: posts
+  #     end
+  #   end
+  #
+  # Request, response, and parameters objects all work the exact same way as
+  # <tt>ActionController::Base</tt>.
+  #
+  # == Renders
+  #
+  # The default API Controller stack includes all renderers, which means you
+  # can use <tt>render :json</tt> and brothers freely in your controllers. Keep
+  # in mind that templates are not going to be rendered, so you need to ensure
+  # your controller is calling either <tt>render</tt> or <tt>redirect_to</tt> in
+  # all actions, otherwise it will return 204 No Content.
+  #
+  #   def show
+  #     post = Post.find(params[:id])
+  #     render json: post
+  #   end
+  #
+  # == Redirects
+  #
+  # Redirects are used to move from one action to another. You can use the
+  # <tt>redirect_to</tt> method in your controllers in the same way as in
+  # <tt>ActionController::Base</tt>. For example:
+  #
+  #   def create
+  #     redirect_to root_url and return if not_authorized?
+  #     # do stuff here
+  #   end
+  #
+  # == Adding New Behavior
+  #
+  # In some scenarios you may want to add back some functionality provided by
+  # <tt>ActionController::Base</tt> that is not present by default in
+  # <tt>ActionController::API</tt>, for instance <tt>MimeResponds</tt>. This
+  # module gives you the <tt>respond_to</tt> method. Adding it is quite simple,
+  # you just need to include the module in a specific controller or in
+  # +ApplicationController+ in case you want it available in your entire
+  # application:
+  #
+  #   class ApplicationController < ActionController::API
+  #     include ActionController::MimeResponds
+  #   end
+  #
+  #   class PostsController < ApplicationController
+  #     def index
+  #       posts = Post.all
+  #
+  #       respond_to do |format|
+  #         format.json { render json: posts }
+  #         format.xml  { render xml: posts }
+  #       end
+  #     end
+  #   end
+  #
+  # Make sure to check the modules included in <tt>ActionController::Base</tt>
+  # if you want to use any other functionality that is not provided
+  # by <tt>ActionController::API</tt> out of the box.
+  class API < Metal
+    abstract!
+
+    # Shortcut helper that returns all the ActionController::API modules except
+    # the ones passed as arguments:
+    #
+    #   class MyAPIBaseController < ActionController::Metal
+    #     ActionController::API.without_modules(:ForceSSL, :UrlFor).each do |left|
+    #       include left
+    #     end
+    #   end
+    #
+    # This gives better control over what you want to exclude and makes it easier
+    # to create an API controller class, instead of listing the modules required
+    # manually.
+    def self.without_modules(*modules)
+      modules = modules.map do |m|
+        m.is_a?(Symbol) ? ActionController.const_get(m) : m
+      end
+
+      MODULES - modules
+    end
+
+    MODULES = [
+      AbstractController::Rendering,
+
+      UrlFor,
+      Redirecting,
+      ApiRendering,
+      Renderers::All,
+      ConditionalGet,
+      BasicImplicitRender,
+      StrongParameters,
+
+      ForceSSL,
+      DataStreaming,
+
+      # Before callbacks should also be executed as early as possible, so
+      # also include them at the bottom.
+      AbstractController::Callbacks,
+
+      # Append rescue at the bottom to wrap as much as possible.
+      Rescue,
+
+      # Add instrumentations hooks at the bottom, to ensure they instrument
+      # all the methods properly.
+      Instrumentation,
+
+      # Params wrapper should come before instrumentation so they are
+      # properly showed in logs
+      ParamsWrapper
+    ]
+
+    MODULES.each do |mod|
+      include mod
+    end
+
+    ActiveSupport.run_load_hooks(:action_controller_api, self)
+    ActiveSupport.run_load_hooks(:action_controller, self)
+  end
+end