omg-actionpack 8.0.0.alpha1

data/lib/abstract_controller/caching.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module AbstractController
+  module Caching
+    extend ActiveSupport::Concern
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :Fragments
+    end
+
+    module ConfigMethods
+      def cache_store
+        config.cache_store
+      end
+
+      def cache_store=(store)
+        config.cache_store = ActiveSupport::Cache.lookup_store(*store)
+      end
+
+      private
+        def cache_configured?
+          perform_caching && cache_store
+        end
+    end
+
+    include ConfigMethods
+    include AbstractController::Caching::Fragments
+
+    included do
+      extend ConfigMethods
+
+      config_accessor :default_static_extension
+      self.default_static_extension ||= ".html"
+
+      config_accessor :perform_caching
+      self.perform_caching = true if perform_caching.nil?
+
+      config_accessor :enable_fragment_cache_logging
+      self.enable_fragment_cache_logging = false
+
+      class_attribute :_view_cache_dependencies, default: []
+      helper_method :view_cache_dependencies if respond_to?(:helper_method)
+    end
+
+    module ClassMethods
+      def view_cache_dependency(&dependency)
+        self._view_cache_dependencies += [dependency]
+      end
+    end
+
+    def view_cache_dependencies
+      self.class._view_cache_dependencies.filter_map { |dep| instance_exec(&dep) }
+    end
+
+    private
+      # Convenience accessor.
+      def cache(key, options = {}, &block) # :doc:
+        if cache_configured?
+          cache_store.fetch(ActiveSupport::Cache.expand_cache_key(key, :controller), options, &block)
+        else
+          yield
+        end
+      end
+  end
+end

data/lib/abstract_controller/callbacks.rb

@@ -0,0 +1,265 @@
+# 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:
+  #
+  # *   `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.
+    include ActiveSupport::Callbacks
+
+    included do
+      define_callbacks :process_action,
+                       terminator: ->(controller, result_lambda) { result_lambda.call; controller.performed? },
+                       skip_after_callbacks_if_terminated: true
+      mattr_accessor :raise_on_missing_callback_actions, default: false
+    end
+
+    class ActionFilter # :nodoc:
+      def initialize(filters, conditional_key, actions)
+        @filters = filters.to_a
+        @conditional_key = conditional_key
+        @actions = Array(actions).map(&:to_s).to_set
+      end
+
+      def match?(controller)
+        if controller.raise_on_missing_callback_actions
+          missing_action = @actions.find { |action| !controller.available_action?(action) }
+          if missing_action
+            filter_names = @filters.length == 1 ? @filters.first.inspect : @filters.inspect
+
+            message = <<~MSG
+              The #{missing_action} action could not be found for the #{filter_names}
+              callback on #{controller.class.name}, but it is listed in the controller's
+              #{@conditional_key.inspect} option.
+
+              Raising for missing callback actions is a new default in Rails 7.1, if you'd
+              like to turn this off you can delete the option from the environment configurations
+              or set `config.action_controller.raise_on_missing_callback_actions` to `false`.
+            MSG
+
+            raise ActionNotFound.new(message, controller, missing_action)
+          end
+        end
+
+        @actions.include?(controller.action_name)
+      end
+
+      alias after  match?
+      alias before match?
+      alias around match?
+    end
+
+    module ClassMethods
+      # If `:only` or `:except` are used, convert the options into the `:if` and
+      # `:unless` options of ActiveSupport::Callbacks.
+      #
+      # The basic idea is that `:only => :index` gets converted to `:if => proc {|c|
+      # c.action_name == "index" }`.
+      #
+      # Note that `:only` has priority over `:if` in case they are used together.
+      #
+      #     only: :index, if: -> { true } # the :if option will be ignored.
+      #
+      # Note that `:if` has priority over `:except` in case they are used together.
+      #
+      #     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.
+      #
+      def _normalize_callback_options(options)
+        _normalize_callback_option(options, :only, :if)
+        _normalize_callback_option(options, :except, :unless)
+      end
+
+      def _normalize_callback_option(options, from, to) # :nodoc:
+        if from_value = options.delete(from)
+          filters = options[:filters]
+          from_value = ActionFilter.new(filters, from, from_value)
+          options[to] = Array(options[to]).unshift(from_value)
+        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
+      # *   `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
+        options[:filters] = callbacks
+        _normalize_callback_options(options)
+        options.delete(:filters)
+        callbacks.each do |callback|
+          yield callback, options
+        end
+      end
+
+      ##
+      # :method: before_action
+      #
+      # :call-seq: before_action(names, block)
+      #
+      # 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.
+
+      ##
+      # :method: prepend_before_action
+      #
+      # :call-seq: prepend_before_action(names, block)
+      #
+      # 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.
+
+      ##
+      # :method: skip_before_action
+      #
+      # :call-seq: skip_before_action(names)
+      #
+      # Skip a callback before actions. See _insert_callbacks for parameter details.
+
+      ##
+      # :method: append_before_action
+      #
+      # :call-seq: append_before_action(names, block)
+      #
+      # 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.
+
+      ##
+      # :method: after_action
+      #
+      # :call-seq: after_action(names, block)
+      #
+      # Append a callback after actions. See _insert_callbacks for parameter details.
+
+      ##
+      # :method: prepend_after_action
+      #
+      # :call-seq: prepend_after_action(names, block)
+      #
+      # Prepend a callback after actions. See _insert_callbacks for parameter details.
+
+      ##
+      # :method: skip_after_action
+      #
+      # :call-seq: skip_after_action(names)
+      #
+      # Skip a callback after actions. See _insert_callbacks for parameter details.
+
+      ##
+      # :method: append_after_action
+      #
+      # :call-seq: append_after_action(names, block)
+      #
+      # Append a callback after actions. See _insert_callbacks for parameter details.
+
+      ##
+      # :method: around_action
+      #
+      # :call-seq: around_action(names, block)
+      #
+      # Append a callback around actions. See _insert_callbacks for parameter details.
+
+      ##
+      # :method: prepend_around_action
+      #
+      # :call-seq: prepend_around_action(names, block)
+      #
+      # Prepend a callback around actions. See _insert_callbacks for parameter
+      # details.
+
+      ##
+      # :method: skip_around_action
+      #
+      # :call-seq: skip_around_action(names)
+      #
+      # Skip a callback around actions. See _insert_callbacks for parameter details.
+
+      ##
+      # :method: append_around_action
+      #
+      # :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.
+      [:before, :after, :around].each do |callback|
+        define_method "#{callback}_action" do |*names, &blk|
+          _insert_callbacks(names, blk) do |name, options|
+            set_callback(:process_action, callback, name, options)
+          end
+        end
+
+        define_method "prepend_#{callback}_action" do |*names, &blk|
+          _insert_callbacks(names, blk) do |name, options|
+            set_callback(:process_action, callback, name, options.merge(prepend: true))
+          end
+        end
+
+        # 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)
+          end
+        end
+
+        # *_action is the same as append_*_action
+        alias_method :"append_#{callback}_action", :"#{callback}_action"
+      end
+    end
+
+    private
+      # Override `AbstractController::Base#process_action` to run the `process_action`
+      # callbacks around the normal behavior.
+      def process_action(...)
+        run_callbacks(:process_action) do
+          super
+        end
+      end
+  end
+end

data/lib/abstract_controller/collector.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "action_dispatch/http/mime_type"
+
+module AbstractController
+  module Collector
+    def self.generate_method_for_mime(mime)
+      sym = mime.is_a?(Symbol) ? mime : mime.to_sym
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{sym}(...)
+          custom(Mime[:#{sym}], ...)
+        end
+      RUBY
+    end
+
+    Mime::SET.each do |mime|
+      generate_method_for_mime(mime)
+    end
+
+    Mime::Type.register_callback do |mime|
+      generate_method_for_mime(mime) unless instance_methods.include?(mime.to_sym)
+    end
+
+  private
+    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. " \
+          "If you meant to respond to a variant like :tablet or :phone, not a custom format, " \
+          "be sure to nest your variant response within a format response: " \
+          "format.html { |html| html.tablet { ... } }"
+      end
+
+      if Mime::SET.include?(mime_constant)
+        AbstractController::Collector.generate_method_for_mime(mime_constant)
+        public_send(symbol, ...)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/abstract_controller/deprecator.rb

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

data/lib/abstract_controller/error.rb

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

data/lib/abstract_controller/helpers.rb

@@ -0,0 +1,243 @@
+# 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 :_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
+      redefine_singleton_method(:_helpers) do
+        if @_helpers ||= nil
+          @_helpers
+        else
+          superclass._helpers
+        end
+      end
+
+      self._helpers = define_helpers_module(self)
+    end
+
+    def _helpers
+      self.class._helpers
+    end
+
+    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.
+      def inherited(klass)
+        # Inherited from parent by default
+        klass._helpers = nil
+
+        klass.class_eval { default_helper_module! } unless klass.anonymous?
+        super
+      end
+
+      attr_writer :_helpers
+
+      include Resolution
+
+      ##
+      # :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
+      # 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.
+      #
+      #     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
+      #
+      # In a view:
+      #     <% 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
+
+      # 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
+      #
+      # 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.
+      #
+      # Namespaces are supported. The following calls include `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"
+      #
+      # 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
+      #
+      # Furthermore, all the above styles can be mixed together:
+      #
+      #     helper FooHelper, "woo", "bar/baz" do
+      #       def wadus
+      #         "wadus"
+      #       end
+      #     end
+      #
+      def helper(*args, &block)
+        modules_for_helpers(args).each do |mod|
+          next if _helpers.include?(mod)
+          _helpers_for_modification.include(mod)
+        end
+
+        _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.
+      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
+
+      def _helpers_for_modification
+        unless @_helpers
+          self._helpers = define_helpers_module(self, superclass._helpers)
+        end
+        _helpers
+      end
+
+      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
+          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!
+          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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+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,25 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/core_ext/module/introspection"
+
+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