module ActionView::RoutingUrlFor

def _generate_paths_by_default
  true
end

def _routes_context
  controller
end

def ensure_only_path_option(options)
  unless options.key?(:only_path)
    options[:only_path] = _generate_paths_by_default unless options[:host]
  end
end

def optimize_routes_generation?
  controller.respond_to?(:optimize_routes_generation?, true) ?
    controller.optimize_routes_generation? : super
end

# => /users
# Specify absolute path with beginning slash
<%= url_for(action: 'index', controller: '/users') %>

# => /admin/users
# Assuming an "admin" namespace
<%= url_for(action: 'index', controller: 'users') %>

# => javascript:history.back()
# if request.env["HTTP_REFERER"] is not set or is blank
<%= url_for(:back) %>

# => http://www.example.com
# if request.env["HTTP_REFERER"] is set to "http://www.example.com"
<%= url_for(:back) %>

# => http://www.example.com
<%= url_for("http://www.example.com") %>

# => /workshops/1-workshop-name
# to_param can be re-defined in a model to provide different URL names:

# => /workshops/5
# calls @workshop.to_param which by default returns the id
<%= url_for(@workshop) %>

# => /workshops
# relies on Workshop answering a persisted? call (and in this case returning false)
<%= url_for(Workshop.new) %>

# => /workshops
<%= url_for(Workshop) %>

# => /testing/jump/#tax&ship
<%= url_for(action: 'jump', anchor: 'tax&ship') %>

# => /messages/play/#player
<%= url_for(action: 'play', anchor: 'player') %>

# => https://www.example.com/members/login/
<%= url_for(action: 'login', controller: 'members', only_path: false, protocol: 'https') %>

# => /books/find
<%= url_for(action: 'find', controller: 'books') %>

# => /blogs/
<%= url_for(action: 'index') %>
==== Examples

Controllers passed in using the +:controller+ option will retain their namespace unless it is an absolute one.

==== Implicit Controller Namespacing

+admin_workshop_path+ you'll have to call that explicitly (it's impossible for +url_for+ to guess that route).
Workshop object will attempt to use the +workshop_path+ route. If you have a nested route, such as
trigger the named route for that record. The lookup will happen on the name of the class. So passing a
Passing a record (like an Active Record) instead of a hash as the options parameter will

==== Relying on named routes

* :password - Inline HTTP authentication (only plucked out if :user is also present).
* :user - Inline HTTP authentication (only plucked out if :password is also present).
* :protocol - Overrides the default (current) protocol if provided.
* :host - Overrides the default (current) host if provided.
is currently not recommended since it breaks caching.
* :trailing_slash - If true, adds a trailing slash, as in "/archive/2005/". Note that this
* :only_path - If true, returns the relative URL (omitting the protocol, host name, and port) (true by default unless :host is specified).
* :anchor - Specifies the anchor name to be appended to the path.
==== Options

instead of the fully qualified URL like "http://example.com/controller/action".
:only_path is true so you'll get the relative "/controller/action"
documentation for ActionDispatch::Routing::UrlFor#url_for). Note that by default
same options as +url_for+ in Action Controller (see the
Returns the URL for the set of +options+ provided. This takes the

def url_for(options = nil)
  case options
  when String
    options
  when nil
    super(only_path: _generate_paths_by_default)
  when Hash
    options = options.symbolize_keys
    ensure_only_path_option(options)
    super(options)
  when ActionController::Parameters
    ensure_only_path_option(options)
    super(options)
  when :back
    _back_url
  when Array
    components = options.dup
    options = components.extract_options!
    ensure_only_path_option(options)
    if options[:only_path]
      polymorphic_path(components, options)
    else
      polymorphic_url(components, options)
    end
  else
    method = _generate_paths_by_default ? :path : :url
    builder = ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder.public_send(method)
    case options
    when Symbol
      builder.handle_string_call(self, options)
    when Class
      builder.handle_class_call(self, options)
    else
      builder.handle_model_call(self, options)
    end
  end
end

:nodoc:

def url_options # :nodoc:
  return super unless controller.respond_to?(:url_options)
  controller.url_options
end