actionpack 3.2.22.5 → 4.0.0.beta1

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
 
@@ -32,9 +32,9 @@ module AbstractController
       #       @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
+      # ==== Options
       # * <tt>*args</tt> - Module, Symbol, String, :all
       # * <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.

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,7 +281,7 @@ 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"]
@@ -279,59 +289,38 @@ module AbstractController
           <<-RUBY
             lookup_context.find_all("#{_implied_layout_name}", #{prefixes.inspect}).first || 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
+          <<-RUBY
+            super
+          RUBY
+        end
 
-          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|
+                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
+              _layout.arity == 0 ? "_layout_from_proc" : "_layout_from_proc(self)"
+          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 +331,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 +379,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