dommy 0.8.1 → 0.10.0

data/lib/dommy/backend.rb

@@ -2,24 +2,23 @@
 
 module Dommy
   # `Dommy::Backend` — pluggable HTML parser abstraction. Lets Dommy
-  # work with either Nokogiri (mature, full namespace support) or
-  # Nokolexbor (faster, HTML5-only). Internally, all DOM library
+  # work with Makiri (Lexbor-based, HTML5-only). Internally, all DOM library
   # code goes through this facade rather than referencing the parser
   # directly.
   #
-  # Defaults to Nokogiri if available, else Nokolexbor.
+  # Defaults to Makiri.
   #
   # Switching backends:
   #
   #   require "dommy"
-  #   Dommy::Backend.use(:nokolexbor)
+  #   Dommy::Backend.use(:makiri)
   #
   # Or set directly:
   #
-  #   Dommy::Backend.current = Dommy::Backend::Nokolexbor
+  #   Dommy::Backend.current = Dommy::Backend::Makiri
   #
   # All adapters must implement the same interface — see
-  # `Backend::Nokogiri` for the canonical reference.
+  # `Backend::Makiri` for the canonical reference.
   module Backend
     class BackendNotAvailable < StandardError
     end
@@ -33,36 +32,133 @@ module Dommy
 
       def use(name)
         @current = case name.to_sym
-        when :nokogiri
-          require_relative "backend/nokogiri_adapter"
-          Nokogiri
-        when :nokolexbor
-          require_relative "backend/nokolexbor_adapter"
-          Nokolexbor
+        when :makiri
+          require_relative "backend/makiri_adapter"
+          Makiri
         else
-          raise ArgumentError, "Unknown backend: #{name.inspect}. Use :nokogiri or :nokolexbor."
+          raise ArgumentError, "Unknown backend: #{name.inspect}. Use :makiri."
         end
       end
 
+      # Stable per-document identity key for a backend node, used to cache DOM
+      # wrappers and key per-node side tables. Makiri mints a fresh wrapper per traversal
+      # but never frees nodes (arena-owned), so it keys on the stable node pointer.
+      def identity_key(node)
+        current.identity_key(node)
+      end
+
+      # Deep (or shallow) copy of an element/node, detached and owned by the
+      # same document — the backing for DOM cloneNode.
+      def clone_node(node, deep:)
+        current.clone_node(node, deep: deep)
+      end
+
+      # Deep copy of a whole document (DOM cloneNode on the document).
+      def clone_document(doc)
+        current.clone_document(doc)
+      end
+
+      # A fresh, empty HTML-backed document.
+      def empty_document
+        current.empty_document
+      end
+
+      # A fresh, empty XML-backed document — for `new Document()` / createDocument,
+      # which the DOM defines as XML documents (case-preserving, real CDATA
+      # nodeType, namespaces).
+      def empty_xml_document
+        current.empty_xml_document
+      end
+
+      # An empty backing document matching `doc`'s kind (HTML stays HTML, XML stays
+      # XML) — for a shallow document clone, whose result keeps the source flavor.
+      def empty_document_like(doc)
+        current.empty_document_like(doc)
+      end
+
+      # Bring `node` (already detached from its old tree) into `target_doc`,
+      # returning the backend node now owned by `target_doc`. Makiri can't move a node
+      # between arenas, so it imports a copy — callers must reseat any wrapper
+      # onto the returned node.
+      def adopt(node, target_doc)
+        current.adopt(node, target_doc)
+      end
+
+      # Whether the backend can move a node between documents in place or must adopt a copy first
+      # (Lexbor's arenas can't move a node, so inserting a foreign node requires importing
+      # it). Lets callers skip a needless — and on an empty target, root-less and
+      # therefore crashing — adoption on backends that don't need it.
+      def moves_nodes_across_documents?
+        current.respond_to?(:moves_nodes_across_documents?) ? current.moves_nodes_across_documents? : true
+      end
+
+      # CSS query that honors Dommy's custom pseudo-classes
+      # (`:disabled`/`:enabled`/`:checked`/`:scope`). Each backend applies its
+      # own mechanism (Lexbor native pseudos plus a
+      # `:scope` rewrite). `scope_node` binds `:scope` to that element.
+      def select_all(node, selector, scope_node: nil)
+        current.select_all(node, selector, scope_node: scope_node)
+      end
+
+      def select_first(node, selector, scope_node: nil)
+        current.select_first(node, selector, scope_node: scope_node)
+      end
+
       # Delegate calls so internal code can use `Backend.parse(...)`.
       def parse(html)
         current.parse(html)
       end
 
-      # Parse XML input into an XML document. Backends without a real XML parser
-      # (HTML-only, e.g. Nokolexbor) fall back to the HTML parser.
+      # Parse XML input into an XML document.
+      # fall back to the HTML parser.
       def parse_xml(xml)
-        current.respond_to?(:parse_xml) ? current.parse_xml(xml) : current.parse(xml)
+        current.parse_xml(xml)
       end
 
       def fragment(html, owner_doc:)
         current.fragment(html, owner_doc: owner_doc)
       end
 
+      # Make `node` the sole document element of `doc` (used by
+      # DOMImplementation.createDocument). Lexbor-backed documents are seeded with an <html> shell
+      # that must be cleared first.
+      def set_document_root(doc, node)
+        current.set_document_root(doc, node)
+      end
+
       def create_element(name, doc)
         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
@@ -81,16 +177,40 @@ module Dommy
         current.respond_to?(:cdata_class) ? current.cdata_class : nil
       end
 
+      # ProcessingInstruction node (`<?target data?>`). Supported by every
+      # backend Dommy ships (both Makiri document families), so — unlike CDATA —
+      # there is no text-node fallback.
+      def create_processing_instruction(target, data, doc)
+        current.create_processing_instruction(target, data, doc)
+      end
+
+      def processing_instruction_class
+        current.processing_instruction_class
+      end
+
       def namespace_of(node)
         current.namespace_of(node)
       end
 
+      # The element's in-scope namespace declarations (each responds to
+      # `prefix`/`href`). Empty on backends without an XML namespace model.
+      def namespace_definitions(node)
+        current.namespace_definitions(node)
+      end
+
+      # The content child nodes of a `<template>` element. HTML5 parsers model
+      # template contents differently — Lexbor/Makiri in a separate content fragment — so reading them goes
+      # through the backend. Used by the template-content registry's migration.
+      def template_content_nodes(node)
+        current.template_content_nodes(node)
+      end
+
       def add_namespace_definition(node, prefix, href)
         current.add_namespace_definition(node, prefix, href)
       end
 
       # Namespaced attribute access (DOM *AttributeNS). `namespace` is an href
-      # String or nil. Nokolexbor degrades to qualified-name (null-namespace).
+      # String or nil.
       def get_attribute_ns(node, namespace, local_name)
         current.get_attribute_ns(node, namespace, local_name)
       end
@@ -148,25 +268,15 @@ module Dommy
       private
 
       def detect_default
-        try_nokogiri ||
-          try_nokolexbor ||
-          raise(BackendNotAvailable, "Dommy requires either 'nokogiri' or 'nokolexbor' gem to be installed.")
-      end
-
-      def try_nokogiri
-        require "nokogiri"
-
-        require_relative "backend/nokogiri_adapter"
-        Nokogiri
-      rescue LoadError
-        nil
+        try_makiri ||
+          raise(BackendNotAvailable, "Dommy requires either 'makiri' gem to be installed.")
       end
 
-      def try_nokolexbor
-        require "nokolexbor"
+      def try_makiri
+        require "makiri"
 
-        require_relative "backend/nokolexbor_adapter"
-        Nokolexbor
+        require_relative "backend/makiri_adapter"
+        Makiri
       rescue LoadError
         nil
       end

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__
@@ -63,23 +77,38 @@ module Dommy
         @size
       when "type"
         @type
+      else
+        Bridge::ABSENT
       end
     end
 
     # 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
 
@@ -113,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

data/lib/dommy/bridge.rb

@@ -37,6 +37,17 @@ module Dommy
     def UNDEFINED.inspect = "#<Dommy::Bridge::UNDEFINED>"
     UNDEFINED.freeze
 
+    # The sentinel a `__js_get__` returns for a GENUINELY-ABSENT property (a key
+    # the object does not have), as distinct from a present property whose value
+    # is `nil`/JS null or `UNDEFINED`/JS undefined. It marshals to JS `undefined`
+    # for the value, but the proxy reports `("x" in obj) === false` for it — so
+    # feature detection like `isUndefined(window.Vue)` AND `"Vue" in window` are
+    # both correct. (UNDEFINED means present-but-undefined → reported present.)
+    ABSENT = Object.new
+    def ABSENT.to_s = "undefined"
+    def ABSENT.inspect = "#<Dommy::Bridge::ABSENT>"
+    ABSENT.freeze
+
     # An opaque handle to a JS-side value that Ruby only stores and hands back
     # (an AbortSignal's reason, a CustomEvent's detail). A non-plain JS object
     # (Error, class instance, …) crosses as one of these instead of being