actionpack 3.2.19 → 4.0.0

data/lib/action_view/renderer/partial_renderer.rb

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/object/blank'
+require 'thread_safe'
 
 module ActionView
   # = Action View Partials
@@ -10,16 +10,16 @@ module ActionView
   #
   # In a template for Advertiser#account:
   #
-  #  <%= render :partial => "account" %>
+  #  <%= render partial: "account" %>
   #
   # This would render "advertiser/_account.html.erb".
   #
   # In another template for Advertiser#buy, we could have:
   #
-  #   <%= render :partial => "account", :locals => { :account => @buyer } %>
+  #   <%= render partial: "account", locals: { account: @buyer } %>
   #
   #   <% @advertisements.each do |ad| %>
-  #     <%= render :partial => "ad", :locals => { :ad => ad } %>
+  #     <%= render partial: "ad", locals: { ad: ad } %>
   #   <% end %>
   #
   # This would first render "advertiser/_account.html.erb" with @buyer passed in as the local variable +account+, then
@@ -30,21 +30,21 @@ module ActionView
   # By default <tt>ActionView::PartialRenderer</tt> doesn't have any local variables.
   # The <tt>:object</tt> option can be used to pass an object to the partial. For instance:
   #
-  #   <%= render :partial => "account", :object => @buyer %>
+  #   <%= render partial: "account", object: @buyer %>
   #
-  # would provide the +@buyer+ object to the partial, available under the local variable +account+ and is
+  # would provide the <tt>@buyer</tt> object to the partial, available under the local variable +account+ and is
   # equivalent to:
   #
-  #   <%= render :partial => "account", :locals => { :account => @buyer } %>
+  #   <%= render partial: "account", locals: { account: @buyer } %>
   #
   # With the <tt>:as</tt> option we can specify a different name for said local variable. For example, if we
   # wanted it to be +user+ instead of +account+ we'd do:
   #
-  #   <%= render :partial => "account", :object => @buyer, :as => 'user' %>
+  #   <%= render partial: "account", object: @buyer, as: 'user' %>
   #
   # This is equivalent to
   #
-  #   <%= render :partial => "account", :locals => { :user => @buyer } %>
+  #   <%= render partial: "account", locals: { user: @buyer } %>
   #
   # == Rendering a collection of partials
   #
@@ -53,7 +53,7 @@ module ActionView
   # accepts an array and renders a partial by the same name as the elements contained within. So the three-lined
   # example in "Using partials" can be rewritten with a single line:
   #
-  #   <%= render :partial => "ad", :collection => @advertisements %>
+  #   <%= render partial: "ad", collection: @advertisements %>
   #
   # This will render "advertiser/_ad.html.erb" and pass the local variable +ad+ to the template for display. An
   # iteration counter will automatically be made available to the template with a name of the form
@@ -64,12 +64,12 @@ module ActionView
   # You can specify a partial to be rendered between elements via the <tt>:spacer_template</tt> option.
   # The following example will render <tt>advertiser/_ad_divider.html.erb</tt> between each ad partial:
   #
-  #   <%= render :partial => "ad", :collection => @advertisements, :spacer_template => "ad_divider" %>
+  #   <%= render partial: "ad", collection: @advertisements, spacer_template: "ad_divider" %>
   #
   # If the given <tt>:collection</tt> is nil or empty, <tt>render</tt> will return nil. This will allow you
   # to specify a text which will displayed instead by using this form:
   #
-  #   <%= render(:partial => "ad", :collection => @advertisements) || "There's no ad to be displayed" %>
+  #   <%= render(partial: "ad", collection: @advertisements) || "There's no ad to be displayed" %>
   #
   # NOTE: Due to backwards compatibility concerns, the collection can't be one of hashes. Normally you'd also
   # just keep domain objects, like Active Records, in there.
@@ -78,43 +78,42 @@ module ActionView
   #
   # Two controllers can share a set of partials and render them like this:
   #
-  #   <%= render :partial => "advertisement/ad", :locals => { :ad => @advertisement } %>
+  #   <%= render partial: "advertisement/ad", locals: { ad: @advertisement } %>
   #
   # This will render the partial "advertisement/_ad.html.erb" regardless of which controller this is being called from.
   #
   # == Rendering objects that respond to `to_partial_path`
   #
   # Instead of explicitly naming the location of a partial, you can also let PartialRenderer do the work
-  # and pick the proper path by checking `to_proper_path` method. If the object passed to render is a collection,
-  # all objects must return the same path.
+  # and pick the proper path by checking `to_partial_path` method.
   #
   #  # @account.to_partial_path returns 'accounts/account', so it can be used to replace:
-  #  # <%= render :partial => "accounts/account", :locals => { :account => @account} %>
-  #  <%= render :partial => @account %>
+  #  # <%= render partial: "accounts/account", locals: { account: @account} %>
+  #  <%= render partial: @account %>
   #
   #  # @posts is an array of Post instances, so every post record returns 'posts/post' on `to_partial_path`,
   #  # that's why we can replace:
-  #  # <%= render :partial => "posts/post", :collection => @posts %>
-  #  <%= render :partial => @posts %>
+  #  # <%= render partial: "posts/post", collection: @posts %>
+  #  <%= render partial: @posts %>
   #
   # == Rendering the default case
   #
   # If you're not going to be using any of the options like collections or layouts, you can also use the short-hand
   # defaults of render to render partials. Examples:
   #
-  #  # Instead of <%= render :partial => "account" %>
+  #  # Instead of <%= render partial: "account" %>
   #  <%= render "account" %>
   #
-  #  # Instead of <%= render :partial => "account", :locals => { :account => @buyer } %>
-  #  <%= render "account", :account => @buyer %>
+  #  # Instead of <%= render partial: "account", locals: { account: @buyer } %>
+  #  <%= render "account", account: @buyer %>
   #
   #  # @account.to_partial_path returns 'accounts/account', so it can be used to replace:
-  #  # <%= render :partial => "accounts/account", :locals => { :account => @account} %>
+  #  # <%= render partial: "accounts/account", locals: { account: @account} %>
   #  <%= render @account %>
   #
   #  # @posts is an array of Post instances, so every post record returns 'posts/post' on `to_partial_path`,
   #  # that's why we can replace:
-  #  # <%= render :partial => "posts/post", :collection => @posts %>
+  #  # <%= render partial: "posts/post", collection: @posts %>
   #  <%= render @posts %>
   #
   # == Rendering partials with layouts
@@ -125,10 +124,10 @@ module ActionView
   #
   #   <%# app/views/users/index.html.erb &>
   #   Here's the administrator:
-  #   <%= render :partial => "user", :layout => "administrator", :locals => { :user => administrator } %>
+  #   <%= render partial: "user", layout: "administrator", locals: { user: administrator } %>
   #
   #   Here's the editor:
-  #   <%= render :partial => "user", :layout => "editor", :locals => { :user => editor } %>
+  #   <%= render partial: "user", layout: "editor", locals: { user: editor } %>
   #
   #   <%# app/views/users/_user.html.erb &>
   #   Name: <%= user.name %>
@@ -159,10 +158,51 @@ module ActionView
   #     Name: <%= user.name %>
   #   </div>
   #
+  # If a collection is given, the layout will be rendered once for each item in
+  # the collection. Just think these two snippets have the same output:
+  #
+  #   <%# app/views/users/_user.html.erb %>
+  #   Name: <%= user.name %>
+  #
+  #   <%# app/views/users/index.html.erb %>
+  #   <%# This does not use layouts %>
+  #   <ul>
+  #     <% users.each do |user| -%>
+  #       <li>
+  #         <%= render partial: "user", locals: { user: user } %>
+  #       </li>
+  #     <% end -%>
+  #   </ul>
+  #
+  #   <%# app/views/users/_li_layout.html.erb %>
+  #   <li>
+  #     <%= yield %>
+  #   </li>
+  #
+  #   <%# app/views/users/index.html.erb %>
+  #   <ul>
+  #     <%= render partial: "user", layout: "li_layout", collection: users %>
+  #   </ul>
+  #
+  # Given two users whose names are Alice and Bob, these snippets return:
+  #
+  #   <ul>
+  #     <li>
+  #       Name: Alice
+  #     </li>
+  #     <li>
+  #       Name: Bob
+  #     </li>
+  #   </ul>
+  #
+  # The current object being rendered, as well as the object_counter, will be
+  # available as local variables inside the layout template under the same names
+  # as available in the partial.
+  #
   # You can also apply a layout to a block within any template:
   #
   #   <%# app/views/users/_chief.html.erb &>
-  #   <%= render(:layout => "administrator", :locals => { :user => chief }) do %>
+  #   <%= render(layout: "administrator", locals: { user: chief }) do %>
   #     Title: <%= chief.title %>
   #   <% end %>
   #
@@ -185,7 +225,7 @@ module ActionView
   #   </div>
   #
   #   <%# app/views/users/index.html.erb &>
-  #   <%= render :layout => @users do |user| %>
+  #   <%= render layout: @users do |user| %>
   #     Title: <%= user.title %>
   #   <% end %>
   #
@@ -201,7 +241,7 @@ module ActionView
   #   </div>
   #
   #   <%# app/views/users/index.html.erb &>
-  #   <%= render :layout => @users do |user, section| %>
+  #   <%= render layout: @users do |user, section| %>
   #     <%- case section when :header -%>
   #       Title: <%= user.title %>
   #     <%- when :footer -%>
@@ -209,12 +249,13 @@ module ActionView
   #     <%- end -%>
   #   <% end %>
   class PartialRenderer < AbstractRenderer
-    PARTIAL_NAMES = Hash.new { |h,k| h[k] = {} }
+    PREFIXED_PARTIAL_NAMES = ThreadSafe::Cache.new do |h, k|
+      h[k] = ThreadSafe::Cache.new
+    end
 
     def initialize(*)
       super
       @context_prefix = @lookup_context.prefixes.first
-      @partial_names = PARTIAL_NAMES[@context_prefix]
     end
 
     def render(context, options, block)
@@ -244,7 +285,7 @@ module ActionView
       return nil if @collection.blank?
 
       if @options.key?(:spacer_template)
-        spacer = find_template(@options[:spacer_template]).render(@view, @locals)
+        spacer = find_template(@options[:spacer_template], @locals.keys).render(@view, @locals)
       end
 
       result = @template ? collection_with_template : collection_without_template
@@ -252,11 +293,11 @@ module ActionView
     end
 
     def render_partial
-      locals, view, block = @locals, @view, @block
+      view, locals, block = @view, @locals, @block
       object, as = @object, @variable
 
       if !block && (layout = @options[:layout])
-        layout = find_template(layout.to_s)
+        layout = find_template(layout.to_s, @template_keys)
       end
 
       object ||= locals[as]
@@ -272,6 +313,13 @@ module ActionView
 
     private
 
+    # Sets up instance variables needed for rendering a partial. This method
+    # finds the options and details and extracts them. The method also contains
+    # logic that handles the type of object passed in as the partial.
+    #
+    # If +options[:partial]+ is a string, then the +@path+ instance variable is
+    # set to that string. Otherwise, the +options[:partial]+ object must
+    # respond to +to_partial_path+ in order to setup the path.
     def setup(context, options, block)
       @view   = context
       partial = options[:partial]
@@ -281,6 +329,8 @@ module ActionView
       @block   = block
       @details = extract_details(options)
 
+      prepend_formats(options[:formats])
+
       if String === partial
         @object     = options[:object]
         @path       = partial
@@ -296,19 +346,18 @@ module ActionView
         end
       end
 
-      if @path
-        @variable, @variable_counter = retrieve_variable(@path)
-      else
-        paths.map! { |path| retrieve_variable(path).unshift(path) }
+      if as = options[:as]
+        raise_invalid_identifier(as) unless as.to_s =~ /\A[a-z_]\w*\z/
+        as = as.to_sym
       end
 
-      if String === partial && @variable.to_s !~ /^[a-z_][a-zA-Z_0-9]*$/
-        raise ArgumentError.new("The partial name (#{partial}) is not a valid Ruby identifier; " +
-                                "make sure your partial name starts with a letter or underscore, " +
-                                "and is followed by any combinations of letters, numbers, or underscores.")
+      if @path
+        @variable, @variable_counter = retrieve_variable(@path, as)
+        @template_keys = retrieve_template_keys
+      else
+        paths.map! { |path| retrieve_variable(path, as).unshift(path) }
       end
 
-      extract_format(@path, @details)
       self
     end
 
@@ -320,73 +369,82 @@ module ActionView
     end
 
     def collection_from_object
-      if @object.respond_to?(:to_ary)
-        @object.to_ary
-      end
+      @object.to_ary if @object.respond_to?(:to_ary)
     end
 
     def find_partial
       if path = @path
-        locals = @locals.keys
-        locals << @variable
-        locals << @variable_counter if @collection
-        find_template(path, locals)
+        find_template(path, @template_keys)
       end
     end
 
-    def find_template(path=@path, locals=@locals.keys)
+    def find_template(path, locals)
       prefixes = path.include?(?/) ? [] : @lookup_context.prefixes
       @lookup_context.find_template(path, prefixes, true, locals, @details)
     end
 
     def collection_with_template
-      segments, locals, template = [], @locals, @template
+      view, locals, template = @view, @locals, @template
       as, counter = @variable, @variable_counter
 
-      locals[counter] = -1
-
-      @collection.each do |object|
-        locals[counter] += 1
-        locals[as] = object
-        segments << template.render(@view, locals)
+      if layout = @options[:layout]
+        layout = find_template(layout, @template_keys)
       end
 
-      segments
+      index = -1
+      @collection.map do |object|
+        locals[as]      = object
+        locals[counter] = (index += 1)
+
+        content = template.render(view, locals)
+        content = layout.render(view, locals) { content } if layout
+        content
+      end
     end
 
     def collection_without_template
-      segments, locals, collection_data = [], @locals, @collection_data
-      index, template, cache = -1, nil, {}
-      keys = @locals.keys
+      view, locals, collection_data = @view, @locals, @collection_data
+      cache = {}
+      keys  = @locals.keys
 
-      @collection.each_with_index do |object, i|
-        path, *data = collection_data[i]
-        template = (cache[path] ||= find_template(path, keys + data))
-        locals[data[0]] = object
-        locals[data[1]] = (index += 1)
-        segments << template.render(@view, locals)
-      end
+      index = -1
+      @collection.map do |object|
+        index += 1
+        path, as, counter = collection_data[index]
 
-      @template = template
-      segments
+        locals[as]      = object
+        locals[counter] = index
+
+        template = (cache[path] ||= find_template(path, keys + [as, counter]))
+        template.render(view, locals)
+      end
     end
 
+    # Obtains the path to where the object's partial is located. If the object
+    # responds to +to_partial_path+, then +to_partial_path+ will be called and
+    # will provide the path. If the object does not respond to +to_partial_path+,
+    # then an +ArgumentError+ is raised.
+    #
+    # If +prefix_partial_path_with_controller_namespace+ is true, then this
+    # method will prefix the partial paths with a namespace.
     def partial_path(object = @object)
       object = object.to_model if object.respond_to?(:to_model)
 
       path = if object.respond_to?(:to_partial_path)
         object.to_partial_path
       else
-        klass = object.class
-        if klass.respond_to?(:model_name)
-          ActiveSupport::Deprecation.warn "ActiveModel-compatible objects whose classes return a #model_name that responds to #partial_path are deprecated. Please respond to #to_partial_path directly instead."
-          klass.model_name.partial_path
-        else
-          raise ArgumentError.new("'#{object.inspect}' is not an ActiveModel-compatible object that returns a valid partial path.")
-        end
+        raise ArgumentError.new("'#{object.inspect}' is not an ActiveModel-compatible object. It must implement :to_partial_path.")
+      end
+
+      if @view.prefix_partial_path_with_controller_namespace
+        prefixed_partial_names[path] ||= merge_prefix_into_object_path(@context_prefix, path.dup)
+      else
+        path
       end
+    end
 
-      @partial_names[path] ||= merge_prefix_into_object_path(@context_prefix, path.dup)
+    def prefixed_partial_names
+      @prefixed_partial_names ||= PREFIXED_PARTIAL_NAMES[@context_prefix]
     end
 
     def merge_prefix_into_object_path(prefix, object_path)
@@ -406,10 +464,29 @@ module ActionView
       end
     end
 
-    def retrieve_variable(path)
-      variable = @options.fetch(:as) { path[%r'_?(\w+)(\.\w+)*$', 1] }.try(:to_sym)
+    def retrieve_template_keys
+      keys = @locals.keys
+      keys << @variable         if @object || @collection
+      keys << @variable_counter if @collection
+      keys
+    end
+
+    def retrieve_variable(path, as)
+      variable = as || begin
+        base = path[-1] == "/" ? "" : File.basename(path)
+        raise_invalid_identifier(path) unless base =~ /\A_?([a-z]\w*)(\.\w+)*\z/
+        $1.to_sym
+      end
       variable_counter = :"#{variable}_counter" if @collection
       [variable, variable_counter]
     end
+
+    IDENTIFIER_ERROR_MESSAGE = "The partial name (%s) is not a valid Ruby identifier; " +
+                               "make sure your partial name starts with a lowercase letter or underscore, " +
+                               "and is followed by any combination of letters, numbers and underscores."
+
+    def raise_invalid_identifier(path)
+      raise ArgumentError.new(IDENTIFIER_ERROR_MESSAGE % (path))
+    end
   end
 end

data/lib/action_view/renderer/renderer.rb

@@ -2,6 +2,12 @@ module ActionView
   # This is the main entry point for rendering. It basically delegates
   # to other objects like TemplateRenderer and PartialRenderer which
   # actually renders the template.
+  #
+  # The Renderer will parse the options from the +render+ or +render_body+
+  # method and render a partial or a template based on the options. The
+  # +TemplateRenderer+ and +PartialRenderer+ objects are wrappers which do all
+  # the setup and logic necessary to render a view and a new object is created
+  # each time +render+ is called.
   class Renderer
     attr_accessor :lookup_context
 
@@ -33,22 +39,12 @@ module ActionView
 
     # Direct accessor to template rendering.
     def render_template(context, options) #:nodoc:
-      _template_renderer.render(context, options)
+      TemplateRenderer.new(@lookup_context).render(context, options)
     end
 
     # Direct access to partial rendering.
     def render_partial(context, options, &block) #:nodoc:
-      _partial_renderer.render(context, options, block)
-    end
-
-    private
-
-    def _template_renderer #:nodoc:
-      @_template_renderer ||= TemplateRenderer.new(@lookup_context)
-    end
-
-    def _partial_renderer #:nodoc:
-      @_partial_renderer ||= PartialRenderer.new(@lookup_context)
+      PartialRenderer.new(@lookup_context).render(context, options, block)
     end
   end
 end

data/lib/action_view/renderer/streaming_template_renderer.rb

@@ -1,7 +1,4 @@
-# 1.9 ships with Fibers but we need to require the extra
-# methods explicitly. We only load those extra methods if
-# Fiber is available in the first place.
-require 'fiber' if defined?(Fiber)
+require 'fiber'
 
 module ActionView
   # == TODO
@@ -33,7 +30,7 @@ module ActionView
       # This is the same logging logic as in ShowExceptions middleware.
       # TODO Once "exceptron" is in, refactor this piece to simply re-use exceptron.
       def log_error(exception) #:nodoc:
-        logger = ActionController::Base.logger
+        logger = ActionView::Base.logger
         return unless logger
 
         message = "\n#{exception.class} (#{exception.message}):\n"

data/lib/action_view/renderer/template_renderer.rb

@@ -1,18 +1,17 @@
 require 'active_support/core_ext/object/try'
-require 'active_support/core_ext/array/wrap'
 
 module ActionView
   class TemplateRenderer < AbstractRenderer #:nodoc:
     def render(context, options)
       @view    = context
       @details = extract_details(options)
-      extract_format(options[:file] || options[:template], @details)
       template = determine_template(options)
       context  = @lookup_context
 
+      prepend_formats(template.formats)
+
       unless context.rendered_format
-        context.formats = template.formats unless template.formats.empty?
-        context.rendered_format = context.formats.first
+        context.rendered_format = template.formats.first || formats.last
       end
 
       render_template(template, options[:layout], options[:locals])
@@ -20,26 +19,29 @@ module ActionView
 
     # Determine the template to be rendered using the given options.
     def determine_template(options) #:nodoc:
-      keys = options[:locals].try(:keys) || []
+      keys = options.fetch(:locals, {}).keys
 
       if options.key?(:text)
-        Template::Text.new(options[:text], formats.try(:first))
+        Template::Text.new(options[:text], formats.first)
       elsif options.key?(:file)
         with_fallbacks { find_template(options[:file], nil, false, keys, @details) }
       elsif options.key?(:inline)
         handler = Template.handler_for_extension(options[:type] || "erb")
         Template.new(options[:inline], "inline template", handler, :locals => keys)
       elsif options.key?(:template)
-        options[:template].respond_to?(:render) ?
-          options[:template] : find_template(options[:template], options[:prefixes], false, keys, @details)
+        if options[:template].respond_to?(:render)
+          options[:template]
+        else
+          find_template(options[:template], options[:prefixes], false, keys, @details)
+        end
       else
         raise ArgumentError, "You invoked render but did not give any of :partial, :template, :inline, :file or :text option."
       end
     end
 
-    # Renders the given template. An string representing the layout can be
+    # Renders the given template. A string representing the layout can be
     # supplied as well.
-    def render_template(template, layout_name = nil, locals = {}) #:nodoc:
+    def render_template(template, layout_name = nil, locals = nil) #:nodoc:
       view, locals = @view, locals || {}
 
       render_with_layout(layout_name, locals) do |layout|

data/lib/action_view/routing_url_for.rb

@@ -0,0 +1,107 @@
+module ActionView
+  module RoutingUrlFor
+
+    # Returns the URL for the set of +options+ provided. This takes the
+    # same options as +url_for+ in Action Controller (see the
+    # documentation for <tt>ActionController::Base#url_for</tt>). Note that by default
+    # <tt>:only_path</tt> is <tt>true</tt> so you'll get the relative "/controller/action"
+    # instead of the fully qualified URL like "http://example.com/controller/action".
+    #
+    # ==== Options
+    # * <tt>:anchor</tt> - Specifies the anchor name to be appended to the path.
+    # * <tt>:only_path</tt> - If true, returns the relative URL (omitting the protocol, host name, and port) (<tt>true</tt> by default unless <tt>:host</tt> is specified).
+    # * <tt>:trailing_slash</tt> - If true, adds a trailing slash, as in "/archive/2005/". Note that this
+    #   is currently not recommended since it breaks caching.
+    # * <tt>:host</tt> - Overrides the default (current) host if provided.
+    # * <tt>:protocol</tt> - Overrides the default (current) protocol if provided.
+    # * <tt>:user</tt> - Inline HTTP authentication (only plucked out if <tt>:password</tt> is also present).
+    # * <tt>:password</tt> - Inline HTTP authentication (only plucked out if <tt>:user</tt> is also present).
+    #
+    # ==== Relying on named routes
+    #
+    # Passing a record (like an Active Record) instead of a hash as the options parameter will
+    # trigger the named route for that record. The lookup will happen on the name of the class. So passing a
+    # Workshop object will attempt to use the +workshop_path+ route. If you have a nested route, such as
+    # +admin_workshop_path+ you'll have to call that explicitly (it's impossible for +url_for+ to guess that route).
+    #
+    # ==== Implicit Controller Namespacing
+    #
+    # Controllers passed in using the +:controller+ option will retain their namespace unless it is an absolute one.
+    #
+    # ==== Examples
+    #   <%= url_for(action: 'index') %>
+    #   # => /blog/
+    #
+    #   <%= url_for(action: 'find', controller: 'books') %>
+    #   # => /books/find
+    #
+    #   <%= url_for(action: 'login', controller: 'members', only_path: false, protocol: 'https') %>
+    #   # => https://www.example.com/members/login/
+    #
+    #   <%= url_for(action: 'play', anchor: 'player') %>
+    #   # => /messages/play/#player
+    #
+    #   <%= url_for(action: 'jump', anchor: 'tax&ship') %>
+    #   # => /testing/jump/#tax&ship
+    #
+    #   <%= url_for(Workshop.new) %>
+    #   # relies on Workshop answering a persisted? call (and in this case returning false)
+    #   # => /workshops
+    #
+    #   <%= url_for(@workshop) %>
+    #   # calls @workshop.to_param which by default returns the id
+    #   # => /workshops/5
+    #
+    #   # to_param can be re-defined in a model to provide different URL names:
+    #   # => /workshops/1-workshop-name
+    #
+    #   <%= url_for("http://www.example.com") %>
+    #   # => http://www.example.com
+    #
+    #   <%= url_for(:back) %>
+    #   # if request.env["HTTP_REFERER"] is set to "http://www.example.com"
+    #   # => http://www.example.com
+    #
+    #   <%= url_for(:back) %>
+    #   # if request.env["HTTP_REFERER"] is not set or is blank
+    #   # => javascript:history.back()
+    #
+    #   <%= url_for(action: 'index', controller: 'users') %>
+    #   # Assuming an "admin" namespace
+    #   # => /admin/users
+    #
+    #   <%= url_for(action: 'index', controller: '/users') %>
+    #   # Specify absolute path with beginning slash
+    #   # => /users
+    def url_for(options = nil)
+      case options
+      when String
+        options
+      when nil, Hash
+        options ||= {}
+        options = { :only_path => options[:host].nil? }.merge!(options.symbolize_keys)
+        super
+      when :back
+        _back_url
+      else
+        polymorphic_path(options)
+      end
+    end
+
+    def url_options #:nodoc:
+      return super unless controller.respond_to?(:url_options)
+      controller.url_options
+    end
+
+    def _routes_context #:nodoc:
+      controller
+    end
+    protected :_routes_context
+
+    def optimize_routes_generation? #:nodoc:
+      controller.respond_to?(:optimize_routes_generation?, true) ?
+        controller.optimize_routes_generation? : super
+    end
+    protected :optimize_routes_generation?
+  end
+end