uri-whatwg_parser 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ae0566e4902f0c52f40969d4b55ae40ac98b075bae062d8167895e847e91854
-  data.tar.gz: 1c9c1a764beb16e6719822138df7ef36fe5f02423052b4f436ae164a70eb7cab
+  metadata.gz: bc2c1e5428af4eaed582a417234dec63ac59554af14bbbbd1cc0c3017e8e32b9
+  data.tar.gz: 749b4ba051cb58a73f0ef8ebe64d6426a4d1f0803176641ff75af539757130c1
 SHA512:
-  metadata.gz: d6dcb5018a93cd1f9a17ed84e5d409a0d6413efd405e50ea80f46169ad4b1970dd3e8732da209171c44a2f1a672f7e12b6914f1c5efa95ed882644a4e86393c1
-  data.tar.gz: 69e9afe795ab64751158bf69665de207649119c42f46a1aee9f34faea73a3756d1d4f4c2b5ffd22eab159c932056fbf1820f6dfc2855015d57dfb0c83910185b
+  metadata.gz: a28ffa266d8013c02ed0da9bfd285eaff113527772019a135ddd092310b942c01b6beab710336d37665f8ec3dcc18829edad14a0a97168ef1fc3c651148eb4f0
+  data.tar.gz: 1ba90031895fe24a39b1ae7ff127ea7af821cb39a0801b83234c40b63801c9ee6c886f1bb0e423bc9c6e9c817d31bea29661db7e22978c8b66891b9864a953f4

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.2.1
+
+* Improve the performance of `parse`
+
 ## 0.2.0
 
 * Fix setter methods compliant with WHATWG URL Living Standard

data/README.md

@@ -2,7 +2,7 @@
 
 Ruby implementation of the [WHATWG URL Living Standard](https://url.spec.whatwg.org/).
 
-The latest revision that this package implements of the standard is ([30 October 2025](https://url.spec.whatwg.org/commit-snapshots/52526653e848c5a56598c84aa4bc8ac9025fb66b/)).
+The latest revision that this package implements of the standard is [13 January 2026](https://url.spec.whatwg.org/commit-snapshots/b6b3251fe911ab33d68fb051efe0e4d39ae4145e/).
 
 ## Installation
 

data/lib/uri/whatwg_parser/generic.rb

@@ -62,7 +62,7 @@ module URI
         if host.nil? || host.empty? || scheme == "file"
           raise InvalidURIError, "cannot set user when host is nil or file schme"
         end
-        set_user(URI::DEFAULT_PARSER.encode_userinfo(v))
+        set_user(URI::DEFAULT_PARSER.utf8_percent_encode_string(v, URI::WhatwgParser::USERINFO_PERCENT_ENCODE_SET))
       end
 
       def password=(v)
@@ -72,7 +72,7 @@ module URI
         if host.nil? || host.empty? || scheme == "file"
           raise InvalidURIError, "cannot set password when host is nil or file schme"
         end
-        set_password(URI::DEFAULT_PARSER.encode_userinfo(v))
+        set_password(URI::DEFAULT_PARSER.utf8_percent_encode_string(v, URI::WhatwgParser::USERINFO_PERCENT_ENCODE_SET))
       end
 
       def host=(v)

data/lib/uri/whatwg_parser/host_parser.rb

@@ -7,8 +7,10 @@ class URI::WhatwgParser
   class HostParser
     include ParserHelper
 
-    FORBIDDEN_HOST_CODE_POINT = ["\x00", "\t", "\x0a", "\x0d", " ", "#", "/", ":", "<", ">", "?", "@", "[", "\\", "]", "^", "|"]
-    FORBIDDEN_DOMAIN_CODE_POINT = FORBIDDEN_HOST_CODE_POINT + C0_CONTROL_PERCENT_ENCODE_SET + ["%", "\x7f"]
+    FORBIDDEN_HOST_CODE_POINT = Set["\x00", "\t", "\x0a", "\x0d", " ", "#", "/", ":", "<", ">", "?", "@", "[", "\\", "]", "^", "|"]
+    FORBIDDEN_DOMAIN_CODE_POINT = FORBIDDEN_HOST_CODE_POINT | C0_CONTROL_PERCENT_ENCODE_SET | Set["%", "\x7f"]
+    FORBIDDEN_HOST_REGEX = Regexp.union(FORBIDDEN_HOST_CODE_POINT.to_a)
+    FORBIDDEN_DOMAIN_REGEX = Regexp.union(FORBIDDEN_DOMAIN_CODE_POINT.to_a)
 
     def parse(input, opaque = false) # :nodoc:
       return "" if input&.empty?
@@ -39,8 +41,7 @@ class URI::WhatwgParser
       raise URI::WhatwgParser::ParseError, "invalid IPv4 format" if parts.size > 4
       numbers = []
       parts.each do |part|
-        value, _validation_error = parse_ipv4_number(part)
-        numbers << value
+        numbers << parse_ipv4_number(part)
       end
 
       (numbers.size-1).times {|i| raise URI::WhatwgParser::ParseError, "invalid IPv4 format" if numbers[i] > 255 }
@@ -191,7 +192,7 @@ class URI::WhatwgParser
 
     def parse_opaque_host(host)
       raise ParseError if include_forbidden_host_code_point?(host)
-      host.chars.map { |c| percent_encode(c, C0_CONTROL_PERCENT_ENCODE_SET) }.join
+      host.chars.map { |c| utf8_percent_encode(c, C0_CONTROL_PERCENT_ENCODE_SET) }.join
     end
 
     def percent_decode(str)
@@ -201,51 +202,63 @@ class URI::WhatwgParser
     end
 
     def ends_in_number?(domain)
-      parts = domain.split(".", -1)
-      if parts.last == ""
-        return false if parts.size == 1
-        parts.pop
+      return false if domain.empty?
+
+      if domain.end_with?(".")
+        # Remove trailing dot and find the actual last segment
+        domain_without_trailing = domain[0...-1]
+        return false if domain_without_trailing.empty?
+
+        last_dot = domain_without_trailing.rindex(".")
+        last = last_dot ? domain_without_trailing[last_dot + 1..-1] : domain_without_trailing
+      else
+        # Find the last segment after the last dot
+        last_dot = domain.rindex(".")
+        last = last_dot ? domain[last_dot + 1..-1] : domain
       end
 
-      last = parts.last
-      return true if last != "" && last.chars.all? { |c| ascii_digit?(c) }
+      return false if last.empty?
+      return true if last.match?(/\A\d+\z/)
 
-      begin
-        parse_ipv4_number(last)
-      rescue ParseError
-        return false
+      if last.start_with?("0x", "0X")
+        hex = last[2..-1] || ""
+        return true if hex.empty? || hex.match?(/\A[0-9A-Fa-f]+\z/)
       end
 
-      true
+      false
     end
 
     def parse_ipv4_number(str)
       raise ParseError, "invalid IPv4 format" if str&.empty?
 
-      validation_error = false
       r = 10
 
       if str.size >= 2 && str.start_with?("0x", "0X")
-        validation_error  = true
         str = str[2..-1]
         r = 16
       elsif str.size >= 2 && str.start_with?("0")
-        validation_error  = true
         str = str[1..-1]
         r = 8
       end
 
-      return 0, true if str.empty?
+      return 0 if str.empty?
 
       begin
-        output = Integer(str, r)
-        return output, validation_error
+        Integer(str, r)
       rescue ArgumentError
         raise ParseError, "invalid IPv4 format"
       end
     end
 
     def domain_to_ascii(domain)
+      # If domain is already ASCII-only, lowercase, and doesn't contain punycode prefix
+      # we can skip IDNA processing
+      if domain.ascii_only? && domain == domain.downcase && !domain.include?("xn--")
+        raise ParseError, "including invalid value in host" if include_forbidden_domain_code_point?(domain)
+        raise ParseError, "host can't be empty" if domain.empty?
+        return domain
+      end
+
       ascii_domain = URI::IDNA.whatwg_to_ascii(domain.force_encoding(Encoding::UTF_8), be_strict: false)
 
       raise ParseError, "including invalid value in host" if include_forbidden_domain_code_point?(ascii_domain)
@@ -255,11 +268,11 @@ class URI::WhatwgParser
     end
 
     def include_forbidden_domain_code_point?(str)
-      FORBIDDEN_DOMAIN_CODE_POINT.any? {|c| str.include?(c) }
+      str.match?(FORBIDDEN_DOMAIN_REGEX)
     end
 
     def include_forbidden_host_code_point?(str)
-      FORBIDDEN_HOST_CODE_POINT.any? {|c| str.include?(c) }
+      str.match?(FORBIDDEN_HOST_REGEX)
     end
   end
 end

data/lib/uri/whatwg_parser/parser_helper.rb

@@ -1,31 +1,23 @@
 # frozen_string_literal: true
 
+require "set"
+
 class URI::WhatwgParser
   module ParserHelper
-    C0_CONTROL_PERCENT_ENCODE_SET = (0..0x1f).map(&:chr)
-    ASCII_ALPHA = ("a".."z").to_a + ("A".."Z").to_a
-    ASCII_DIGIT = ("0".."9").to_a
-
-    def ascii_alpha?(c)
-      ASCII_ALPHA.include?(c)
-    end
-
-    def ascii_alphanumerica?(c)
-      ascii_alpha?(c) || ascii_digit?(c)
-    end
+    # NOTE: This set isn't accurate, but it's OK now because greater than `0x7e` is checked inside a method.
+    C0_CONTROL_PERCENT_ENCODE_SET = Set.new((0..0x1f).map(&:chr))
 
-    def ascii_digit?(c)
-      ASCII_DIGIT.include?(c)
-    end
-
-    def percent_encode(c, encode_set, encoding = Encoding::UTF_8)
+    def utf8_percent_encode(c, encode_set)
       return c unless encode_set.include?(c) || c.ord > 0x7e
 
       # For ASCII single-byte characters
       return "%%%02X" % c.ord if c.bytesize == 1
 
-      bytes = c.encoding == encoding ? c.bytes : c.encode(encoding).bytes
-      bytes.map { |b| "%%%02X" % b }.join
+      c.bytes.map { |b| "%%%02X" % b }.join
+    end
+
+    def utf8_percent_encode_string(str, encode_set)
+      str.chars.map { |c| utf8_percent_encode(c, encode_set) }.join
     end
   end
 end

data/lib/uri/whatwg_parser/version.rb

@@ -2,6 +2,6 @@
 
 module URI
   class WhatwgParser
-    VERSION = "0.2.0"
+    VERSION = "0.2.1"
   end
 end

data/lib/uri/whatwg_parser.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "set"
 require "uri"
 require_relative "whatwg_parser/error"
 require_relative "whatwg_parser/version"
@@ -13,19 +14,28 @@ module URI
 
     SPECIAL_SCHEME = { "ftp" => 21, "file" => nil, "http" => 80, "https" => 443, "ws" => 80, "wss" => 443 }
 
-    FRAGMENT_PERCENT_ENCODE_SET = C0_CONTROL_PERCENT_ENCODE_SET + [" ", "\"", "<", ">", "`"]
-    QUERY_PERCENT_ENCODE_SET = C0_CONTROL_PERCENT_ENCODE_SET + [" ", "\"", "#", "<", ">"]
-    SPECIAL_QUERY_PERCENT_ENCODE_SET = QUERY_PERCENT_ENCODE_SET + ["'"]
-    PATH_PERCENT_ENCODE_SET = QUERY_PERCENT_ENCODE_SET + ["?", "^", "`", "{", "}"]
-    USERINFO_PERCENT_ENCODE_SET = PATH_PERCENT_ENCODE_SET + ["/", ":", ";", "=","@", "[", "\\", "]", "|"]
+    FRAGMENT_PERCENT_ENCODE_SET = C0_CONTROL_PERCENT_ENCODE_SET | Set[" ", "\"", "<", ">", "`"]
+    QUERY_PERCENT_ENCODE_SET = C0_CONTROL_PERCENT_ENCODE_SET | Set[" ", "\"", "#", "<", ">"]
+    SPECIAL_QUERY_PERCENT_ENCODE_SET = QUERY_PERCENT_ENCODE_SET | Set["'"]
+    PATH_PERCENT_ENCODE_SET = QUERY_PERCENT_ENCODE_SET | Set["?", "^", "`", "{", "}"]
+    USERINFO_PERCENT_ENCODE_SET = PATH_PERCENT_ENCODE_SET | Set["/", ":", ";", "=", "@", "[", "\\", "]", "|"]
 
-    SINGLE_DOT_PATH_SEGMENTS = [".", "%2e", "%2E"]
-    DOUBLE_DOT_PATH_SEGMENTS = ["..", ".%2e", ".%2E", "%2e.", "%2e%2e", "%2e%2E", "%2E.", "%2E%2e", "%2E%2E"]
+    SINGLE_DOT_PATH_SEGMENTS = Set[".", "%2e", "%2E"]
+    DOUBLE_DOT_PATH_SEGMENTS = Set["..", ".%2e", ".%2E", "%2e.", "%2e%2e", "%2e%2E", "%2E.", "%2E%2e", "%2E%2E"]
 
     WINDOWS_DRIVE_LETTER = Regexp.new("\\A([a-zA-Z][:|])\\z")
     NORMALIZED_WINDOWS_DRIVE_LETTER = Regexp.new("\\A([a-zA-Z][:])\\z")
     STARTS_WITH_WINDOWS_DRIVE_LETTER = Regexp.new("\\A([a-zA-Z][:|])(?:[/\\?#])?\\z")
 
+    VALID_SIGNS_FOR_SCHEME = Set["+", "-", "."]
+    DELIMITER_SIGNS = Set["/", "?", "#"]
+
+    WS_SCHEMES = Set["ws", "wss"]
+
+    ASCII_ALPHA_LOWERCASE = Set.new(("a".."z").to_a)
+    ASCII_ALPHA_UPPERCASE = Set.new(("A".."Z").to_a)
+    ASCII_DIGIT = Set.new(("0".."9").to_a)
+
     def initialize
       reset
       @host_parser = HostParser.new
@@ -35,15 +45,15 @@ module URI
       {}
     end
 
-    def parse(input, base: nil, encoding: Encoding::UTF_8, url: nil, state_override: nil) # :nodoc:
-      URI.for(*self.split(input, base: base, encoding: encoding, url: url, state_override: state_override))
+    def parse(input, base: nil, url: nil, state_override: nil) # :nodoc:
+      URI.for(*self.split(input, base: base, url: url, state_override: state_override))
     end
 
-    def split(input, base: nil, encoding: Encoding::UTF_8, url: nil, state_override: nil) # :nodoc:
+    def split(input, base: nil, url: nil, state_override: nil) # :nodoc:
       reset
       @base = nil
       if base != nil
-        ary = split(base, base: nil, encoding: encoding)
+        ary = split(base, base: nil)
         @base = { scheme: ary[0], userinfo: ary[1], host: ary[2], port: ary[3], registry: ary[4], path: ary[5], opaque: ary[6], query: ary[7], fragment: ary[8]}
         @base_paths = @paths
         reset
@@ -52,7 +62,10 @@ module URI
       if url
         raise ArgumentError, "bad argument (expected URI object)" unless url.is_a?(URI::Generic)
         @parse_result.merge!(url.component.zip(url.send(:component_ary)).to_h)
-        @parse_result[:path] = nil
+        @username = url.user
+        @password = url.password
+        @parse_result.delete(:userinfo)
+        @special_url = special_url?(@parse_result[:scheme])
       end
 
       if state_override
@@ -63,30 +76,27 @@ module URI
         raise ParseError, "uri can't be empty" if (input.nil? || input.empty?) && @base.nil?
       end
 
-      @encoding = encoding
-      @input = input.dup
+      input = input.dup
 
       unless url
-        @input.sub!(/\A[\u0000-\u0020]*/, "")
-        @input.sub!(/[\u0000-\u0020]*\z/, "")
+        remove_c0_control_or_space!(input)
       end
 
-      @input.delete!("\t")
-      @input.delete!("\n")
-      @input.delete!("\r")
+      input.delete!("\t\n\r") if /[\t\n\r]/.match?(input)
 
+      @input_chars = input.chars
+      input_chars_length = @input_chars.length
       @pos = 0
 
-      while @pos <= @input.length
-        c = @input[@pos]
-        ret = send(@state, c)
-        break if ret == :terminate
+      while @pos <= input_chars_length
+        dispatch_state(@input_chars[@pos])
+        break if @terminate
         @pos += 1
       end
 
-      @parse_result[:userinfo] = [@username, @password].compact.reject(&:empty?).join(":")
-      @parse_result[:path] = "/#{@paths.join("/")}" if @paths && !@paths.empty?
-      @parse_result.values
+      userinfo = [@username, @password].compact.reject(&:empty?).join(":")
+      path = "/#{@paths.join("/")}" if @paths && !@paths.empty?
+      [@parse_result[:scheme], userinfo, @parse_result[:host], @parse_result[:port], @parse_result[:registry], path, @parse_result[:opaque], @parse_result[:query], @parse_result[:fragment]]
     end
 
     def join(*uris)
@@ -101,14 +111,33 @@ module URI
       uri
     end
 
-    def encode_userinfo(str)
-      str.chars.map do |char|
-        percent_encode(char, USERINFO_PERCENT_ENCODE_SET)
-      end.join
-    end
-
     private
 
+    def dispatch_state(c)
+      case @state
+      when :scheme_start_state                     then scheme_start_state(c)
+      when :scheme_state                           then scheme_state(c)
+      when :no_scheme_state                        then no_scheme_state(c)
+      when :special_relative_or_authority_state    then special_relative_or_authority_state(c)
+      when :path_or_authority_state                then path_or_authority_state(c)
+      when :relative_state                         then relative_state(c)
+      when :relative_slash_state                   then relative_slash_state(c)
+      when :special_authority_slashes_state        then special_authority_slashes_state(c)
+      when :special_authority_ignore_slashes_state then special_authority_ignore_slashes_state(c)
+      when :authority_state                        then authority_state(c)
+      when :host_state                             then host_state(c)
+      when :port_state                             then port_state(c)
+      when :file_state                             then file_state(c)
+      when :file_slash_state                       then file_slash_state(c)
+      when :file_host_state                        then file_host_state(c)
+      when :path_start_state                       then path_start_state(c)
+      when :path_state                             then path_state(c)
+      when :opaque_path_state                      then opaque_path_state(c)
+      when :query_state                            then query_state(c)
+      when :fragment_state                         then fragment_state(c)
+      end
+    end
+
     def reset
       @buffer = +""
       @at_sign_seen = nil
@@ -117,13 +146,18 @@ module URI
       @paths = nil
       @username = nil
       @password = nil
-      @parse_result = { scheme: nil, userinfo: nil, host: nil, port: nil, registry: nil, path: nil, opaque: nil, query: nil, fragment: nil }
+      @parse_result = { scheme: nil, host: nil, port: nil, registry: nil, path: nil, opaque: nil, query: nil, fragment: nil }
       @state_override = nil
       @state = :scheme_start_state
+      @special_url = nil
+      @terminate = nil
     end
 
     def scheme_start_state(c)
-      if ascii_alpha?(c)
+      if ASCII_ALPHA_LOWERCASE.include?(c)
+        @buffer << c
+        @state = :scheme_state
+      elsif ASCII_ALPHA_UPPERCASE.include?(c)
         @buffer << c.downcase
         @state = :scheme_state
       elsif @state_override.nil?
@@ -135,7 +169,9 @@ module URI
     end
 
     def scheme_state(c)
-      if ascii_alphanumerica?(c) || ["+", "-", "."].include?(c)
+      if ASCII_ALPHA_LOWERCASE.include?(c) || ASCII_DIGIT.include?(c) || VALID_SIGNS_FOR_SCHEME.include?(c)
+        @buffer << c
+      elsif ASCII_ALPHA_UPPERCASE.include?(c)
         @buffer << c.downcase
       elsif c == ":"
         if @state_override
@@ -143,17 +179,20 @@ module URI
             (!special_url? && special_url?(@buffer)) ||
             ((includes_credentials? || !@parse_result[:port].nil?) && @buffer == "file") ||
             (@parse_result[:scheme] == "file" && @parse_result[:host]&.empty?)
-            return :terminate
+            @terminate = true
+            return
           end
         end
 
         @parse_result[:scheme] = @buffer
+        @special_url = special_url?(@buffer)
 
         if @state_override
           if SPECIAL_SCHEME.value?(@parse_result[:port].to_i)
             @parse_result[:port] = nil
           end
-          return :terminate
+          @terminate = true
+          return
         end
 
         @buffer = +""
@@ -164,11 +203,11 @@ module URI
           @state = :special_relative_or_authority_state
         elsif special_url?
           @state = :special_authority_slashes_state
-        elsif rest.start_with?("/")
+        elsif @input_chars[@pos + 1] == "/"
           @state = :path_or_authority_state
           @pos += 1
         else
-          @parse_result[:opaque] = ""
+          @parse_result[:opaque] = +""
           @state = :opaque_path_state
         end
       elsif @state_override.nil?
@@ -185,6 +224,7 @@ module URI
 
       if !@base[:opaque].nil? && c == "#"
         @parse_result[:scheme] = @base[:scheme]
+        @special_url = special_url?(@base[:scheme])
         @paths = @base_paths
         @parse_result[:query] = @base[:query]
         @parse_result[:fragment] = nil
@@ -199,7 +239,7 @@ module URI
     end
 
     def special_relative_or_authority_state(c)
-      if c == "/" && rest.start_with?("/")
+      if c == "/" && @input_chars[@pos + 1] == "/"
         @state = :special_authority_ignore_slashes_state
         @pos -= 1
       else
@@ -219,6 +259,7 @@ module URI
 
     def relative_state(c)
       @parse_result[:scheme] = @base[:scheme]
+      @special_url = special_url?(@base[:scheme])
       if c == "/"
         @state = :relative_slash_state
       elsif special_url? && c == "\\"
@@ -246,7 +287,7 @@ module URI
     end
 
     def relative_slash_state(c)
-      if special_url? && (c == "/" || c == "\\")
+      if @special_url && (c == "/" || c == "\\")
         @state = :special_authority_ignore_slashes_state
       elsif c == "/"
         @state = :authority_state
@@ -260,7 +301,7 @@ module URI
     end
 
     def special_authority_slashes_state(c)
-      if c == "/" && rest.start_with?("/")
+      if c == "/" && @input_chars[@pos + 1] == "/"
         @state = :special_authority_ignore_slashes_state
         @pos += 1
       else
@@ -280,23 +321,23 @@ module URI
       if c == "@"
         @buffer.prepend("%40") if @at_sign_seen
         @at_sign_seen = true
-        @buffer.chars.each do |char|
+        @buffer.each_char do |char|
           if char == ":" && !@password_token_seen
             @password_token_seen = true
             next
           end
 
-          encoded_char = percent_encode(char, USERINFO_PERCENT_ENCODE_SET, @encoding)
+          encoded_char = utf8_percent_encode(char, USERINFO_PERCENT_ENCODE_SET)
 
           if @password_token_seen
-            @password = @password.to_s + encoded_char
+            (@password ||= +"") << encoded_char
           else
-            @username = @username.to_s + encoded_char
+            (@username ||= +"") << encoded_char
           end
         end
 
         @buffer.clear
-      elsif c.nil? || ["/", "?", "#"].include?(c) || (special_url? && c == "\\")
+      elsif c.nil? || DELIMITER_SIGNS.include?(c) || (@special_url && c == "\\")
         raise ParseError, "host is missing" if @at_sign_seen && @buffer.empty?
 
         @pos -= (@buffer.size + 1)
@@ -315,20 +356,23 @@ module URI
         raise ParseError, "host is missing" if @buffer.empty?
         raise ParseError, "invalid host" if @state_override && @state_override == :hostname_state
 
-        @parse_result[:host] = @host_parser.parse(@buffer, !special_url?)
+        @parse_result[:host] = @host_parser.parse(@buffer, !@special_url)
         @buffer.clear
         @state = :port_state
-      elsif c.nil? || ["/", "?", "#"].include?(c) || (special_url? && c == "\\")
+      elsif c.nil? || DELIMITER_SIGNS.include?(c) || (@special_url && c == "\\")
         @pos -= 1
-        if special_url? && @buffer.empty?
+        if @special_url && @buffer.empty?
           raise ParseError, "host is missing"
         elsif @state_override && @buffer.empty? && (includes_credentials? || !@parse_result[:port].nil?)
           raise ParseError, "invalid host"
         else
-          @parse_result[:host] = @host_parser.parse(@buffer, !special_url?)
+          @parse_result[:host] = @host_parser.parse(@buffer, !@special_url)
           @buffer.clear
           @state = :path_start_state
-          return :terminate if @state_override
+          if @state_override
+            @terminate = true
+            return
+          end
         end
       else
         @inside_brackets = true if c == "["
@@ -338,9 +382,9 @@ module URI
     end
 
     def port_state(c)
-      if ascii_digit?(c)
+      if ASCII_DIGIT.include?(c)
         @buffer << c
-      elsif c.nil? || ["/", "?", "#"].include?(c) || (special_url? && c == "\\") || @state_override
+      elsif c.nil? || DELIMITER_SIGNS.include?(c) || (@special_url && c == "\\") || @state_override
         unless @buffer.empty?
           port = Integer(@buffer, 10)
           raise ParseError, "port is invalid value" if port < 0 || port > 65535
@@ -351,7 +395,10 @@ module URI
           end
 
           @buffer.clear
-          return :terminate if @state_override
+          if @state_override
+            @terminate = true
+            return
+          end
         end
 
         raise ParseError, "port is invalid value" if @state_override
@@ -364,6 +411,7 @@ module URI
 
     def file_state(c)
       @parse_result[:scheme] = "file"
+      @special_url = true
       @parse_result[:host] = nil
 
       if c == "/" || c == "\\"
@@ -412,20 +460,26 @@ module URI
     end
 
     def file_host_state(c)
-      if c.nil? || c == "/" || c == "\\" || c == "?" || c == "#"
+      if c.nil? || DELIMITER_SIGNS.include?(c) || (@special_url && c == "\\")
         @pos -= 1
 
         if !@state_override && windows_drive_letter?(@buffer)
           @state = :path_state
         elsif @buffer.empty?
           @parse_result[:host] = nil
-          return :terminate if @state_override
+          if @state_override
+            @terminate = true
+            return
+          end
           @state = :path_start_state
         else
-          host = @host_parser.parse(@buffer, !special_url?)
+          host = @host_parser.parse(@buffer, !@special_url)
           host = "" if host == "localhost"
           @parse_result[:host] = host
-          return :terminate if @state_override
+          if @state_override
+            @terminate = true
+            return
+          end
           @buffer.clear
           @state = :path_start_state
         end
@@ -435,7 +489,7 @@ module URI
     end
 
     def path_start_state(c)
-      if special_url?
+      if @special_url
         @pos -= 1 if c != "/" && c != "\\"
         @state = :path_state
       elsif !@state_override && c == "?"
@@ -454,14 +508,14 @@ module URI
     def path_state(c)
       @paths ||= []
 
-      if (c.nil? || c == "/") || (special_url? && c == "\\") || (!@state_override && (c == "?" || c == "#"))
+      if (c.nil? || c == "/") || (@special_url && c == "\\") || (!@state_override && (c == "?" || c == "#"))
         if double_dot_path_segments?(@buffer)
           shorten_url_path
 
-          if c != "/" && !(special_url? && c == "\\")
+          if c != "/" && !(@special_url && c == "\\")
             @paths << ""
           end
-        elsif single_dot_path_segments?(@buffer) && c != "/" && !((special_url? && c == "\\"))
+        elsif single_dot_path_segments?(@buffer) && c != "/" && !((@special_url && c == "\\"))
           @paths << ""
         elsif !single_dot_path_segments?(@buffer)
           if @parse_result[:scheme] == "file" && @paths.empty? && windows_drive_letter?(@buffer)
@@ -481,7 +535,7 @@ module URI
           @state = :fragment_state
         end
       else
-        @buffer << percent_encode(c, PATH_PERCENT_ENCODE_SET, @encoding)
+        @buffer << utf8_percent_encode(c, PATH_PERCENT_ENCODE_SET)
       end
     end
 
@@ -493,24 +547,22 @@ module URI
         @parse_result[:fragment] = nil
         @state = :fragment_state
       elsif c == " "
-        if rest.start_with?("?", "#")
-          @parse_result[:opaque] += "%20"
+        first_of_rest = @input_chars[@pos + 1]
+        if first_of_rest == "?" || first_of_rest == "#"
+          @parse_result[:opaque] << "%20"
         else
-          @parse_result[:opaque] += " "
+          @parse_result[:opaque] << " "
         end
       elsif !c.nil?
-        @parse_result[:opaque] += percent_encode(c, C0_CONTROL_PERCENT_ENCODE_SET, @encoding)
+        @parse_result[:opaque] << utf8_percent_encode(c, C0_CONTROL_PERCENT_ENCODE_SET)
       end
     end
 
     def query_state(c)
-      if @encoding != Encoding::UTF_8 && (!special_url? || %w[ws wss].include?(@parse_result[:scheme]))
-        @encoding = Encoding::UTF_8
-      end
-
       if c.nil? || (!@state_override && c == "#")
-        query_percent_encode_set = special_url? ? SPECIAL_QUERY_PERCENT_ENCODE_SET : QUERY_PERCENT_ENCODE_SET
-        @parse_result[:query] = @buffer.chars.map { |c| percent_encode(c, query_percent_encode_set, @encoding) }.join
+        query_percent_encode_set = @special_url ? SPECIAL_QUERY_PERCENT_ENCODE_SET : QUERY_PERCENT_ENCODE_SET
+        # TODO: We need to consider encoding here.
+        @parse_result[:query] = utf8_percent_encode_string(@buffer, query_percent_encode_set)
         @buffer.clear
         @state = :fragment_state if c == "#"
       elsif !c.nil?
@@ -520,7 +572,7 @@ module URI
 
     def fragment_state(c)
       return if c.nil?
-      @parse_result[:fragment] = @parse_result[:fragment].to_s + percent_encode(c, FRAGMENT_PERCENT_ENCODE_SET, @encoding)
+      (@parse_result[:fragment] ||= +"") << utf8_percent_encode(c, FRAGMENT_PERCENT_ENCODE_SET)
     end
 
     def windows_drive_letter?(str)
@@ -554,11 +606,11 @@ module URI
     end
 
     def includes_credentials?
-      !@parse_result[:userinfo].nil? || (@username && !@username.empty?) || (@password && !@password.empty?)
+      (@username && !@username.empty?) || (@password && !@password.empty?)
     end
 
     def rest
-      @input[@pos+1..]
+      @input_chars[@pos + 1..]&.join
     end
 
     def convert_to_uri(uri)
@@ -571,6 +623,21 @@ module URI
           "bad argument (expected URI object or URI string)"
       end
     end
+
+    if RUBY_VERSION >= "4.0"
+      def remove_c0_control_or_space!(str)
+        if /[\u0000-\u0020]/.match?(str)
+          str.strip!("\u0000-\u0020")
+        end
+      end
+    else
+      def remove_c0_control_or_space!(str)
+        if /[\u0000-\u0020]/.match?(str)
+          str.sub!(/\A[\u0000-\u0020]*/, "")
+          str.sub!(/[\u0000-\u0020]*\z/, "")
+        end
+      end
+    end
   end
 
   WHATWG_PARSER = URI::WhatwgParser.new

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: uri-whatwg_parser
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Yuji Yaginuma
@@ -37,20 +37,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: debug
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 email:
 - yuuji.yaginuma@gmail.com
 executables: []