dommy 0.5.0 → 0.7.0

data/lib/dommy/url.rb

@@ -30,7 +30,7 @@ module Dommy
 
     class << self
       # Create a unique blob: URL that resolves back to `blob` via
-      # `URL.__resolve_blob_url__(url)`. Returns nil for non-Blob input.
+      # `URL.__test_resolve_blob_url__(url)`. Returns nil for non-Blob input.
       def create_object_url(blob)
         return nil unless blob.is_a?(Blob)
 
@@ -53,14 +53,31 @@ module Dommy
 
       # Resolve a blob: URL back to its Blob, or nil if revoked / unknown.
       # Internal — used by fetch / XHR implementations that load blob URLs.
-      def __resolve_blob_url__(url)
+      def __test_resolve_blob_url__(url)
         @blob_urls[url.to_s]
       end
 
       # Test seam: drop all registered blob URLs.
-      def __reset_blob_urls__
+      def __test_reset_blob_urls__
         @blob_urls.clear
       end
+
+      # WHATWG URL Standard — `URL.parse(input, base)` is the
+      # non-throwing static factory. Returns a URL on success, `nil`
+      # on parse failure. The constructor (`new URL(...)`) raises
+      # `SyntaxError` for the same failure case.
+      def parse(input, base = nil)
+        new(input, base)
+      rescue DOMException::SyntaxError
+        nil
+      end
+
+      # WHATWG URL Standard — `URL.canParse(input, base)`. Boolean
+      # counterpart to `parse`: lets callers peek at validity
+      # without rescuing an exception or holding a URL reference.
+      def can_parse(input, base = nil)
+        !parse(input, base).nil?
+      end
     end
 
     attr_reader :search_params
@@ -78,7 +95,7 @@ module Dommy
     def href=(value)
       raw = parse_with_base(value.to_s, nil)
       @uri = raw
-      @search_params.__replace__(raw.query.to_s)
+      @search_params.__internal_replace__(raw.query.to_s)
       build_href
     end
 
@@ -93,7 +110,7 @@ module Dommy
 
     def host
       port = @uri.port
-      default = @uri.default_port
+      default = default_port_for(@uri.scheme.to_s.downcase)
       hostpart = @uri.host.to_s
       return hostpart if port.nil? || port == default
 
@@ -111,11 +128,14 @@ module Dommy
     end
 
     def hostname=(value)
-      @uri.host = value.to_s
+      # WHATWG: a non-ASCII hostname assigned through the setter is
+      # Punycode-encoded before storage (matches `new URL("...")`).
+      @uri.host = Internal::IDNA.to_ascii(value.to_s)
     end
 
     def port
-      return "" if @uri.port.nil? || @uri.port == @uri.default_port
+      default = default_port_for(@uri.scheme.to_s.downcase)
+      return "" if @uri.port.nil? || @uri.port == default
 
       @uri.port.to_s
     end
@@ -124,8 +144,18 @@ module Dommy
       @uri.port = value.to_s.empty? ? nil : value.to_i
     end
 
+    # WHATWG: for opaque-body schemes (javascript:, mailto:, data:,
+    # tel:, blob:) the body sits in `URI`'s `opaque` slot, not `path`.
+    # For special schemes (http/https/ws/wss/ftp), an empty path is
+    # canonicalized to `"/"`.
     def pathname
-      @uri.path.to_s
+      opaque = @uri.respond_to?(:opaque) ? @uri.opaque : nil
+      return opaque.to_s if opaque
+
+      path = @uri.path.to_s
+      return "/" if path.empty? && special_scheme?
+
+      path
     end
 
     def pathname=(value)
@@ -134,15 +164,19 @@ module Dommy
       @uri.path = v
     end
 
+    # WHATWG: `url.search` is the raw query string (with `?` prefix),
+    # preserving percent-encoding and stray `?` characters as parsed.
+    # `url.searchParams.toString()` re-serializes via the form-encoded
+    # contract (`+` for space, etc.) — distinct from `url.search`.
     def search
-      q = @search_params.to_s
-      q.empty? ? "" : "?#{q}"
+      q = @uri.query
+      q.nil? || q.empty? ? "" : "?#{q}"
     end
 
     def search=(value)
       q = value.to_s.sub(/^\?/, "")
-      @search_params.__replace__(q)
-      sync_uri_query
+      @uri.query = q.empty? ? nil : q
+      @search_params.__internal_replace__(q)
     end
 
     def hash
@@ -155,11 +189,30 @@ module Dommy
       @uri.fragment = f.empty? ? nil : f
     end
 
+    # WHATWG URL §origin. Tuple origins for http(s) / ws(s) / ftp;
+    # `"null"` for file/data/javascript/etc. Blob URLs unwrap their
+    # inner URL recursively.
     def origin
-      return "null" unless @uri.scheme && @uri.host
+      scheme = @uri.scheme.to_s.downcase
+      return blob_inner_origin if scheme == "blob"
+      return "null" unless TUPLE_ORIGIN_SCHEMES.include?(scheme)
+      return "null" unless @uri.host
+
+      default = default_port_for(scheme)
+      port_part = (@uri.port && @uri.port != default) ? ":#{@uri.port}" : ""
+      "#{scheme}://#{@uri.host}#{port_part}"
+    end
+
+    def blob_inner_origin
+      # `blob:<inner-url>` — the body after `blob:` is itself a URL
+      # whose origin we adopt. Anything that fails to parse falls
+      # back to "null".
+      opaque = @uri.respond_to?(:opaque) ? @uri.opaque : nil
+      return "null" if opaque.nil? || opaque.empty?
 
-      port_part = (@uri.port && @uri.port != @uri.default_port) ? ":#{@uri.port}" : ""
-      "#{@uri.scheme}://#{@uri.host}#{port_part}"
+      URL.new(opaque).origin
+    rescue DOMException::SyntaxError
+      "null"
     end
 
     def username
@@ -253,44 +306,236 @@ module Dommy
     # Called by URLSearchParams when it mutates; we need to keep the
     # underlying URI's query string in sync so subsequent `href` is
     # accurate.
-    def __notify_params_changed__
+    def __internal_notify_params_changed__
       sync_uri_query
     end
 
+    SPECIAL_SCHEMES = %w[http https ws wss ftp file].freeze
+
+    # WHATWG: only http(s) / ws(s) / ftp produce a tuple origin. file
+    # / data / javascript / etc. resolve to `"null"`. `blob:` is
+    # handled specially (inner-URL origin).
+    TUPLE_ORIGIN_SCHEMES = %w[http https ws wss ftp].freeze
+
+    # Default ports per scheme (Ruby URI knows http/https/ftp; we add
+    # ws/wss).
+    DEFAULT_PORTS = {
+      "http" => 80,
+      "https" => 443,
+      "ws" => 80,
+      "wss" => 443,
+      "ftp" => 21
+    }.freeze
+
+    # Chars that Ruby URI rejects in the path/query/fragment portion
+    # but WHATWG silently percent-encodes.
+    UNSAFE_PATH_CHARS = /[ "<>`{}|\\\^\[\]]/
+
     private
 
+    def special_scheme?
+      SPECIAL_SCHEMES.include?(@uri.scheme.to_s.downcase)
+    end
+
+    def default_port_for(scheme)
+      DEFAULT_PORTS[scheme]
+    end
+
     def parse_with_base(input, base)
-      str = input.to_s
+      str = preprocess(input.to_s)
       uri = nil
       if base
-        base_uri = base.is_a?(URL) ? URI.parse(base.href) : URI.parse(base.to_s)
+        base_str = preprocess(base.is_a?(URL) ? base.href : base.to_s)
+        base_uri = URI.parse(base_str)
         uri = URI.join(base_uri, str)
       else
         uri = URI.parse(str)
         raise DOMException::SyntaxError, "Invalid URL: #{str}" unless uri.scheme
       end
 
+      normalize_path_segments(uri) if special_scheme_for?(uri)
       uri
     rescue URI::InvalidURIError => e
       raise DOMException::SyntaxError, "Invalid URL: #{e.message}"
+    rescue Internal::Punycode::Error, Internal::IDNA::Error => e
+      raise DOMException::SyntaxError, "Invalid URL host: #{e.message}"
+    end
+
+    # WHATWG URL preprocessing — turn a raw input string into a form
+    # Ruby URI accepts. Order matters: each step can depend on
+    # earlier normalizations.
+    def preprocess(str)
+      str = strip_c0_and_space(str)
+      str = strip_tab_and_newline(str)
+      str = replace_backslashes_for_special_scheme(str)
+      str = normalize_idn_host(str)
+      str = normalize_ipv4_host(str)
+      percent_encode_unsafe(str)
+    end
+
+    # WHATWG §basic-url-parser step 1: strip leading and trailing
+    # C0 controls and ASCII space.
+    def strip_c0_and_space(str)
+      str.sub(/\A[\x00-\x20]+/, "").sub(/[\x00-\x20]+\z/, "")
+    end
+
+    # WHATWG: remove ASCII tab and newline anywhere in the URL.
+    def strip_tab_and_newline(str)
+      str.delete("\t\n\r")
+    end
+
+    # WHATWG: for special-scheme URLs, treat `\` as `/` in the
+    # authority and path portions.
+    def replace_backslashes_for_special_scheme(str)
+      m = str.match(/\A([a-zA-Z][a-zA-Z0-9+.\-]*):/)
+      return str unless m
+      return str unless SPECIAL_SCHEMES.include?(m[1].downcase)
+
+      scheme_end = m.end(0)
+      str[0...scheme_end] + str[scheme_end..].tr("\\", "/")
+    end
+
+    # Percent-encode chars after the authority section that Ruby URI
+    # would reject (space, `<`, `>`, `{`, `}`, `|`, etc.) and any
+    # non-ASCII byte. Preserves already-encoded `%XX` sequences.
+    def percent_encode_unsafe(str)
+      m = str.match(%r{\A([a-zA-Z][a-zA-Z0-9+.\-]*:(?://[^/?#]*)?)(.*)\z}m)
+      return str unless m
+
+      prefix = m[1]
+      tail = m[2]
+      out = +""
+      i = 0
+      while i < tail.length
+        c = tail[i]
+        if c == "%" && tail[i + 1, 2].to_s.match?(/\A[0-9A-Fa-f]{2}\z/)
+          out << tail[i, 3]
+          i += 3
+          next
+        end
+
+        needs_encoding = c.bytesize > 1 ||
+          c.ord < 0x20 ||
+          c.ord == 0x7F ||
+          UNSAFE_PATH_CHARS.match?(c)
+
+        if needs_encoding
+          c.bytes.each { |b| out << format("%%%02X", b) }
+        else
+          out << c
+        end
+
+        i += 1
+      end
+
+      prefix + out
+    end
+
+    # Detect dotted-quad / hex / octal / short-form IPv4 hosts and
+    # canonicalize to dotted-decimal. Touches the authority section
+    # only; non-special schemes are skipped.
+    def normalize_ipv4_host(str)
+      m = str.match(%r{\A([a-zA-Z][a-zA-Z0-9+.\-]*://(?:[^@/?#]*@)?)([^/:?#]+)(.*)\z}m)
+      return str unless m
+
+      scheme = str.match(/\A([a-zA-Z][a-zA-Z0-9+.\-]*):/)[1].downcase
+      return str unless SPECIAL_SCHEMES.include?(scheme)
+
+      ip = Internal::Ipv4Parser.parse(m[2])
+      return str unless ip
+
+      "#{m[1]}#{ip}#{m[3]}"
+    end
+
+    def special_scheme_for?(uri)
+      SPECIAL_SCHEMES.include?(uri.scheme.to_s.downcase)
+    end
+
+    # WHATWG: resolve `.` / `..` path segments. Applied only to
+    # special-scheme URIs (opaque schemes' path is verbatim).
+    def normalize_path_segments(uri)
+      path = uri.path
+      return if path.nil? || path.empty?
+
+      segments = path.split("/", -1)
+      result = []
+      segments.each do |seg|
+        case seg
+        when ".."
+          # Pop unless we'd remove the leading-empty marker.
+          result.pop if result.length > 1
+        when "."
+          # Skip.
+        else
+          result << seg
+        end
+      end
+
+      # Preserve the trailing slash if the input had one.
+      result << "" if path.end_with?("/", ".") && result.last != ""
+      uri.path = result.join("/")
+    end
+
+    # WHATWG: non-ASCII host labels must be Punycode-encoded
+    # (`日本.test` → `xn--wgv71a.test`) before storage. Ruby's URI
+    # parser rejects non-ASCII hosts outright, so we rewrite the host
+    # portion of the authority section here. Userinfo / port / path /
+    # query / fragment are left untouched.
+    def normalize_idn_host(str)
+      return str unless str.is_a?(String)
+      return str unless str.match?(%r{://})
+
+      str.sub(%r{(://)([^/?#]*)}) do
+        sep = Regexp.last_match(1)
+        authority = Regexp.last_match(2)
+        sep + rewrite_authority(authority)
+      end
+    end
+
+    def rewrite_authority(authority)
+      userinfo, hostport = authority.include?("@") ? authority.split("@", 2) : [nil, authority]
+      host, port = hostport.rpartition(":").then { |h, sep, p|
+        sep.empty? || h.empty? ? [hostport, nil] : [h, p]
+      }
+
+      ascii_host = Internal::IDNA.to_ascii(host)
+      out = +""
+      out << "#{userinfo}@" if userinfo
+      out << ascii_host
+      out << ":#{port}" if port
+      out
     end
 
     def build_href
       out = +""
       out << "#{@uri.scheme}:" if @uri.scheme
-      if @uri.host
-        out << "//"
-        if @uri.user
-          out << @uri.user
-          out << ":#{@uri.password}" if @uri.password
-          out << "@"
+
+      opaque = @uri.respond_to?(:opaque) ? @uri.opaque : nil
+      if opaque
+        # Opaque-body scheme (javascript:, mailto:, data:, tel:, blob:)
+        # — emit the body verbatim, no authority section.
+        out << opaque
+      else
+        if @uri.host
+          out << "//"
+          if @uri.user
+            out << @uri.user
+            out << ":#{@uri.password}" if @uri.password
+            out << "@"
+          end
+
+          out << @uri.host
+          default = default_port_for(@uri.scheme.to_s.downcase)
+          out << ":#{@uri.port}" if @uri.port && @uri.port != default
         end
 
-        out << @uri.host
-        out << ":#{@uri.port}" if @uri.port && @uri.port != @uri.default_port
+        path = @uri.path.to_s
+        # WHATWG: for special schemes the path is normalized to `/`
+        # when empty (matches `pathname` accessor).
+        path = "/" if path.empty? && special_scheme?
+        out << path
       end
 
-      out << @uri.path.to_s
       out << search
       out << hash
       out
@@ -408,7 +653,7 @@ module Dommy
       @pairs.map { |k, v| "#{encode(k)}=#{encode(v)}" }.join("&")
     end
 
-    def __replace__(query_string)
+    def __internal_replace__(query_string)
       @pairs = parse(query_string)
       nil
     end
@@ -473,7 +718,7 @@ module Dommy
     end
 
     def notify
-      @owner&.__notify_params_changed__
+      @owner&.__internal_notify_params_changed__
     end
   end
 end

data/lib/dommy/url_pattern.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Dommy
+  # `URLPattern` — pattern matching for URL components, modelled on
+  # the WICG URLPattern spec. Supports the path-like syntax familiar
+  # from Express / Sinatra / React Router:
+  #
+  #   /users/:id          → captures `id`
+  #   /docs/*             → captures the rest of the path as `0`
+  #   /api/:version+      → one-or-more segments
+  #   /api/:version?      → optional segment
+  #
+  # Each pattern is compiled per URL component (`protocol` / `username`
+  # / `password` / `hostname` / `port` / `pathname` / `search` / `hash`);
+  # `test(url)` returns boolean, `exec(url)` returns a result Hash
+  # whose `pathname.groups` etc. carry the captured values.
+  #
+  # Spec: https://urlpattern.spec.whatwg.org/
+  class URLPattern
+    COMPONENTS = %w[protocol username password hostname port pathname search hash].freeze
+
+    def initialize(init = nil, _base_url = nil)
+      @patterns = {}
+      input = init.is_a?(Hash) ? init.transform_keys(&:to_s) : {"pathname" => init.to_s}
+
+      COMPONENTS.each do |comp|
+        pattern = input[comp]
+        @patterns[comp] = pattern ? compile(pattern.to_s) : compile("*")
+      end
+    end
+
+    def test(input)
+      !exec(input).nil?
+    end
+
+    def exec(input)
+      values = extract_components(input)
+      result = {}
+
+      COMPONENTS.each do |comp|
+        compiled = @patterns[comp]
+        match = compiled[:regex].match(values[comp].to_s)
+        return nil unless match
+
+        groups = {}
+        compiled[:names].each_with_index do |name, idx|
+          groups[name] = match[idx + 1] if name
+        end
+
+        result[comp] = {"input" => values[comp].to_s, "groups" => groups}
+      end
+
+      result["inputs"] = [input]
+      result
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "test"
+        test(args[0])
+      when "exec"
+        exec(args[0])
+      end
+    end
+
+    private
+
+    def extract_components(input)
+      if input.is_a?(Hash)
+        h = input.transform_keys(&:to_s)
+        COMPONENTS.each_with_object({}) { |c, m| m[c] = h[c].to_s }
+      else
+        url_string = input.is_a?(URL) ? input.href : input.to_s
+        # Bare path / search / hash inputs are accepted: try to parse
+        # as a URL; if that fails, treat the whole string as a pathname.
+        u = (URL.new(url_string) rescue nil) ||
+          URL.new("http://example.test#{url_string.start_with?("/") ? url_string : "/#{url_string}"}")
+        {
+          "protocol" => u.protocol.sub(/:$/, ""),
+          "username" => u.username,
+          "password" => u.password,
+          "hostname" => u.hostname,
+          "port" => u.port,
+          "pathname" => u.pathname,
+          "search" => u.search.sub(/^\?/, ""),
+          "hash" => u.hash.sub(/^#/, "")
+        }
+      end
+    end
+
+    # Compile a URLPattern fragment into a Regexp + ordered capture
+    # names. Supported syntax:
+    #
+    #   *           → match anything (named "0", "1", ...)
+    #   :name       → match `[^/]+`
+    #   :name+      → match `[^/]+(?:/[^/]+)*`
+    #   :name?      → optional
+    #
+    # Literal chars are regex-escaped. This is a deliberately small
+    # subset of the spec — sufficient for typical routing patterns.
+    def compile(pattern)
+      names = []
+      wildcard_idx = 0
+      regex_src = +"\\A"
+      i = 0
+
+      while i < pattern.length
+        c = pattern[i]
+        case c
+        when "*"
+          names << wildcard_idx.to_s
+          wildcard_idx += 1
+          regex_src << "(.*)"
+          i += 1
+        when ":"
+          name_match = pattern[i + 1..].match(/\A([A-Za-z_][A-Za-z0-9_]*)([?+*]?)/)
+          break unless name_match
+
+          name = name_match[1]
+          modifier = name_match[2]
+          names << name
+          regex_src <<
+            case modifier
+            when "+"
+              "([^/]+(?:/[^/]+)*)"
+            when "?"
+              "([^/]*)"
+            when "*"
+              "(.*)"
+            else
+              "([^/]+)"
+            end
+          i += 1 + name_match[0].length
+        else
+          regex_src << Regexp.escape(c)
+          i += 1
+        end
+      end
+
+      regex_src << "\\z"
+      {regex: Regexp.new(regex_src), names: names}
+    end
+  end
+end

data/lib/dommy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dommy
-  VERSION = "0.5.0"
+  VERSION = "0.7.0"
 end