actionpack 4.2.11.3 → 5.0.7.2

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2004-2014 David Heinemeier Hansson
+Copyright (c) 2004-2016 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/5-0-stable/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/base.rb

@@ -1,18 +1,16 @@
 require 'erubis'
-require 'set'
+require 'abstract_controller/error'
 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:
-  end
-
   # Raised when a non-existing controller action is triggered.
   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.
@@ -49,7 +47,7 @@ module AbstractController
       # instance methods on that abstract class. Public instance methods of
       # a controller would normally be considered action methods, so methods
       # declared on abstract classes are being removed.
-      # (ActionController::Metal and ActionController::Base are defined as abstract)
+      # (<tt>ActionController::Metal</tt> and ActionController::Base are defined as abstract)
       def internal_methods
         controller = self
 
@@ -57,21 +55,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 +70,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
-      # you run action_methods, they will be recalculated
+      # action_methods are cached and there is sometimes a need to refresh
+      # 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 +126,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 +146,15 @@ 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
+
+    # Tests if a response body is set. Used to determine if the
+    # +process_action+ callback needs to be terminated in
+    # +AbstractController::Callbacks+.
+    def performed?
+      response_body
     end
 
     # Returns true if the given controller is capable of rendering
@@ -180,9 +173,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/{action_controller → abstract_controller}/caching/fragments.rb

@@ -1,4 +1,4 @@
-module ActionController
+module AbstractController
   module Caching
     # Fragment caching is used for caching various blocks within
     # views without caching the entire action as a whole. This is
@@ -14,12 +14,57 @@ module ActionController
     #
     #   expire_fragment('name_of_cache')
     module Fragments
+      extend ActiveSupport::Concern
+
+      included do
+        if respond_to?(:class_attribute)
+          class_attribute :fragment_cache_keys
+        else
+          mattr_writer :fragment_cache_keys
+        end
+
+        self.fragment_cache_keys = []
+
+        helper_method :fragment_cache_key if respond_to?(:helper_method)
+      end
+
+      module ClassMethods
+        # Allows you to specify controller-wide key prefixes for
+        # cache fragments. Pass either a constant +value+, or a block
+        # which computes a value each time a cache key is generated.
+        #
+        # For example, you may want to prefix all fragment cache keys
+        # with a global version identifier, so you can easily
+        # invalidate all caches.
+        #
+        #   class ApplicationController
+        #     fragment_cache_key "v1"
+        #   end
+        #
+        # When it's time to invalidate all fragments, simply change
+        # the string constant. Or, progressively roll out the cache
+        # invalidation using a computed value:
+        #
+        #   class ApplicationController
+        #     fragment_cache_key do
+        #       @account.id.odd? ? "v1" : "v2"
+        #     end
+        #   end
+        def fragment_cache_key(value = nil, &key)
+          self.fragment_cache_keys += [key || ->{ value }]
+        end
+      end
+
       # Given a key (as described in +expire_fragment+), returns
       # a key suitable for use in reading, writing, or expiring a
-      # cached fragment. All keys are prefixed with <tt>views/</tt> and uses
-      # ActiveSupport::Cache.expand_cache_key for the expansion.
+      # cached fragment. All keys begin with <tt>views/</tt>,
+      # followed by any controller-wide key prefix values, ending
+      # with the specified +key+ value. The key is expanded using
+      # ActiveSupport::Cache.expand_cache_key.
       def fragment_cache_key(key)
-        ActiveSupport::Cache.expand_cache_key(key.is_a?(Hash) ? url_for(key).split("://").last : key, :views)
+        head = self.class.fragment_cache_keys.map { |k| instance_exec(&k) }
+        tail = key.is_a?(Hash) ? url_for(key).split("://").last : key
+        ActiveSupport::Cache.expand_cache_key([*head, *tail], :views)
       end
 
       # Writes +content+ to the location signified by
@@ -90,13 +135,8 @@ module ActionController
       end
 
       def instrument_fragment_cache(name, key) # :nodoc:
-        payload = {
-          controller: controller_name,
-          action: action_name,
-          key: key
-        }
-
-        ActiveSupport::Notifications.instrument("#{name}.action_controller", payload) { yield }
+        payload = instrument_payload(key)
+        ActiveSupport::Notifications.instrument("#{name}.#{instrument_name}", payload) { yield }
       end
     end
   end

data/lib/abstract_controller/caching.rb

@@ -0,0 +1,62 @@
+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?
+
+      class_attribute :_view_cache_dependencies
+      self._view_cache_dependencies = []
+      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.map { |dep| instance_exec(&dep) }.compact
+    end
+
+    protected
+      # Convenience accessor.
+      def cache(key, options = {}, &block)
+        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

@@ -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.performed? },
                        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,20 @@ 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_before_action(*names, raise: false)
+        skip_after_action(*names, raise: false)
+        skip_around_action(*names, raise: false)
       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 +85,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 +188,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 +212,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/error.rb

@@ -0,0 +1,4 @@
+module AbstractController
+  class Error < StandardError #:nodoc:
+  end
+end

data/lib/abstract_controller/helpers.rb

@@ -38,7 +38,8 @@ module AbstractController
       end
 
       # Declare a controller method as a helper. For example, the following
-      # makes the +current_user+ controller method available to the view:
+      # makes the +current_user+ and +logged_in?+ controller methods available
+      # to the view:
       #   class ApplicationController < ActionController::Base
       #     helper_method :current_user, :logged_in?
       #
@@ -181,10 +182,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

@@ -1,3 +1,4 @@
+require 'abstract_controller/error'
 require 'active_support/concern'
 require 'active_support/core_ext/class/attribute'
 require 'action_view'
@@ -17,24 +18,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 +56,12 @@ 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(
-      @_action_name @_response_body @_formats @_prefixes @_config
-      @_view_context_class @_view_renderer @_lookup_context
-      @_routes @_db_runtime
-    ).map(&:to_sym)
+    DEFAULT_PROTECTED_INSTANCE_VARIABLES = Set.new %i(
+      @_action_name @_response_body @_formats @_prefixes
+    )
 
     # This method should return a hash with assigns.
     # You can overwrite this configuration per controller.
@@ -73,8 +76,9 @@ 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?)
@@ -104,7 +108,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 +122,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.nil? && 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.flatten
+        key = "#{path}.#{action_name}#{key}"
       end
-
-      I18n.translate(*args)
+      I18n.translate(key, options)
     end
     alias :t :translate
 

data/lib/abstract_controller.rb

@@ -1,13 +1,12 @@
 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
   extend ActiveSupport::Autoload
 
   autoload :Base
+  autoload :Caching
   autoload :Callbacks
   autoload :Collector
   autoload :DoubleRenderError, "abstract_controller/rendering"
@@ -17,4 +16,9 @@ module AbstractController
   autoload :Translation
   autoload :AssetPaths
   autoload :UrlFor
+
+  def self.eager_load!
+    super
+    AbstractController::Caching.eager_load!
+  end
 end