dommy 0.9.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab840b2c863131b5f20d7be40f28028bec227fb490688b4b0f26157058c0ea68
-  data.tar.gz: a87acf4824167a08eae696de0ffe504cdf808d9085176e084b3e4f3d225e5c7a
+  metadata.gz: 47c59ce209a6e63313db2b6685126910463abfc26020ec5f24a7b7494b67b10f
+  data.tar.gz: 43980f4f5eb7b2c5bfe76e41bd2786e9c8cad571df1eb882e0e6d5107fbe04c6
 SHA512:
-  metadata.gz: db29082c6b8b686eb762aa53f3ae213b40da69210732c99a53f15a1f18318a326fd6bcf4c65fcfa4abc27dc41bebff0b16164682b7d18e7fed7a44415a9bb7e6
-  data.tar.gz: 71669401a09832106ec301e0b2d4747fb7782b2ac2514fbf4cfbf625358695f0c498561cbd3efb565b7b2abbaf43b4b2068dbe5f1831523a74ec25dc2c2e1435
+  metadata.gz: b2627fa8969554f7ecb7a04ed16c331a77e604b44a9ca9e95412a89e48412744a3dd606892255e93eb56988cfda5214000a15821bbc5eb6ed7d18701740b3262
+  data.tar.gz: 632bddbea02093111566d46ba9fc44af35ed17879bf9921c4ad477a138d44b83e2c2761337d34f5bdfa31cc150353a4b7afe47b0cca8d817e79eda95d7b556ad

data/lib/dommy/attr.rb

@@ -22,9 +22,12 @@ module Dommy
       nil
     end
 
-    def initialize(name, owner: nil, value: "", namespace_uri: nil, prefix: nil, local_name: nil)
+    def initialize(name, owner: nil, value: "", namespace_uri: nil, prefix: nil, local_name: nil, document: nil)
       qname = name.to_s
       @owner = owner
+      # The node document (for baseURI/ownerDocument when detached from an
+      # element). Owned attrs derive it from their owner instead.
+      @document = document
       @detached_value = value.to_s
       if namespace_uri && !namespace_uri.to_s.empty?
         # Namespaced attributes preserve case and carry prefix / localName.
@@ -50,13 +53,28 @@ module Dommy
       @owner
     end
 
+    # Node.baseURI — the node document's base URL. Derived from the owner
+    # element when attached, else the document the attr was created in.
+    def base_uri
+      return @owner.base_uri if @owner.respond_to?(:base_uri)
+
+      @document&.base_uri
+    end
+
+    # Node.ownerDocument — the owner element's current document when attached (so
+    # it follows the element across adoptNode), else the creation document.
+    def owner_document
+      return @owner.document if @owner.respond_to?(:document)
+
+      @document
+    end
+
     def value
       if @owner
-        if @namespace_uri
-          Backend.get_attribute_ns(@owner.__dommy_backend_node__, @namespace_uri, @local_name).to_s
-        else
-          @owner.__dommy_backend_node__[@name].to_s
-        end
+        # Both branches go through the namespace-aware read: the backend's
+        # `node[name]` indexes by local name, so a null-namespace `b` would read
+        # back the value of a prefixed `xml:b` sitting on the same element.
+        Backend.get_attribute_ns(@owner.__dommy_backend_node__, @namespace_uri, @local_name).to_s
       else
         @detached_value
       end
@@ -89,6 +107,8 @@ module Dommy
         value
       when "ownerElement"
         @owner
+      when "ownerDocument"
+        owner_document
       when "localName"
         @local_name
       when "namespaceURI"
@@ -97,6 +117,8 @@ module Dommy
         @prefix
       when "nodeType"
         2
+      when "baseURI"
+        base_uri
       when "specified"
         # Legacy/useless attribute — always true (WHATWG DOM).
         true
@@ -119,12 +141,20 @@ module Dommy
     include Bridge::Methods
     js_methods %w[cloneNode isSameNode getRootNode hasChildNodes normalize compareDocumentPosition
       appendChild insertBefore removeChild replaceChild
+      lookupNamespaceURI lookupPrefix isDefaultNamespace
       addEventListener removeEventListener dispatchEvent]
     def __js_call__(method, args)
       case method
+      when "lookupNamespaceURI"
+        lookup_namespace_uri(args[0])
+      when "lookupPrefix"
+        lookup_prefix(args[0])
+      when "isDefaultNamespace"
+        is_default_namespace(args[0])
       when "cloneNode"
         Attr.new(@name, owner: nil, value: value,
-                        namespace_uri: @namespace_uri, prefix: @prefix, local_name: @local_name)
+                        namespace_uri: @namespace_uri, prefix: @prefix, local_name: @local_name,
+                        document: @document || (@owner.respond_to?(:document) ? @owner.document : nil))
       when "isSameNode"
         is_same_node(args[0])
       when "getRootNode"
@@ -209,7 +239,9 @@ module Dommy
     end
 
     def get_named_item(name)
-      key = name.to_s.downcase
+      # getNamedItem / getAttribute lowercase the qualified name only for an HTML
+      # element in an HTML document; other elements match case-sensitively.
+      key = @element.__internal_normalize_attr_key__(name)
       node = Backend.attribute_nodes(@element.__dommy_backend_node__).find do |a|
         Backend.attribute_ns_info(a)[:qualified_name] == key
       end
@@ -221,7 +253,7 @@ module Dommy
     end
 
     def remove_named_item(name)
-      key = name.to_s.downcase
+      key = @element.__internal_normalize_attr_key__(name)
       node = Backend.attribute_nodes(@element.__dommy_backend_node__).find do |a|
         Backend.attribute_ns_info(a)[:qualified_name] == key
       end
@@ -329,12 +361,17 @@ module Dommy
       end
     end
 
-    # WebIDL "supported property names" for NamedNodeMap: the qualified name of
-    # each attribute, in order (the indexed names are reflected separately).
+    # WebIDL "supported property names" for NamedNodeMap: each attribute's
+    # qualified name, in order with duplicates omitted (the indexed names are
+    # reflected separately). For an HTML element in an HTML document, names
+    # containing an ASCII upper alpha are excluded (they can't be reached by the
+    # case-insensitive named getter).
     def __js_named_props__
-      Backend.attribute_nodes(@element.__dommy_backend_node__).map do |a|
+      names = Backend.attribute_nodes(@element.__dommy_backend_node__).map do |a|
         Backend.attribute_ns_info(a)[:qualified_name]
-      end
+      end.uniq
+      names.reject! { |n| n.match?(/[A-Z]/) } unless @element.__internal_case_sensitive_attribute_names__?
+      names
     end
 
     include Bridge::Methods

data/lib/dommy/backend/makiri_adapter.rb

@@ -21,6 +21,7 @@ module Dommy
       CDATASection = ::Makiri::CDATASection
       ProcessingInstruction = ::Makiri::ProcessingInstruction
       DocumentFragment = ::Makiri::DocumentFragment
+      DocumentType = ::Makiri::DocumentType
       Node = ::Makiri::Node
 
       # A minimal namespace wrapper exposing the same `href` API that Nokogiri's
@@ -168,6 +169,39 @@ module Dommy
         doc.create_element(name)
       end
 
+      # An XML-backed document rejects a qualified name that DOM allows (e.g.
+      # "f}oo" — an invalid char in the local part), so createElementNS uses
+      # Makiri's loose creator, which builds it verbatim (case/prefix preserved).
+      # nil for a non-XML backend → the caller uses the strict #create_element.
+      def create_element_loose(qualified_name, prefix, local, namespace, doc)
+        return nil unless doc.is_a?(::Makiri::XML::Document) && doc.respond_to?(:create_loose_dom_element)
+
+        doc.create_loose_dom_element(qualified_name, prefix, local, namespace)
+      end
+
+      # A detached DocumentType node owned by `doc`, for
+      # DOMImplementation.createDocumentType. Only the HTML backend ships the
+      # factory (`create_document_type`); nil signals the caller to fall back to a
+      # synthetic (non-tree) DocumentType. Raises ArgumentError for a name the
+      # factory rejects.
+      def create_document_type(name, public_id, system_id, doc)
+        return nil unless doc.respond_to?(:create_document_type)
+
+        doc.create_document_type(name.to_s, public_id.to_s, system_id.to_s)
+      end
+
+      # The parsed document's DocumentType node (`<!DOCTYPE …>`), or nil when the
+      # document declares none.
+      def internal_subset(doc)
+        doc.respond_to?(:internal_subset) ? doc.internal_subset : nil
+      end
+
+      # The backend class for a DocumentType node, so the wrapper routes it to
+      # Dommy::DocumentType (node-backed).
+      def document_type_class
+        ::Makiri::DocumentType
+      end
+
       def create_text(content, doc)
         doc.create_text_node(content)
       end
@@ -242,6 +276,12 @@ module Dommy
 
         node["xmlns:#{prefix}"] = href.to_s
         nil
+      rescue ArgumentError
+        # DOM validates a qualified name against the Name production, which
+        # admits prefixes an XML backend cannot spell as an `xmlns:` attribute
+        # ("0:a", ";:a"). The element is still valid — its prefix and namespace
+        # live on the wrapper — so the declaration is simply not written.
+        nil
       end
 
       def namespace_definitions(_node)
@@ -296,6 +336,22 @@ module Dommy
         node.attribute_nodes
       end
 
+      # Attribute node matching the qualified name exactly. `node[name]` would
+      # also answer for a prefixed attribute with that local name.
+      #
+      # This sits under `getAttribute` / `hasAttribute` / `setAttribute` /
+      # `removeAttribute`, so it runs on the hottest path in the library — every
+      # CSS match, every reflected IDL attribute — and Makiri does the scan
+      # natively (0.9.0). The value-returning spelling is what the two readers
+      # that only want the value ask for: it wraps no Attr at all.
+      def attr_by_qualified_name(node, qualified_name)
+        node.attribute_by_qualified_name(qualified_name.to_s)
+      end
+
+      def attr_value_by_qualified_name(node, qualified_name)
+        node.attribute_value_by_qualified_name(qualified_name.to_s)
+      end
+
       # Attribute node matching (namespace, local name) case-sensitively; a
       # null/empty namespace matches a null-namespace attribute.
       def attr_by_ns(node, namespace, local_name)

data/lib/dommy/backend.rb

@@ -130,6 +130,35 @@ module Dommy
         current.create_element(name, doc)
       end
 
+      # Create a namespaced element permitting a DOM-valid qualified name that a
+      # strict XML backend would reject (an internal invalid char like "f}oo"),
+      # preserving case/prefix. Returns nil when the backend has no loose path
+      # (fall back to #create_element); raises ArgumentError for a genuinely
+      # invalid name (the caller maps it to InvalidCharacterError).
+      def create_element_loose(qualified_name, prefix, local, namespace, doc)
+        current.create_element_loose(qualified_name, prefix, local, namespace, doc)
+      end
+
+      # A detached DocumentType node owned by `doc` (for
+      # DOMImplementation.createDocumentType). Returns nil when the backend has no
+      # doctype factory (the caller falls back to a synthetic DocumentType); raises
+      # ArgumentError for a name the factory rejects (the caller then also falls
+      # back, since createDocumentType is permissive).
+      def create_document_type(name, public_id, system_id, doc)
+        current.respond_to?(:create_document_type) ? current.create_document_type(name, public_id, system_id, doc) : nil
+      end
+
+      # The parsed document's DocumentType node, or nil when it declares none.
+      def internal_subset(doc)
+        current.respond_to?(:internal_subset) ? current.internal_subset(doc) : nil
+      end
+
+      # The backend class for a DocumentType node (nil if unsupported), so the
+      # wrapper cache can route it to Dommy::DocumentType.
+      def document_type_class
+        current.respond_to?(:document_type_class) ? current.document_type_class : nil
+      end
+
       def create_text(content, doc)
         current.create_text(content, doc)
       end
@@ -204,6 +233,24 @@ module Dommy
         current.attribute_ns_info(attr_node)
       end
 
+      # The attribute node whose QUALIFIED name is `qualified_name`, or nil.
+      #
+      # WHATWG's by-name family ("get an attribute by name", `setAttribute`,
+      # `removeAttribute`) matches on the qualified name. A lookup by local name
+      # confuses `b` with a prefixed `xml:b`, so those paths must come through
+      # here rather than through `node[name]`.
+      def attr_by_qualified_name(node, qualified_name)
+        current.attr_by_qualified_name(node, qualified_name)
+      end
+
+      # That attribute's VALUE, or nil when there is no such attribute. The same
+      # match without an attribute node in hand, for the two readers that only
+      # ever wanted the value — `getAttribute` and `hasAttribute` — which run on
+      # every CSS match and every reflected IDL attribute.
+      def attr_value_by_qualified_name(node, qualified_name)
+        current.attr_value_by_qualified_name(node, qualified_name)
+      end
+
       # The element's attribute nodes (each readable via attribute_ns_info).
       # The single choke point so DOM code doesn't touch parser internals.
       def attribute_nodes(node)

data/lib/dommy/blob.rb

@@ -21,19 +21,26 @@ module Dommy
     # Promises (they need a scheduler). A window-less Blob falls back to a
     # synchronous result, which `await` still handles.
     def initialize(parts = [], options = {}, window = nil)
+      # WebIDL: an omitted / `undefined` blobParts argument defaults to an empty
+      # sequence (`new Blob()` / `new Blob(undefined)` is a zero-length Blob), so
+      # it must not be coerced to the string "undefined".
+      parts = [] if parts.nil? || (defined?(Bridge::UNDEFINED) && parts.equal?(Bridge::UNDEFINED))
       parts = [parts] unless parts.is_a?(Array)
       @data = collect_bytes(parts)
       @size = @data.bytesize
-      raw_type = options["type"] || options[:type] || ""
-      @type = raw_type.to_s.downcase
+      raw_type = (options["type"] || options[:type] || "").to_s
+      # A type string with any code point outside U+0020..U+007E is discarded
+      # (→ ""); otherwise it is ASCII-lowercased (FileAPI "parse a MIME type"
+      # gate, applied to both the constructor and slice's contentType).
+      @type = raw_type.match?(/[^ -~]/) ? "" : raw_type.downcase
       @window = window
     end
 
     # Return a new Blob over a byte range of this one.
     # Negative indices are treated as offsets from the end (per spec).
     def slice(start = 0, last = @size, content_type = "")
-      s = clamp_index(start.to_i, @size)
-      e = clamp_index(last.to_i, @size)
+      s = clamp_index(clamp_long_long(start), @size)
+      e = clamp_index(clamp_long_long(last), @size)
       e = s if e < s
       Blob.new([@data.byteslice(s, e - s) || ""], {"type" => content_type.to_s}, @window)
     end
@@ -51,6 +58,13 @@ module Dommy
       Bridge::ArrayBuffer.new(@data.bytes)
     end
 
+    # Read the bytes as a Uint8Array (the spec return type). The DOM spec returns
+    # a Promise<Uint8Array>; Dommy is synchronous. `Bridge::Bytes` crosses the JS
+    # boundary as a Uint8Array (vs `ArrayBuffer` for #array_buffer).
+    def bytes
+      Bridge::Bytes.new(@data.bytes)
+    end
+
     # Raw binary bytes (Ruby ASCII-8BIT string). Used by FormData /
     # fetch when serializing multipart bodies.
     def __dommy_bytes__
@@ -71,17 +85,30 @@ module Dommy
     # Methods routed through __js_call__ (keep in sync with its when-arms).
     # File < Blob inherits these (it adds only properties).
     include Bridge::Methods
-    js_methods %w[slice text arrayBuffer]
+    js_methods %w[slice text arrayBuffer bytes]
     def __js_call__(method, args)
       case method
       when "slice"
-        slice(args[0] || 0, args[1] || @size, args[2] || "")
+        # An omitted / `undefined` start|end uses the default (0 / size); map
+        # UNDEFINED to nil so the `|| default` fallbacks apply (a bare UNDEFINED
+        # is truthy and has no #to_i). contentType is a plain DOMString: omitted
+        # / undefined → "" (default), but an explicit JS null coerces to "null".
+        a = args.map { |v| v.equal?(Bridge::UNDEFINED) ? nil : v }
+        ctype = if args.length < 3 || args[2].equal?(Bridge::UNDEFINED)
+          ""
+        else
+          args[2].nil? ? "null" : args[2].to_s
+        end
+        slice(a[0] || 0, a[1] || @size, ctype)
       when "text"
         # WHATWG: Blob.text() returns a Promise<string>.
         promise_or_value(text)
       when "arrayBuffer"
         # WHATWG: Blob.arrayBuffer() returns a Promise<ArrayBuffer>.
         promise_or_value(array_buffer)
+      when "bytes"
+        # WHATWG: Blob.bytes() returns a Promise<Uint8Array>.
+        promise_or_value(bytes)
       end
     end
 
@@ -115,6 +142,21 @@ module Dommy
       idx = length + idx if idx.negative?
       idx.clamp(0, length)
     end
+
+    # WebIDL `[Clamp] long long` conversion of a slice bound: a fractional value
+    # rounds to the nearest integer, ties to even (banker's rounding) — so
+    # `slice(1.5)` starts at 2 and `slice(3.5)` at 4, per the [Clamp] extended
+    # attribute on Blob.slice.
+    def clamp_long_long(value)
+      return value if value.is_a?(Integer)
+
+      f = value.to_f
+      return 0 if f.nan?
+
+      f.round(half: :even)
+    rescue StandardError
+      0
+    end
   end
 
   # `File` — Blob with a filename and an optional last-modified