actionpack 4.2.11.3 → 5.0.0.beta1

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2004-2014 David Heinemeier Hansson
+Copyright (c) 2004-2015 David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -28,11 +28,11 @@ can be used outside of Rails.
 
 The latest version of Action Pack can be installed with RubyGems:
 
-  % [sudo] gem install actionpack
+  $ gem install actionpack
 
 Source code can be downloaded as part of the Rails project on GitHub
 
-* https://github.com/rails/rails/tree/4-2-stable/actionpack
+* https://github.com/rails/rails/tree/master/actionpack
 
 
 == License
@@ -55,4 +55,3 @@ Bug reports can be filed for the Ruby on Rails project here:
 Feature requests should be discussed on the rails-core mailing list here:
 
 * https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core
-

data/lib/abstract_controller.rb

@@ -1,7 +1,5 @@
 require 'action_pack'
 require 'active_support/rails'
-require 'active_support/core_ext/module/attr_internal'
-require 'active_support/core_ext/module/anonymous'
 require 'active_support/i18n'
 
 module AbstractController

data/lib/abstract_controller/base.rb

@@ -1,8 +1,8 @@
 require 'erubis'
-require 'set'
 require 'active_support/configurable'
 require 'active_support/descendants_tracker'
 require 'active_support/core_ext/module/anonymous'
+require 'active_support/core_ext/module/attr_internal'
 
 module AbstractController
   class Error < StandardError #:nodoc:
@@ -12,7 +12,7 @@ module AbstractController
   class ActionNotFound < StandardError
   end
 
-  # <tt>AbstractController::Base</tt> is a low-level API. Nobody should be
+  # AbstractController::Base is a low-level API. Nobody should be
   # using it directly, and subclasses (like ActionController::Base) are
   # expected to provide their own +render+ method, since rendering means
   # different things depending on the context.
@@ -57,21 +57,11 @@ module AbstractController
         controller.public_instance_methods(true)
       end
 
-      # The list of hidden actions. Defaults to an empty array.
-      # This can be modified by other modules or subclasses
-      # to specify particular actions as hidden.
-      #
-      # ==== Returns
-      # * <tt>Array</tt> - An array of method names that should not be considered actions.
-      def hidden_actions
-        []
-      end
-
       # A list of method names that should be considered actions. This
       # includes all public instance methods on a controller, less
-      # any internal methods (see #internal_methods), adding back in
+      # any internal methods (see internal_methods), adding back in
       # any methods that are internal, but still exist on the class
-      # itself. Finally, #hidden_actions are removed.
+      # itself.
       #
       # ==== Returns
       # * <tt>Set</tt> - A set of all methods that should be considered actions.
@@ -82,30 +72,31 @@ module AbstractController
             # Except for public instance methods of Base and its ancestors
             internal_methods +
             # Be sure to include shadowed public instance methods of this class
-            public_instance_methods(false)).uniq.map { |x| x.to_s } -
-            # And always exclude explicitly hidden actions
-            hidden_actions.to_a
+            public_instance_methods(false)).uniq.map(&:to_s)
 
-          # Clear out AS callback method pollution
-          Set.new(methods.reject { |method| method =~ /_one_time_conditions/ })
+          methods.to_set
         end
       end
 
       # action_methods are cached and there is sometimes need to refresh
-      # them. clear_action_methods! allows you to do that, so next time
+      # them. ::clear_action_methods! allows you to do that, so next time
       # you run action_methods, they will be recalculated
       def clear_action_methods!
         @action_methods = nil
       end
 
       # Returns the full controller name, underscored, without the ending Controller.
-      # For instance, MyApp::MyPostsController would return "my_app/my_posts" for
-      # controller_path.
+      #
+      #   class MyApp::MyPostsController < AbstractController::Base
+      #
+      #   end
+      #
+      #   MyApp::MyPostsController.controller_path # => "my_app/my_posts"
       #
       # ==== Returns
       # * <tt>String</tt>
       def controller_path
-        @controller_path ||= name.sub(/Controller$/, '').underscore unless anonymous?
+        @controller_path ||= name.sub(/Controller$/, ''.freeze).underscore unless anonymous?
       end
 
       # Refresh the cached action_methods when a new action_method is added.
@@ -137,12 +128,12 @@ module AbstractController
       process_action(action_name, *args)
     end
 
-    # Delegates to the class' #controller_path
+    # Delegates to the class' ::controller_path
     def controller_path
       self.class.controller_path
     end
 
-    # Delegates to the class' #action_methods
+    # Delegates to the class' ::action_methods
     def action_methods
       self.class.action_methods
     end
@@ -157,11 +148,8 @@ module AbstractController
     #
     # ==== Parameters
     # * <tt>action_name</tt> - The name of an action to be tested
-    #
-    # ==== Returns
-    # * <tt>TrueClass</tt>, <tt>FalseClass</tt>
     def available_action?(action_name)
-      _find_action_name(action_name).present?
+      _find_action_name(action_name)
     end
 
     # Returns true if the given controller is capable of rendering
@@ -180,9 +168,6 @@ module AbstractController
       # ==== Parameters
       # * <tt>name</tt> - The name of an action to be tested
       #
-      # ==== Returns
-      # * <tt>TrueClass</tt>, <tt>FalseClass</tt>
-      #
       # :api: private
       def action_method?(name)
         self.class.action_methods.include?(name)

data/lib/abstract_controller/callbacks.rb

@@ -9,7 +9,7 @@ module AbstractController
 
     included do
       define_callbacks :process_action,
-                       terminator: ->(controller,_) { controller.response_body },
+                       terminator: ->(controller, result_lambda) { result_lambda.call if result_lambda.is_a?(Proc); controller.response_body },
                        skip_after_callbacks_if_terminated: true
     end
 
@@ -22,14 +22,25 @@ module AbstractController
     end
 
     module ClassMethods
-      # If :only or :except are used, convert the options into the
-      # :unless and :if options of ActiveSupport::Callbacks.
-      # The basic idea is that :only => :index gets converted to
-      # :if => proc {|c| c.action_name == "index" }.
+      # 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
+      # * <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)
@@ -37,7 +48,8 @@ module AbstractController
 
       def _normalize_callback_option(options, from, to) # :nodoc:
         if from = options[from]
-          from = Array(from).map {|o| "action_name == '#{o}'"}.join(" || ")
+          _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
@@ -48,13 +60,18 @@ module AbstractController
       # * <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_action_callback
+      #   using #skip_action_callback.
       def skip_action_callback(*names)
-        skip_before_action(*names)
-        skip_after_action(*names)
-        skip_around_action(*names)
+        ActiveSupport::Deprecation.warn('`skip_action_callback` is deprecated and will be removed in Rails 5.1. Please use skip_before_action, skip_after_action or skip_around_action instead.')
+        skip_before_action(*names, raise: false)
+        skip_after_action(*names, raise: false)
+        skip_around_action(*names, raise: false)
+      end
+
+      def skip_filter(*names)
+        ActiveSupport::Deprecation.warn("`skip_filter` is deprecated and will be removed in Rails 5.1. Use skip_before_action, skip_after_action or skip_around_action instead.")
+        skip_action_callback(*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
@@ -66,8 +83,8 @@ module AbstractController
       # * <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
+      # * <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)
@@ -169,14 +186,22 @@ module AbstractController
             set_callback(:process_action, callback, name, options)
           end
         end
-        alias_method :"#{callback}_filter", :"#{callback}_action"
+
+        define_method "#{callback}_filter" do |*names, &blk|
+          ActiveSupport::Deprecation.warn("#{callback}_filter is deprecated and will be removed in Rails 5.1. Use #{callback}_action instead.")
+          send("#{callback}_action", *names, &blk)
+        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
-        alias_method :"prepend_#{callback}_filter", :"prepend_#{callback}_action"
+
+        define_method "prepend_#{callback}_filter" do |*names, &blk|
+          ActiveSupport::Deprecation.warn("prepend_#{callback}_filter is deprecated and will be removed in Rails 5.1. Use prepend_#{callback}_action instead.")
+          send("prepend_#{callback}_action", *names, &blk)
+        end
 
         # Skip a before, after or around callback. See _insert_callbacks
         # for details on the allowed parameters.
@@ -185,11 +210,19 @@ module AbstractController
             skip_callback(:process_action, callback, name, options)
           end
         end
-        alias_method :"skip_#{callback}_filter", :"skip_#{callback}_action"
+
+        define_method "skip_#{callback}_filter" do |*names, &blk|
+          ActiveSupport::Deprecation.warn("skip_#{callback}_filter is deprecated and will be removed in Rails 5.1. Use skip_#{callback}_action instead.")
+          send("skip_#{callback}_action", *names, &blk)
+        end
 
         # *_action is the same as append_*_action
         alias_method :"append_#{callback}_action", :"#{callback}_action"
-        alias_method :"append_#{callback}_filter", :"#{callback}_action"
+
+        define_method "append_#{callback}_filter" do |*names, &blk|
+          ActiveSupport::Deprecation.warn("append_#{callback}_filter is deprecated and will be removed in Rails 5.1. Use append_#{callback}_action instead.")
+          send("append_#{callback}_action", *names, &blk)
+        end
       end
     end
   end

data/lib/abstract_controller/collector.rb

@@ -4,11 +4,10 @@ module AbstractController
   module Collector
     def self.generate_method_for_mime(mime)
       sym = mime.is_a?(Symbol) ? mime : mime.to_sym
-      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)
-        end                                      # end
+        def #{sym}(*args, &block)
+          custom(Mime[:#{sym}], *args, &block)
+        end
       RUBY
     end
 
@@ -23,9 +22,7 @@ module AbstractController
   protected
 
     def method_missing(symbol, &block)
-      const_name = symbol.upcase
-
-      unless Mime.const_defined?(const_name)
+      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, " \
@@ -33,8 +30,6 @@ module AbstractController
           "format.html { |html| html.tablet { ... } }"
       end
 
-      mime_constant = Mime.const_get(const_name)
-
       if Mime::SET.include?(mime_constant)
         AbstractController::Collector.generate_method_for_mime(mime_constant)
         send(symbol, &block)

data/lib/abstract_controller/helpers.rb

@@ -181,10 +181,10 @@ module AbstractController
       end
 
       def default_helper_module!
-        module_name = name.sub(/Controller$/, '')
+        module_name = name.sub(/Controller$/, ''.freeze)
         module_path = module_name.underscore
         helper module_path
-      rescue MissingSourceFile => e
+      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"

data/lib/abstract_controller/railties/routes_helpers.rb

@@ -6,9 +6,9 @@ module AbstractController
           define_method(:inherited) do |klass|
             super(klass)
             if namespace = klass.parents.detect { |m| m.respond_to?(:railtie_routes_url_helpers) }
-              klass.send(:include, namespace.railtie_routes_url_helpers(include_path_helpers))
+              klass.include(namespace.railtie_routes_url_helpers(include_path_helpers))
             else
-              klass.send(:include, routes.url_helpers(include_path_helpers))
+              klass.include(routes.url_helpers(include_path_helpers))
             end
           end
         end

data/lib/abstract_controller/rendering.rb

@@ -17,24 +17,28 @@ module AbstractController
     extend ActiveSupport::Concern
     include ActionView::ViewPaths
 
-    # Normalize arguments, options and then delegates render_to_body and
-    # sticks the result in self.response_body.
+    # Normalizes arguments, options and then delegates render_to_body and
+    # sticks the result in <tt>self.response_body</tt>.
     # :api: public
     def render(*args, &block)
       options = _normalize_render(*args, &block)
-      self.response_body = render_to_body(options)
-      _process_format(rendered_format, options) if rendered_format
-      self.response_body
+      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
+    # set the +response_body+ and it should be guaranteed
     # to always return a string.
     #
-    # If a component extends the semantics of response_body
-    # (as Action Controller extends it to be anything that
+    # 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.
     # :api: plugin
@@ -51,14 +55,14 @@ module AbstractController
     # Returns Content-Type of rendered content
     # :api: public
     def rendered_format
-      Mime::TEXT
+      Mime[:text]
     end
 
-    DEFAULT_PROTECTED_INSTANCE_VARIABLES = Set.new %w(
+    DEFAULT_PROTECTED_INSTANCE_VARIABLES = Set.new %i(
       @_action_name @_response_body @_formats @_prefixes @_config
       @_view_context_class @_view_renderer @_lookup_context
       @_routes @_db_runtime
-    ).map(&:to_sym)
+    )
 
     # This method should return a hash with assigns.
     # You can overwrite this configuration per controller.
@@ -73,17 +77,12 @@ module AbstractController
       }
     end
 
-    # Normalize args by converting render "foo" to render :action => "foo" and
-    # render "foo/bar" to render :file => "foo/bar".
+    # 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>.
     # :api: plugin
     def _normalize_args(action=nil, options={})
-      if action.respond_to?(:permitted?)
-        if action.permitted?
-          action
-        else
-          raise ArgumentError, "render parameters are not permitted"
-        end
-      elsif action.is_a?(Hash)
+      if action.is_a? Hash
         action
       else
         options
@@ -104,7 +103,13 @@ module AbstractController
 
     # Process the rendered format.
     # :api: private
-    def _process_format(format, options = {})
+    def _process_format(format)
+    end
+
+    def _set_html_content_type # :nodoc:
+    end
+
+    def _set_rendered_content_type(format) # :nodoc:
     end
 
     # Normalize args and options.
@@ -112,7 +117,7 @@ module AbstractController
     def _normalize_render(*args, &block)
       options = _normalize_args(*args, &block)
       #TODO: remove defined? when we restore AP <=> AV dependency
-      if defined?(request) && request && request.variant.present?
+      if defined?(request) && request.variant.present?
         options[:variant] = request.variant
       end
       _normalize_options(options)

data/lib/abstract_controller/translation.rb

@@ -8,14 +8,15 @@ module AbstractController
     # <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(*args)
-      key = args.first
-      if key.is_a?(String) && (key[0] == '.')
-        key = "#{ controller_path.tr('/', '.') }.#{ action_name }#{ key }"
-        args[0] = key
+    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
+        key = "#{path}.#{action_name}#{key}"
       end
-
-      I18n.translate(*args)
+      I18n.translate(key, options)
     end
     alias :t :translate