uri-whatwg_parser 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f268e45182363045ad2658cd458e9bd6c1309688889a056ab3c507c1805b41f6
+  data.tar.gz: 842b5a01c0860e9293f5c1b58d71fbd22fbc38de8775488865f2ecd060f5d546
+SHA512:
+  metadata.gz: df6b26333982d0ab865d4c3b436b6f0b61ba06e2e034c8e8453586bfd5dbffe0493be6bc36b295f4d7ca8511892c454c8b3b178beb387c7e8588290f25cbd462
+  data.tar.gz: ad8179360bcd2b0e963841936978aa04f38075142762114c7fb0a7c7dae459ad54f2e31deaa8cd9e9a16820d34235d9ad89038c6677648fcc40135f0350e5867

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Yuji Yaginuma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+# Uri::WhatwgParser
+
+Ruby implementation of the [WHATWG URL Living Standard](https://url.spec.whatwg.org/).
+
+The latest revision that this package implements of the standard is ([24 March 2025](https://url.spec.whatwg.org/commit-snapshots/cc8b776b89a6d92b5cc74581c8d90450d3c1e762/)).
+
+NOTE: Some features haven't been implemented yet. Please see the TODO for details.
+
+## Installation
+
+```bash
+gem install uri-whatwg_parser
+```
+
+## Usage
+
+This gem is compatible with [`uri`](https://github.com/ruby/uri) gem and automatically switches parser's behavior. So users don't need to set up.
+
+```ruby
+URI.parse("http://日本語.jp")
+# => #<URI::HTTP http://xn--wgv71a119e.jp>
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## TODO
+
+* Support passing `base`
+* Support state override
+* Support validations
+* Support encodings other than UTF-8
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/y-yagi/uri-whatwg_parser.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/**/test_*.rb"]
+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)
+  end
+end
+
+task default: :test

data/lib/uri/whatwg_parser/error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+class URI::WhatwgParser
+  class Error < URI::Error; end
+  class ParseError < Error; end
+end

data/lib/uri/whatwg_parser/host_parser.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "uri/idna"
+require "ipaddr"
+require_relative "parser_helper"
+
+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 + ["%"]
+
+    def parse(input, opaque = false) # :nodoc:
+      return if input&.empty?
+
+      if input.start_with?("[")
+        raise ParseError unless input.end_with?("]")
+        return parse_ipv6(input)
+      end
+
+      return parse_opaque_host(input) if opaque
+
+      domain = percent_decode(input)
+      ascii_domain = URI::IDNA.whatwg_to_ascii(domain.force_encoding(Encoding::UTF_8))
+      if ends_in_number?(ascii_domain)
+        ipv4 = parse_ipv4(ascii_domain)
+        return serialize_ipv4(ipv4)
+      end
+
+      raise ParseError if include_forbidden_domain_code_point?(ascii_domain)
+      ascii_domain
+    rescue URI::IDNA::Error, Encoding::CompatibilityError, ArgumentError => _e
+      raise ParseError
+    end
+
+    private
+
+    def parse_ipv4(host)
+      parts = host.split(".")
+      raise URI::WhatwgParser::ParseError if parts.size > 4
+      numbers = []
+      parts.each do |part|
+        value, _validation_error = parse_ipv4_number(part)
+        numbers << value
+      end
+
+      (numbers.size-1).times {|i| raise URI::WhatwgParser::ParseError if numbers[i] > 255 }
+
+      raise ParseError if numbers.last >= 256 ** (5 - numbers.size)
+
+      ipv4 = numbers.pop
+      numbers.each_with_index do |number, index|
+        ipv4 += number * (256 ** (3 - index))
+      end
+
+      ipv4
+    end
+
+    def serialize_ipv4(ipv4)
+      output = []
+      4.times.each do |_|
+        output.prepend("#{ipv4 % 256}")
+        ipv4 /= 256
+      end
+
+      output.join(".")
+    end
+
+    def parse_ipv6(host)
+      "[#{IPAddr.new(host).to_s}]"
+    rescue
+      raise ParseError
+    end
+
+    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
+    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
+    end
+
+    def ends_in_number?(domain)
+      parts = domain.split(".")
+      return false if parts.size == 0
+
+      last = parts.last
+      return true if last.chars.all? { |c| ascii_digit?(c) }
+
+      begin
+        parse_ipv4_number(last)
+      rescue ParseError
+        return false
+      end
+
+      true
+    end
+
+    def parse_ipv4_number(str)
+      raise ParseError if str&.empty?
+
+      validation_error = false
+      r = 10
+
+      if str.size >= 2 && (str.start_with?("0x") || str.start_with?("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?
+
+      begin
+        output = Integer(str, r)
+        return output, validation_error
+      rescue ArgumentError
+        raise ParseError
+      end
+    end
+
+    def include_forbidden_domain_code_point?(str)
+      str.chars.intersect?(FORBIDDEN_DOMAIN_CODE_POINT)
+    end
+
+    def include_forbidden_host_code_point?(str)
+      str.chars.intersect?(FORBIDDEN_HOST_CODE_POINT)
+    end
+  end
+end

data/lib/uri/whatwg_parser/parser_helper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class URI::WhatwgParser
+  module ParserHelper
+    C0_CONTROL = (0..0x1f).to_a
+    C0_CONTROL_PERCENT_ENCODE_SET = C0_CONTROL.map(&:chr)
+
+    def ascii_alpha?(c)
+      ASCII_ALPHA.include?(c)
+    end
+
+    def ascii_alphanumerica?(c)
+      ascii_alpha?(c) || ascii_digit?(c)
+    end
+
+    def ascii_digit?(c)
+      ASCII_DIGIT.include?(c)
+    end
+
+    def percent_encode(c, encode_set)
+      if encode_set.include?(c) || c.ord > 0x7e
+        return c.unpack("C*").map { |b| sprintf("%%%02X", b) }.join
+      end
+      c
+    end
+  end
+end

data/lib/uri/whatwg_parser/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module URI
+  class WhatwgParser
+    VERSION = "0.1.0"
+  end
+end

data/lib/uri/whatwg_parser.rb

@@ -0,0 +1,391 @@
+# frozen_string_literal: true
+
+require "strscan"
+require "uri"
+require_relative "whatwg_parser/error"
+require_relative "whatwg_parser/version"
+require_relative "whatwg_parser/parser_helper"
+require_relative "whatwg_parser/host_parser"
+
+module URI
+  class WhatwgParser
+    include ParserHelper
+
+    SPECIAL_SCHEME = { "ftp" => 21, "file" => nil, "http" => 80, "https" => 443, "ws" => 80, "wss" => 443 }
+    ASCII_ALPHA = ("a".."z").to_a + ("A".."Z").to_a
+    ASCII_DIGIT = ("0".."9").to_a
+
+    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 + ["/", ":", ";", "=","@", "[", "\\", "]", "|"]
+
+    SINGLE_DOT_PATH_SEGMENTS = [".", "%2e", "%2E"]
+    DOUBLE_DOT_PATH_SEGMENTS = ["..", ".%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")
+
+    def initialize
+      reset
+      @host_parser = HostParser.new
+    end
+
+    def regexp
+      {}
+    end
+
+    def parse(uri) # :nodoc:
+      reset
+      URI.for(*self.split(uri))
+    end
+
+    def split(uri) # :nodoc:
+      uri = uri.dup
+      uri.gsub!(/\A[\u0000-\u0020]*/, "")
+      uri.gsub!(/[\u0000-\u0020]*\z/, "")
+      uri.delete!("\t")
+      uri.delete!("\n")
+      uri.delete!("\r")
+
+      raise ParseError if uri.empty?
+
+      @scanner = StringScanner.new(uri)
+
+      loop do
+        c = @scanner.getch
+        send("on_#{@state}", c)
+
+        break if c.nil? && @scanner.eos?
+      end
+
+      @parse_result[:userinfo] = "#{@username}:#{@password}" if !@username.nil? || !@password.nil?
+      @parse_result[:path] = "/#{@paths.join("/")}" if !@paths.empty?
+
+      @parse_result.values
+    end
+
+    private
+
+    def reset
+      @state = nil
+      @scanner = nil
+      @buffer = +""
+      @at_sign_seen = nil
+      @password_token_seen = nil
+      @inside_brackets = nil
+      @paths = []
+      @username = nil
+      @password = nil
+      @parse_result = { scheme: nil, userinfo: nil, host: nil, port: nil, registry: nil, path: nil, opaque: nil, query: nil, fragment: nil }
+      @state = :scheme_start_state
+    end
+
+    def on_scheme_start_state(c)
+      if ascii_alpha?(c)
+        @buffer += c.downcase
+        @state = :scheme_state
+      else
+        @scanner.pos -= c.bytesize unless c.nil?
+        @state = :no_scheme_state
+      end
+    end
+
+    def on_scheme_state(c)
+      if ascii_alphanumerica?(c) || ["+", "-", "."].include?(c)
+        @buffer += c.downcase
+      elsif c == ":"
+        @parse_result[:scheme] = @buffer
+        @buffer = +""
+
+        if @parse_result[:scheme] == "file"
+          @state = :file_state
+        elsif special_url?
+          @state = :special_authority_slashes_state
+        elsif @scanner.rest.start_with?("/")
+          @state = :path_or_authority_state
+          @scanner.pos += c.bytesize
+        else
+          @parse_result[:path] = ""
+          @state = :opaque_path_state
+        end
+      else
+        @buffer = +""
+        @scanner.pos = 0
+        @state = :no_scheme_state
+      end
+    end
+
+    def on_no_scheme_state(c)
+      raise ParseError
+    end
+
+    def on_special_relative_or_authority_state(c)
+      if c == "/" && @scanner.rest.start_with?("/")
+        @state = :special_authority_ignore_slashes_state
+        @scanner.pos += c.bytesize
+      else
+        @state = :relative_state
+        @scanner.pos -= c.bytesize
+      end
+    end
+
+    def on_path_or_authority_state(c)
+      if c == "/"
+        @state = :authority_state
+      else
+        @state = :path_state
+        @scanner.pos -= c.bytesize
+      end
+    end
+
+    def on_special_authority_slashes_state(c)
+      if c != "\\" && c != "/"
+        @state = :authority_state
+        @scanner.pos -= c.bytesize
+      end
+    end
+
+    def on_authority_state(c)
+      if c == "@"
+        @buffer.prepend("%40") if @at_sign_seen
+        @at_sign_seen = true
+        @buffer.chars.each do |char|
+          if char == ":" && !@password_token_seen
+            @password_token_seen = true
+            next
+          end
+
+          encoded_char = percent_encode(char, USERINFO_PERCENT_ENCODE_SET)
+
+          if @password_token_seen
+            @password = @password.to_s + encoded_char
+          else
+            @username = @username.to_s + encoded_char
+          end
+        end
+
+        @buffer = +""
+      elsif c.nil? || ["/", "?", "#"].include?(c) || (special_url? && c == "\\")
+        raise ParseError if @at_sign_seen && @buffer.empty?
+        @scanner.pos -= (@buffer.bytesize + c&.bytesize.to_i)
+        @buffer = +""
+        @state = :host_state
+      else
+        @buffer << c
+      end
+    end
+
+    def on_host_state(c)
+      if c == ":" && !@inside_brackets
+        raise ParseError if @buffer.empty?
+
+        @parse_result[:host] = @host_parser.parse(@buffer, !special_url?)
+        @buffer = +""
+        @state = :port_state
+      elsif c.nil? || ["/", "?", "#"].include?(c) || (special_url? && c == "\\")
+        @scanner.pos -= c.bytesize unless c.nil?
+        if special_url? && @buffer.empty?
+          raise ParseError
+        else
+          @parse_result[:host] = @host_parser.parse(@buffer, !special_url?)
+          @buffer = +""
+          @state = :path_start_state
+        end
+      else
+        @inside_brackets = true if c == "["
+        @inside_brackets = false if c == "]"
+        @buffer += c
+      end
+    end
+
+    def on_port_state(c)
+      if ascii_digit?(c)
+        @buffer += c
+      elsif c.nil? || ["/", "?", "#"].include?(c) || (special_url? && c == "\\")
+        unless @buffer.empty?
+          begin
+            port = Integer(@buffer)
+            raise ParseError if port < 0 || port > 65535
+            @parse_result[:port] = port unless SPECIAL_SCHEME[@parse_result[:scheme]] == port
+          rescue ArgumentError
+            raise ParseError
+          end
+
+          @buffer = +""
+        end
+
+        @state = :path_start_state
+        @scanner.pos -= c.bytesize unless c.nil?
+      else
+        raise ParseError
+      end
+    end
+
+    def on_file_state(c)
+      @parse_result[:scheme] = "file"
+      @parse_result[:host] = ""
+
+      if c == "/" || c == "\\"
+        @state = :file_slash_state
+      else
+        @scanner.pos -= c.bytesize unless c.nil?
+        @state = :path_state
+      end
+    end
+
+    def on_file_slash_state(c)
+      if c == "/" || c == "\\"
+        @state = :file_host_state
+      else
+        @scanner.pos -= c.bytesize unless c.nil?
+        @state = :path_state
+      end
+    end
+
+    def on_file_host_state(c)
+      if c.nil? || c == "/" || c == "\\" || c == "?" || c == "#"
+        @scanner.pos -= c.bytesize unless c.nil?
+
+        if windows_drive_letter?(@buffer)
+          @state = :path_state
+        elsif @buffer.empty?
+          @parse_result[:host] = ""
+          @state = :path_start_state
+        else
+          host = @host_parser.parse(@buffer, !special_url?)
+          if host != "localhost"
+            @parse_result[:host] = host
+          end
+
+          @buffer = +""
+          @state = :path_start_state
+        end
+      end
+
+      @buffer += c unless c.nil?
+    end
+
+    def on_path_start_state(c)
+      return if c.nil?
+
+      if special_url?
+        @scanner.pos -= c.bytesize if c != "/" && c != "\\"
+        @state = :path_state
+      elsif c == "?"
+        @state = :query_state
+      elsif c == "#"
+        @state = :fragment_state
+      elsif c != nil
+        @scanner.pos -= c.bytesize if c != "/"
+        @state = :path_state
+      end
+    end
+
+    def on_path_state(c)
+      if (c.nil? || c == "/") || (special_url? && c == "\/") || (c == "?" || c == "#")
+
+        if double_dot_path_segments?(@buffer)
+          shorten_url_path
+          if c != "/" || (special_url? && c == "\/")
+            @paths << ""
+          end
+        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)
+            @buffer[1] = ":"
+          end
+          @paths << @buffer
+        end
+
+        @buffer = +""
+
+        if c == "?"
+          @parse_result[:query] = ""
+          @state = :query_state
+        elsif c == "#"
+          @parse_result[:frament] = ""
+          @state = :fragment_state
+        end
+      else
+        @buffer << percent_encode(c, PATH_PERCENT_ENCODE_SET)
+      end
+    end
+
+    def on_opaque_path_state(c)
+      if c == "?"
+        @parse_result[:query] = ""
+        @state = :query_state
+      elsif c == "#"
+        @parse_result[:fragment] = ""
+        @state = :fragment_state
+      elsif c == " "
+        if @scanner.rest.start_with?("?") || @scanner.rest.start_with?("#")
+          @parse_result[:path] = @parse_result[:path].to_s + "%20"
+        else
+          @parse_result[:path] = @parse_result[:path].to_s + " "
+        end
+      elsif !c.nil?
+        @parse_result[:path] = @parse_result[:path].to_s + percent_encode(c, C0_CONTROL_PERCENT_ENCODE_SET)
+      end
+    end
+
+    def on_query_state(c)
+      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) }.join
+        @buffer = +""
+        @state = :fragment_state if c == "#"
+      elsif !c.nil?
+        @buffer << c
+      end
+    end
+
+    def on_fragment_state(c)
+      return if c.nil?
+      @parse_result[:fragment] = @parse_result[:fragment].to_s + percent_encode(c, FRAGMENT_PERCENT_ENCODE_SET)
+    end
+
+    def c0_control_or_space?(c)
+      c0_control? || c == " "
+    end
+
+    def c0_control?(c)
+      C0_CONTROL.include?(c.ord)
+    end
+
+    def windows_drive_letter?(str)
+      WINDOWS_DRIVE_LETTER.match?(str)
+    end
+
+    def normalized_windows_drive_letter?(str)
+      NORMALIZED_WINDOWS_DRIVE_LETTER.match?(str)
+    end
+
+    def special_url?
+      SPECIAL_SCHEME.keys.include?(@parse_result[:scheme])
+    end
+
+    def single_dot_path_segments?(c)
+      SINGLE_DOT_PATH_SEGMENTS.include?(c)
+    end
+
+    def double_dot_path_segments?(c)
+      DOUBLE_DOT_PATH_SEGMENTS.include?(c)
+    end
+
+    def shorten_url_path
+      return if @parse_result[:path]&.empty?
+
+      return true if @parse_result[:scheme] == "file" && @parse_result[:path]&.length == 1 && normalized_windows_drive_letter?(@parse_result[:path])
+      @parse_result[:path]&.chomp!
+    end
+  end
+end
+
+URI.send(:remove_const, :DEFAULT_PARSER) if defined?(URI::DEFAULT_PARSER)
+URI::DEFAULT_PARSER = URI::WhatwgParser.new
+URI.parser = URI::DEFAULT_PARSER

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: uri-whatwg_parser
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yuji Yaginuma
+bindir: exe
+cert_chain: []
+date: 2025-05-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: strscan
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: uri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: uri-idna
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !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: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/uri/whatwg_parser.rb
+- lib/uri/whatwg_parser/error.rb
+- lib/uri/whatwg_parser/host_parser.rb
+- lib/uri/whatwg_parser/parser_helper.rb
+- lib/uri/whatwg_parser/version.rb
+homepage: https://github.com/y-yagi/uri-whatwg_parser
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/y-yagi/uri-whatwg_parser
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Ruby implementation of the WHATWG URL Living Standard
+test_files: []