uri-whatwg_parser 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ae0566e4902f0c52f40969d4b55ae40ac98b075bae062d8167895e847e91854
-  data.tar.gz: 1c9c1a764beb16e6719822138df7ef36fe5f02423052b4f436ae164a70eb7cab
+  metadata.gz: 7e3c073b711f9600fd66938070b1cc254a1067b684437f27038a69bc65076c9c
+  data.tar.gz: fe833972e0fe8265958d94a97b127983bca064cd29f554c78fb1c2459be008f9
 SHA512:
-  metadata.gz: d6dcb5018a93cd1f9a17ed84e5d409a0d6413efd405e50ea80f46169ad4b1970dd3e8732da209171c44a2f1a672f7e12b6914f1c5efa95ed882644a4e86393c1
-  data.tar.gz: 69e9afe795ab64751158bf69665de207649119c42f46a1aee9f34faea73a3756d1d4f4c2b5ffd22eab159c932056fbf1820f6dfc2855015d57dfb0c83910185b
+  metadata.gz: 541f8b1b1d02b2ac2f16b4af59e5fe3b02e01b2f291529b2698590d01dfc6e1da528926920af1dad8c2d21a11437030356859b30d6e972d2fd3e54aad04cd89a
+  data.tar.gz: 639c0241664afd68d4f0f4c2cea36e71f484cb53215fc12bb89e65749626e1769e9a777420201468e7863a624afe62a0bb8839776a9e565252a35211c845dbf4

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.3.0
+
+* Fix several incorrect parsing processes
+* Fix serialize URL
+
+## 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 [14 April 2026](https://url.spec.whatwg.org/commit-snapshots/b11d73b8caefe90403afe19210db05acba897722/)
 
 ## Installation
 

data/lib/uri/whatwg_parser/generic.rb

@@ -3,16 +3,11 @@ require "uri/generic"
 module URI
   class WhatwgParser
     module Generic
-      def initialize(scheme,
-                     userinfo, host, port, registry,
-                     path, opaque,
-                     query,
-                     fragment,
-                     parser = DEFAULT_PARSER,
-                     arg_check = false)
-
-        return super unless URI::DEFAULT_PARSER.is_a?(URI::WhatwgParser)
-        return super if registry
+      def initialize(scheme, userinfo, host, port, registry, path, opaque, query, fragment, parser = DEFAULT_PARSER, arg_check = false)
+        @parsed_by_whatwg_parser = parser.is_a?(URI::WhatwgParser)
+        unless parser.is_a?(URI::WhatwgParser)
+          return super(scheme, userinfo, host, port, registry, path, opaque, query, fragment)
+        end
 
         @scheme = nil
         @user = nil
@@ -20,6 +15,7 @@ module URI
         @host = nil
         @port = nil
         @path = nil
+        @raw_path = nil
         @query = nil
         @opaque = nil
         @fragment = nil
@@ -32,64 +28,67 @@ module URI
         self.set_path(path)
         self.query = query
         self.set_opaque(opaque)
-        self.fragment=(fragment)
+        @fragment = fragment
+        @raw_path = parser&.path
 
         self.set_path("") if !@path && !@opaque
-        DEFAULT_PARSER.parse(to_s) if arg_check
+        parser.parse(to_s) if arg_check
 
         @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)
+        return super unless @parsed_by_whatwg_parser
+
+        parser.join(self.to_s, oth.to_s)
       end
       alias + merge
 
       def scheme=(v)
-        return super unless URI::DEFAULT_PARSER.is_a?(URI::WhatwgParser)
+        return super unless @parsed_by_whatwg_parser
         return if v.nil? || v.empty?
 
-        parse_result = URI::DEFAULT_PARSER.split("#{v}:", url: self, state_override: :scheme_start_state)
+        parse_result = 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 super unless @parsed_by_whatwg_parser
         return v unless v
 
         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(parser.utf8_percent_encode_string(v, URI::WhatwgParser::USERINFO_PERCENT_ENCODE_SET))
       end
 
       def password=(v)
-        return super unless URI::DEFAULT_PARSER.is_a?(URI::WhatwgParser)
+        return super unless @parsed_by_whatwg_parser
         return v unless v
 
         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(parser.utf8_percent_encode_string(v, URI::WhatwgParser::USERINFO_PERCENT_ENCODE_SET))
       end
 
       def host=(v)
-        return super unless URI::DEFAULT_PARSER.is_a?(URI::WhatwgParser)
+        return super unless @parsed_by_whatwg_parser
         return if v.nil?
 
         if @opaque
-          raise InvalidURIError, "cannot set host with registry or opaque"
+          raise InvalidURIError, "cannot set host with opaque"
         end
 
-        parse_result = URI::DEFAULT_PARSER.split(v.to_s, url: self, state_override: :host_state)
+        parse_result = parser.split(v.to_s, url: self, state_override: :host_state)
         set_host(parse_result[2])
         set_port(parse_result[3])
       end
 
       def port=(v)
-        return super unless URI::DEFAULT_PARSER.is_a?(URI::WhatwgParser)
+        return super unless @parsed_by_whatwg_parser
         return if v.nil?
 
         if v.to_s.empty?
@@ -101,24 +100,55 @@ module URI
           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)
+        parse_result = parser.split("#{v}:", url: self, state_override: :port_state)
         set_port(parse_result[3])
       end
 
       def path=(v)
-        return super unless URI::DEFAULT_PARSER.is_a?(URI::WhatwgParser)
+        return super unless @parsed_by_whatwg_parser
         return if v.nil?
 
         if @opaque
           raise InvalidURIError, "path conflicts with opaque"
         end
 
-        parse_result = URI::DEFAULT_PARSER.split(v.to_s, url: self, state_override: :path_start_state)
+        parse_result = parser.split(v.to_s, url: self, state_override: :path_start_state)
+        @raw_path = parser.path
         set_path(parse_result[5])
       end
 
+      def query=(v)
+        return super unless @parsed_by_whatwg_parser
+
+        if v.nil? || v.empty?
+          @query = nil
+          return
+        end
+
+        v = v.start_with?("?") ? v[1..-1] : v
+        @query = +""
+
+        parse_result = parser.split(v, url: self, state_override: :query_state)
+        @query = parse_result[7].to_s
+      end
+
+      def fragment=(v)
+        return super unless @parsed_by_whatwg_parser
+
+        if v.nil? || v.empty?
+          @fragment = nil
+          return
+        end
+
+        v = v.start_with?("#") ? v[1..-1] : v
+        @fragment = +""
+
+        parse_result = parser.split(v, url: self, state_override: :fragment_state)
+        @fragment = parse_result[8].to_s
+      end
+
       def userinfo=(userinfo)
-        return super unless URI::DEFAULT_PARSER.is_a?(URI::WhatwgParser)
+        return super unless @parsed_by_whatwg_parser
 
         user, password = split_userinfo(userinfo)
         self.user = user
@@ -126,17 +156,59 @@ module URI
       end
 
       def check_opaque(v)
-        return super unless URI::DEFAULT_PARSER.is_a?(URI::WhatwgParser)
+        return super unless @parsed_by_whatwg_parser
+
         return v unless v
 
-        if @host || @port || @user || @path
-          raise InvalidURIError, "cannot set opaque with host, port, userinfo or path"
+        if @host || @port || @user
+          raise InvalidURIError, "cannot set opaque with host, port, or userinfo"
         end
 
         self.set_opaque(v)
-        DEFAULT_PARSER.parse(to_s)
+        # NOTE: WHATWG URL Living Standard doesn't define "opaque" setter. So parse a URL whole.
+        parser.parse(to_s)
         true
       end
+
+      def to_s
+        return super unless @parsed_by_whatwg_parser
+
+        str = "".dup
+        if @scheme
+          str << @scheme
+          str << ":"
+        end
+
+        if @host || %w[file postgres].include?(@scheme)
+          str << "//"
+        end
+        if self.userinfo
+          str << self.userinfo
+          str << "@"
+        end
+        if @host
+          str << @host
+        end
+        if @port && @port != self.default_port
+          str << ":"
+          str << @port.to_s
+        end
+        if @host.nil? && @opaque.nil? && @raw_path && @raw_path.length > 1 && @raw_path[0] == ""
+          str << "/."
+        end
+        str << @path if @path
+        str << @opaque if @opaque
+        if @query
+          str << "?"
+          str << @query
+        end
+
+        if @fragment
+          str << "#"
+          str << @fragment
+        end
+        str
+      end
     end
   end
 end

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.3.0"
   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,30 @@ 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)
+
+    attr_reader :path
+
     def initialize
       reset
       @host_parser = HostParser.new
@@ -35,24 +47,27 @@ 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), self)
     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)
-        @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
+        ary = split(base, base: nil)
+        @base = { scheme: ary[0], userinfo: ary[1], host: ary[2], port: ary[3], query: ary[7], fragment: ary[8]}
+        @base_path = @path
         reset
       end
 
       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 +78,33 @@ 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(":")
+      if @path
+        if @path.is_a?(Array)
+          path = "/#{@path.join("/")}"
+        else
+          opaque = @path
+        end
+      end
+      [@parse_result[:scheme], userinfo, @parse_result[:host], @parse_result[:port], nil, path, opaque, @parse_result[:query], @parse_result[:fragment]]
     end
 
     def join(*uris)
@@ -101,29 +119,53 @@ 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
       @password_token_seen = nil
       @inside_brackets = nil
-      @paths = nil
+      @path = 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 = {}
       @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 +177,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 +187,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 +211,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] = ""
+          @path = +""
           @state = :opaque_path_state
         end
       elsif @state_override.nil?
@@ -181,11 +228,12 @@ module URI
     end
 
     def no_scheme_state(c)
-      raise ParseError, "scheme is missing" if @base.nil? || (!@base[:opaque].nil? && c != "#")
+      raise ParseError, "scheme is missing" if @base.nil? || (has_opaque_path?(@base_path) && c != "#")
 
-      if !@base[:opaque].nil? && c == "#"
+      if has_opaque_path?(@base_path) && c == "#"
         @parse_result[:scheme] = @base[:scheme]
-        @paths = @base_paths
+        @special_url = special_url?(@base[:scheme])
+        @path = @base_path
         @parse_result[:query] = @base[:query]
         @parse_result[:fragment] = nil
         @state = :fragment_state
@@ -199,7 +247,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 +267,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 == "\\"
@@ -227,7 +276,7 @@ module URI
         @username, @password = @base[:userinfo].split(":") if @base[:userinfo]
         @parse_result[:host] = @base[:host]
         @parse_result[:port] = @base[:port]
-        @paths = @base_paths
+        @path = @base_path
         @parse_result[:query] = @base[:query]
 
         if c == "?"
@@ -246,7 +295,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 +309,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 +329,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 +364,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 +390,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 +403,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 +419,7 @@ module URI
 
     def file_state(c)
       @parse_result[:scheme] = "file"
+      @special_url = true
       @parse_result[:host] = nil
 
       if c == "/" || c == "\\"
@@ -382,7 +438,7 @@ module URI
           if !starts_with_windows_drive_letter?(rest)
             shorten_url_path
           else
-            @paths = nil
+            @path = nil
           end
           @state = :path_state
           @pos -= 1
@@ -399,10 +455,10 @@ module URI
       else
         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])
-            if @paths.nil?
-              @paths ||= []
-              @paths[0] = @base_paths[0]
+          if !starts_with_windows_drive_letter?(rest) && @base_path && normalized_windows_drive_letter?(@base_path[0])
+            if @path.nil?
+              @path ||= []
+              @path[0] = @base_path[0]
             end
           end
         end
@@ -412,20 +468,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 +497,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 == "?"
@@ -446,29 +508,29 @@ module URI
         @pos -= 1 if c != "/"
         @state = :path_state
       elsif @state_override && @parse_result[:host].nil?
-        @paths ||= []
-        @paths << ""
+        @path ||= []
+        @path << ""
       end
     end
 
     def path_state(c)
-      @paths ||= []
+      @path ||= []
 
-      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 == "\\")
-            @paths << ""
+          if c != "/" && !(@special_url && c == "\\")
+            @path << ""
           end
-        elsif single_dot_path_segments?(@buffer) && c != "/" && !((special_url? && c == "\\"))
-          @paths << ""
+        elsif single_dot_path_segments?(@buffer) && c != "/" && !((@special_url && c == "\\"))
+          @path << ""
         elsif !single_dot_path_segments?(@buffer)
-          if @parse_result[:scheme] == "file" && @paths.empty? && windows_drive_letter?(@buffer)
+          if @parse_result[:scheme] == "file" && @path.empty? && windows_drive_letter?(@buffer)
             @buffer[1] = ":"
           end
 
-          @paths << @buffer
+          @path << @buffer
         end
 
         @buffer = +""
@@ -477,11 +539,11 @@ module URI
           @parse_result[:query] = nil
           @state = :query_state
         elsif c == "#"
-          @parse_result[:frament] = nil
+          @parse_result[:fragment] = nil
           @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,26 +555,27 @@ 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 == "#"
+          @path += "%20"
         else
-          @parse_result[:opaque] += " "
+          @path += " "
         end
       elsif !c.nil?
-        @parse_result[:opaque] += percent_encode(c, C0_CONTROL_PERCENT_ENCODE_SET, @encoding)
+        @path += 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 == "#"
+        if c == "#"
+          @parse_result[:fragment] = +""
+          @state = :fragment_state
+        end
       elsif !c.nil?
         @buffer << c
       end
@@ -520,7 +583,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)
@@ -548,17 +611,17 @@ module URI
     end
 
     def shorten_url_path
-      return if @paths.nil?
-      return if @parse_result[:scheme] == "file" && @paths.length == 1 && normalized_windows_drive_letter?(@paths.first)
-      @paths.pop
+      return if @path.nil? || @path.is_a?(String)
+      return if @parse_result[:scheme] == "file" && @path.length == 1 && normalized_windows_drive_letter?(@path.first)
+      @path.pop
     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 +634,25 @@ 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
+
+    def has_opaque_path?(path)
+      path.is_a?(String)
+    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.3.0
 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: []
@@ -80,14 +66,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Ruby implementation of the WHATWG URL Living Standard
 test_files: []