jets 1.9.7 → 1.9.8

data/vendor/rails/actionpack/lib/action_dispatch/routing/route_set.rb

@@ -1,890 +0,0 @@
-# frozen_string_literal: true
-
-require "action_dispatch/journey"
-require "active_support/core_ext/object/to_query"
-require "active_support/core_ext/hash/slice"
-require "active_support/core_ext/module/redefine_method"
-require "active_support/core_ext/module/remove_method"
-require "active_support/core_ext/array/extract_options"
-require "action_controller/metal/exceptions"
-require "action_dispatch/http/request"
-require "action_dispatch/routing/endpoint"
-
-module ActionDispatch
-  module Routing
-    # :stopdoc:
-    class RouteSet
-      # Since the router holds references to many parts of the system
-      # like engines, controllers and the application itself, inspecting
-      # the route set can actually be really slow, therefore we default
-      # alias inspect to to_s.
-      alias inspect to_s
-
-      class Dispatcher < Routing::Endpoint
-        def initialize(raise_on_name_error)
-          @raise_on_name_error = raise_on_name_error
-        end
-
-        def dispatcher?; true; end
-
-        def serve(req)
-          params     = req.path_parameters
-          controller = controller req
-          res        = controller.make_response! req
-          dispatch(controller, params[:action], req, res)
-        rescue ActionController::RoutingError
-          if @raise_on_name_error
-            raise
-          else
-            return [404, { "X-Cascade" => "pass" }, []]
-          end
-        end
-
-      private
-
-        def controller(req)
-          req.controller_class
-        rescue NameError => e
-          raise ActionController::RoutingError, e.message, e.backtrace
-        end
-
-        def dispatch(controller, action, req, res)
-          controller.dispatch(action, req, res)
-        end
-      end
-
-      class StaticDispatcher < Dispatcher
-        def initialize(controller_class)
-          super(false)
-          @controller_class = controller_class
-        end
-
-        private
-
-          def controller(_); @controller_class; end
-      end
-
-      # A NamedRouteCollection instance is a collection of named routes, and also
-      # maintains an anonymous module that can be used to install helpers for the
-      # named routes.
-      class NamedRouteCollection
-        include Enumerable
-        attr_reader :routes, :url_helpers_module, :path_helpers_module
-        private :routes
-
-        def initialize
-          @routes = {}
-          @path_helpers = Set.new
-          @url_helpers = Set.new
-          @url_helpers_module  = Module.new
-          @path_helpers_module = Module.new
-        end
-
-        def route_defined?(name)
-          key = name.to_sym
-          @path_helpers.include?(key) || @url_helpers.include?(key)
-        end
-
-        def helper_names
-          @path_helpers.map(&:to_s) + @url_helpers.map(&:to_s)
-        end
-
-        def clear!
-          @path_helpers.each do |helper|
-            @path_helpers_module.send :remove_method, helper
-          end
-
-          @url_helpers.each do |helper|
-            @url_helpers_module.send  :remove_method, helper
-          end
-
-          @routes.clear
-          @path_helpers.clear
-          @url_helpers.clear
-        end
-
-        def add(name, route)
-          key       = name.to_sym
-          path_name = :"#{name}_path"
-          url_name  = :"#{name}_url"
-
-          if routes.key? key
-            @path_helpers_module.send :undef_method, path_name
-            @url_helpers_module.send  :undef_method, url_name
-          end
-          routes[key] = route
-          define_url_helper @path_helpers_module, route, path_name, route.defaults, name, PATH
-          define_url_helper @url_helpers_module,  route, url_name,  route.defaults, name, UNKNOWN
-
-          @path_helpers << path_name
-          @url_helpers << url_name
-        end
-
-        def get(name)
-          routes[name.to_sym]
-        end
-
-        def key?(name)
-          return unless name
-          routes.key? name.to_sym
-        end
-
-        alias []=   add
-        alias []    get
-        alias clear clear!
-
-        def each
-          routes.each { |name, route| yield name, route }
-          self
-        end
-
-        def names
-          routes.keys
-        end
-
-        def length
-          routes.length
-        end
-
-        # Given a +name+, defines name_path and name_url helpers.
-        # Used by 'direct', 'resolve', and 'polymorphic' route helpers.
-        def add_url_helper(name, defaults, &block)
-          helper = CustomUrlHelper.new(name, defaults, &block)
-          path_name = :"#{name}_path"
-          url_name = :"#{name}_url"
-
-          @path_helpers_module.module_eval do
-            define_method(path_name) do |*args|
-              helper.call(self, args, true)
-            end
-          end
-
-          @url_helpers_module.module_eval do
-            define_method(url_name) do |*args|
-              helper.call(self, args, false)
-            end
-          end
-
-          @path_helpers << path_name
-          @url_helpers << url_name
-
-          self
-        end
-
-        class UrlHelper
-          def self.create(route, options, route_name, url_strategy)
-            if optimize_helper?(route)
-              OptimizedUrlHelper.new(route, options, route_name, url_strategy)
-            else
-              new route, options, route_name, url_strategy
-            end
-          end
-
-          def self.optimize_helper?(route)
-            !route.glob? && route.path.requirements.empty?
-          end
-
-          attr_reader :url_strategy, :route_name
-
-          class OptimizedUrlHelper < UrlHelper
-            attr_reader :arg_size
-
-            def initialize(route, options, route_name, url_strategy)
-              super
-              @required_parts = @route.required_parts
-              @arg_size       = @required_parts.size
-            end
-
-            def call(t, args, inner_options)
-              if args.size == arg_size && !inner_options && optimize_routes_generation?(t)
-                options = t.url_options.merge @options
-                options[:path] = optimized_helper(args)
-
-                original_script_name = options.delete(:original_script_name)
-                script_name = t._routes.find_script_name(options)
-
-                if original_script_name
-                  script_name = original_script_name + script_name
-                end
-
-                options[:script_name] = script_name
-
-                url_strategy.call options
-              else
-                super
-              end
-            end
-
-            private
-
-              def optimized_helper(args)
-                params = parameterize_args(args) do
-                  raise_generation_error(args)
-                end
-
-                @route.format params
-              end
-
-              def optimize_routes_generation?(t)
-                t.send(:optimize_routes_generation?)
-              end
-
-              def parameterize_args(args)
-                params = {}
-                @arg_size.times { |i|
-                  key = @required_parts[i]
-                  value = args[i].to_param
-                  yield key if value.nil? || value.empty?
-                  params[key] = value
-                }
-                params
-              end
-
-              def raise_generation_error(args)
-                missing_keys = []
-                params = parameterize_args(args) { |missing_key|
-                  missing_keys << missing_key
-                }
-                constraints = Hash[@route.requirements.merge(params).sort_by { |k, v| k.to_s }]
-                message = "No route matches #{constraints.inspect}".dup
-                message << ", missing required keys: #{missing_keys.sort.inspect}"
-
-                raise ActionController::UrlGenerationError, message
-              end
-          end
-
-          def initialize(route, options, route_name, url_strategy)
-            @options      = options
-            @segment_keys = route.segment_keys.uniq
-            @route        = route
-            @url_strategy = url_strategy
-            @route_name   = route_name
-          end
-
-          def call(t, args, inner_options)
-            controller_options = t.url_options
-            options = controller_options.merge @options
-            hash = handle_positional_args(controller_options,
-                                          inner_options || {},
-                                          args,
-                                          options,
-                                          @segment_keys)
-
-            t._routes.url_for(hash, route_name, url_strategy)
-          end
-
-          def handle_positional_args(controller_options, inner_options, args, result, path_params)
-            if args.size > 0
-              # take format into account
-              if path_params.include?(:format)
-                path_params_size = path_params.size - 1
-              else
-                path_params_size = path_params.size
-              end
-
-              if args.size < path_params_size
-                path_params -= controller_options.keys
-                path_params -= result.keys
-              else
-                path_params = path_params.dup
-              end
-              inner_options.each_key do |key|
-                path_params.delete(key)
-              end
-
-              args.each_with_index do |arg, index|
-                param = path_params[index]
-                result[param] = arg if param
-              end
-            end
-
-            result.merge!(inner_options)
-          end
-        end
-
-        private
-          # Create a URL helper allowing ordered parameters to be associated
-          # with corresponding dynamic segments, so you can do:
-          #
-          #   foo_url(bar, baz, bang)
-          #
-          # Instead of:
-          #
-          #   foo_url(bar: bar, baz: baz, bang: bang)
-          #
-          # Also allow options hash, so you can do:
-          #
-          #   foo_url(bar, baz, bang, sort_by: 'baz')
-          #
-          def define_url_helper(mod, route, name, opts, route_key, url_strategy)
-            helper = UrlHelper.create(route, opts, route_key, url_strategy)
-            mod.module_eval do
-              define_method(name) do |*args|
-                last = args.last
-                options = \
-                  case last
-                  when Hash
-                    args.pop
-                  when ActionController::Parameters
-                    args.pop.to_h
-                  end
-                helper.call self, args, options
-              end
-            end
-          end
-      end
-
-      # strategy for building urls to send to the client
-      PATH    = ->(options) { ActionDispatch::Http::URL.path_for(options) }
-      UNKNOWN = ->(options) { ActionDispatch::Http::URL.url_for(options) }
-
-      attr_accessor :formatter, :set, :named_routes, :default_scope, :router
-      attr_accessor :disable_clear_and_finalize, :resources_path_names
-      attr_accessor :default_url_options
-      attr_reader :env_key, :polymorphic_mappings
-
-      alias :routes :set
-
-      def self.default_resources_path_names
-        { new: "new", edit: "edit" }
-      end
-
-      def self.new_with_config(config)
-        route_set_config = DEFAULT_CONFIG
-
-        # 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
-
-        new route_set_config
-      end
-
-      Config = Struct.new :relative_url_root, :api_only
-
-      DEFAULT_CONFIG = Config.new(nil, false)
-
-      def initialize(config = DEFAULT_CONFIG)
-        self.named_routes = NamedRouteCollection.new
-        self.resources_path_names = self.class.default_resources_path_names
-        self.default_url_options = {}
-
-        @config                     = config
-        @append                     = []
-        @prepend                    = []
-        @disable_clear_and_finalize = false
-        @finalized                  = false
-        @env_key                    = "ROUTES_#{object_id}_SCRIPT_NAME".freeze
-
-        @set    = Journey::Routes.new
-        @router = Journey::Router.new @set
-        @formatter = Journey::Formatter.new self
-        @polymorphic_mappings = {}
-      end
-
-      def eager_load!
-        router.eager_load!
-        routes.each(&:eager_load!)
-        nil
-      end
-
-      def relative_url_root
-        @config.relative_url_root
-      end
-
-      def api_only?
-        @config.api_only
-      end
-
-      def request_class
-        ActionDispatch::Request
-      end
-
-      def make_request(env)
-        request_class.new env
-      end
-      private :make_request
-
-      def draw(&block)
-        clear! unless @disable_clear_and_finalize
-        eval_block(block)
-        finalize! unless @disable_clear_and_finalize
-        nil
-      end
-
-      def append(&block)
-        @append << block
-      end
-
-      def prepend(&block)
-        @prepend << block
-      end
-
-      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
-      private :eval_block
-
-      def finalize!
-        return if @finalized
-        @append.each { |blk| eval_block(blk) }
-        @finalized = true
-      end
-
-      def clear!
-        @finalized = false
-        named_routes.clear
-        set.clear
-        formatter.clear
-        @polymorphic_mappings.clear
-        @prepend.each { |blk| eval_block(blk) }
-      end
-
-      module MountedHelpers
-        extend ActiveSupport::Concern
-        include UrlFor
-      end
-
-      # 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.
-      def mounted_helpers
-        MountedHelpers
-      end
-
-      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 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)
-          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
-        end
-      end
-
-      def empty?
-        routes.empty?
-      end
-
-      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" \
-            "http://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)
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            Using a dynamic :controller segment in a route is deprecated and
-            will be removed in Rails 6.0.
-          MSG
-        end
-
-        if route.segment_keys.include?(:action)
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            Using a dynamic :action segment in a route is deprecated and
-            will be removed in Rails 6.0.
-          MSG
-        end
-
-        route
-      end
-
-      def add_polymorphic_mapping(klass, options, &block)
-        @polymorphic_mappings[klass] = CustomUrlHelper.new(klass, options, &block)
-      end
-
-      def add_url_helper(name, options, &block)
-        named_routes.add_url_helper(name, options, &block)
-      end
-
-      class CustomUrlHelper
-        attr_reader :name, :defaults, :block
-
-        def initialize(name, defaults, &block)
-          @name = name
-          @defaults = defaults
-          @block = block
-        end
-
-        def call(t, args, only_path = false)
-          options = args.extract_options!
-          url = t.full_url_for(eval_block(t, args, options))
-
-          if only_path
-            "/" + url.partition(%r{(?<!/)/(?!/)}).last
-          else
-            url
-          end
-        end
-
-        private
-          def eval_block(t, args, options)
-            t.instance_exec(*args, merge_defaults(options), &block)
-          end
-
-          def merge_defaults(options)
-            defaults ? defaults.merge(options) : options
-          end
-      end
-
-      class Generator
-        PARAMETERIZE = lambda do |name, value|
-          if name == :controller
-            value
-          else
-            value.to_param
-          end
-        end
-
-        attr_reader :options, :recall, :set, :named_route
-
-        def initialize(named_route, options, recall, set)
-          @named_route = named_route
-          @options     = options
-          @recall      = recall
-          @set         = set
-
-          normalize_options!
-          normalize_controller_action_id!
-          use_relative_controller!
-          normalize_controller!
-        end
-
-        def controller
-          @options[:controller]
-        end
-
-        def current_controller
-          @recall[:controller]
-        end
-
-        def use_recall_for(key)
-          if @recall[key] && (!@options.key?(key) || @options[key] == @recall[key])
-            if !named_route_exists? || segment_keys.include?(key)
-              @options[key] = @recall[key]
-            end
-          end
-        end
-
-        def normalize_options!
-          # If an explicit :controller was given, always make :action explicit
-          # too, so that action expiry works as expected for things like
-          #
-          #   generate({controller: 'content'}, {controller: 'content', action: 'show'})
-          #
-          # (the above is from the unit tests). In the above case, because the
-          # controller was explicitly given, but no action, the action is implied to
-          # be "index", not the recalled action of "show".
-
-          if options[:controller]
-            options[:action]     ||= "index"
-            options[:controller]   = options[:controller].to_s
-          end
-
-          if options.key?(:action)
-            options[:action] = (options[:action] || "index").to_s
-          end
-        end
-
-        # This pulls :controller, :action, and :id out of the recall.
-        # The recall key is only used if there is no key in the options
-        # or if the key in the options is identical. If any of
-        # :controller, :action or :id is not found, don't pull any
-        # more keys from the recall.
-        def normalize_controller_action_id!
-          use_recall_for(:controller) || return
-          use_recall_for(:action) || return
-          use_recall_for(:id)
-        end
-
-        # if the current controller is "foo/bar/baz" and controller: "baz/bat"
-        # is specified, the controller becomes "foo/baz/bat"
-        def use_relative_controller!
-          if !named_route && different_controller? && !controller.start_with?("/")
-            old_parts = current_controller.split("/")
-            size = controller.count("/") + 1
-            parts = old_parts[0...-size] << controller
-            @options[:controller] = parts.join("/")
-          end
-        end
-
-        # Remove leading slashes from controllers
-        def normalize_controller!
-          if controller
-            if controller.start_with?("/".freeze)
-              @options[:controller] = controller[1..-1]
-            else
-              @options[:controller] = controller
-            end
-          end
-        end
-
-        # Generates a path from routes, returns [path, params].
-        # If no route is generated the formatter will raise ActionController::UrlGenerationError
-        def generate
-          @set.formatter.generate(named_route, options, recall, PARAMETERIZE)
-        end
-
-        def different_controller?
-          return false unless current_controller
-          controller.to_param != current_controller.to_param
-        end
-
-        private
-          def named_route_exists?
-            named_route && set.named_routes[named_route]
-          end
-
-          def segment_keys
-            set.named_routes[named_route].segment_keys
-          end
-      end
-
-      # Generate the path indicated by the arguments, and return an array of
-      # the keys that were not used to generate it.
-      def extra_keys(options, recall = {})
-        generate_extras(options, recall).last
-      end
-
-      def generate_extras(options, recall = {})
-        route_key = options.delete :use_route
-        path, params = generate(route_key, options, recall)
-        return path, params.keys
-      end
-
-      def generate(route_key, options, recall = {})
-        Generator.new(route_key, options, recall, self).generate
-      end
-      private :generate
-
-      RESERVED_OPTIONS = [:host, :protocol, :port, :subdomain, :domain, :tld_length,
-                          :trailing_slash, :anchor, :params, :only_path, :script_name,
-                          :original_script_name, :relative_url_root]
-
-      def optimize_routes_generation?
-        default_url_options.empty?
-      end
-
-      def find_script_name(options)
-        options.delete(:script_name) || find_relative_url_root(options) || ""
-      end
-
-      def find_relative_url_root(options)
-        options.delete(:relative_url_root) || relative_url_root
-      end
-
-      def path_for(options, route_name = nil)
-        url_for(options, route_name, PATH)
-      end
-
-      # The +options+ argument must be a hash whose keys are *symbols*.
-      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
-
-      def call(env)
-        req = make_request(env)
-        req.path_info = Journey::Router::Utils.normalize_path(req.path_info)
-        @router.serve(req)
-      end
-
-      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 = make_request(env)
-        recognize_path_with_request(req, path, extras)
-      end
-
-      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.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
-    end
-    # :startdoc:
-  end
-end