actionpack 7.1.5.1 → 8.1.2

data/lib/action_dispatch/http/url.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 require "active_support/core_ext/module/attribute_accessors"
 
 module ActionDispatch
@@ -9,26 +11,123 @@ module ActionDispatch
       HOST_REGEXP     = /(^[^:]+:\/\/)?(\[[^\]]+\]|[^:]+)(?::(\d+$))?/
       PROTOCOL_REGEXP = /^([^:]+)(:)?(\/\/)?$/
 
+      # DomainExtractor provides utility methods for extracting domain and subdomain
+      # information from host strings. This module is used internally by Action Dispatch
+      # to parse host names and separate the domain from subdomains based on the
+      # top-level domain (TLD) length.
+      #
+      # The module assumes a standard domain structure where domains consist of:
+      # - Subdomains (optional, can be multiple levels)
+      # - Domain name
+      # - Top-level domain (TLD, can be multiple levels like .co.uk)
+      #
+      # For example, in "api.staging.example.co.uk":
+      # - Subdomains: ["api", "staging"]
+      # - Domain: "example.co.uk" (with tld_length=2)
+      # - TLD: "co.uk"
+      module DomainExtractor
+        extend self
+
+        # Extracts the domain part from a host string, including the specified
+        # number of top-level domain components.
+        #
+        # The domain includes the main domain name plus the TLD components.
+        # The +tld_length+ parameter specifies how many components from the right
+        # should be considered part of the TLD.
+        #
+        # ==== Parameters
+        #
+        # [+host+]
+        #   The host string to extract the domain from.
+        #
+        # [+tld_length+]
+        #   The number of domain components that make up the TLD. For example,
+        #   use 1 for ".com" or 2 for ".co.uk".
+        #
+        # ==== Examples
+        #
+        #   # Standard TLD (tld_length = 1)
+        #   DomainExtractor.domain_from("www.example.com", 1)
+        #   # => "example.com"
+        #
+        #   # Country-code TLD (tld_length = 2)
+        #   DomainExtractor.domain_from("www.example.co.uk", 2)
+        #   # => "example.co.uk"
+        #
+        #   # Multiple subdomains
+        #   DomainExtractor.domain_from("api.staging.myapp.herokuapp.com", 1)
+        #   # => "herokuapp.com"
+        #
+        #   # Single component (returns the host itself)
+        #   DomainExtractor.domain_from("localhost", 1)
+        #   # => "localhost"
+        def domain_from(host, tld_length)
+          host.split(".").last(1 + tld_length).join(".")
+        end
+
+        # Extracts the subdomain components from a host string as an Array.
+        #
+        # Returns all the components that come before the domain and TLD parts.
+        # The +tld_length+ parameter is used to determine where the domain begins
+        # so that everything before it is considered a subdomain.
+        #
+        # ==== Parameters
+        #
+        # [+host+]
+        #   The host string to extract subdomains from.
+        #
+        # [+tld_length+]
+        #   The number of domain components that make up the TLD. This affects
+        #   where the domain boundary is calculated.
+        #
+        # ==== Examples
+        #
+        #   # Standard TLD (tld_length = 1)
+        #   DomainExtractor.subdomains_from("www.example.com", 1)
+        #   # => ["www"]
+        #
+        #   # Country-code TLD (tld_length = 2)
+        #   DomainExtractor.subdomains_from("api.staging.example.co.uk", 2)
+        #   # => ["api", "staging"]
+        #
+        #   # No subdomains
+        #   DomainExtractor.subdomains_from("example.com", 1)
+        #   # => []
+        #
+        #   # Single subdomain with complex TLD
+        #   DomainExtractor.subdomains_from("www.mysite.co.uk", 2)
+        #   # => ["www"]
+        #
+        #   # Multiple levels of subdomains
+        #   DomainExtractor.subdomains_from("dev.api.staging.example.com", 1)
+        #   # => ["dev", "api", "staging"]
+        def subdomains_from(host, tld_length)
+          parts = host.split(".")
+          parts[0..-(tld_length + 2)]
+        end
+      end
+
       mattr_accessor :secure_protocol, default: false
       mattr_accessor :tld_length, default: 1
+      mattr_accessor :domain_extractor, default: DomainExtractor
 
       class << self
         # Returns the domain part of a host given the domain level.
         #
-        #    # Top-level domain example
-        #    extract_domain('www.example.com', 1) # => "example.com"
-        #    # Second-level domain example
-        #    extract_domain('dev.www.example.co.uk', 2) # => "example.co.uk"
+        #     # Top-level domain example
+        #     extract_domain('www.example.com', 1) # => "example.com"
+        #     # Second-level domain example
+        #     extract_domain('dev.www.example.co.uk', 2) # => "example.co.uk"
         def extract_domain(host, tld_length)
           extract_domain_from(host, tld_length) if named_host?(host)
         end
 
         # Returns the subdomains of a host as an Array given the domain level.
         #
-        #    # Top-level domain example
-        #    extract_subdomains('www.example.com', 1) # => ["www"]
-        #    # Second-level domain example
-        #    extract_subdomains('dev.www.example.co.uk', 2) # => ["dev", "www"]
+        #     # Top-level domain example
+        #     extract_subdomains('www.example.com', 1) # => ["www"]
+        #     # Second-level domain example
+        #     extract_subdomains('dev.www.example.co.uk', 2) # => ["dev", "www"]
         def extract_subdomains(host, tld_length)
           if named_host?(host)
             extract_subdomains_from(host, tld_length)
@@ -39,10 +138,10 @@ module ActionDispatch
 
         # Returns the subdomains of a host as a String given the domain level.
         #
-        #    # Top-level domain example
-        #    extract_subdomain('www.example.com', 1) # => "www"
-        #    # Second-level domain example
-        #    extract_subdomain('dev.www.example.co.uk', 2) # => "dev.www"
+        #     # Top-level domain example
+        #     extract_subdomain('www.example.com', 1) # => "www"
+        #     # Second-level domain example
+        #     extract_subdomain('dev.www.example.co.uk', 2) # => "dev.www"
         def extract_subdomain(host, tld_length)
           extract_subdomains(host, tld_length).join(".")
         end
@@ -94,34 +193,33 @@ module ActionDispatch
           end
 
           def extract_domain_from(host, tld_length)
-            host.split(".").last(1 + tld_length).join(".")
+            domain_extractor.domain_from(host, tld_length)
           end
 
           def extract_subdomains_from(host, tld_length)
-            parts = host.split(".")
-            parts[0..-(tld_length + 2)]
+            domain_extractor.subdomains_from(host, tld_length)
           end
 
           def build_host_url(host, port, protocol, options, path)
             if match = host.match(HOST_REGEXP)
-              protocol ||= match[1] unless protocol == false
-              host       = match[2]
-              port       = match[3] unless options.key? :port
+              protocol_from_host = match[1] if protocol.nil?
+              host               = match[2]
+              port               = match[3] unless options.key? :port
             end
 
-            protocol = normalize_protocol protocol
+            protocol = protocol_from_host || normalize_protocol(protocol).dup
             host     = normalize_host(host, options)
+            port     = normalize_port(port, protocol)
 
-            result = protocol.dup
+            result = protocol
 
             if options[:user] && options[:password]
               result << "#{Rack::Utils.escape(options[:user])}:#{Rack::Utils.escape(options[:password])}@"
             end
 
             result << host
-            normalize_port(port, protocol) { |normalized_port|
-              result << ":#{normalized_port}"
-            }
+
+            result << ":" << port.to_s if port
 
             result.concat path
           end
@@ -167,11 +265,11 @@ module ActionDispatch
             return unless port
 
             case protocol
-            when "//" then yield port
+            when "//" then port
             when "https://"
-              yield port unless port.to_i == 443
+              port unless port.to_i == 443
             else
-              yield port unless port.to_i == 80
+              port unless port.to_i == 80
             end
           end
       end
@@ -184,33 +282,33 @@ module ActionDispatch
 
       # Returns the complete URL used for this request.
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com'
-      #   req.url # => "http://example.com"
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com'
+      #     req.url # => "http://example.com"
       def url
         protocol + host_with_port + fullpath
       end
 
       # Returns 'https://' if this is an SSL request and 'http://' otherwise.
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com'
-      #   req.protocol # => "http://"
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com'
+      #     req.protocol # => "http://"
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com', 'HTTPS' => 'on'
-      #   req.protocol # => "https://"
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com', 'HTTPS' => 'on'
+      #     req.protocol # => "https://"
       def protocol
         @protocol ||= ssl? ? "https://" : "http://"
       end
 
-      # Returns the \host and port for this request, such as "example.com:8080".
+      # Returns the host and port for this request, such as "example.com:8080".
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com'
-      #   req.raw_host_with_port # => "example.com"
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com'
+      #     req.raw_host_with_port # => "example.com"
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:80'
-      #   req.raw_host_with_port # => "example.com:80"
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:80'
+      #     req.raw_host_with_port # => "example.com:80"
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
-      #   req.raw_host_with_port # => "example.com:8080"
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
+      #     req.raw_host_with_port # => "example.com:8080"
       def raw_host_with_port
         if forwarded = x_forwarded_host.presence
           forwarded.split(/,\s?/).last
@@ -221,35 +319,35 @@ module ActionDispatch
 
       # Returns the host for this request, such as "example.com".
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
-      #   req.host # => "example.com"
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
+      #     req.host # => "example.com"
       def host
         raw_host_with_port.sub(/:\d+$/, "")
       end
 
-      # Returns a \host:\port string for this request, such as "example.com" or
-      # "example.com:8080". Port is only included if it is not a default port
-      # (80 or 443)
+      # Returns a host:port string for this request, such as "example.com" or
+      # "example.com:8080". Port is only included if it is not a default port (80 or
+      # 443)
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com'
-      #   req.host_with_port # => "example.com"
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com'
+      #     req.host_with_port # => "example.com"
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:80'
-      #   req.host_with_port # => "example.com"
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:80'
+      #     req.host_with_port # => "example.com"
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
-      #   req.host_with_port # => "example.com:8080"
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
+      #     req.host_with_port # => "example.com:8080"
       def host_with_port
         "#{host}#{port_string}"
       end
 
       # Returns the port number of this request as an integer.
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com'
-      #   req.port # => 80
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com'
+      #     req.port # => 80
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
-      #   req.port # => 8080
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
+      #     req.port # => 8080
       def port
         @port ||= if raw_host_with_port =~ /:(\d+)$/
           $1.to_i
@@ -258,10 +356,10 @@ module ActionDispatch
         end
       end
 
-      # Returns the standard \port number for this request's protocol.
+      # Returns the standard port number for this request's protocol.
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
-      #   req.standard_port # => 80
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
+      #     req.standard_port # => 80
       def standard_port
         if "https://" == protocol
           443
@@ -270,70 +368,70 @@ module ActionDispatch
         end
       end
 
-      # Returns whether this request is using the standard port
+      # Returns whether this request is using the standard port.
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:80'
-      #   req.standard_port? # => true
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:80'
+      #     req.standard_port? # => true
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
-      #   req.standard_port? # => false
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
+      #     req.standard_port? # => false
       def standard_port?
         port == standard_port
       end
 
-      # Returns a number \port suffix like 8080 if the \port number of this request
-      # is not the default HTTP \port 80 or HTTPS \port 443.
+      # Returns a number port suffix like 8080 if the port number of this request is
+      # not the default HTTP port 80 or HTTPS port 443.
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:80'
-      #   req.optional_port # => nil
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:80'
+      #     req.optional_port # => nil
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
-      #   req.optional_port # => 8080
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
+      #     req.optional_port # => 8080
       def optional_port
         standard_port? ? nil : port
       end
 
-      # Returns a string \port suffix, including colon, like ":8080" if the \port
-      # number of this request is not the default HTTP \port 80 or HTTPS \port 443.
+      # Returns a string port suffix, including colon, like ":8080" if the port number
+      # of this request is not the default HTTP port 80 or HTTPS port 443.
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:80'
-      #   req.port_string # => ""
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:80'
+      #     req.port_string # => ""
       #
-      #   req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
-      #   req.port_string # => ":8080"
+      #     req = ActionDispatch::Request.new 'HTTP_HOST' => 'example.com:8080'
+      #     req.port_string # => ":8080"
       def port_string
         standard_port? ? "" : ":#{port}"
       end
 
-      # Returns the requested port, such as 8080, based on SERVER_PORT
+      # Returns the requested port, such as 8080, based on SERVER_PORT.
       #
-      #   req = ActionDispatch::Request.new 'SERVER_PORT' => '80'
-      #   req.server_port # => 80
+      #     req = ActionDispatch::Request.new 'SERVER_PORT' => '80'
+      #     req.server_port # => 80
       #
-      #   req = ActionDispatch::Request.new 'SERVER_PORT' => '8080'
-      #   req.server_port # => 8080
+      #     req = ActionDispatch::Request.new 'SERVER_PORT' => '8080'
+      #     req.server_port # => 8080
       def server_port
         get_header("SERVER_PORT").to_i
       end
 
-      # Returns the \domain part of a \host, such as "rubyonrails.org" in "www.rubyonrails.org". You can specify
-      # a different <tt>tld_length</tt>, such as 2 to catch rubyonrails.co.uk in "www.rubyonrails.co.uk".
+      # Returns the domain part of a host, such as "rubyonrails.org" in
+      # "www.rubyonrails.org". You can specify a different `tld_length`, such as 2 to
+      # catch rubyonrails.co.uk in "www.rubyonrails.co.uk".
       def domain(tld_length = @@tld_length)
         ActionDispatch::Http::URL.extract_domain(host, tld_length)
       end
 
-      # Returns all the \subdomains as an array, so <tt>["dev", "www"]</tt> would be
-      # returned for "dev.www.rubyonrails.org". You can specify a different <tt>tld_length</tt>,
-      # such as 2 to catch <tt>["www"]</tt> instead of <tt>["www", "rubyonrails"]</tt>
-      # in "www.rubyonrails.co.uk".
+      # Returns all the subdomains as an array, so `["dev", "www"]` would be returned
+      # for "dev.www.rubyonrails.org". You can specify a different `tld_length`, such
+      # as 2 to catch `["www"]` instead of `["www", "rubyonrails"]` in
+      # "www.rubyonrails.co.uk".
       def subdomains(tld_length = @@tld_length)
         ActionDispatch::Http::URL.extract_subdomains(host, tld_length)
       end
 
-      # Returns all the \subdomains as a string, so <tt>"dev.www"</tt> would be
-      # returned for "dev.www.rubyonrails.org". You can specify a different <tt>tld_length</tt>,
-      # such as 2 to catch <tt>"www"</tt> instead of <tt>"www.rubyonrails"</tt>
-      # in "www.rubyonrails.co.uk".
+      # Returns all the subdomains as a string, so `"dev.www"` would be returned for
+      # "dev.www.rubyonrails.org". You can specify a different `tld_length`, such as 2
+      # to catch `"www"` instead of `"www.rubyonrails"` in "www.rubyonrails.co.uk".
       def subdomain(tld_length = @@tld_length)
         ActionDispatch::Http::URL.extract_subdomain(host, tld_length)
       end

data/lib/action_dispatch/journey/formatter.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 require "action_controller/metal/exceptions"
 
 module ActionDispatch
   # :stopdoc:
   module Journey
     # The Formatter class is used for formatting URLs. For example, parameters
-    # passed to +url_for+ in Rails will eventually call Formatter#generate.
+    # passed to `url_for` in Rails will eventually call Formatter#generate.
     class Formatter
       attr_reader :routes
 
@@ -58,26 +60,31 @@ module ActionDispatch
 
       def generate(name, options, path_parameters)
         original_options = options.dup
-        path_params = options.delete(:path_params) || {}
-        options = path_params.merge(options)
+        path_params = options.delete(:path_params)
+        if path_params.is_a?(Hash)
+          options = path_params.merge(options)
+        else
+          path_params = nil
+          options = options.dup
+        end
         constraints = path_parameters.merge(options)
         missing_keys = nil
 
         match_route(name, constraints) do |route|
           parameterized_parts = extract_parameterized_parts(route, options, path_parameters)
 
-          # Skip this route unless a name has been provided or it is a
-          # standard Rails route since we can't determine whether an options
-          # hash passed to url_for matches a Rack application or a redirect.
+          # Skip this route unless a name has been provided or it is a standard Rails
+          # route since we can't determine whether an options hash passed to url_for
+          # matches a Rack application or a redirect.
           next unless name || route.dispatcher?
 
           missing_keys = missing_keys(route, parameterized_parts)
           next if missing_keys && !missing_keys.empty?
           params = options.delete_if do |key, _|
-            # top-level params' normal behavior of generating query_params
-            # should be preserved even if the same key is also a bind_param
+            # top-level params' normal behavior of generating query_params should be
+            # preserved even if the same key is also a bind_param
             parameterized_parts.key?(key) || route.defaults.key?(key) ||
-              (path_params.key?(key) && !original_options.key?(key))
+              (path_params&.key?(key) && !original_options.key?(key))
           end
 
           defaults       = route.defaults
@@ -104,6 +111,11 @@ module ActionDispatch
         @cache = nil
       end
 
+      def eager_load!
+        cache
+        nil
+      end
+
       private
         def extract_parameterized_parts(route, options, recall)
           parameterized_parts = recall.merge(options)

data/lib/action_dispatch/journey/gtg/builder.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 require "action_dispatch/journey/gtg/transition_table"
 
 module ActionDispatch
@@ -66,9 +68,8 @@ module ActionDispatch
           when Nodes::Group
             true
           when Nodes::Star
-            # the default star regex is /(.+)/ which is NOT nullable
-            # but since different constraints can be provided we must
-            # actually check if this is the case or not.
+            # the default star regex is /(.+)/ which is NOT nullable but since different
+            # constraints can be provided we must actually check if this is the case or not.
             node.regexp.match?("")
           when Nodes::Or
             node.children.any? { |c| nullable?(c) }

data/lib/action_dispatch/journey/gtg/simulator.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "strscan"
+# :markup: markdown
 
 module ActionDispatch
   module Journey # :nodoc:
@@ -14,7 +14,13 @@ module ActionDispatch
       end
 
       class Simulator # :nodoc:
-        INITIAL_STATE = [ [0, nil] ].freeze
+        STATIC_TOKENS = Array.new(64)
+        STATIC_TOKENS[".".ord] = "."
+        STATIC_TOKENS["/".ord] = "/"
+        STATIC_TOKENS["?".ord] = "?"
+        STATIC_TOKENS.freeze
+
+        INITIAL_STATE = [0, nil].freeze
 
         attr_reader :tt
 
@@ -23,21 +29,38 @@ module ActionDispatch
         end
 
         def memos(string)
-          input = StringScanner.new(string)
           state = INITIAL_STATE
-          start_index = 0
 
-          while sym = input.scan(%r([/.?]|[^/.?]+))
-            end_index = start_index + sym.length
+          pos = 0
+          eos = string.bytesize
+
+          while pos < eos
+            start_index = pos
+            pos += 1
 
-            state = tt.move(state, string, start_index, end_index)
+            if (token = STATIC_TOKENS[string.getbyte(start_index)])
+              state = tt.move(state, string, token, start_index, false)
+            else
+              while pos < eos && STATIC_TOKENS[string.getbyte(pos)].nil?
+                pos += 1
+              end
 
-            start_index = end_index
+              token = string.byteslice(start_index, pos - start_index)
+              state = tt.move(state, string, token, start_index, true)
+            end
           end
 
-          acceptance_states = state.each_with_object([]) do |s_d, memos|
-            s, idx = s_d
-            memos.concat(tt.memo(s)) if idx.nil? && tt.accepting?(s)
+          acceptance_states = []
+          states_count = state.size
+          i = 0
+          while i < states_count
+            if state[i + 1].nil?
+              s = state[i]
+              if tt.accepting?(s)
+                acceptance_states.concat(tt.memo(s))
+              end
+            end
+            i += 2
           end
 
           acceptance_states.empty? ? yield : acceptance_states