backbone-queryparams-rails 0.0.1 → 0.0.2

data/vendor/bundle/gems/actionpack-3.2.11/lib/abstract_controller/callbacks.rb

@@ -1,198 +0,0 @@
-module AbstractController
-  module Callbacks
-    extend ActiveSupport::Concern
-
-    # Uses ActiveSupport::Callbacks as the base functionality. For
-    # more details on the whole callback system, read the documentation
-    # for ActiveSupport::Callbacks.
-    include ActiveSupport::Callbacks
-
-    included do
-      define_callbacks :process_action, :terminator => "response_body"
-    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
-        super
-      end
-    end
-
-    module ClassMethods
-      # If :only or :except are used, convert the options into the
-      # primitive form (:per_key) used by 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.
-      #
-      # ==== 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}
-        end
-      end
-
-      # Skip before, after, and around filters matching any of the names
-      #
-      # ==== 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)
-      end
-
-      # 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.
-      #
-      # ==== Parameters
-      # * <tt>callbacks</tt> - An array of callbacks, with an optional
-      #   options hash as the last parameter.
-      # * <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
-      def _insert_callbacks(callbacks, block)
-        options = callbacks.last.is_a?(Hash) ? callbacks.pop : {}
-        _normalize_callback_options(options)
-        callbacks.push(block) if block
-        callbacks.each do |callback|
-          yield callback, options
-        end
-      end
-
-      ##
-      # :method: before_filter
-      #
-      # :call-seq: before_filter(names, block)
-      #
-      # Append a before filter. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: prepend_before_filter
-      #
-      # :call-seq: prepend_before_filter(names, block)
-      #
-      # Prepend a before filter. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: skip_before_filter
-      #
-      # :call-seq: skip_before_filter(names, block)
-      #
-      # Skip a before filter. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: append_before_filter
-      #
-      # :call-seq: append_before_filter(names, block)
-      #
-      # Append a before filter. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: after_filter
-      #
-      # :call-seq: after_filter(names, block)
-      #
-      # Append an after filter. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: prepend_after_filter
-      #
-      # :call-seq: prepend_after_filter(names, block)
-      #
-      # Prepend an after filter. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: skip_after_filter
-      #
-      # :call-seq: skip_after_filter(names, block)
-      #
-      # Skip an after filter. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: append_after_filter
-      #
-      # :call-seq: append_after_filter(names, block)
-      #
-      # Append an after filter. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: around_filter
-      #
-      # :call-seq: around_filter(names, block)
-      #
-      # Append an around filter. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: prepend_around_filter
-      #
-      # :call-seq: prepend_around_filter(names, block)
-      #
-      # Prepend an around filter. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: skip_around_filter
-      #
-      # :call-seq: skip_around_filter(names, block)
-      #
-      # Skip an around filter. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: append_around_filter
-      #
-      # :call-seq: append_around_filter(names, block)
-      #
-      # Append an around filter. See _insert_callbacks for parameter details.
-
-      # set up before_filter, prepend_before_filter, skip_before_filter, etc.
-      # for each of before, after, and around.
-      [:before, :after, :around].each do |filter|
-        class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-          # Append a before, after or around filter. 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
-          # 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
-          # 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
-        RUBY_EVAL
-      end
-    end
-  end
-end

data/vendor/bundle/gems/actionpack-3.2.11/lib/abstract_controller/collector.rb

@@ -1,32 +0,0 @@
-require "action_dispatch/http/mime_type"
-
-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
-      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
-      RUBY
-    end
-
-    Mime::SET.each do |mime|
-      generate_method_for_mime(mime)
-    end
-
-  protected
-
-    def method_missing(symbol, &block)
-      mime_constant = Mime.const_get(symbol.to_s.upcase)
-
-      if Mime::SET.include?(mime_constant)
-        AbstractController::Collector.generate_method_for_mime(mime_constant)
-        send(symbol, &block)
-      else
-        super
-      end
-    end
-  end
-end

data/vendor/bundle/gems/actionpack-3.2.11/lib/abstract_controller/helpers.rb

@@ -1,167 +0,0 @@
-require 'active_support/dependencies'
-
-module AbstractController
-  module Helpers
-    extend ActiveSupport::Concern
-
-    included do
-      class_attribute :_helpers
-      self._helpers = Module.new
-
-      class_attribute :_helper_methods
-      self._helper_methods = Array.new
-    end
-
-    module ClassMethods
-      # When a class is inherited, wrap its helper module in a new module.
-      # This ensures that the parent class's module can be changed
-      # independently of the child class's.
-      def inherited(klass)
-        helpers = _helpers
-        klass._helpers = Module.new { include helpers }
-        klass.class_eval { default_helper_module! unless anonymous? }
-        super
-      end
-
-      # Declare a controller method as a helper. For example, the following
-      # makes the +current_user+ controller method available to the view:
-      #   class ApplicationController < ActionController::Base
-      #     helper_method :current_user, :logged_in?
-      #
-      #     def current_user
-      #       @current_user ||= User.find_by_id(session[:user])
-      #     end
-      #
-      #      def logged_in?
-      #        current_user != nil
-      #      end
-      #   end
-      #
-      # In a view:
-      #  <% if logged_in? -%>Welcome, <%= current_user.name %><% end -%>
-      #
-      # ==== Parameters
-      # * <tt>method[, method]</tt> - A name or names of a method on the controller
-      #   to be made available on the view.
-      def helper_method(*meths)
-        meths.flatten!
-        self._helper_methods += meths
-
-        meths.each do |meth|
-          _helpers.class_eval <<-ruby_eval, __FILE__, __LINE__ + 1
-            def #{meth}(*args, &blk)
-              controller.send(%(#{meth}), *args, &blk)
-            end
-          ruby_eval
-        end
-      end
-
-      # The +helper+ class method can take a series of helper module names, a block, or both.
-      #
-      # ==== Parameters
-      # * <tt>*args</tt> - Module, Symbol, String, :all
-      # * <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
-      #
-      # When the argument is a string or symbol, the method will provide the "_helper" suffix, require the file
-      # and include the module in the template class. The second form illustrates how to include custom helpers
-      # when working with namespaced controllers, or other cases where the file containing the helper definition is not
-      # in one of Rails' standard load paths:
-      #   helper :foo             # => requires 'foo_helper' and includes FooHelper
-      #   helper 'resources/foo'  # => requires 'resources/foo_helper' and includes Resources::FooHelper
-      #
-      # Additionally, the +helper+ class method can receive and evaluate a block, making the methods defined available
-      # to the template.
-      #
-      #   # One line
-      #   helper { def hello() "Hello, world!" end }
-      #
-      #   # Multi-line
-      #   helper do
-      #     def foo(bar)
-      #       "#{bar} is the very best"
-      #     end
-      #   end
-      #
-      # Finally, all the above styles can be mixed together, and the +helper+ method can be invoked with a mix of
-      # +symbols+, +strings+, +modules+ and blocks.
-      #
-      #   helper(:three, BlindHelper) { def mice() 'mice' end }
-      #
-      def helper(*args, &block)
-        modules_for_helpers(args).each do |mod|
-          add_template_helper(mod)
-        end
-
-        _helpers.module_eval(&block) if block_given?
-      end
-
-      # Clears up all existing helpers in this class, only keeping the helper
-      # with the same name as this class.
-      def clear_helpers
-        inherited_helper_methods = _helper_methods
-        self._helpers = Module.new
-        self._helper_methods = Array.new
-
-        inherited_helper_methods.each { |meth| helper_method meth }
-        default_helper_module! unless anonymous?
-      end
-
-      # Returns a list of modules, normalized from the acceptable kinds of
-      # 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.
-      #
-      # Module:: No further processing
-      #
-      # After loading the appropriate files, the corresponding modules
-      # are returned.
-      #
-      # ==== Parameters
-      # * <tt>args</tt> - An array of helpers
-      #
-      # ==== Returns
-      # * <tt>Array</tt> - A normalized list of modules for the list of
-      #   helpers provided.
-      def modules_for_helpers(args)
-        args.flatten.map! do |arg|
-          case arg
-          when String, Symbol
-            file_name = "#{arg.to_s.underscore}_helper"
-            require_dependency(file_name, "Missing helper file helpers/%s.rb")
-            file_name.camelize.constantize
-          when Module
-            arg
-          else
-            raise ArgumentError, "helper must be a String, Symbol, or Module"
-          end
-        end
-      end
-
-      private
-      # Makes all the (instance) methods in the helper module available to templates
-      # rendered through this controller.
-      #
-      # ==== Parameters
-      # * <tt>module</tt> - The module to include into the current helper module
-      #   for the class
-      def add_template_helper(mod)
-        _helpers.module_eval { include mod }
-      end
-
-      def default_helper_module!
-        module_name = name.sub(/Controller$/, '')
-        module_path = module_name.underscore
-        helper module_path
-      rescue MissingSourceFile => e
-        raise e unless e.is_missing? "helpers/#{module_path}_helper"
-      rescue NameError => e
-        raise e unless e.missing_name? "#{module_name}Helper"
-      end
-    end
-  end
-end

data/vendor/bundle/gems/actionpack-3.2.11/lib/abstract_controller/layouts.rb

@@ -1,423 +0,0 @@
-require "active_support/core_ext/module/remove_method"
-
-module AbstractController
-  # Layouts reverse the common pattern of including shared headers and footers in many templates to isolate changes in
-  # repeated setups. The inclusion pattern has pages that look like this:
-  #
-  #   <%= render "shared/header" %>
-  #   Hello World
-  #   <%= render "shared/footer" %>
-  #
-  # This approach is a decent way of keeping common structures isolated from the changing content, but it's verbose
-  # and if you ever want to change the structure of these two includes, you'll have to change all the templates.
-  #
-  # With layouts, you can flip it around and have the common structure know where to insert changing content. This means
-  # that the header and footer are only mentioned in one place, like this:
-  #
-  #   // The header part of this layout
-  #   <%= yield %>
-  #   // The footer part of this layout
-  #
-  # And then you have content pages that look like this:
-  #
-  #    hello world
-  #
-  # At rendering time, the content page is computed and then inserted in the layout, like this:
-  #
-  #   // The header part of this layout
-  #   hello world
-  #   // The footer part of this layout
-  #
-  # == Accessing shared variables
-  #
-  # Layouts have access to variables specified in the content pages and vice versa. This allows you to have layouts with
-  # references that won't materialize before rendering time:
-  #
-  #   <h1><%= @page_title %></h1>
-  #   <%= yield %>
-  #
-  # ...and content pages that fulfill these references _at_ rendering time:
-  #
-  #    <% @page_title = "Welcome" %>
-  #    Off-world colonies offers you a chance to start a new life
-  #
-  # The result after rendering is:
-  #
-  #   <h1>Welcome</h1>
-  #   Off-world colonies offers you a chance to start a new life
-  #
-  # == Layout assignment
-  #
-  # You can either specify a layout declaratively (using the #layout class method) or give
-  # it the same name as your controller, and place it in <tt>app/views/layouts</tt>.
-  # If a subclass does not have a layout specified, it inherits its layout using normal Ruby inheritance.
-  #
-  # For instance, if you have PostsController and a template named <tt>app/views/layouts/posts.html.erb</tt>,
-  # that template will be used for all actions in PostsController and controllers inheriting
-  # from PostsController.
-  #
-  # If you use a module, for instance Weblog::PostsController, you will need a template named
-  # <tt>app/views/layouts/weblog/posts.html.erb</tt>.
-  #
-  # Since all your controllers inherit from ApplicationController, they will use
-  # <tt>app/views/layouts/application.html.erb</tt> if no other layout is specified
-  # or provided.
-  #
-  # == Inheritance Examples
-  #
-  #   class BankController < ActionController::Base
-  #     # bank.html.erb exists
-  #
-  #   class ExchangeController < BankController
-  #     # exchange.html.erb exists
-  #
-  #   class CurrencyController < BankController
-  #
-  #   class InformationController < BankController
-  #     layout "information"
-  #
-  #   class TellerController < InformationController
-  #     # teller.html.erb exists
-  #
-  #   class EmployeeController < InformationController
-  #     # employee.html.erb exists
-  #     layout nil
-  #
-  #   class VaultController < BankController
-  #     layout :access_level_layout
-  #
-  #   class TillController < BankController
-  #     layout false
-  #
-  # In these examples, we have three implicit lookup scenrios:
-  # * The BankController uses the "bank" layout.
-  # * The ExchangeController uses the "exchange" layout.
-  # * The CurrencyController inherits the layout from BankController.
-  #
-  # However, when a layout is explicitly set, the explicitly set layout wins:
-  # * The InformationController uses the "information" layout, explicitly set.
-  # * The TellerController also uses the "information" layout, because the parent explicitly set it.
-  # * The EmployeeController uses the "employee" layout, because it set the layout to nil, resetting the parent configuration.
-  # * The VaultController chooses a layout dynamically by calling the <tt>access_level_layout</tt> method.
-  # * The TillController does not use a layout at all.
-  #
-  # == Types of layouts
-  #
-  # Layouts are basically just regular templates, but the name of this template needs not be specified statically. Sometimes
-  # you want to alternate layouts depending on runtime information, such as whether someone is logged in or not. This can
-  # be done either by specifying a method reference as a symbol or using an inline method (as a proc).
-  #
-  # The method reference is the preferred approach to variable layouts and is used like this:
-  #
-  #   class WeblogController < ActionController::Base
-  #     layout :writers_and_readers
-  #
-  #     def index
-  #       # fetching posts
-  #     end
-  #
-  #     private
-  #       def writers_and_readers
-  #         logged_in? ? "writer_layout" : "reader_layout"
-  #       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.
-  #
-  # 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" }
-  #   end
-  #
-  # Of course, the most common way of specifying a layout is still just as a plain template name:
-  #
-  #   class WeblogController < ActionController::Base
-  #     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.
-  #
-  # 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:
-  #
-  #     class ApplicationController < ActionController::Base
-  #       layout "application"
-  #     end
-  #
-  #     class PostsController < ApplicationController
-  #       # Will use "application" layout
-  #     end
-  #
-  #     class CommentsController < ApplicationController
-  #       # Will search for "comments" layout and fallback "application" layout
-  #       layout nil
-  #     end
-  #
-  # == Conditional layouts
-  #
-  # If you have a layout that by default is applied to all the actions of a controller, you still have the option of rendering
-  # a given action or set of actions without a layout, or restricting a layout to only a single action or a set of actions. The
-  # <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
-  #
-  #     # ...
-  #
-  #   end
-  #
-  # This will assign "weblog_standard" as the WeblogController's layout for all actions except for the +rss+ action, which will
-  # 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>.
-  #
-  # == Using a different layout in the action render call
-  #
-  # If most of your actions use the same layout, it makes perfect sense to define a controller-wide layout as described above.
-  # Sometimes you'll have exceptions where one action wants to use a different layout than the rest of the controller.
-  # You can do this by passing a <tt>:layout</tt> option to the <tt>render</tt> call. For example:
-  #
-  #   class WeblogController < ActionController::Base
-  #     layout "weblog_standard"
-  #
-  #     def help
-  #       render :action => "help", :layout => "help"
-  #     end
-  #   end
-  #
-  # This will override the controller-wide "weblog_standard" layout, and will render the help action with the "help" layout instead.
-  module Layouts
-    extend ActiveSupport::Concern
-
-    include Rendering
-
-    included do
-      class_attribute :_layout_conditions
-      remove_possible_method :_layout_conditions
-      self._layout_conditions = {}
-      _write_layout_method
-    end
-
-    delegate :_layout_conditions, :to => "self.class"
-
-    module ClassMethods
-      def inherited(klass)
-        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.
-        #
-        # ==== Returns
-        # * <tt> Boolean</tt> - True if the action has a layout, false otherwise.
-        def conditional_layout?
-          return unless super
-
-          conditions = _layout_conditions
-
-          if only = conditions[:only]
-            only.include?(action_name)
-          elsif except = conditions[:except]
-            !except.include?(action_name)
-          else
-            true
-          end
-        end
-      end
-
-      # Specify the layout to use for this class.
-      #
-      # If the specified layout is a:
-      # String:: the String is the template name
-      # Symbol:: call the method specified by the symbol, which will return the template name
-      # false::  There is no layout
-      # true::   raise an ArgumentError
-      # nil::    Force default layout behavior with inheritance
-      #
-      # ==== Parameters
-      # * <tt>layout</tt> - The layout to use.
-      #
-      # ==== Options (conditions)
-      # * :only   - A list of actions to apply this layout to.
-      # * :except - Apply this layout to all actions but this one.
-      def layout(layout, conditions = {})
-        include LayoutConditions unless conditions.empty?
-
-        conditions.each {|k, v| conditions[k] = Array(v).map {|a| a.to_s} }
-        self._layout_conditions = conditions
-
-        @_layout = layout
-        _write_layout_method
-      end
-
-      # If no layout is supplied, look for a template named the return
-      # value of this method.
-      #
-      # ==== Returns
-      # * <tt>String</tt> - A template name
-      def _implied_layout_name
-        controller_path
-      end
-
-      # Creates a _layout method to be called by _default_layout .
-      #
-      # 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
-        remove_possible_method(:_layout)
-
-        prefixes    = _implied_layout_name =~ /\blayouts/ ? [] : ["layouts"]
-        name_clause = if name
-          <<-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
-
-          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
-                end
-              RUBY
-            end
-        end
-
-        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def _layout
-            if conditional_layout?
-              #{layout_definition}
-            else
-              #{name_clause}
-            end
-          end
-          private :_layout
-        RUBY
-      end
-    end
-
-    def _normalize_options(options)
-      super
-
-      if _include_layout?(options)
-        layout = options.key?(:layout) ? options.delete(:layout) : :default
-        options[:layout] = _layout_for_option(layout)
-      end
-    end
-
-    attr_internal_writer :action_has_layout
-
-    def initialize(*)
-      @_action_has_layout = true
-      super
-    end
-
-    def action_has_layout?
-      @_action_has_layout
-    end
-
-    def conditional_layout?
-      true
-    end
-
-  private
-
-    # This will be overwritten by _write_layout_method
-    def _layout; end
-
-    # Determine the layout for a given name, taking into account the name type.
-    #
-    # ==== Parameters
-    # * <tt>name</tt> - The name of the template
-    def _layout_for_option(name)
-      case name
-      when String     then _normalize_layout(name)
-      when Proc       then name
-      when true       then Proc.new { _default_layout(true)  }
-      when :default   then Proc.new { _default_layout(false) }
-      when false, nil then nil
-      else
-        raise ArgumentError,
-          "String, true, or false, expected for `layout'; you passed #{name.inspect}"
-      end
-    end
-
-    def _normalize_layout(value)
-      value.is_a?(String) && value !~ /\blayouts/ ? "layouts/#{value}" : value
-    end
-
-    # Returns the default layout for this controller.
-    # Optionally raises an exception if the layout could not be found.
-    #
-    # ==== Parameters
-    # * <tt>require_layout</tt> - If set to true and layout is not found,
-    #   an ArgumentError exception is raised (defaults to false)
-    #
-    # ==== Returns
-    # * <tt>template</tt> - The template object for the default layout (or nil)
-    def _default_layout(require_layout = false)
-      begin
-        value = _layout if action_has_layout?
-      rescue NameError => e
-        raise e, "Could not render layout: #{e.message}"
-      end
-
-      if require_layout && action_has_layout? && !value
-        raise ArgumentError,
-          "There was no default layout for #{self.class} in #{view_paths.inspect}"
-      end
-
-      _normalize_layout(value)
-    end
-
-    def _include_layout?(options)
-      (options.keys & [:text, :inline, :partial]).empty? || options.key?(:layout)
-    end
-  end
-end