actionpack 3.2.19 → 4.0.0

data/lib/abstract_controller/layouts.rb

@@ -89,7 +89,7 @@ module AbstractController
   #   class TillController < BankController
   #     layout false
   #
-  # In these examples, we have three implicit lookup scenrios:
+  # In these examples, we have three implicit lookup scenarios:
   # * The BankController uses the "bank" layout.
   # * The ExchangeController uses the "exchange" layout.
   # * The CurrencyController inherits the layout from BankController.
@@ -120,6 +120,7 @@ module AbstractController
   #       def writers_and_readers
   #         logged_in? ? "writer_layout" : "reader_layout"
   #       end
+  #   end
   #
   # Now when a new request for the index action is processed, the layout will vary depending on whether the person accessing
   # is logged in or not.
@@ -127,7 +128,14 @@ module AbstractController
   # If you want to use an inline method, such as a proc, do something like this:
   #
   #   class WeblogController < ActionController::Base
-  #     layout proc{ |controller| controller.logged_in? ? "writer_layout" : "reader_layout" }
+  #     layout proc { |controller| controller.logged_in? ? "writer_layout" : "reader_layout" }
+  #   end
+  #
+  # If an argument isn't given to the proc, it's evaluated in the context of
+  # the current controller anyway.
+  #
+  #   class WeblogController < ActionController::Base
+  #     layout proc { logged_in? ? "writer_layout" : "reader_layout" }
   #   end
   #
   # Of course, the most common way of specifying a layout is still just as a plain template name:
@@ -136,8 +144,8 @@ module AbstractController
   #     layout "weblog_standard"
   #   end
   #
-  # If no directory is specified for the template name, the template will by default be looked for in <tt>app/views/layouts/</tt>.
-  # Otherwise, it will be looked up relative to the template root.
+  # The template will be looked always in <tt>app/views/layouts/</tt> folder. But you can point
+  # <tt>layouts</tt> folder direct also. <tt>layout "layouts/demo"</tt> is the same as <tt>layout "demo"</tt>.
   #
   # Setting the layout to nil forces it to be looked up in the filesystem and fallbacks to the parent behavior if none exists.
   # Setting it to nil is useful to re-enable template lookup overriding a previous configuration set in the parent:
@@ -162,7 +170,7 @@ module AbstractController
   # <tt>:only</tt> and <tt>:except</tt> options can be passed to the layout call. For example:
   #
   #   class WeblogController < ActionController::Base
-  #     layout "weblog_standard", :except => :rss
+  #     layout "weblog_standard", except: :rss
   #
   #     # ...
   #
@@ -172,7 +180,7 @@ module AbstractController
   # be rendered directly, without wrapping a layout around the rendered view.
   #
   # Both the <tt>:only</tt> and <tt>:except</tt> condition can accept an arbitrary number of method references, so
-  # #<tt>:except => [ :rss, :text_only ]</tt> is valid, as is <tt>:except => :rss</tt>.
+  # #<tt>except: [ :rss, :text_only ]</tt> is valid, as is <tt>except: :rss</tt>.
   #
   # == Using a different layout in the action render call
   #
@@ -184,7 +192,7 @@ module AbstractController
   #     layout "weblog_standard"
   #
   #     def help
-  #       render :action => "help", :layout => "help"
+  #       render action: "help", layout: "help"
   #     end
   #   end
   #
@@ -195,30 +203,32 @@ module AbstractController
     include Rendering
 
     included do
-      class_attribute :_layout_conditions
-      remove_possible_method :_layout_conditions
+      class_attribute :_layout, :_layout_conditions, :instance_accessor => false
+      self._layout = nil
       self._layout_conditions = {}
       _write_layout_method
     end
 
-    delegate :_layout_conditions, :to => "self.class"
+    delegate :_layout_conditions, to: :class
 
     module ClassMethods
-      def inherited(klass)
+      def inherited(klass) # :nodoc:
         super
         klass._write_layout_method
       end
 
       # This module is mixed in if layout conditions are provided. This means
       # that if no layout conditions are used, this method is not used
-      module LayoutConditions
-        # Determines whether the current action has a layout by checking the
-        # action name against the :only and :except conditions set on the
-        # layout.
+      module LayoutConditions # :nodoc:
+      private
+
+        # Determines whether the current action has a layout definition by
+        # checking the action name against the :only and :except conditions
+        # set by the <tt>layout</tt> method.
         #
         # ==== Returns
-        # * <tt> Boolean</tt> - True if the action has a layout, false otherwise.
-        def conditional_layout?
+        # * <tt> Boolean</tt> - True if the action has a layout definition, false otherwise.
+        def _conditional_layout?
           return unless super
 
           conditions = _layout_conditions
@@ -254,7 +264,7 @@ module AbstractController
         conditions.each {|k, v| conditions[k] = Array(v).map {|a| a.to_s} }
         self._layout_conditions = conditions
 
-        @_layout = layout
+        self._layout = layout
         _write_layout_method
       end
 
@@ -263,7 +273,7 @@ module AbstractController
       #
       # ==== Returns
       # * <tt>String</tt> - A template name
-      def _implied_layout_name
+      def _implied_layout_name # :nodoc:
         controller_path
       end
 
@@ -271,67 +281,51 @@ module AbstractController
       #
       # If a layout is not explicitly mentioned then look for a layout with the controller's name.
       # if nothing is found then try same procedure to find super class's layout.
-      def _write_layout_method
+      def _write_layout_method # :nodoc:
         remove_possible_method(:_layout)
 
         prefixes    = _implied_layout_name =~ /\blayouts/ ? [] : ["layouts"]
+        default_behavior = "lookup_context.find_all('#{_implied_layout_name}', #{prefixes.inspect}).first || super"
         name_clause = if name
+          default_behavior
+        else
           <<-RUBY
-            lookup_context.find_all("#{_implied_layout_name}", #{prefixes.inspect}).first || super
+            super
           RUBY
         end
 
-        if defined?(@_layout)
-          layout_definition = case @_layout
-            when String
-              @_layout.inspect
-            when Symbol
-              <<-RUBY
-                #{@_layout}.tap do |layout|
-                  unless layout.is_a?(String) || !layout
-                    raise ArgumentError, "Your layout method :#{@_layout} returned \#{layout}. It " \
-                      "should have returned a String, false, or nil"
-                  end
-                end
-              RUBY
-            when Proc
-              define_method :_layout_from_proc, &@_layout
-              "_layout_from_proc(self)"
-            when false
-              nil
-            when true
-              raise ArgumentError, "Layouts must be specified as a String, Symbol, false, or nil"
-            when nil
-              name_clause
-            end
-        else
-          # Add a deprecation if the parent layout was explicitly set and the child
-          # still does a dynamic lookup. In next Rails release, we should @_layout
-          # to be inheritable so we can skip the child lookup if the parent explicitly
-          # set the layout.
-          parent   = self.superclass.instance_eval { @_layout if defined?(@_layout) }
-          @_layout = nil
-          inspect  = parent.is_a?(Proc) ? parent.inspect : parent
-
-          layout_definition = if parent.nil?
-              name_clause
-            elsif name
-              <<-RUBY
-                if template = lookup_context.find_all("#{_implied_layout_name}", #{prefixes.inspect}).first
-                  ActiveSupport::Deprecation.warn 'Layout found at "#{_implied_layout_name}" for #{name} but parent controller ' \
-                    'set layout to #{inspect.inspect}. Please explicitly set your layout to "#{_implied_layout_name}" ' \
-                    'or set it to nil to force a dynamic lookup.'
-                  template
-                else
-                  super
+        layout_definition = case _layout
+          when String
+            _layout.inspect
+          when Symbol
+            <<-RUBY
+              #{_layout}.tap do |layout|
+                return #{default_behavior} if layout.nil?
+                unless layout.is_a?(String) || !layout
+                  raise ArgumentError, "Your layout method :#{_layout} returned \#{layout}. It " \
+                    "should have returned a String, false, or nil"
                 end
-              RUBY
-            end
+              end
+            RUBY
+          when Proc
+            define_method :_layout_from_proc, &_layout
+            protected :_layout_from_proc
+            <<-RUBY
+              result = _layout_from_proc(#{_layout.arity == 0 ? '' : 'self'})
+              return #{default_behavior} if result.nil?
+              result
+            RUBY
+          when false
+            nil
+          when true
+            raise ArgumentError, "Layouts must be specified as a String, Symbol, Proc, false, or nil"
+          when nil
+            name_clause
         end
 
         self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def _layout
-            if conditional_layout?
+            if _conditional_layout?
               #{layout_definition}
             else
               #{name_clause}
@@ -342,32 +336,38 @@ module AbstractController
       end
     end
 
-    def _normalize_options(options)
+    def _normalize_options(options) # :nodoc:
       super
 
       if _include_layout?(options)
-        layout = options.key?(:layout) ? options.delete(:layout) : :default
+        layout = options.delete(:layout) { :default }
         options[:layout] = _layout_for_option(layout)
       end
     end
 
     attr_internal_writer :action_has_layout
 
-    def initialize(*)
+    def initialize(*) # :nodoc:
       @_action_has_layout = true
       super
     end
 
+    # Controls whether an action should be rendered using a layout.
+    # If you want to disable any <tt>layout</tt> settings for the
+    # current action so that it is rendered without a layout then
+    # either override this method in your controller to return false
+    # for that action or set the <tt>action_has_layout</tt> attribute
+    # to false before rendering.
     def action_has_layout?
       @_action_has_layout
     end
 
-    def conditional_layout?
+  private
+
+    def _conditional_layout?
       true
     end
 
-  private
-
     # This will be overwritten by _write_layout_method
     def _layout; end
 
@@ -384,7 +384,7 @@ module AbstractController
       when false, nil then nil
       else
         raise ArgumentError,
-          "String, true, or false, expected for `layout'; you passed #{name.inspect}"
+          "String, Proc, :default, true, or false, expected for `layout'; you passed #{name.inspect}"
       end
     end
 

data/lib/abstract_controller/logger.rb

@@ -1,8 +1,7 @@
-require "active_support/core_ext/logger"
 require "active_support/benchmarkable"
 
 module AbstractController
-  module Logger
+  module Logger #:nodoc:
     extend ActiveSupport::Concern
 
     included do

data/lib/abstract_controller/rendering.rb

@@ -1,6 +1,5 @@
 require "abstract_controller/base"
 require "action_view"
-require "active_support/core_ext/object/instance_variables"
 
 module AbstractController
   class DoubleRenderError < Error
@@ -50,9 +49,19 @@ module AbstractController
     module ClassMethods
       def view_context_class
         @view_context_class ||= begin
-          routes  = _routes  if respond_to?(:_routes)
-          helpers = _helpers if respond_to?(:_helpers)
-          ActionView::Base.prepare(routes, helpers)
+          routes = respond_to?(:_routes) && _routes
+          helpers = respond_to?(:_helpers) && _helpers
+
+          Class.new(ActionView::Base) do
+            if routes
+              include routes.url_helpers
+              include routes.mounted_helpers
+            end
+
+            if helpers
+              include helpers
+            end
+          end
         end
       end
     end
@@ -88,15 +97,23 @@ module AbstractController
       self.response_body = render_to_body(options)
     end
 
-    # Raw rendering of a template to a string. Just convert the results of
-    # render_response into a String.
+    # 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
+    # to always return a string.
+    #
+    # If a component extends the semantics of response_body
+    # (as Action Controller 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
     def render_to_string(*args, &block)
       options = _normalize_render(*args, &block)
       render_to_body(options)
     end
 
-    # Raw rendering of a template to a Rack-compatible body.
+    # Raw rendering of a template.
     # :api: plugin
     def render_to_body(options = {})
       _process_options(options)
@@ -110,20 +127,20 @@ module AbstractController
       view_renderer.render(view_context, options)
     end
 
-    DEFAULT_PROTECTED_INSTANCE_VARIABLES = %w(
-      @_action_name @_response_body @_formats @_prefixes @_config
-      @_view_context_class @_view_renderer @_lookup_context
-    )
+    DEFAULT_PROTECTED_INSTANCE_VARIABLES = [
+      :@_action_name, :@_response_body, :@_formats, :@_prefixes, :@_config,
+      :@_view_context_class, :@_view_renderer, :@_lookup_context
+    ]
 
     # This method should return a hash with assigns.
     # You can overwrite this configuration per controller.
     # :api: public
     def view_assigns
       hash = {}
-      variables  = instance_variable_names
+      variables  = instance_variables
       variables -= protected_instance_variables
       variables -= DEFAULT_PROTECTED_INSTANCE_VARIABLES
-      variables.each { |name| hash[name.to_s[1, name.length]] = instance_variable_get(name) }
+      variables.each { |name| hash[name[1..-1]] = instance_variable_get(name) }
       hash
     end
 

data/lib/abstract_controller/translation.rb

@@ -1,13 +1,28 @@
 module AbstractController
   module Translation
+    # Delegates to <tt>I18n.translate</tt>. Also aliased as <tt>t</tt>.
+    #
+    # When the given key starts with a period, it will be scoped by the current
+    # controller and action. So if you call <tt>translate(".foo")</tt> from
+    # <tt>PeopleController#index</tt>, it will convert the call to
+    # <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
+      end
+
       I18n.translate(*args)
     end
     alias :t :translate
 
+    # Delegates to <tt>I18n.localize</tt>. Also aliased as <tt>l</tt>.
     def localize(*args)
       I18n.localize(*args)
     end
     alias :l :localize
   end
-end
+end

data/lib/abstract_controller/url_for.rb

@@ -1,10 +1,10 @@
-# Includes +url_for+ into the host class (e.g. an abstract controller or mailer). The class
-# has to provide a +RouteSet+ by implementing the <tt>_routes</tt> methods. Otherwise, an
-# exception will be raised.
-#
-# Note that this module is completely decoupled from HTTP - the only requirement is a valid 
-# <tt>_routes</tt> implementation.
 module AbstractController
+  # Includes +url_for+ into the host class (e.g. an abstract controller or mailer). The class
+  # has to provide a +RouteSet+ by implementing the <tt>_routes</tt> methods. Otherwise, an
+  # exception will be raised.
+  #
+  # Note that this module is completely decoupled from HTTP - the only requirement is a valid
+  # <tt>_routes</tt> implementation.
   module UrlFor
     extend ActiveSupport::Concern
     include ActionDispatch::Routing::UrlFor

data/lib/abstract_controller/view_paths.rb

@@ -89,7 +89,7 @@ module AbstractController
       # * <tt>paths</tt> - If a PathSet is provided, use that;
       #   otherwise, process the parameter into a PathSet.
       def view_paths=(paths)
-        self._view_paths = ActionView::PathSet.new(Array.wrap(paths))
+        self._view_paths = ActionView::PathSet.new(Array(paths))
       end
     end
   end

data/lib/abstract_controller.rb

@@ -1,13 +1,6 @@
-activesupport_path = File.expand_path('../../../activesupport/lib', __FILE__)
-$:.unshift(activesupport_path) if File.directory?(activesupport_path) && !$:.include?(activesupport_path)
-
 require 'action_pack'
-require 'active_support/concern'
-require 'active_support/ruby/shim'
-require 'active_support/dependencies/autoload'
-require 'active_support/core_ext/class/attribute'
+require 'active_support/rails'
 require 'active_support/core_ext/module/attr_internal'
-require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/module/anonymous'
 require 'active_support/i18n'
 

data/lib/action_controller/base.rb

@@ -1,4 +1,5 @@
 require "action_controller/log_subscriber"
+require "action_controller/metal/params_wrapper"
 
 module ActionController
   # Action Controllers are the core of a web request in \Rails. They are made up of one or more actions that are executed
@@ -43,7 +44,7 @@ module ActionController
   #
   #   def server_ip
   #     location = request.env["SERVER_ADDR"]
-  #     render :text => "This server hosted at #{location}"
+  #     render text: "This server hosted at #{location}"
   #   end
   #
   # == Parameters
@@ -88,15 +89,6 @@ module ActionController
   #
   # Do not put secret information in cookie-based sessions!
   #
-  # Other options for session storage:
-  #
-  # * ActiveRecord::SessionStore - Sessions are stored in your database, which works better than PStore with multiple app servers and,
-  #   unlike CookieStore, hides your session contents from the user. To use ActiveRecord::SessionStore, set
-  #
-  #     MyApplication::Application.config.session_store :active_record_store
-  #
-  #   in your <tt>config/initializers/session_store.rb</tt> and run <tt>script/rails g session_migration</tt>.
-  #
   # == Responses
   #
   # Each action results in a response, which holds the headers and document to be sent to the user's browser. The actual response
@@ -116,15 +108,15 @@ module ActionController
   #
   #   Title: <%= @post.title %>
   #
-  # You don't have to rely on the automated rendering. For example, actions that could result in the rendering of different templates 
+  # You don't have to rely on the automated rendering. For example, actions that could result in the rendering of different templates
   # will use the manual rendering methods:
   #
   #   def search
   #     @results = Search.find(params[:query])
   #     case @results.count
-  #       when 0 then render :action => "no_results"
-  #       when 1 then render :action => "show"
-  #       when 2..10 then render :action => "show_many"
+  #       when 0 then render action: "no_results"
+  #       when 1 then render action: "show"
+  #       when 2..10 then render action: "show_many"
   #     end
   #   end
   #
@@ -133,14 +125,14 @@ module ActionController
   # == Redirects
   #
   # Redirects are used to move from one action to another. For example, after a <tt>create</tt> action, which stores a blog entry to the
-  # database, we might like to show the user the new entry. Because we're following good DRY principles (Don't Repeat Yourself), we're 
+  # database, we might like to show the user the new entry. Because we're following good DRY principles (Don't Repeat Yourself), we're
   # going to reuse (and redirect to) a <tt>show</tt> action that we'll assume has already been created. The code might look like this:
   #
   #   def create
   #     @entry = Entry.new(params[:entry])
   #     if @entry.save
   #       # The entry was saved correctly, redirect to show
-  #       redirect_to :action => 'show', :id => @entry.id
+  #       redirect_to action: 'show', id: @entry.id
   #     else
   #       # things didn't go so well, do something else
   #     end
@@ -157,20 +149,48 @@ module ActionController
   # An action may contain only a single render or a single redirect. Attempting to try to do either again will result in a DoubleRenderError:
   #
   #   def do_something
-  #     redirect_to :action => "elsewhere"
-  #     render :action => "overthere" # raises DoubleRenderError
+  #     redirect_to action: "elsewhere"
+  #     render action: "overthere" # raises DoubleRenderError
   #   end
   #
   # If you need to redirect on the condition of something, then be sure to add "and return" to halt execution.
   #
   #   def do_something
-  #     redirect_to(:action => "elsewhere") and return if monkeys.nil?
-  #     render :action => "overthere" # won't be called if monkeys is nil
+  #     redirect_to(action: "elsewhere") and return if monkeys.nil?
+  #     render action: "overthere" # won't be called if monkeys is nil
   #   end
   #
   class Base < Metal
     abstract!
 
+    # We document the request and response methods here because albeit they are
+    # implemented in ActionController::Metal, the type of the returned objects
+    # is unknown at that level.
+
+    ##
+    # :method: request
+    #
+    # Returns an ActionDispatch::Request instance that represents the
+    # current request.
+
+    ##
+    # :method: response
+    #
+    # Returns an ActionDispatch::Response that represents the current
+    # response.
+
+    # Shortcut helper that returns all the modules included in
+    # ActionController::Base except the ones passed as arguments:
+    #
+    #   class MetalController
+    #     ActionController::Base.without_modules(:ParamsWrapper, :Streaming).each do |left|
+    #       include left
+    #     end
+    #   end
+    #
+    # This gives better control over what you want to exclude and makes it
+    # easier to create a bare controller class, instead of listing the modules
+    # required manually.
     def self.without_modules(*modules)
       modules = modules.map do |m|
         m.is_a?(Symbol) ? ActionController.const_get(m) : m
@@ -195,6 +215,7 @@ module ActionController
       Caching,
       MimeResponds,
       ImplicitRender,
+      StrongParameters,
 
       Cookies,
       Flash,
@@ -227,8 +248,11 @@ module ActionController
       include mod
     end
 
-    # Rails 2.x compatibility
-    include ActionController::Compatibility
+    # Define some internal variables that should not be propagated to the view.
+    self.protected_instance_variables = [
+      :@_status, :@_headers, :@_params, :@_env, :@_response, :@_request,
+      :@_view_runtime, :@_stream, :@_url_options, :@_action_has_layout
+    ]
 
     ActiveSupport.run_load_hooks(:action_controller, self)
   end