actionpack 3.2.19 → 4.0.0

data/lib/abstract_controller/callbacks.rb

@@ -8,52 +8,54 @@ module AbstractController
     include ActiveSupport::Callbacks
 
     included do
-      define_callbacks :process_action, :terminator => "response_body"
+      define_callbacks :process_action, :terminator => "response_body", :skip_after_callbacks_if_terminated => true
     end
 
     # Override AbstractController::Base's process_action to run the
     # process_action callbacks around the normal behavior.
     def process_action(*args)
-      run_callbacks(:process_action, action_name) do
+      run_callbacks(:process_action) do
         super
       end
     end
 
     module ClassMethods
       # If :only or :except are used, convert the options into the
-      # primitive form (:per_key) used by ActiveSupport::Callbacks.
+      # :unless and :if options of ActiveSupport::Callbacks.
       # The basic idea is that :only => :index gets converted to
-      # :if => proc {|c| c.action_name == "index" }, but that the
-      # proc is only evaluated once per action for the lifetime of
-      # a Rails process.
+      # :if => proc {|c| c.action_name == "index" }.
       #
       # ==== 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)
-        if only = options[:only]
-          only = Array(only).map {|o| "action_name == '#{o}'"}.join(" || ")
-          options[:per_key] = {:if => only}
-        end
-        if except = options[:except]
-          except = Array(except).map {|e| "action_name == '#{e}'"}.join(" || ")
-          options[:per_key] = {:unless => except}
+        _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 {|o| "action_name == '#{o}'"}.join(" || ")
+          options[to] = Array(options[to]) << from
         end
       end
 
-      # Skip before, after, and around filters matching any of the names
+      # Skip before, after, and around action callbacks matching any of the names
+      # Aliased as skip_filter.
       #
       # ==== Parameters
       # * <tt>names</tt> - A list of valid names that could be used for
       #   callbacks. Note that skipping uses Ruby equality, so it's
       #   impossible to skip a callback defined using an anonymous proc
       #   using #skip_filter
-      def skip_filter(*names, &blk)
-        skip_before_filter(*names)
-        skip_after_filter(*names)
-        skip_around_filter(*names)
+      def skip_action_callback(*names)
+        skip_before_action(*names)
+        skip_after_action(*names)
+        skip_around_action(*names)
       end
 
+      alias_method :skip_filter, :skip_action_callback
+
       # 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.
@@ -66,7 +68,7 @@ module AbstractController
       # ==== 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)
+      def _insert_callbacks(callbacks, block = nil)
         options = callbacks.last.is_a?(Hash) ? callbacks.pop : {}
         _normalize_callback_options(options)
         callbacks.push(block) if block
@@ -76,121 +78,138 @@ module AbstractController
       end
 
       ##
-      # :method: before_filter
+      # :method: before_action
       #
-      # :call-seq: before_filter(names, block)
+      # :call-seq: before_action(names, block)
       #
-      # Append a before filter. See _insert_callbacks for parameter details.
+      # Append a callback before actions. See _insert_callbacks for parameter details.
+      # Aliased as before_filter.
 
       ##
-      # :method: prepend_before_filter
+      # :method: prepend_before_action
       #
-      # :call-seq: prepend_before_filter(names, block)
+      # :call-seq: prepend_before_action(names, block)
       #
-      # Prepend a before filter. See _insert_callbacks for parameter details.
+      # Prepend a callback before actions. See _insert_callbacks for parameter details.
+      # Aliased as prepend_before_filter.
 
       ##
-      # :method: skip_before_filter
+      # :method: skip_before_action
       #
-      # :call-seq: skip_before_filter(names, block)
+      # :call-seq: skip_before_action(names)
       #
-      # Skip a before filter. See _insert_callbacks for parameter details.
+      # Skip a callback before actions. See _insert_callbacks for parameter details.
+      # Aliased as skip_before_filter.
 
       ##
-      # :method: append_before_filter
+      # :method: append_before_action
       #
-      # :call-seq: append_before_filter(names, block)
+      # :call-seq: append_before_action(names, block)
       #
-      # Append a before filter. See _insert_callbacks for parameter details.
+      # Append a callback before actions. See _insert_callbacks for parameter details.
+      # Aliased as append_before_filter.
 
       ##
-      # :method: after_filter
+      # :method: after_action
       #
-      # :call-seq: after_filter(names, block)
+      # :call-seq: after_action(names, block)
       #
-      # Append an after filter. See _insert_callbacks for parameter details.
+      # Append a callback after actions. See _insert_callbacks for parameter details.
+      # Aliased as after_filter.
 
       ##
-      # :method: prepend_after_filter
+      # :method: prepend_after_action
       #
-      # :call-seq: prepend_after_filter(names, block)
+      # :call-seq: prepend_after_action(names, block)
       #
-      # Prepend an after filter. See _insert_callbacks for parameter details.
+      # Prepend a callback after actions. See _insert_callbacks for parameter details.
+      # Aliased as prepend_after_filter.
 
       ##
-      # :method: skip_after_filter
+      # :method: skip_after_action
       #
-      # :call-seq: skip_after_filter(names, block)
+      # :call-seq: skip_after_action(names)
       #
-      # Skip an after filter. See _insert_callbacks for parameter details.
+      # Skip a callback after actions. See _insert_callbacks for parameter details.
+      # Aliased as skip_after_filter.
 
       ##
-      # :method: append_after_filter
+      # :method: append_after_action
       #
-      # :call-seq: append_after_filter(names, block)
+      # :call-seq: append_after_action(names, block)
       #
-      # Append an after filter. See _insert_callbacks for parameter details.
+      # Append a callback after actions. See _insert_callbacks for parameter details.
+      # Aliased as append_after_filter.
 
       ##
-      # :method: around_filter
+      # :method: around_action
       #
-      # :call-seq: around_filter(names, block)
+      # :call-seq: around_action(names, block)
       #
-      # Append an around filter. See _insert_callbacks for parameter details.
+      # Append a callback around actions. See _insert_callbacks for parameter details.
+      # Aliased as around_filter.
 
       ##
-      # :method: prepend_around_filter
+      # :method: prepend_around_action
       #
-      # :call-seq: prepend_around_filter(names, block)
+      # :call-seq: prepend_around_action(names, block)
       #
-      # Prepend an around filter. See _insert_callbacks for parameter details.
+      # Prepend a callback around actions. See _insert_callbacks for parameter details.
+      # Aliased as prepend_around_filter.
 
       ##
-      # :method: skip_around_filter
+      # :method: skip_around_action
       #
-      # :call-seq: skip_around_filter(names, block)
+      # :call-seq: skip_around_action(names)
       #
-      # Skip an around filter. See _insert_callbacks for parameter details.
+      # Skip a callback around actions. See _insert_callbacks for parameter details.
+      # Aliased as skip_around_filter.
 
       ##
-      # :method: append_around_filter
+      # :method: append_around_action
       #
-      # :call-seq: append_around_filter(names, block)
+      # :call-seq: append_around_action(names, block)
       #
-      # Append an around filter. See _insert_callbacks for parameter details.
+      # Append a callback around actions. See _insert_callbacks for parameter details.
+      # Aliased as append_around_filter.
 
-      # set up before_filter, prepend_before_filter, skip_before_filter, etc.
+      # set up before_action, prepend_before_action, skip_before_action, etc.
       # for each of before, after, and around.
-      [:before, :after, :around].each do |filter|
+      [:before, :after, :around].each do |callback|
         class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-          # Append a before, after or around filter. See _insert_callbacks
+          # Append a before, after or around callback. See _insert_callbacks
           # for details on the allowed parameters.
-          def #{filter}_filter(*names, &blk)                                                 # def before_filter(*names, &blk)
-            _insert_callbacks(names, blk) do |name, options|                                 #   _insert_callbacks(names, blk) do |name, options|
-              options[:if] = (Array.wrap(options[:if]) << "!halted") if #{filter == :after}  #     options[:if] = (Array.wrap(options[:if]) << "!halted") if false
-              set_callback(:process_action, :#{filter}, name, options)                       #     set_callback(:process_action, :before, name, options)
-            end                                                                              #   end
-          end                                                                                # end
-
-          # Prepend a before, after or around filter. See _insert_callbacks
+          def #{callback}_action(*names, &blk)                                                    # def before_action(*names, &blk)
+            _insert_callbacks(names, blk) do |name, options|                                      #   _insert_callbacks(names, blk) do |name, options|
+              set_callback(:process_action, :#{callback}, name, options)                          #     set_callback(:process_action, :before, name, options)
+            end                                                                                   #   end
+          end                                                                                     # end
+
+          alias_method :#{callback}_filter, :#{callback}_action
+
+          # Prepend a before, after or around callback. See _insert_callbacks
           # for details on the allowed parameters.
-          def prepend_#{filter}_filter(*names, &blk)                                            # def prepend_before_filter(*names, &blk)
-            _insert_callbacks(names, blk) do |name, options|                                    #   _insert_callbacks(names, blk) do |name, options|
-              options[:if] = (Array.wrap(options[:if]) << "!halted") if #{filter == :after}     #     options[:if] = (Array.wrap(options[:if]) << "!halted") if false
-              set_callback(:process_action, :#{filter}, name, options.merge(:prepend => true))  #     set_callback(:process_action, :before, name, options.merge(:prepend => true))
-            end                                                                                 #   end
-          end                                                                                   # end
-
-          # Skip a before, after or around filter. See _insert_callbacks
+          def prepend_#{callback}_action(*names, &blk)                                            # def prepend_before_action(*names, &blk)
+            _insert_callbacks(names, blk) do |name, options|                                      #   _insert_callbacks(names, blk) do |name, options|
+              set_callback(:process_action, :#{callback}, name, options.merge(:prepend => true))  #     set_callback(:process_action, :before, name, options.merge(:prepend => true))
+            end                                                                                   #   end
+          end                                                                                     # end
+
+          alias_method :prepend_#{callback}_filter, :prepend_#{callback}_action
+
+          # Skip a before, after or around callback. See _insert_callbacks
           # for details on the allowed parameters.
-          def skip_#{filter}_filter(*names, &blk)                        # def skip_before_filter(*names, &blk)
-            _insert_callbacks(names, blk) do |name, options|             #   _insert_callbacks(names, blk) do |name, options|
-              skip_callback(:process_action, :#{filter}, name, options)  #     skip_callback(:process_action, :before, name, options)
-            end                                                          #   end
-          end                                                            # end
-
-          # *_filter is the same as append_*_filter
-          alias_method :append_#{filter}_filter, :#{filter}_filter  # alias_method :append_before_filter, :before_filter
+          def skip_#{callback}_action(*names)                                                     # def skip_before_action(*names)
+            _insert_callbacks(names) do |name, options|                                           #   _insert_callbacks(names) do |name, options|
+              skip_callback(:process_action, :#{callback}, name, options)                         #     skip_callback(:process_action, :before, name, options)
+            end                                                                                   #   end
+          end                                                                                     # end
+
+          alias_method :skip_#{callback}_filter, :skip_#{callback}_action
+
+          # *_action is the same as append_*_action
+          alias_method :append_#{callback}_action, :#{callback}_action  # alias_method :append_before_action, :before_action
+          alias_method :append_#{callback}_filter, :#{callback}_action  # alias_method :append_before_filter, :before_action
         RUBY_EVAL
       end
     end

data/lib/abstract_controller/collector.rb

@@ -4,7 +4,7 @@ module AbstractController
   module Collector
     def self.generate_method_for_mime(mime)
       sym = mime.is_a?(Symbol) ? mime : mime.to_sym
-      const = sym.to_s.upcase
+      const = sym.upcase
       class_eval <<-RUBY, __FILE__, __LINE__ + 1
         def #{sym}(*args, &block)                # def html(*args, &block)
           custom(Mime::#{const}, *args, &block)  #   custom(Mime::HTML, *args, &block)
@@ -16,10 +16,14 @@ module AbstractController
       generate_method_for_mime(mime)
     end
 
+    Mime::Type.register_callback do |mime|
+      generate_method_for_mime(mime) unless self.instance_methods.include?(mime.to_sym)
+    end
+
   protected
 
     def method_missing(symbol, &block)
-      mime_constant = Mime.const_get(symbol.to_s.upcase)
+      mime_constant = Mime.const_get(symbol.upcase)
 
       if Mime::SET.include?(mime_constant)
         AbstractController::Collector.generate_method_for_mime(mime_constant)
@@ -29,4 +33,4 @@ module AbstractController
       end
     end
   end
-end
+end

data/lib/abstract_controller/helpers.rb

@@ -19,7 +19,7 @@ module AbstractController
       def inherited(klass)
         helpers = _helpers
         klass._helpers = Module.new { include helpers }
-        klass.class_eval { default_helper_module! unless anonymous? }
+        klass.class_eval { default_helper_module! } unless klass.anonymous?
         super
       end
 
@@ -29,12 +29,12 @@ module AbstractController
       #     helper_method :current_user, :logged_in?
       #
       #     def current_user
-      #       @current_user ||= User.find_by_id(session[:user])
+      #       @current_user ||= User.find_by(id: session[:user])
       #     end
       #
-      #      def logged_in?
-      #        current_user != nil
-      #      end
+      #     def logged_in?
+      #       current_user != nil
+      #     end
       #   end
       #
       # In a view:
@@ -49,20 +49,19 @@ module AbstractController
 
         meths.each do |meth|
           _helpers.class_eval <<-ruby_eval, __FILE__, __LINE__ + 1
-            def #{meth}(*args, &blk)
-              controller.send(%(#{meth}), *args, &blk)
-            end
+            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.
       #
-      # ==== Parameters
-      # * <tt>*args</tt> - Module, Symbol, String, :all
+      # ==== Options
+      # * <tt>*args</tt> - Module, Symbol, String
       # * <tt>block</tt> - A block defining helper methods
       #
-      # ==== Examples
       # When the argument is a module it will be included directly in the template class.
       #   helper FooHelper # => includes FooHelper
       #
@@ -114,7 +113,7 @@ module AbstractController
       # 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.
+      # and "foo_bar_helper.rb" is loaded using require_dependency.
       #
       # Module:: No further processing
       #
@@ -132,7 +131,11 @@ module AbstractController
           case arg
           when String, Symbol
             file_name = "#{arg.to_s.underscore}_helper"
-            require_dependency(file_name, "Missing helper file helpers/%s.rb")
+            begin
+              require_dependency(file_name)
+            rescue LoadError => e
+              raise MissingHelperError.new(e, file_name)
+            end
             file_name.camelize.constantize
           when Module
             arg
@@ -142,6 +145,15 @@ module AbstractController
         end
       end
 
+      class MissingHelperError < LoadError
+        def initialize(error, path)
+          @error = error
+          @path  = "helpers/#{path}.rb"
+          set_backtrace error.backtrace
+          super("Missing helper file helpers/%s.rb" % path)
+        end
+      end
+
       private
       # Makes all the (instance) methods in the helper module available to templates
       # rendered through this controller.