class ActionDispatch::Routing::RouteSet

typically defined in ‘config/routes.rb`.
The RouteSet contains a collection of Route instances, representing the routes

def self.default_resources_path_names

def self.default_resources_path_names
  { new: "new", edit: "edit" }
end

def self.included(base)

inclusion of each copy.
inclusion, whereas the above `included` block is run only for the initial
module (recursively if necessary). Note that this method is called for each
instance methods return the desired route set by including a new copy of the
ancestor that includes the module), ensure that the `_routes` singleton and
If the module is included more than once (for example, in a subclass of an
def self.included(base)
  super
  if base.respond_to?(:_routes) && !base._routes.equal?(@_proxy._routes)
    @dup_for_reinclude ||= self.dup
    base.include @dup_for_reinclude
  end
end

def self.new_with_config(config)

def self.new_with_config(config)
  route_set_config = DEFAULT_CONFIG.dup
  # engines apparently don't have this set
  if config.respond_to? :relative_url_root
    route_set_config.relative_url_root = config.relative_url_root
  end
  if config.respond_to? :api_only
    route_set_config.api_only = config.api_only
  end
  if config.respond_to? :default_scope
    route_set_config.default_scope = config.default_scope
  end
  new route_set_config
end

def _routes; @_proxy._routes; end

def _routes; @_proxy._routes; end

def add_polymorphic_mapping(klass, options, &block)

def add_polymorphic_mapping(klass, options, &block)
  @polymorphic_mappings[klass] = CustomUrlHelper.new(klass, options, &block)
end

def add_route(mapping, name)

def add_route(mapping, name)
  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" \
      "https://guides.rubyonrails.org/routing.html#restricting-the-routes-created"
  end
  route = @set.add_route(name, mapping)
  named_routes[name] = route if name
  if route.segment_keys.include?(:controller)
    ActionDispatch.deprecator.warn(<<-MSG.squish)
      Using a dynamic :controller segment in a route is deprecated and
      will be removed in Rails 8.1.
    MSG
  end
  if route.segment_keys.include?(:action)
    ActionDispatch.deprecator.warn(<<-MSG.squish)
      Using a dynamic :action segment in a route is deprecated and
      will be removed in Rails 8.1.
    MSG
  end
  route
end

def add_url_helper(name, options, &block)

def add_url_helper(name, options, &block)
  named_routes.add_url_helper(name, options, &block)
end

def api_only?

def api_only?
  @config.api_only
end

def append(&block)

def append(&block)
  @append << block
end

def call(env)

def call(env)
  req = make_request(env)
  req.path_info = Journey::Router::Utils.normalize_path(req.path_info)
  @router.serve(req)
end

def clear!

def clear!
  @finalized = false
  named_routes.clear
  set.clear
  formatter.clear
  @polymorphic_mappings.clear
  @prepend.each { |blk| eval_block(blk) }
end

def default_env

def default_env
  if default_url_options != @default_env&.[]("action_dispatch.routes.default_url_options")
    url_options = default_url_options.dup.freeze
    uri = URI(ActionDispatch::Http::URL.full_url_for(host: "example.org", **url_options))
    @default_env = {
      "action_dispatch.routes" => self,
      "action_dispatch.routes.default_url_options" => url_options,
      "HTTPS" => uri.scheme == "https" ? "on" : "off",
      "rack.url_scheme" => uri.scheme,
      "HTTP_HOST" => uri.port == uri.default_port ? uri.host : "#{uri.host}:#{uri.port}",
      "SCRIPT_NAME" => uri.path.chomp("/"),
      "rack.input" => "",
    }.freeze
  end
  @default_env
end

def default_scope

def default_scope
  @config.default_scope
end

def default_scope=(new_default_scope)

def default_scope=(new_default_scope)
  @config.default_scope = new_default_scope
end

def define_mounted_helper(name, script_namer = nil)

def define_mounted_helper(name, script_namer = nil)
  return if MountedHelpers.method_defined?(name)
  routes = self
  helpers = routes.url_helpers
  MountedHelpers.class_eval do
    define_method "_#{name}" do
      RoutesProxy.new(routes, _routes_context, helpers, script_namer)
    end
  end
  MountedHelpers.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
    def #{name}
      @_#{name} ||= _#{name}
    end
  RUBY
end

def draw(&block)

def draw(&block)
  clear! unless @disable_clear_and_finalize
  eval_block(block)
  finalize! unless @disable_clear_and_finalize
  nil
end

def eager_load!

def eager_load!
  router.eager_load!
  routes.each(&:eager_load!)
  formatter.eager_load!
  nil
end

def empty?

def empty?
  routes.empty?
end

def eval_block(block)

def eval_block(block)
  mapper = Mapper.new(self)
  if default_scope
    mapper.with_default_scope(default_scope, &block)
  else
    mapper.instance_exec(&block)
  end
end

def extra_keys(options, recall = {})

that were not used to generate it.
Generate the path indicated by the arguments, and return an array of the keys
def extra_keys(options, recall = {})
  generate_extras(options, recall).last
end

def finalize!

def finalize!
  return if @finalized
  @append.each { |blk| eval_block(blk) }
  @finalized = true
end

def find_script_name(options)

def find_script_name(options)
  options.delete(:script_name) || relative_url_root || ""
end

def from_requirements(requirements)

Rails.application.routes.from_requirements(controller: "posts", action: "show")

Then the following will return the Route for the `show` action:

resources :posts

Given the routes are defined as:

This is intended for use by tools such as Language Servers.

Returns a Route matching the given requirements, or `nil` if none are found.
def from_requirements(requirements)
  routes.find { |route| route.requirements == requirements }
end

def full_url_for(options)

def full_url_for(options)
  @_proxy.full_url_for(options)
end

def generate(route_name, options, recall = {}, method_name = nil)

def generate(route_name, options, recall = {}, method_name = nil)
  Generator.new(route_name, options, recall, self).generate
end

def generate_extras(options, recall = {})

def generate_extras(options, recall = {})
  if recall
    options = options.merge(_recall: recall)
  end
  route_name = options.delete :use_route
  generator = generate(route_name, options, recall)
  path_info = path_for(options, route_name, [])
  [URI(path_info).path, generator.params.except(:_recall).keys]
end

def generate_url_helpers(supports_path)

def generate_url_helpers(supports_path)
  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)
    proxy_class = Class.new do
      include UrlFor
      include routes.named_routes.path_helpers_module
      include routes.named_routes.url_helpers_module
      attr_reader :_routes
      def initialize(routes)
        @_routes = routes
      end
      def optimize_routes_generation?
        @_routes.optimize_routes_generation?
      end
    end
    @_proxy = proxy_class.new(routes)
    class << self
      def url_for(options)
        @_proxy.url_for(options)
      end
      def full_url_for(options)
        @_proxy.full_url_for(options)
      end
      def route_for(name, *args)
        @_proxy.route_for(name, *args)
      end
      def optimize_routes_generation?
        @_proxy.optimize_routes_generation?
      end
      def polymorphic_url(record_or_hash_or_array, options = {})
        @_proxy.polymorphic_url(record_or_hash_or_array, options)
      end
      def polymorphic_path(record_or_hash_or_array, options = {})
        @_proxy.polymorphic_path(record_or_hash_or_array, options)
      end
      def _routes; @_proxy._routes; end
      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
      include path_helpers
      extend path_helpers
    end
    # plus a singleton class method called _routes ...
    included do
      redefine_singleton_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
    # If the module is included more than once (for example, in a subclass of an
    # ancestor that includes the module), ensure that the `_routes` singleton and
    # instance methods return the desired route set by including a new copy of the
    # module (recursively if necessary). Note that this method is called for each
    # inclusion, whereas the above `included` block is run only for the initial
    # inclusion of each copy.
    def self.included(base)
      super
      if base.respond_to?(:_routes) && !base._routes.equal?(@_proxy._routes)
        @dup_for_reinclude ||= self.dup
        base.include @dup_for_reinclude
      end
    end
  end
end

def initialize(config = DEFAULT_CONFIG.dup)

def initialize(config = DEFAULT_CONFIG.dup)
  self.named_routes = NamedRouteCollection.new
  self.resources_path_names = self.class.default_resources_path_names
  self.default_url_options = {}
  self.draw_paths = []
  @config                     = config
  @append                     = []
  @prepend                    = []
  @disable_clear_and_finalize = false
  @finalized                  = false
  @env_key                    = "ROUTES_#{object_id}_SCRIPT_NAME"
  @default_env                = nil
  @set    = Journey::Routes.new
  @router = Journey::Router.new @set
  @formatter = Journey::Formatter.new self
  @polymorphic_mappings = {}
end

def initialize(routes)

def initialize(routes)
  @_routes = routes
end

def make_request(env)

def make_request(env)
  request_class.new env
end

def mounted_helpers

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

def optimize_routes_generation?

def optimize_routes_generation?
  @_routes.optimize_routes_generation?
end

def optimize_routes_generation?

def optimize_routes_generation?
  @_proxy.optimize_routes_generation?
end

def optimize_routes_generation?

def optimize_routes_generation?
  default_url_options.empty?
end

def path_for(options, route_name = nil, reserved = RESERVED_OPTIONS)

def path_for(options, route_name = nil, reserved = RESERVED_OPTIONS)
  url_for(options, route_name, PATH, nil, reserved)
end

def polymorphic_path(record_or_hash_or_array, options = {})

def polymorphic_path(record_or_hash_or_array, options = {})
  @_proxy.polymorphic_path(record_or_hash_or_array, options)
end

def polymorphic_url(record_or_hash_or_array, options = {})

def polymorphic_url(record_or_hash_or_array, options = {})
  @_proxy.polymorphic_url(record_or_hash_or_array, options)
end

def prepend(&block)

def prepend(&block)
  @prepend << block
end

def recognize_path(path, environment = {})

def recognize_path(path, environment = {})
  method = (environment[:method] || "GET").to_s.upcase
  path = Journey::Router::Utils.normalize_path(path) unless path&.include?("://")
  extras = environment[:extras] || {}
  begin
    env = Rack::MockRequest.env_for(path, method: method)
  rescue URI::InvalidURIError => e
    raise ActionController::RoutingError, e.message
  end
  req = make_request(env)
  recognize_path_with_request(req, path, extras)
end

def recognize_path_with_request(req, path, extras, raise_on_missing: true)

def recognize_path_with_request(req, path, extras, raise_on_missing: true)
  @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::RFC2396_PARSER.unescape(value)
      end
    end
    req.path_parameters = params
    app = route.app
    if app.matches?(req) && app.dispatcher?
      begin
        req.controller_class
      rescue NameError
        raise ActionController::RoutingError, "A route matches #{path.inspect}, but references missing controller: #{params[:controller].camelize}Controller"
      end
      return req.path_parameters
    elsif app.matches?(req) && app.engine?
      path_parameters = app.rack_app.routes.recognize_path_with_request(req, path, extras, raise_on_missing: false)
      return path_parameters if path_parameters
    end
  end
  if raise_on_missing
    raise ActionController::RoutingError, "No route matches #{path.inspect}"
  end
end

def relative_url_root

def relative_url_root
  @config.relative_url_root
end

def request_class

def request_class
  ActionDispatch::Request
end

def route_for(name, *args)

def route_for(name, *args)
  @_proxy.route_for(name, *args)
end

def url_for(options)

def url_for(options)
  @_proxy.url_for(options)
end

def url_for(options, route_name = nil, url_strategy = UNKNOWN, method_name = nil, reserved = RESERVED_OPTIONS)

The `options` argument must be a hash whose keys are **symbols**.
def url_for(options, route_name = nil, url_strategy = UNKNOWN, method_name = nil, reserved = RESERVED_OPTIONS)
  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.each { |ro| path_options.delete ro }
  route_with_params = generate(route_name, path_options, recall)
  path = route_with_params.path(method_name)
  if options[:trailing_slash] && !options[:format] && !path.end_with?("/")
    path += "/"
  end
  params = route_with_params.params
  if options.key? :params
    if options[:params].respond_to?(:to_hash)
      params.merge! options[:params]
    else
      params[:params] = options[:params]
    end
  end
  options[:path]        = path
  options[:script_name] = script_name
  options[:params]      = params
  options[:user]        = user
  options[:password]    = password
  url_strategy.call options
end

def url_helpers(supports_path = true)

def url_helpers(supports_path = true)
  if supports_path
    @url_helpers_with_paths ||= generate_url_helpers(true)
  else
    @url_helpers_without_paths ||= generate_url_helpers(false)
  end
end

def url_options; {}; end

def url_options; {}; end