actionpack 5.2.3

data/lib/abstract_controller/callbacks.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+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:
+  #
+  # * <tt>after_action</tt>
+  # * <tt>append_after_action</tt>
+  # * <tt>append_around_action</tt>
+  # * <tt>append_before_action</tt>
+  # * <tt>around_action</tt>
+  # * <tt>before_action</tt>
+  # * <tt>prepend_after_action</tt>
+  # * <tt>prepend_around_action</tt>
+  # * <tt>prepend_before_action</tt>
+  # * <tt>skip_after_action</tt>
+  # * <tt>skip_around_action</tt>
+  # * <tt>skip_before_action</tt>
+  #
+  # NOTE: Calling the same callback multiple times will overwrite previous callback definitions.
+  #
+  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
+    end
+
+    # Override <tt>AbstractController::Base#process_action</tt> to run the
+    # <tt>process_action</tt> callbacks around the normal behavior.
+    def process_action(*args)
+      run_callbacks(:process_action) do
+        super
+      end
+    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 <tt>:only => :index</tt> gets converted to
+      # <tt>:if => proc {|c| c.action_name == "index" }</tt>.
+      #
+      # Note that <tt>:only</tt> has priority over <tt>:if</tt> in case they
+      # are used together.
+      #
+      #   only: :index, if: -> { true } # the :if option will be ignored.
+      #
+      # Note that <tt>:if</tt> has priority over <tt>:except</tt> in case they
+      # are used together.
+      #
+      #   except: :index, if: -> { true } # the :except option will be ignored.
+      #
+      # ==== Options
+      # * <tt>only</tt>   - The callback should be run only for this action.
+      # * <tt>except</tt>  - 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 = options[from]
+          _from = Array(from).map(&:to_s).to_set
+          from = proc { |c| _from.include? c.action_name }
+          options[to] = Array(options[to]).unshift(from)
+        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
+      # * <tt>callbacks</tt> - An array of callbacks, with an optional
+      #   options hash as the last parameter.
+      # * <tt>block</tt>    - A proc that should be added to the callbacks.
+      #
+      # ==== Block Parameters
+      # * <tt>name</tt>     - The callback to be added.
+      # * <tt>options</tt>  - A hash of options to be used when adding the callback.
+      def _insert_callbacks(callbacks, block = nil)
+        options = callbacks.extract_options!
+        _normalize_callback_options(options)
+        callbacks.push(block) if block
+        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.
+
+      ##
+      # :method: prepend_before_action
+      #
+      # :call-seq: prepend_before_action(names, block)
+      #
+      # Prepend a callback before actions. See _insert_callbacks for parameter details.
+
+      ##
+      # :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.
+
+      ##
+      # :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
+  end
+end

data/lib/abstract_controller/collector.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+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}(*args, &block)
+          custom(Mime[:#{sym}], *args, &block)
+        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, &block)
+      unless mime_constant = Mime[symbol]
+        raise NoMethodError, "To respond to a custom format, register it as a MIME type first: " \
+          "http://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)
+        send(symbol, &block)
+      else
+        super
+      end
+    end
+  end
+end

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 error.path =~ /^#{path}(\.rb)?$/
+          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$/, "".freeze)
+          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