uri-whatwg_parser 0.1.8 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4463680cf6d13f3daf3513549ebe358f7b45484888704bbefffcecbb1790b8c7
-  data.tar.gz: b5ec5b9ad687c53f71f2fa21bcb049215dfff6ecdcb8305594f569ba86c0b210
+  metadata.gz: bc2c1e5428af4eaed582a417234dec63ac59554af14bbbbd1cc0c3017e8e32b9
+  data.tar.gz: 749b4ba051cb58a73f0ef8ebe64d6426a4d1f0803176641ff75af539757130c1
 SHA512:
-  metadata.gz: 3ff5fd142e640d265e4d3bd11174e7658732430055d45cce16364bc783c85f7f642d3654d9621e2fa198d63f8e82959fa5d4588d611f6c3e3c3f2d46f382df9e
-  data.tar.gz: b389a5a39685d81ce3ade458b1d61746e9b0dca6e227b73658fe6c04910f20908a1669fd884c5e445bb401edc1db3915e21d15bdec8acf1b441c9c9b3e7e65d8
+  metadata.gz: a28ffa266d8013c02ed0da9bfd285eaff113527772019a135ddd092310b942c01b6beab710336d37665f8ec3dcc18829edad14a0a97168ef1fc3c651148eb4f0
+  data.tar.gz: 1ba90031895fe24a39b1ae7ff127ea7af821cb39a0801b83234c40b63801c9ee6c886f1bb0e423bc9c6e9c817d31bea29661db7e22978c8b66891b9864a953f4

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.2.1
+
+* Improve the performance of `parse`
+
+## 0.2.0
+
+* Fix setter methods compliant with WHATWG URL Living Standard
+* Fix several incorrect parsing processes
+
 ## 0.1.8
 
 * Support `.build` method

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
 
@@ -29,7 +29,6 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## TODO
 
-* Support state override
 * Support validations
 
 ## Contributing

data/Rakefile

@@ -11,6 +11,7 @@ end
 task :download_wpt_resources do
   Dir.chdir "test/resources" do
     system("curl -O https://raw.githubusercontent.com/web-platform-tests/wpt/master/url/resources/urltestdata.json", exception: true)
+    system("curl -O https://raw.githubusercontent.com/web-platform-tests/wpt/master/url/resources/setters_tests.json", exception: true)
   end
 end
 

data/lib/uri/whatwg_parser/generic.rb

@@ -10,6 +10,10 @@ module URI
                      fragment,
                      parser = DEFAULT_PARSER,
                      arg_check = false)
+
+        return super unless URI::DEFAULT_PARSER.is_a?(URI::WhatwgParser)
+        return super if registry
+
         @scheme = nil
         @user = nil
         @password = nil
@@ -33,91 +37,96 @@ module URI
         self.set_path("") if !@path && !@opaque
         DEFAULT_PARSER.parse(to_s) if arg_check
 
-        if registry
-          raise InvalidURIError,
-            "the scheme #{@scheme} does not accept registry part: #{registry} (or bad hostname?)"
-        end
-
         @scheme&.freeze
         self.set_port(self.default_port) if self.default_port && !@port
       end
 
-
       def merge(oth)
         URI::DEFAULT_PARSER.join(self.to_s, oth.to_s)
       end
       alias + merge
 
-      def check_scheme(v)
-        self.set_scheme(v)
-        DEFAULT_PARSER.parse(to_s)
-        true
-      end
+      def scheme=(v)
+        return super unless URI::DEFAULT_PARSER.is_a?(URI::WhatwgParser)
+        return if v.nil? || v.empty?
 
-      def check_user(v)
-        if @opaque
-          raise InvalidURIError, "cannot set user with opaque"
-        end
+        parse_result = URI::DEFAULT_PARSER.split("#{v}:", url: self, state_override: :scheme_start_state)
+        set_scheme(parse_result[0])
+        set_port(parse_result[3])
+      end
 
+      def user=(v)
+        return super unless URI::DEFAULT_PARSER.is_a?(URI::WhatwgParser)
         return v unless v
 
-        self.set_user(v)
-        DEFAULT_PARSER.parse(to_s)
-        true
+        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.utf8_percent_encode_string(v, URI::WhatwgParser::USERINFO_PERCENT_ENCODE_SET))
       end
 
-      def check_password(v, user = @user)
-        if @opaque
-          raise InvalidURIError, "cannot set password with opaque"
-        end
+      def password=(v)
+        return super unless URI::DEFAULT_PARSER.is_a?(URI::WhatwgParser)
         return v unless v
 
-        if !user
-          raise InvalidURIError, "password component depends user component"
+        if host.nil? || host.empty? || scheme == "file"
+          raise InvalidURIError, "cannot set password when host is nil or file schme"
         end
-
-        self.set_password(v)
-        DEFAULT_PARSER.parse(to_s)
-        true
+        set_password(URI::DEFAULT_PARSER.utf8_percent_encode_string(v, URI::WhatwgParser::USERINFO_PERCENT_ENCODE_SET))
       end
 
-      def check_host(v)
-        return v unless v
+      def host=(v)
+        return super unless URI::DEFAULT_PARSER.is_a?(URI::WhatwgParser)
+        return if v.nil?
 
         if @opaque
           raise InvalidURIError, "cannot set host with registry or opaque"
         end
 
-        self.set_host(v)
-        DEFAULT_PARSER.parse(to_s)
-        true
+        parse_result = URI::DEFAULT_PARSER.split(v.to_s, url: self, state_override: :host_state)
+        set_host(parse_result[2])
+        set_port(parse_result[3])
       end
 
-      def check_port(v)
-        return v unless v
+      def port=(v)
+        return super unless URI::DEFAULT_PARSER.is_a?(URI::WhatwgParser)
+        return if v.nil?
 
-        if @opaque
-          raise InvalidURIError, "cannot set port with registry or opaque"
+        if v.to_s.empty?
+          set_port(nil)
+          return
         end
 
-        self.set_port(v)
-        DEFAULT_PARSER.parse(to_s)
-        true
+        if host.nil? || host.empty? || scheme == "file"
+          raise InvalidURIError, "cannot set port when host is nil or scheme is file"
+        end
+
+        parse_result = URI::DEFAULT_PARSER.split("#{v}:", url: self, state_override: :port_state)
+        set_port(parse_result[3])
       end
 
-      def check_path(v)
-        return v unless v
+      def path=(v)
+        return super unless URI::DEFAULT_PARSER.is_a?(URI::WhatwgParser)
+        return if v.nil?
 
         if @opaque
           raise InvalidURIError, "path conflicts with opaque"
         end
 
-        self.set_path(v)
-        DEFAULT_PARSER.parse(to_s)
-        true
+        parse_result = URI::DEFAULT_PARSER.split(v.to_s, url: self, state_override: :path_start_state)
+        set_path(parse_result[5])
+      end
+
+      def userinfo=(userinfo)
+        return super unless URI::DEFAULT_PARSER.is_a?(URI::WhatwgParser)
+
+        user, password = split_userinfo(userinfo)
+        self.user = user
+        self.password = password
       end
 
       def check_opaque(v)
+        return super unless URI::DEFAULT_PARSER.is_a?(URI::WhatwgParser)
         return v unless v
 
         if @host || @port || @user || @path

data/lib/uri/whatwg_parser/host_parser.rb

@@ -7,11 +7,13 @@ 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?
+      return "" if input&.empty?
 
       if input.start_with?("[")
         raise ParseError, "invalid IPv6 format" unless input.end_with?("]")
@@ -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,63 +192,73 @@ 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)
       str.gsub(/%[0-9A-Fa-f]{2}/) do |m|
         m[1..2].to_i(16).chr
       end
-    rescue ArgumentError
-      raise ParseError, "including invalid value in host"
     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)
@@ -257,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.1.8"
+    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,18 +14,27 @@ 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")
+    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
@@ -35,51 +45,67 @@ module URI
       {}
     end
 
-    def parse(uri, base = nil, encoding = Encoding::UTF_8) # :nodoc:
-      URI.for(*self.split(uri, base, encoding))
+    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(uri, base = nil, encoding = Encoding::UTF_8) # :nodoc:
+    def split(input, base: nil, url: nil, state_override: nil) # :nodoc:
       reset
       @base = nil
       if base != nil
-        ary = split(base, nil, 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
       end
 
-      @encoding = encoding
-      @uri = uri.dup
-      @uri.sub!(/\A[\u0000-\u0020]*/, "")
-      @uri.sub!(/[\u0000-\u0020]*\z/, "")
-      @uri.delete!("\t")
-      @uri.delete!("\n")
-      @uri.delete!("\r")
+      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)
+        @username = url.user
+        @password = url.password
+        @parse_result.delete(:userinfo)
+        @special_url = special_url?(@parse_result[:scheme])
+      end
+
+      if state_override
+        @state = state_override.to_sym
+        @state_override = @state
+        raise ArgumentError, "state override is invalid" if !state_override.to_s.end_with?("_state") || !respond_to?(@state_override, private: true)
+      else
+        raise ParseError, "uri can't be empty" if (input.nil? || input.empty?) && @base.nil?
+      end
 
-      raise ParseError, "uri can't be empty" if uri.empty? && @base.nil?
+      input = input.dup
 
+      unless url
+        remove_c0_control_or_space!(input)
+      end
+
+      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 <= @uri.length
-        c = @uri[@pos]
-        send(@state, c)
+      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)
       return parse(uris[0]) if uris.size == 1
 
       base, input = uris.shift(2)
-      uri = parse(input.to_s, base.to_s)
+      uri = parse(input.to_s, base: base.to_s)
       uris.each do |input|
-        uri = parse(input.to_s, uri.to_s)
+        uri = parse(input.to_s, base: uri.to_s)
       end
 
       uri
@@ -87,6 +113,31 @@ module URI
 
     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
@@ -95,26 +146,55 @@ 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 }
-      @force_continue = false
+      @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
-      else
+      elsif @state_override.nil?
         @pos -= 1
         @state = :no_scheme_state
+      else
+        raise ParseError, "scheme is invalid value"
       end
     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
+          if (special_url? && !special_url?(@buffer)) ||
+            (!special_url? && special_url?(@buffer)) ||
+            ((includes_credentials? || !@parse_result[:port].nil?) && @buffer == "file") ||
+            (@parse_result[:scheme] == "file" && @parse_result[:host]&.empty?)
+            @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
+          @terminate = true
+          return
+        end
+
         @buffer = +""
 
         if @parse_result[:scheme] == "file"
@@ -123,17 +203,19 @@ 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
-      else
+      elsif @state_override.nil?
         @buffer.clear
         @pos = -1
         @state = :no_scheme_state
+      else
+        raise ParseError, "parsing scheme failed"
       end
     end
 
@@ -142,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
@@ -156,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
@@ -176,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 == "\\"
@@ -203,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
@@ -217,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
@@ -237,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)
@@ -265,20 +349,30 @@ module URI
     end
 
     def host_state(c)
-      if c == ":" && !@inside_brackets
+      if @state_override && @parse_result[:scheme] == "file"
+        @pos -= 1
+        @state = :file_host_state
+      elsif c == ":" && !@inside_brackets
         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
+          if @state_override
+            @terminate = true
+            return
+          end
         end
       else
         @inside_brackets = true if c == "["
@@ -288,21 +382,26 @@ 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 == "\\")
+      elsif c.nil? || DELIMITER_SIGNS.include?(c) || (@special_url && c == "\\") || @state_override
         unless @buffer.empty?
-          begin
-            port = Integer(@buffer, 10)
-            raise ParseError, "port is invalid value" if port < 0 || port > 65535
-            @parse_result[:port] = port unless SPECIAL_SCHEME[@parse_result[:scheme]] == port
-          rescue ArgumentError
-            raise ParseError, "port is invalid value"
+          port = Integer(@buffer, 10)
+          raise ParseError, "port is invalid value" if port < 0 || port > 65535
+          if SPECIAL_SCHEME[@parse_result[:scheme]] == port
+            @parse_result[:port] = nil
+          else
+            @parse_result[:port] = port
           end
 
           @buffer.clear
+          if @state_override
+            @terminate = true
+            return
+          end
         end
 
+        raise ParseError, "port is invalid value" if @state_override
         @state = :path_start_state
         @pos -= 1
       else
@@ -312,6 +411,7 @@ module URI
 
     def file_state(c)
       @parse_result[:scheme] = "file"
+      @special_url = true
       @parse_result[:host] = nil
 
       if c == "/" || c == "\\"
@@ -348,7 +448,10 @@ module URI
         if !@base.nil? && @base[:scheme] == "file"
           @parse_result[:host] = @base[:host]
           if !starts_with_windows_drive_letter?(rest) && @base_paths && normalized_windows_drive_letter?(@base_paths[0])
-            @paths[0] << @base_paths[0]
+            if @paths.nil?
+              @paths ||= []
+              @paths[0] = @base_paths[0]
+            end
           end
         end
         @state = :path_state
@@ -357,52 +460,62 @@ 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 windows_drive_letter?(@buffer)
+        if !@state_override && windows_drive_letter?(@buffer)
           @state = :path_state
         elsif @buffer.empty?
           @parse_result[:host] = nil
+          if @state_override
+            @terminate = true
+            return
+          end
           @state = :path_start_state
         else
-          host = @host_parser.parse(@buffer, !special_url?)
-          if host != "localhost"
-            @parse_result[:host] = host
+          host = @host_parser.parse(@buffer, !@special_url)
+          host = "" if host == "localhost"
+          @parse_result[:host] = host
+          if @state_override
+            @terminate = true
+            return
           end
-
           @buffer.clear
           @state = :path_start_state
         end
+      else
+        @buffer << c unless c.nil?
       end
-
-      @buffer << c unless c.nil?
     end
 
     def path_start_state(c)
-      if special_url?
+      if @special_url
         @pos -= 1 if c != "/" && c != "\\"
         @state = :path_state
-      elsif c == "?"
+      elsif !@state_override && c == "?"
         @state = :query_state
-      elsif c == "#"
+      elsif !@state_override && c == "#"
         @state = :fragment_state
       elsif c != nil
         @pos -= 1 if c != "/"
         @state = :path_state
+      elsif @state_override && @parse_result[:host].nil?
+        @paths ||= []
+        @paths << ""
       end
     end
 
     def path_state(c)
       @paths ||= []
 
-      if (c.nil? || c == "/") || (special_url? && c == "\/") || (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)
@@ -422,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
 
@@ -434,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? || 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
+      if c.nil? || (!@state_override && c == "#")
+        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?
@@ -461,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)
@@ -469,15 +580,15 @@ module URI
     end
 
     def starts_with_windows_drive_letter?(str)
-      STARTS_WITH_wINDOWS_DRIVE_LETTER.match?(str)
+      STARTS_WITH_WINDOWS_DRIVE_LETTER.match?(str)
     end
 
     def normalized_windows_drive_letter?(str)
       NORMALIZED_WINDOWS_DRIVE_LETTER.match?(str)
     end
 
-    def special_url?
-      SPECIAL_SCHEME.key?(@parse_result[:scheme])
+    def special_url?(str = @parse_result[:scheme])
+      SPECIAL_SCHEME.key?(str)
     end
 
     def single_dot_path_segments?(c)
@@ -490,13 +601,16 @@ module URI
 
     def shorten_url_path
       return if @paths.nil?
-
-      return true if @parse_result[:scheme] == "file" && @paths.length == 1 && normalized_windows_drive_letter?(@paths.first)
+      return if @parse_result[:scheme] == "file" && @paths.length == 1 && normalized_windows_drive_letter?(@paths.first)
       @paths.pop
     end
 
+    def includes_credentials?
+      (@username && !@username.empty?) || (@password && !@password.empty?)
+    end
+
     def rest
-      @uri[@pos+1..]
+      @input_chars[@pos + 1..]&.join
     end
 
     def convert_to_uri(uri)
@@ -509,9 +623,26 @@ 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
 end
 
 URI.send(:remove_const, :DEFAULT_PARSER) if defined?(URI::DEFAULT_PARSER)
-URI::DEFAULT_PARSER = URI::WhatwgParser.new
+URI::DEFAULT_PARSER = URI::WHATWG_PARSER
 URI.parser = URI::DEFAULT_PARSER

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: uri-whatwg_parser
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  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: []
@@ -87,7 +73,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Ruby implementation of the WHATWG URL Living Standard
 test_files: []