dommy 0.12.0 → 0.13.0

data/lib/dommy/html_elements.rb

@@ -241,107 +241,169 @@ module Dommy
     end
   end
 
-  # The HTMLHyperlinkElementUtils IDL mixin, shared by <a> and <area>. `href`
-  # reads back as the RESOLVED absolute URL (the URL-decomposition IDL
-  # attributes all report resolved values), while the setter writes the content
-  # attribute verbatim — `link.href = url` is how most code sets a link.
+  # The HTMLHyperlinkElementUtils IDL mixin, shared by <a> and <area>. The
+  # `href` content attribute, parsed against the document base URL, is the
+  # element's URL; every getter reads a component of it and every setter
+  # changes that component the way the URL API does, then writes the
+  # serialization back into the attribute. Without an href there is no URL
+  # and the getters return the empty string (":" for protocol); an href that
+  # does not parse reads back as written.
+  #
+  # Spec: https://html.spec.whatwg.org/multipage/links.html#htmlhyperlinkelementutils
   module HyperlinkUtils
+    URL_COMPONENTS = %w[origin protocol username password host hostname port pathname search hash].freeze
+
     # WebIDL stringifier: `String(link)` / `link.toString()` is its href (the
     # resolved absolute URL), not the element's serialization.
     def to_s
-      anchor_href
+      href
     end
 
     def href
-      anchor_href
+      raw = @__node__["href"]
+      return "" if raw.nil?
+
+      url = hyperlink_url
+      url ? url.href : raw
     end
 
     def href=(value)
       set_attribute("href", value.to_s)
     end
 
-    # URL-decomposition helpers. The href is resolved to an absolute URL
-    # (Element#anchor_href); break it into the standard components on demand.
-    def hash
-      uri_part(:fragment) ? "##{uri_part(:fragment)}" : ""
+    def origin
+      url = hyperlink_url
+      url ? url.origin : ""
+    end
+
+    def protocol
+      url = hyperlink_url
+      url ? url.protocol : ":"
+    end
+
+    def protocol=(value)
+      change_url { |url| url.protocol = value }
+    end
+
+    def username
+      hyperlink_url&.username.to_s
+    end
+
+    def username=(value)
+      change_url { |url| url.username = value }
+    end
+
+    def password
+      hyperlink_url&.password.to_s
+    end
+
+    def password=(value)
+      change_url { |url| url.password = value }
     end
 
     def host
-      uri.host ? "#{uri.host}#{port_suffix}" : ""
+      hyperlink_url&.host.to_s
+    end
+
+    def host=(value)
+      change_url { |url| url.host = value }
     end
 
     def hostname
-      uri.host || ""
+      hyperlink_url&.hostname.to_s
+    end
+
+    def hostname=(value)
+      change_url { |url| url.hostname = value }
+    end
+
+    def port
+      hyperlink_url&.port.to_s
+    end
+
+    def port=(value)
+      change_url { |url| url.port = value }
     end
 
     def pathname
-      uri.path || "/"
+      hyperlink_url&.pathname.to_s
     end
 
-    def protocol
-      uri.scheme ? "#{uri.scheme}:" : ""
+    def pathname=(value)
+      change_url { |url| url.pathname = value }
     end
 
     def search
-      uri.query ? "?#{uri.query}" : ""
+      hyperlink_url&.search.to_s
     end
 
-    def port
-      uri.port ? uri.port.to_s : ""
+    def search=(value)
+      change_url { |url| url.search = value }
     end
 
-    def origin
-      uri.scheme && uri.host ? "#{uri.scheme}://#{uri.host}#{port_suffix}" : ""
+    def hash
+      hyperlink_url&.hash.to_s
+    end
+
+    def hash=(value)
+      change_url { |url| url.hash = value }
     end
 
     def __js_get__(key)
       case key
-      when "href"
-        href
-      when "hash"
-        self.hash
-      when "host"
-        host
-      when "hostname"
-        hostname
-      when "pathname"
-        pathname
-      when "protocol"
-        protocol
-      when "search"
-        search
-      when "port"
-        port
-      when "origin"
-        origin
-      else
-        super
+      when "href" then href
+      when "origin" then origin
+      when "protocol" then protocol
+      when "username" then username
+      when "password" then password
+      when "host" then host
+      when "hostname" then hostname
+      when "port" then port
+      when "pathname" then pathname
+      when "search" then search
+      when "hash" then self.hash
+      else super
       end
     end
 
     def __js_set__(key, value)
-      key == "href" ? (self.href = value) : super
+      case key
+      when "href" then self.href = value
+      when "protocol" then self.protocol = value
+      when "username" then self.username = value
+      when "password" then self.password = value
+      when "host" then self.host = value
+      when "hostname" then self.hostname = value
+      when "port" then self.port = value
+      when "pathname" then self.pathname = value
+      when "search" then self.search = value
+      when "hash" then self.hash = value
+      else super
+      end
     end
 
     private
 
-    def uri
-      require "uri"
+    # HTML "reinitialize url": the href attribute parsed against the
+    # document base URL, or nil when there is none or it does not parse.
+    def hyperlink_url
+      raw = @__node__["href"]
+      return nil if raw.nil?
 
-      URI(anchor_href)
-    rescue URI::InvalidURIError, ArgumentError
-      URI("")
-    end
-
-    def uri_part(part)
-      uri.send(part)
+      base = @document.base_uri.to_s
+      URL.new(raw, base.empty? ? nil : base)
+    rescue Bridge::TypeError
+      nil
     end
 
-    def port_suffix
-      return "" unless uri.port
+    # A setter: nothing without a URL; otherwise the change, then "update
+    # href" with the serialization.
+    def change_url
+      url = hyperlink_url
+      return unless url
 
-      default = uri.scheme == "https" ? 443 : 80
-      uri.port == default ? "" : ":#{uri.port}"
+      yield url
+      set_attribute("href", url.href)
     end
   end
 
@@ -747,12 +809,12 @@ module Dommy
       str.gsub(/[\r\n]/, "")
     end
 
+    # HTML's value sanitization for number and range: anything that is not a
+    # valid floating-point number, or is out of the finite range, is the
+    # empty string. Ruby's Float() is wider than the spec (" 1", "+1", "1.").
     def sanitize_number(raw)
       s = raw.to_s
-      Float(s)
-      s
-    rescue ArgumentError, TypeError
-      ""
+      parse_valid_float(s).finite? ? s : ""
     end
 
     # Underlying string the user supplied to `value=`, before any
@@ -1068,10 +1130,15 @@ module Dommy
       return if mn && mx && mn > mx
 
       before = value_as_number
-      base = before.nan? ? (mn || 0.0) : before
+      # The arithmetic runs on the decimal values the attributes spell, not on
+      # their nearest doubles: 0.1 + 0.1 + 0.1 is 0.3, not 0.30000000000000004.
+      allowed = decimal(allowed)
+      mn = decimal(mn) if mn
+      mx = decimal(mx) if mx
+      base = before.nan? ? (mn || 0r) : decimal(before)
       result = base + count * allowed
 
-      step_base = mn || 0.0
+      step_base = mn || 0r
       result = mx - (mx - step_base) % allowed if mx && result > mx
       result = mn + (step_base - mn) % allowed if mn && result < mn
 
@@ -1082,10 +1149,16 @@ module Dommy
         return if count.negative? && result > before
       end
 
-      self.value_as_number = result
+      self.value_as_number = result.to_f
       nil
     end
 
+    # The decimal number a double stands for: 0.1 is 1/10, not the binary
+    # fraction nearest to it.
+    def decimal(number)
+      number.rationalize(Rational(1, 10**12))
+    end
+
     # The scale that turns one declared step into valueAsNumber units (ms for the
     # date/time types, natural units for number/range/month).
     def step_scale_factor
@@ -1132,7 +1205,8 @@ module Dommy
     # WHATWG "valid floating-point number": no surrounding whitespace (unlike
     # Ruby's Float()), optional sign, digits with optional fraction, optional
     # exponent. Anything else — including " 1 " or "1e" — yields NaN.
-    VALID_FLOAT_RE = /\A-?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?\z/
+    # A fraction needs a digit after the dot, so "1." is not a number.
+    VALID_FLOAT_RE = /\A-?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][-+]?\d+)?\z/
 
     def parse_valid_float(str)
       s = str.to_s

data/lib/dommy/internal/exception_report.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Dommy
+  module Internal
+    # Shared shaping for WHATWG "report an exception": turn whatever a throwing
+    # entry point handed us into the pair the report needs — the value to expose
+    # as `ErrorEvent#error` and the string to expose as `ErrorEvent#message`.
+    #
+    # Two shapes arrive. A JS callback's throw comes wrapped in a
+    # `Bridge::ThrowValue` carrying the thrown JS value with its identity intact
+    # (so `event.error === thrown` holds in the page); everything else is a plain
+    # Ruby exception raised by the host or the engine. Unwrapping in one place
+    # keeps every report site (event dispatch, script evaluation, a timer
+    # callback, `reportError`) agreeing on what the page sees.
+    module ExceptionReport
+      module_function
+
+      # The `error` value a report should expose: a ThrowValue's payload keeps
+      # JS identity, anything else reports itself.
+      def error_value(error)
+        error.is_a?(Bridge::ThrowValue) ? error.value : error
+      end
+
+      # The `message` a report should expose for `error`. A JS Error proxy and a
+      # Ruby exception both answer `message`; a thrown non-Error (a string, an
+      # object literal) has only its string form.
+      def message_for(error)
+        value = error_value(error)
+        return value.message.to_s if value.respond_to?(:message)
+
+        value.to_s
+      end
+
+      # Both halves at once, for a caller that needs the pair.
+      def describe(error)
+        [error_value(error), message_for(error)]
+      end
+
+      # One JS stack frame, in either of the two forms an engine writes:
+      # `at name (file:line:col)` and the anonymous `at file:line:col`.
+      STACK_FRAME = /\Aat\s+(?:\S+\s+\()?(?<file>.+?):(?<line>\d+):(?<column>\d+)\)?\z/
+
+      # Frames inside Dommy's own JS plumbing. The page did not write them, so
+      # they must not be reported as where its error happened.
+      INTERNAL_SOURCES = %w[host_runtime.js observable_runtime.js].freeze
+
+      # Where the error happened, as `ErrorEvent`'s [filename, lineno, colno].
+      # A JS engine puts its frames on the raised exception's backtrace, so the
+      # topmost frame the PAGE owns is the position to report. Zeroes when there
+      # is no usable frame, which is what the spec says to expose when the
+      # position is unknown.
+      def source_position(error)
+        Array(error.backtrace).each do |frame|
+          match = STACK_FRAME.match(frame.to_s.strip)
+          next unless match
+          next if INTERNAL_SOURCES.any? { |source| match[:file].end_with?(source) }
+
+          return [match[:file], match[:line].to_i, match[:column].to_i]
+        end
+        ["", 0, 0]
+      end
+
+      # WHATWG "report an exception" at `window`, shaping the thrown value, its
+      # message and its source position from whatever the entry point caught.
+      # Every entry point reports through here, so none of them can drift from
+      # the others in what the page gets to see. Returns whether the page
+      # handled it.
+      # `value` overrides what the page sees as `event.error`, for a caller that
+      # can supply a better one than the raw catch: an engine that converted the
+      # throw to a host exception can rebuild the JS Error the page threw, which
+      # is the difference between a handler reading `.message` and one crashing
+      # on `undefined`.
+      def report_at(window, error, value: nil)
+        value ||= error_value(error)
+        message = message_for(error)
+        file, line, column = source_position(error)
+        window.__internal_report_exception__(value, message,
+          filename: document_source(file, window), lineno: line, colno: column, host_error: error)
+      end
+
+      # What an engine calls source it was handed with no name of its own — an
+      # inline `<script>`, an `eval`. A browser reports the document's URL for
+      # those, so the placeholder is swapped for it rather than leaking an
+      # engine-internal name into `ErrorEvent#filename`.
+      ANONYMOUS_SOURCES = ["<code>", "<input>", "<eval>", "<anonymous>"].freeze
+
+      def document_source(file, window)
+        return file unless ANONYMOUS_SOURCES.include?(file)
+
+        location = window.location if window.respond_to?(:location)
+        location.respond_to?(:href) ? location.href.to_s : file
+      end
+
+      # A host-loggable exception for a value that came straight off the bridge
+      # with no exception attached — a rejection reason, which the engine hands
+      # over as the JS value itself. `Bridge::ThrowValue` is that shape already:
+      # it is raisable, keeps the value, and takes the JS frames as its backtrace
+      # so the report can still say where the page failed.
+      def thrown_host_error(value)
+        return value if value.is_a?(::Exception)
+
+        name = value.js_name if value.respond_to?(:js_name)
+        text = value.to_s
+        error = Bridge::ThrowValue.new(value, name && name != "Object" ? "#{name}: #{text}" : text)
+        frames = value.respond_to?(:stack_frames) ? value.stack_frames : nil
+        error.set_backtrace(frames) if frames && !frames.empty?
+        error
+      end
+
+      # The form the HOST logs. A report's `error` value is whatever the page
+      # threw, which for JS code is an opaque `Bridge::JSValue` with no `class` /
+      # `message` / backtrace — everything an error log wants. A caller that has
+      # the original Ruby exception passes it as `host_error`; otherwise the bare
+      # value is wrapped, so the log never has to special-case what it holds.
+      def host_form(error_value, host_error)
+        return host_error if host_error
+        return error_value if error_value.is_a?(::Exception)
+
+        Bridge::ThrowValue.new(error_value)
+      end
+    end
+  end
+end

data/lib/dommy/internal/idna.rb

@@ -7,7 +7,7 @@ module Dommy
     # IDNA ToASCII / ToUnicode for domain names. Built on
     # `Internal::Punycode` plus the Unicode tables in
     # `Internal::IDNAData` (generated by `script/build_idna_tables.rb`
-    # from Unicode 16.0 source files in `vendor/unicode/`).
+    # from Unicode 17.0 source files in `vendor/unicode/`).
     #
     # Conforms (approximately) to UTS #46 with WHATWG URL parameters:
     #
@@ -201,12 +201,12 @@ module Dommy
         end
       end
 
+      # UTS #46 V6: General_Category Mark (Mn, Mc or Me), which is wider than
+      # the Bidi class NSM; a spacing mark such as U+1B44 is L.
       def self.validate_no_leading_combining_mark(label)
         first_cp = label.codepoints.first
         return unless first_cp
-
-        bidi_class = bidi_class_of(first_cp)
-        return unless bidi_class == :NSM
+        return unless IDNAData.lookup(IDNAData::MARK, first_cp)
 
         raise Error, "label starts with combining mark: #{label.inspect}"
       end