omg-actionpack 8.0.0.alpha1

data/lib/action_controller/metal/testing.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionController
+  module Testing
+    # Behavior specific to functional tests
+    module Functional # :nodoc:
+      def clear_instance_variables_between_requests
+        if defined?(@_ivars)
+          new_ivars = instance_variables - @_ivars
+          new_ivars.each { |ivar| remove_instance_variable(ivar) }
+        end
+
+        @_ivars = instance_variables
+      end
+
+      def recycle!
+        @_url_options = nil
+        self.formats = nil
+        self.params = nil
+      end
+    end
+  end
+end

data/lib/action_controller/metal/url_for.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionController
+  # # Action Controller UrlFor
+  #
+  # Includes `url_for` into the host class. The class has to provide a `RouteSet`
+  # by implementing the `_routes` method. Otherwise, an exception will be raised.
+  #
+  # In addition to AbstractController::UrlFor, this module accesses the HTTP layer
+  # to define URL options like the `host`. In order to do so, this module requires
+  # the host class to implement `env` which needs to be Rack-compatible, and
+  # `request` which returns an ActionDispatch::Request instance.
+  #
+  #     class RootUrl
+  #       include ActionController::UrlFor
+  #       include Rails.application.routes.url_helpers
+  #
+  #       delegate :env, :request, to: :controller
+  #
+  #       def initialize(controller)
+  #         @controller = controller
+  #         @url        = root_path # named route from the application.
+  #       end
+  #     end
+  module UrlFor
+    extend ActiveSupport::Concern
+
+    include AbstractController::UrlFor
+
+    def initialize(...)
+      super
+      @_url_options = nil
+    end
+
+    def url_options
+      @_url_options ||= {
+        host: request.host,
+        port: request.optional_port,
+        protocol: request.protocol,
+        _recall: request.path_parameters
+      }.merge!(super).freeze
+
+      if (same_origin = _routes.equal?(request.routes)) ||
+         (script_name = request.engine_script_name(_routes)) ||
+         (original_script_name = request.original_script_name)
+
+        options = @_url_options.dup
+        if original_script_name
+          options[:original_script_name] = original_script_name
+        else
+          if same_origin
+            options[:script_name] = request.script_name.empty? ? "" : request.script_name.dup
+          else
+            options[:script_name] = script_name
+          end
+        end
+        options.freeze
+      else
+        @_url_options
+      end
+    end
+  end
+end

data/lib/action_controller/metal.rb

@@ -0,0 +1,339 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/core_ext/array/extract_options"
+require "action_dispatch/middleware/stack"
+
+module ActionController
+  # # Action Controller MiddlewareStack
+  #
+  # Extend ActionDispatch middleware stack to make it aware of options allowing
+  # the following syntax in controllers:
+  #
+  #     class PostsController < ApplicationController
+  #       use AuthenticationMiddleware, except: [:index, :show]
+  #     end
+  #
+  class MiddlewareStack < ActionDispatch::MiddlewareStack # :nodoc:
+    class Middleware < ActionDispatch::MiddlewareStack::Middleware # :nodoc:
+      def initialize(klass, args, actions, strategy, block)
+        @actions = actions
+        @strategy = strategy
+        super(klass, args, block)
+      end
+
+      def valid?(action)
+        @strategy.call @actions, action
+      end
+    end
+
+    def build(action, app = nil, &block)
+      action = action.to_s
+
+      middlewares.reverse.inject(app || block) do |a, middleware|
+        middleware.valid?(action) ? middleware.build(a) : a
+      end
+    end
+
+    private
+      INCLUDE = ->(list, action) { list.include? action }
+      EXCLUDE = ->(list, action) { !list.include? action }
+      NULL    = ->(list, action) { true }
+
+      def build_middleware(klass, args, block)
+        options = args.extract_options!
+        only   = Array(options.delete(:only)).map(&:to_s)
+        except = Array(options.delete(:except)).map(&:to_s)
+        args << options unless options.empty?
+
+        strategy = NULL
+        list     = nil
+
+        if only.any?
+          strategy = INCLUDE
+          list     = only
+        elsif except.any?
+          strategy = EXCLUDE
+          list     = except
+        end
+
+        Middleware.new(klass, args, list, strategy, block)
+      end
+  end
+
+  # # Action Controller Metal
+  #
+  # `ActionController::Metal` is the simplest possible controller, providing a
+  # valid Rack interface without the additional niceties provided by
+  # ActionController::Base.
+  #
+  # A sample metal controller might look like this:
+  #
+  #     class HelloController < ActionController::Metal
+  #       def index
+  #         self.response_body = "Hello World!"
+  #       end
+  #     end
+  #
+  # And then to route requests to your metal controller, you would add something
+  # like this to `config/routes.rb`:
+  #
+  #     get 'hello', to: HelloController.action(:index)
+  #
+  # The ::action method returns a valid Rack application for the Rails router to
+  # dispatch to.
+  #
+  # ## Rendering Helpers
+  #
+  # By default, `ActionController::Metal` provides no utilities for rendering
+  # views, partials, or other responses aside from some low-level setters such
+  # as #response_body=, #content_type=, and #status=. To add the render helpers
+  # you're used to having in a normal controller, you can do the following:
+  #
+  #     class HelloController < ActionController::Metal
+  #       include AbstractController::Rendering
+  #       include ActionView::Layouts
+  #       append_view_path "#{Rails.root}/app/views"
+  #
+  #       def index
+  #         render "hello/index"
+  #       end
+  #     end
+  #
+  # ## Redirection Helpers
+  #
+  # To add redirection helpers to your metal controller, do the following:
+  #
+  #     class HelloController < ActionController::Metal
+  #       include ActionController::Redirecting
+  #       include Rails.application.routes.url_helpers
+  #
+  #       def index
+  #         redirect_to root_url
+  #       end
+  #     end
+  #
+  # ## Other Helpers
+  #
+  # You can refer to the modules included in ActionController::Base to see other
+  # features you can bring into your metal controller.
+  class Metal < AbstractController::Base
+    abstract!
+
+    # Returns the last part of the controller's name, underscored, without the
+    # ending `Controller`. For instance, `PostsController` returns `posts`.
+    # Namespaces are left out, so `Admin::PostsController` returns `posts` as well.
+    #
+    # #### Returns
+    # *   `string`
+    def self.controller_name
+      @controller_name ||= (name.demodulize.delete_suffix("Controller").underscore unless anonymous?)
+    end
+
+    def self.make_response!(request)
+      ActionDispatch::Response.new.tap do |res|
+        res.request = request
+      end
+    end
+
+    def self.action_encoding_template(action) # :nodoc:
+      false
+    end
+
+    class << self
+      private
+        def inherited(subclass)
+          super
+          subclass.middleware_stack = middleware_stack.dup
+          subclass.class_eval do
+            @controller_name = nil
+          end
+        end
+    end
+
+    # Delegates to the class's ::controller_name.
+    def controller_name
+      self.class.controller_name
+    end
+
+    ##
+    # :attr_reader: request
+    #
+    # The ActionDispatch::Request instance for the current request.
+    attr_internal :request
+
+    ##
+    # :attr_reader: response
+    #
+    # The ActionDispatch::Response instance for the current response.
+    attr_internal_reader :response
+
+    ##
+    # The ActionDispatch::Request::Session instance for the current request.
+    # See further details in the
+    # [Active Controller Session guide](https://guides.rubyonrails.org/action_controller_overview.html#session).
+    delegate :session, to: "@_request"
+
+    ##
+    # Delegates to ActionDispatch::Response#headers.
+    delegate :headers, to: "@_response"
+
+    ##
+    # Delegates to ActionDispatch::Response#status=
+    delegate :status=, to: "@_response"
+
+    ##
+    # Delegates to ActionDispatch::Response#location=
+    delegate :location=, to: "@_response"
+
+    ##
+    # Delegates to ActionDispatch::Response#content_type=
+    delegate :content_type=, to: "@_response"
+
+    ##
+    # Delegates to ActionDispatch::Response#status
+    delegate :status, to: "@_response"
+
+    ##
+    # Delegates to ActionDispatch::Response#location
+    delegate :location, to: "@_response"
+
+    ##
+    # Delegates to ActionDispatch::Response#content_type
+    delegate :content_type, to: "@_response"
+
+    ##
+    # Delegates to ActionDispatch::Response#media_type
+    delegate :media_type, to: "@_response"
+
+    def initialize
+      @_request = nil
+      @_response = nil
+      @_response_body = nil
+      @_routes = nil
+      @_params = nil
+      super
+    end
+
+    def params
+      @_params ||= request.parameters
+    end
+
+    def params=(val)
+      @_params = val
+    end
+
+    alias :response_code :status # :nodoc:
+
+    # Basic `url_for` that can be overridden for more robust functionality.
+    def url_for(string)
+      string
+    end
+
+    def response_body=(body)
+      if body
+        body = [body] if body.is_a?(String)
+        response.body = body
+        super
+      else
+        response.reset_body!
+      end
+    end
+
+    # Tests if render or redirect has already happened.
+    def performed?
+      response_body || response.committed?
+    end
+
+    def dispatch(name, request, response) # :nodoc:
+      set_request!(request)
+      set_response!(response)
+      process(name)
+      request.commit_flash
+      to_a
+    end
+
+    def set_response!(response) # :nodoc:
+      if @_response
+        _, _, body = @_response
+        body.close if body.respond_to?(:close)
+      end
+
+      @_response = response
+    end
+
+    # Assign the response and mark it as committed. No further processing will
+    # occur.
+    def response=(response)
+      set_response!(response)
+
+      # Force `performed?` to return true:
+      @_response_body = true
+    end
+
+    def set_request!(request) # :nodoc:
+      @_request = request
+      @_request.controller_instance = self
+    end
+
+    def to_a # :nodoc:
+      response.to_a
+    end
+
+    def reset_session
+      @_request.reset_session
+    end
+
+    class_attribute :middleware_stack, default: ActionController::MiddlewareStack.new
+
+    class << self
+      # Pushes the given Rack middleware and its arguments to the bottom of the
+      # middleware stack.
+      def use(...)
+        middleware_stack.use(...)
+      end
+    end
+
+    # The middleware stack used by this controller.
+    #
+    # By default uses a variation of ActionDispatch::MiddlewareStack which allows
+    # for the following syntax:
+    #
+    #     class PostsController < ApplicationController
+    #       use AuthenticationMiddleware, except: [:index, :show]
+    #     end
+    #
+    # Read more about [Rails middleware stack]
+    # (https://guides.rubyonrails.org/rails_on_rack.html#action-dispatcher-middleware-stack)
+    # in the guides.
+    def self.middleware
+      middleware_stack
+    end
+
+    # Returns a Rack endpoint for the given action name.
+    def self.action(name)
+      app = lambda { |env|
+        req = ActionDispatch::Request.new(env)
+        res = make_response! req
+        new.dispatch(name, req, res)
+      }
+
+      if middleware_stack.any?
+        middleware_stack.build(name, app)
+      else
+        app
+      end
+    end
+
+    # Direct dispatch to the controller. Instantiates the controller, then executes
+    # the action named `name`.
+    def self.dispatch(name, req, res)
+      if middleware_stack.any?
+        middleware_stack.build(name) { |env| new.dispatch(name, req, res) }.call req.env
+      else
+        new.dispatch(name, req, res)
+      end
+    end
+  end
+end

data/lib/action_controller/railtie.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "rails"
+require "action_controller"
+require "action_dispatch/railtie"
+require "abstract_controller/railties/routes_helpers"
+require "action_controller/railties/helpers"
+require "action_view/railtie"
+
+module ActionController
+  class Railtie < Rails::Railtie # :nodoc:
+    config.action_controller = ActiveSupport::OrderedOptions.new
+    config.action_controller.raise_on_open_redirects = false
+    config.action_controller.log_query_tags_around_actions = true
+    config.action_controller.wrap_parameters_by_default = false
+
+    config.eager_load_namespaces << AbstractController
+    config.eager_load_namespaces << ActionController
+
+    initializer "action_controller.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:action_controller] = ActionController.deprecator
+    end
+
+    initializer "action_controller.assets_config", group: :all do |app|
+      app.config.action_controller.assets_dir ||= app.config.paths["public"].first
+    end
+
+    initializer "action_controller.set_helpers_path" do |app|
+      ActionController::Helpers.helpers_path = app.helpers_paths
+    end
+
+    initializer "action_controller.parameters_config" do |app|
+      options = app.config.action_controller
+
+      ActiveSupport.on_load(:action_controller, run_once: true) do
+        ActionController::Parameters.permit_all_parameters = options.permit_all_parameters || false
+        if app.config.action_controller[:always_permitted_parameters]
+          ActionController::Parameters.always_permitted_parameters =
+            app.config.action_controller.always_permitted_parameters
+        end
+
+        action_on_unpermitted_parameters = options.action_on_unpermitted_parameters
+
+        if action_on_unpermitted_parameters.nil?
+          action_on_unpermitted_parameters = Rails.env.local? ? :log : false
+        end
+
+        ActionController::Parameters.action_on_unpermitted_parameters = action_on_unpermitted_parameters
+
+        unless options.allow_deprecated_parameters_hash_equality.nil?
+          ActionController::Parameters.allow_deprecated_parameters_hash_equality =
+            options.allow_deprecated_parameters_hash_equality
+        end
+      end
+    end
+
+    initializer "action_controller.set_configs" do |app|
+      paths   = app.config.paths
+      options = app.config.action_controller
+
+      options.logger      ||= Rails.logger
+      options.cache_store ||= Rails.cache
+
+      options.javascripts_dir ||= paths["public/javascripts"].first
+      options.stylesheets_dir ||= paths["public/stylesheets"].first
+
+      # Ensure readers methods get compiled.
+      options.asset_host        ||= app.config.asset_host
+      options.relative_url_root ||= app.config.relative_url_root
+
+      ActiveSupport.on_load(:action_controller) do
+        include app.routes.mounted_helpers
+        extend ::AbstractController::Railties::RoutesHelpers.with(app.routes)
+        extend ::ActionController::Railties::Helpers
+
+        wrap_parameters format: [:json] if options.wrap_parameters_by_default && respond_to?(:wrap_parameters)
+
+        # Configs used in other initializers
+        filtered_options = options.except(
+          :default_protect_from_forgery,
+          :log_query_tags_around_actions,
+          :permit_all_parameters,
+          :action_on_unpermitted_parameters,
+          :always_permitted_parameters,
+          :wrap_parameters_by_default,
+          :allow_deprecated_parameters_hash_equality
+        )
+
+        filtered_options.each do |k, v|
+          k = "#{k}="
+          if respond_to?(k)
+            send(k, v)
+          elsif !Base.respond_to?(k)
+            raise "Invalid option key: #{k}"
+          end
+        end
+      end
+    end
+
+    initializer "action_controller.compile_config_methods" do
+      ActiveSupport.on_load(:action_controller) do
+        config.compile_methods! if config.respond_to?(:compile_methods!)
+      end
+    end
+
+    initializer "action_controller.request_forgery_protection" do |app|
+      ActiveSupport.on_load(:action_controller_base) do
+        if app.config.action_controller.default_protect_from_forgery
+          protect_from_forgery with: :exception
+        end
+      end
+    end
+
+    initializer "action_controller.query_log_tags" do |app|
+      query_logs_tags_enabled = app.config.respond_to?(:active_record) &&
+        app.config.active_record.query_log_tags_enabled &&
+        app.config.action_controller.log_query_tags_around_actions
+
+      if query_logs_tags_enabled
+        app.config.active_record.query_log_tags |= [:controller] unless app.config.active_record.query_log_tags.include?(:namespaced_controller)
+        app.config.active_record.query_log_tags |= [:action]
+
+        ActiveSupport.on_load(:active_record) do
+          ActiveRecord::QueryLogs.taggings = ActiveRecord::QueryLogs.taggings.merge(
+            controller:            ->(context) { context[:controller]&.controller_name },
+            action:                ->(context) { context[:controller]&.action_name },
+            namespaced_controller: ->(context) {
+              if context[:controller]
+                controller_class = context[:controller].class
+                # based on ActionController::Metal#controller_name, but does not demodulize
+                unless controller_class.anonymous?
+                  controller_class.name.delete_suffix("Controller").underscore
+                end
+              end
+            }
+          )
+        end
+      end
+    end
+
+    initializer "action_controller.test_case" do |app|
+      ActiveSupport.on_load(:action_controller_test_case) do
+        ActionController::TestCase.executor_around_each_request = app.config.active_support.executor_around_test_case
+      end
+    end
+  end
+end

data/lib/action_controller/railties/helpers.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionController
+  module Railties
+    module Helpers
+      def inherited(klass)
+        super
+        return unless klass.respond_to?(:helpers_path=)
+
+        if namespace = klass.module_parents.detect { |m| m.respond_to?(:railtie_helpers_paths) }
+          paths = namespace.railtie_helpers_paths
+        else
+          paths = ActionController::Helpers.helpers_path
+        end
+
+        klass.helpers_path = paths
+
+        if klass.superclass == ActionController::Base && ActionController::Base.include_all_helpers
+          klass.helper :all
+        end
+      end
+    end
+  end
+end