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()
Link
new(request_class = ActionDispatch::Request)
Link
# 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
url_options()
Link
Instance Public methods
add_route(app, conditions = {}, requirements = {}, defaults = {}, name = nil, anchor = true)
Link
# File actionpack/lib/action_dispatch/routing/route_set.rb, line 534 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)
Link
call(env)
Link
clear!()
Link
define_mounted_helper(name)
Link
# 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)
Link
draw(&block)
Link
empty?()
Link
extra_keys(options, recall={})
Link
Generate the path indicated by the arguments, and return an array of the keys that were not used to generate it.
finalize!()
Link
find_script_name(options)
Link
generate_extras(options, recall={})
Link
mounted_helpers()
Link
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.
optimize_routes_generation?()
Link
prepend(&block)
Link
recognize_path(path, environment = {})
Link
# File actionpack/lib/action_dispatch/routing/route_set.rb, line 805 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)
Link
The options
argument must be a hash whose keys are
symbols.
# File actionpack/lib/action_dispatch/routing/route_set.rb, line 762 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)
Link
# 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 private :_generate_paths_by_default end end