module ActionView::RoutingUrlFor - actionview-4.2.3 Documentation

# module ActionView::RoutingUrlFor

### Public Instance Methods

url_for(options = nil) click to toggle source

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

#### Options¶ ↑

- `:anchor` - Specifies the anchor name to be appended to the path.

- `:only_path` - If true, returns the relative URL (omitting the protocol, host name, and port) (`true` by default unless `:host` is specified).

- `:trailing_slash` - If true, adds a trailing slash, as in “/archive/2005/”. Note that this is currently not recommended since it breaks caching.

- `:host` - Overrides the default (current) host if provided.

- `:protocol` - Overrides the default (current) protocol if provided.

- `:user` - Inline HTTP authentication (only plucked out if `:password` is also present).

- `:password` - Inline HTTP authentication (only plucked out if `:user` 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

Calls superclass method

    # File lib/action_view/routing_url_for.rb, line 78
    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
        unless options.key?(:only_path)
          if options[:host].nil?
            options[:only_path] = _generate_paths_by_default
          else
            options[:only_path] = false
          end
        end

        super(options)
      when :back
        _back_url
      when Array
        if _generate_paths_by_default
          polymorphic_path(options, options.extract_options!)
        else
          polymorphic_url(options, options.extract_options!)
        end
      else
        method = _generate_paths_by_default ? :path : :url
        builder = ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder.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