edge badge
Methods
A
C
D
E
F
G
M
N
O
P
R
U
Included Modules
Constants
RESERVED_OPTIONS = [:host, :protocol, :port, :subdomain, :domain, :tld_length, :trailing_slash, :anchor, :params, :only_path, :script_name, :original_script_name]
 
Attributes
[R] _routes
[RW] default_scope
[RW] default_url_options
[RW] disable_clear_and_finalize
[RW] formatter
[RW] named_routes
[RW] request_class
[RW] resources_path_names
[RW] router
[RW] routes
[RW] set
Class Public methods
default_resources_path_names()
# File actionpack/lib/action_dispatch/routing/route_set.rb, line 379
def self.default_resources_path_names
  { :new => 'new', :edit => 'edit' }
end
new(request_class = ActionDispatch::Request)
# File actionpack/lib/action_dispatch/routing/route_set.rb, line 383
def initialize(request_class = ActionDispatch::Request)
  self.named_routes = NamedRouteCollection.new
  self.resources_path_names = self.class.default_resources_path_names
  self.default_url_options = {}
  self.request_class = request_class

  @append                     = []
  @prepend                    = []
  @disable_clear_and_finalize = false
  @finalized                  = false

  @set    = Journey::Routes.new
  @router = Journey::Router.new @set
  @formatter = Journey::Formatter.new @set
end
Instance Public methods
add_route(app, conditions = {}, requirements = {}, defaults = {}, name = nil, anchor = true)
# File actionpack/lib/action_dispatch/routing/route_set.rb, line 532
def add_route(app, conditions = {}, requirements = {}, defaults = {}, name = nil, anchor = true)
  raise ArgumentError, "Invalid route name: '#{name}'" unless name.blank? || name.to_s.match(/^[_a-z]\w*$/i)

  if name && named_routes[name]
    raise ArgumentError, "Invalid route name, already in use: '#{name}' \n"              "You may have defined two routes with the same name using the `:as` option, or "              "you may be overriding a route already defined by a resource with the same naming. "              "For the latter, you can restrict the routes created with `resources` as explained here: \n"              "http://guides.rubyonrails.org/routing.html#restricting-the-routes-created"
  end

  path = conditions.delete :path_info
  ast  = conditions.delete :parsed_path_info
  path = build_path(path, ast, requirements, anchor)
  conditions = build_conditions(conditions, path.names.map { |x| x.to_sym })

  route = @set.add_route(app, path, conditions, defaults, name)
  named_routes[name] = route if name
  route
end
append(&block)
# File actionpack/lib/action_dispatch/routing/route_set.rb, line 406
def append(&block)
  @append << block
end
call(env)
# File actionpack/lib/action_dispatch/routing/route_set.rb, line 797
def call(env)
  req = request_class.new(env)
  req.path_info = Journey::Router::Utils.normalize_path(req.path_info)
  @router.serve(req)
end
clear!()
# File actionpack/lib/action_dispatch/routing/route_set.rb, line 434
def clear!
  @finalized = false
  named_routes.clear
  set.clear
  formatter.clear
  @prepend.each { |blk| eval_block(blk) }
end
define_mounted_helper(name)
# File actionpack/lib/action_dispatch/routing/route_set.rb, line 459
      def define_mounted_helper(name)
        return if MountedHelpers.method_defined?(name)

        routes = self
        MountedHelpers.class_eval do
          define_method "_#{name}" do
            RoutesProxy.new(routes, _routes_context)
          end
        end

        MountedHelpers.class_eval("          def #{name}
            @_#{name} ||= _#{name}
          end
", __FILE__, __LINE__ + 1)
      end
dispatcher(defaults)
# File actionpack/lib/action_dispatch/routing/route_set.rb, line 442
def dispatcher(defaults)
  Routing::RouteSet::Dispatcher.new(defaults)
end
draw(&block)
# File actionpack/lib/action_dispatch/routing/route_set.rb, line 399
def draw(&block)
  clear! unless @disable_clear_and_finalize
  eval_block(block)
  finalize! unless @disable_clear_and_finalize
  nil
end
empty?()
# File actionpack/lib/action_dispatch/routing/route_set.rb, line 528
def empty?
  routes.empty?
end
extra_keys(options, recall={})

Generate the path indicated by the arguments, and return an array of the keys that were not used to generate it.

# File actionpack/lib/action_dispatch/routing/route_set.rb, line 728
def extra_keys(options, recall={})
  generate_extras(options, recall).last
end
finalize!()
# File actionpack/lib/action_dispatch/routing/route_set.rb, line 428
def finalize!
  return if @finalized
  @append.each { |blk| eval_block(blk) }
  @finalized = true
end
find_script_name(options)
# File actionpack/lib/action_dispatch/routing/route_set.rb, line 751
def find_script_name(options)
  options.delete(:script_name) || ''
end
generate_extras(options, recall={})
# File actionpack/lib/action_dispatch/routing/route_set.rb, line 732
def generate_extras(options, recall={})
  route_key = options.delete :use_route
  path, params = generate(route_key, options, recall)
  return path, params.keys
end
mounted_helpers()

Contains all the mounted helpers across different engines and the `main_app` helper for the application. You can include this in your classes if you want to access routes for other engines.

# File actionpack/lib/action_dispatch/routing/route_set.rb, line 455
def mounted_helpers
  MountedHelpers
end
optimize_routes_generation?()
# File actionpack/lib/action_dispatch/routing/route_set.rb, line 747
def optimize_routes_generation?
  default_url_options.empty?
end
prepend(&block)
# File actionpack/lib/action_dispatch/routing/route_set.rb, line 410
def prepend(&block)
  @prepend << block
end
recognize_path(path, environment = {})
# File actionpack/lib/action_dispatch/routing/route_set.rb, line 803
def recognize_path(path, environment = {})
  method = (environment[:method] || "GET").to_s.upcase
  path = Journey::Router::Utils.normalize_path(path) unless path =~ %r{://}
  extras = environment[:extras] || {}

  begin
    env = Rack::MockRequest.env_for(path, {:method => method})
  rescue URI::InvalidURIError => e
    raise ActionController::RoutingError, e.message
  end

  req = request_class.new(env)
  @router.recognize(req) do |route, params|
    params.merge!(extras)
    params.each do |key, value|
      if value.is_a?(String)
        value = value.dup.force_encoding(Encoding::BINARY)
        params[key] = URI.parser.unescape(value)
      end
    end
    old_params = req.path_parameters
    req.path_parameters = old_params.merge params
    app = route.app
    if app.matches?(req) && app.dispatcher?
      dispatcher = app.app

      if dispatcher.controller(params, false)
        dispatcher.prepare_params!(params)
        return params
      else
        raise ActionController::RoutingError, "A route matches #{path.inspect}, but references missing controller: #{params[:controller].camelize}Controller"
      end
    end
  end

  raise ActionController::RoutingError, "No route matches #{path.inspect}"
end
url_for(options, route_name = nil, url_strategy = UNKNOWN)

The options argument must be a hash whose keys are symbols.

# File actionpack/lib/action_dispatch/routing/route_set.rb, line 760
def url_for(options, route_name = nil, url_strategy = UNKNOWN)
  options = default_url_options.merge options

  user = password = nil

  if options[:user] && options[:password]
    user     = options.delete :user
    password = options.delete :password
  end

  recall  = options.delete(:_recall) { {} }

  original_script_name = options.delete(:original_script_name)
  script_name = find_script_name options

  if original_script_name
    script_name = original_script_name + script_name
  end

  path_options = options.dup
  RESERVED_OPTIONS.each { |ro| path_options.delete ro }

  path, params = generate(route_name, path_options, recall)

  if options.key? :params
    params.merge! options[:params]
  end

  options[:path]        = path
  options[:script_name] = script_name
  options[:params]      = params
  options[:user]        = user
  options[:password]    = password

  url_strategy.call options
end
url_helpers(supports_path = true)
# File actionpack/lib/action_dispatch/routing/route_set.rb, line 476
def url_helpers(supports_path = true)
  routes = self

  Module.new do
    extend ActiveSupport::Concern
    include UrlFor

    # Define url_for in the singleton level so one can do:
    # Rails.application.routes.url_helpers.url_for(args)
    @_routes = routes
    class << self
      delegate :url_for, :optimize_routes_generation?, to: '@_routes'
      attr_reader :_routes
      def url_options; {}; end
    end

    url_helpers = routes.named_routes.url_helpers_module

    # Make named_routes available in the module singleton
    # as well, so one can do:
    # Rails.application.routes.url_helpers.posts_path
    extend url_helpers

    # Any class that includes this module will get all
    # named routes...
    include url_helpers

    if supports_path
      path_helpers = routes.named_routes.path_helpers_module
    else
      path_helpers = routes.named_routes.path_helpers_module(true)
    end

    include path_helpers
    extend path_helpers

    # plus a singleton class method called _routes ...
    included do
      singleton_class.send(:redefine_method, :_routes) { routes }
    end

    # And an instance method _routes. Note that
    # UrlFor (included in this module) add extra
    # conveniences for working with @_routes.
    define_method(:_routes) { @_routes || routes }

    define_method(:_generate_paths_by_default) do
      supports_path
    end
  end
end
url_options()
# File actionpack/lib/action_dispatch/routing/route_set.rb, line 489
def url_options; {}; end