Class: ActionDispatch::Routing::RouteSet

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 411

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

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 491

def default_scope
  @config.default_scope
end

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 495

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

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 402

attr_accessor :default_url_options, :draw_paths

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 401

attr_accessor :disable_clear_and_finalize, :resources_path_names

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 402

attr_accessor :default_url_options, :draw_paths

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 714

def empty?
  routes.empty?
end

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 403

attr_reader :env_key, :polymorphic_mappings

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 400

attr_accessor :formatter, :set, :named_routes, :router

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 400

attr_accessor :formatter, :set, :named_routes, :router

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 903

def optimize_routes_generation?
  default_url_options.empty?
end

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 403

attr_reader :env_key, :polymorphic_mappings

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 401

attr_accessor :disable_clear_and_finalize, :resources_path_names

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 400

attr_accessor :formatter, :set, :named_routes, :router

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 405

alias :routes :set

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 400

attr_accessor :formatter, :set, :named_routes, :router

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 718

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

  route
end

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 739

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

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 534

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

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 955

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

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 563

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

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 508

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

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 584

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

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 527

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

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 454

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

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 542

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

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 879

def extra_keys(options, recall = {})
  generate_extras(options, recall).last
end

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 552

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

  url_helpers(true)
  url_helpers(false)
  @finalized = true

  ActiveSupport::Ractors.try_make_shareable(self)
end

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 907

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

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 29

def from_requirements(requirements)
  routes.find { |route| route.requirements == requirements }
end

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 894

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

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 883

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

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 611

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).freeze

    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

    helper_module = self

    # plus a singleton class method called _routes ...
    included do
      redefine_singleton_method(:_routes, &ActiveSupport::Ractors.try_shareable_proc { helper_module._routes })
    end

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

    define_method(:_generate_paths_by_default, ActiveSupport::Ractors.try_shareable_proc { supports_path })

    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

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 37

alias inspect to_s

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 503

def make_request(env)
  request_class.new env
end

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 465

def missing_controller_messages # :nodoc:
  request = request_class.empty

  routes.filter_map do |route|
    next unless route.dispatcher?
    next if StaticDispatcher === route.app

    begin
      request.controller_class_for(route.defaults[:controller])
      nil
    rescue MissingController => error
      message = +"#{route.verb} #{route.path.spec} references a missing controller: #{error.message}"
      message << " (defined at #{route.source_location})" if route.source_location
      message
    end
  end
end

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 580

def mounted_helpers
  MountedHelpers
end

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 911

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

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 538

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

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 964

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

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 979

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

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 483

def relative_url_root
  @config.relative_url_root
end

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 499

def request_class
  ActionDispatch::Request
end

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 916

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

  has_auth = options[:user] && options[:password]

  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 = has_auth ? options.except(:user, :password, *reserved) : options.except(*reserved)
  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

  url_strategy.call options
end

# File 'actionpack/lib/action_dispatch/routing/route_set.rb', line 603

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