uri-whatwg_parser 0.1.8 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4463680cf6d13f3daf3513549ebe358f7b45484888704bbefffcecbb1790b8c7
-  data.tar.gz: b5ec5b9ad687c53f71f2fa21bcb049215dfff6ecdcb8305594f569ba86c0b210
+  metadata.gz: 4ae0566e4902f0c52f40969d4b55ae40ac98b075bae062d8167895e847e91854
+  data.tar.gz: 1c9c1a764beb16e6719822138df7ef36fe5f02423052b4f436ae164a70eb7cab
 SHA512:
-  metadata.gz: 3ff5fd142e640d265e4d3bd11174e7658732430055d45cce16364bc783c85f7f642d3654d9621e2fa198d63f8e82959fa5d4588d611f6c3e3c3f2d46f382df9e
-  data.tar.gz: b389a5a39685d81ce3ade458b1d61746e9b0dca6e227b73658fe6c04910f20908a1669fd884c5e445bb401edc1db3915e21d15bdec8acf1b441c9c9b3e7e65d8
+  metadata.gz: d6dcb5018a93cd1f9a17ed84e5d409a0d6413efd405e50ea80f46169ad4b1970dd3e8732da209171c44a2f1a672f7e12b6914f1c5efa95ed882644a4e86393c1
+  data.tar.gz: 69e9afe795ab64751158bf69665de207649119c42f46a1aee9f34faea73a3756d1d4f4c2b5ffd22eab159c932056fbf1820f6dfc2855015d57dfb0c83910185b

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 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

@@ -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.encode_userinfo(v))
       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.encode_userinfo(v))
       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

@@ -11,7 +11,7 @@ class URI::WhatwgParser
     FORBIDDEN_DOMAIN_CODE_POINT = FORBIDDEN_HOST_CODE_POINT + C0_CONTROL_PERCENT_ENCODE_SET + ["%", "\x7f"]
 
     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?("]")
@@ -198,8 +198,6 @@ class URI::WhatwgParser
       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)

data/lib/uri/whatwg_parser/version.rb

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

data/lib/uri/whatwg_parser.rb

@@ -24,7 +24,7 @@ module URI
 
     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")
 
     def initialize
       reset
@@ -35,41 +35,57 @@ 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, 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))
     end
 
-    def split(uri, base = nil, encoding = Encoding::UTF_8) # :nodoc:
+    def split(input, base: nil, encoding: Encoding::UTF_8, url: nil, state_override: nil) # :nodoc:
       reset
       @base = nil
       if base != nil
-        ary = split(base, nil, encoding)
+        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
         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
+      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
+
       @encoding = encoding
-      @uri = uri.dup
-      @uri.sub!(/\A[\u0000-\u0020]*/, "")
-      @uri.sub!(/[\u0000-\u0020]*\z/, "")
-      @uri.delete!("\t")
-      @uri.delete!("\n")
-      @uri.delete!("\r")
+      @input = input.dup
 
-      raise ParseError, "uri can't be empty" if uri.empty? && @base.nil?
+      unless url
+        @input.sub!(/\A[\u0000-\u0020]*/, "")
+        @input.sub!(/[\u0000-\u0020]*\z/, "")
+      end
+
+      @input.delete!("\t")
+      @input.delete!("\n")
+      @input.delete!("\r")
 
       @pos = 0
 
-      while @pos <= @uri.length
-        c = @uri[@pos]
-        send(@state, c)
+      while @pos <= @input.length
+        c = @input[@pos]
+        ret = send(@state, c)
+        break if ret == :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
     end
 
@@ -77,14 +93,20 @@ module URI
       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
     end
 
+    def encode_userinfo(str)
+      str.chars.map do |char|
+        percent_encode(char, USERINFO_PERCENT_ENCODE_SET)
+      end.join
+    end
+
     private
 
     def reset
@@ -96,7 +118,7 @@ module URI
       @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
+      @state_override = nil
       @state = :scheme_start_state
     end
 
@@ -104,9 +126,11 @@ module URI
       if ascii_alpha?(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
 
@@ -114,7 +138,24 @@ module URI
       if ascii_alphanumerica?(c) || ["+", "-", "."].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?)
+            return :terminate
+          end
+        end
+
         @parse_result[:scheme] = @buffer
+
+        if @state_override
+          if SPECIAL_SCHEME.value?(@parse_result[:port].to_i)
+            @parse_result[:port] = nil
+          end
+          return :terminate
+        end
+
         @buffer = +""
 
         if @parse_result[:scheme] == "file"
@@ -130,10 +171,12 @@ module URI
           @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
 
@@ -265,8 +308,12 @@ 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?)
         @buffer.clear
@@ -275,10 +322,13 @@ module URI
         @pos -= 1
         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?)
           @buffer.clear
           @state = :path_start_state
+          return :terminate if @state_override
         end
       else
         @inside_brackets = true if c == "["
@@ -290,19 +340,21 @@ module URI
     def port_state(c)
       if ascii_digit?(c)
         @buffer << c
-      elsif c.nil? || ["/", "?", "#"].include?(c) || (special_url? && c == "\\")
+      elsif c.nil? || ["/", "?", "#"].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
+          return :terminate if @state_override
         end
 
+        raise ParseError, "port is invalid value" if @state_override
         @state = :path_start_state
         @pos -= 1
       else
@@ -348,7 +400,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
@@ -360,49 +415,53 @@ module URI
       if c.nil? || c == "/" || c == "\\" || c == "?" || 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
+          return :terminate if @state_override
           @state = :path_start_state
         else
           host = @host_parser.parse(@buffer, !special_url?)
-          if host != "localhost"
-            @parse_result[:host] = host
-          end
-
+          host = "" if host == "localhost"
+          @parse_result[:host] = host
+          return :terminate if @state_override
           @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?
         @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)
@@ -449,7 +508,7 @@ module URI
         @encoding = Encoding::UTF_8
       end
 
-      if c.nil? || c == "#"
+      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
         @buffer.clear
@@ -469,15 +528,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 +549,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?
+      !@parse_result[:userinfo].nil? || (@username && !@username.empty?) || (@password && !@password.empty?)
+    end
+
     def rest
-      @uri[@pos+1..]
+      @input[@pos+1..]
     end
 
     def convert_to_uri(uri)
@@ -510,8 +572,10 @@ module URI
       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.0
 platform: ruby
 authors:
 - Yuji Yaginuma
@@ -87,7 +87,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: []