dommy 0.6.0 → 0.7.0

data/lib/dommy/tree_walker.rb

@@ -45,9 +45,11 @@ module Dommy
   # tree rooted at `root` and filter by `whatToShow` + an optional
   # filter callable (or object with `acceptNode`).
   module TreeTraversalCore
+    private
+
     # Returns FILTER_ACCEPT / FILTER_REJECT / FILTER_SKIP for the
     # given wrapped node.
-    def __accept__(node)
+    def accept(node)
       return NodeFilter::FILTER_REJECT unless node
       return NodeFilter::FILTER_SKIP if (NodeFilter.bitmask_for(node) & @what_to_show) == 0
 
@@ -55,8 +57,6 @@ module Dommy
       result || NodeFilter::FILTER_ACCEPT
     end
 
-    private
-
     def invoke_filter(node)
       return NodeFilter::FILTER_ACCEPT if @filter.nil?
 
@@ -92,7 +92,7 @@ module Dommy
     def next_node
       node = first_descendant_or_following(@current_node)
       while node
-        verdict = __accept__(node)
+        verdict = accept(node)
         if verdict == NodeFilter::FILTER_ACCEPT
           @current_node = node
           return node
@@ -109,7 +109,7 @@ module Dommy
     def previous_node
       node = preceding(@current_node)
       while node && node != @root
-        verdict = __accept__(node)
+        verdict = accept(node)
         if verdict == NodeFilter::FILTER_ACCEPT
           @current_node = node
           return node
@@ -124,7 +124,7 @@ module Dommy
     def parent_node
       node = wrapped_parent(@current_node)
       while node && reachable_from_root?(node)
-        return @current_node = node if __accept__(node) == NodeFilter::FILTER_ACCEPT
+        return @current_node = node if accept(node) == NodeFilter::FILTER_ACCEPT
 
         node = wrapped_parent(node)
       end
@@ -192,7 +192,7 @@ module Dommy
     def walk_siblings(start, direction)
       node = start
       while node
-        v = __accept__(node)
+        v = accept(node)
         return @current_node = node if v == NodeFilter::FILTER_ACCEPT
 
         node = (v == NodeFilter::FILTER_REJECT) ? nil : send(direction, node)
@@ -246,30 +246,30 @@ module Dommy
     end
 
     def wrapped_parent(node)
-      parent_nk = node.respond_to?(:__node__) ? node.__node__.parent : nil
-      return nil unless parent_nk && !parent_nk.is_a?(Nokogiri::XML::Document)
+      parent_nk = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__.parent : nil
+      return nil unless parent_nk && !parent_nk.is_a?(Backend.document_class)
 
       doc = node.instance_variable_get(:@document) || (@root.respond_to?(:document) ? @root.document : @root)
       doc.wrap_node(parent_nk)
     end
 
     def first_wrapped_child(node)
-      child_nk = node.respond_to?(:__node__) ? node.__node__.children.first : nil
+      child_nk = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__.children.first : nil
       child_nk && document_for(node).wrap_node(child_nk)
     end
 
     def last_wrapped_child(node)
-      child_nk = node.respond_to?(:__node__) ? node.__node__.children.last : nil
+      child_nk = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__.children.last : nil
       child_nk && document_for(node).wrap_node(child_nk)
     end
 
     def next_sibling_wrapped(node)
-      n = node.respond_to?(:__node__) ? node.__node__.next : nil
+      n = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__.next : nil
       n && document_for(node).wrap_node(n)
     end
 
     def previous_sibling_wrapped(node)
-      n = node.respond_to?(:__node__) ? node.__node__.previous : nil
+      n = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__.previous : nil
       n && document_for(node).wrap_node(n)
     end
 
@@ -306,7 +306,7 @@ module Dommy
 
         @reference_node = node
         @pointer_before_reference = false
-        return node if __accept__(node) == NodeFilter::FILTER_ACCEPT
+        return node if accept(node) == NodeFilter::FILTER_ACCEPT
       end
     end
 
@@ -322,7 +322,7 @@ module Dommy
 
         @reference_node = node
         @pointer_before_reference = true
-        return node if __accept__(node) == NodeFilter::FILTER_ACCEPT
+        return node if accept(node) == NodeFilter::FILTER_ACCEPT
       end
     end
 
@@ -392,28 +392,28 @@ module Dommy
     end
 
     def first_child_node(node)
-      n = node.respond_to?(:__node__) ? node.__node__.children.first : nil
+      n = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__.children.first : nil
       n && document_for(node).wrap_node(n)
     end
 
     def last_child_node(node)
-      n = node.respond_to?(:__node__) ? node.__node__.children.last : nil
+      n = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__.children.last : nil
       n && document_for(node).wrap_node(n)
     end
 
     def next_sibling_node(node)
-      n = node.respond_to?(:__node__) ? node.__node__.next : nil
+      n = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__.next : nil
       n && document_for(node).wrap_node(n)
     end
 
     def previous_sibling_node(node)
-      n = node.respond_to?(:__node__) ? node.__node__.previous : nil
+      n = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__.previous : nil
       n && document_for(node).wrap_node(n)
     end
 
     def parent_node_of(node)
-      parent_nk = node.respond_to?(:__node__) ? node.__node__.parent : nil
-      return nil unless parent_nk && !parent_nk.is_a?(Nokogiri::XML::Document)
+      parent_nk = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__.parent : nil
+      return nil unless parent_nk && !parent_nk.is_a?(Backend.document_class)
 
       document_for(node).wrap_node(parent_nk)
     end

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
 
@@ -159,7 +176,7 @@ module Dommy
     def search=(value)
       q = value.to_s.sub(/^\?/, "")
       @uri.query = q.empty? ? nil : q
-      @search_params.__replace__(q)
+      @search_params.__internal_replace__(q)
     end
 
     def hash
@@ -289,7 +306,7 @@ 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
 
@@ -636,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
@@ -701,7 +718,7 @@ module Dommy
     end
 
     def notify
-      @owner&.__notify_params_changed__
+      @owner&.__internal_notify_params_changed__
     end
   end
 end

data/lib/dommy/version.rb

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

data/lib/dommy/web_socket.rb

@@ -5,11 +5,11 @@ module Dommy
   # connection; dommy exposes an in-memory transport tests drive via
   # the `__*` seams:
   #
-  #   ws.__simulate_open__               — fires `open`
-  #   ws.__simulate_message__(data)      — fires `message`
-  #   ws.__simulate_close__(code, reason) — fires `close`
-  #   ws.__simulate_error__              — fires `error`
-  #   ws.__sent_messages__               — array of sent payloads
+  #   ws.__test_simulate_open__               — fires `open`
+  #   ws.__test_simulate_message__(data)      — fires `message`
+  #   ws.__test_simulate_close__(code, reason) — fires `close`
+  #   ws.__test_simulate_error__              — fires `error`
+  #   ws.__test_sent_messages__               — array of sent payloads
   #
   # By default a `new WebSocket(url)` auto-opens via microtask so the
   # common pattern (`ws.onopen = ...; ws.send(...)`) works without
@@ -42,7 +42,7 @@ module Dommy
 
       # Auto-open via microtask unless tests disable.
       auto_open = window.globals["__ws_auto_open__"]
-      @window.scheduler.queue_microtask(proc { __simulate_open__ }) unless auto_open == false
+      @window.scheduler.queue_microtask(proc { __test_simulate_open__ }) unless auto_open == false
     end
 
     def send(data)
@@ -56,30 +56,30 @@ module Dommy
       return if @ready_state == CLOSED || @ready_state == CLOSING
 
       @ready_state = CLOSING
-      @window.scheduler.queue_microtask(proc { __simulate_close__(code, reason) })
+      @window.scheduler.queue_microtask(proc { __test_simulate_close__(code, reason) })
       nil
     end
 
     # --- Test seams ------------------------------------------------
 
-    def __sent_messages__
+    def __test_sent_messages__
       @sent_messages.dup
     end
 
-    def __simulate_open__
+    def __test_simulate_open__
       return if @ready_state != CONNECTING
 
       @ready_state = OPEN
       dispatch_event(Event.new("open"))
     end
 
-    def __simulate_message__(data)
+    def __test_simulate_message__(data)
       return if @ready_state != OPEN
 
       dispatch_event(MessageEvent.new("message", "data" => data))
     end
 
-    def __simulate_close__(code = 1000, reason = "", was_clean: true)
+    def __test_simulate_close__(code = 1000, reason = "", was_clean: true)
       @ready_state = CLOSED
       dispatch_event(
         CloseEvent.new(
@@ -91,7 +91,7 @@ module Dommy
       )
     end
 
-    def __simulate_error__
+    def __test_simulate_error__
       dispatch_event(Event.new("error"))
     end
 
@@ -151,7 +151,7 @@ module Dommy
       end
     end
 
-    def __event_parent__
+    def __internal_event_parent__
       nil
     end
 

data/lib/dommy/window.rb

@@ -101,6 +101,8 @@ module Dommy
       @url_ctor = Bridge::Constructor.new { |args| URL.new(args[0], args[1]) }
       @url_ctor.define_class_method("createObjectURL") { |args| URL.create_object_url(args[0]) }
       @url_ctor.define_class_method("revokeObjectURL") { |args| URL.revoke_object_url(args[0]) }
+      @url_ctor.define_class_method("parse") { |args| URL.parse(args[0], args[1]) }
+      @url_ctor.define_class_method("canParse") { |args| URL.can_parse(args[0], args[1]) }
       # `JS.global[:__some_key__] = ...` from user code lands here.
       # Test code uses this for stub installation (e.g. a custom
       # `__fetch_stub__`); production code stays on the typed
@@ -273,6 +275,17 @@ module Dommy
       nil
     end
 
+    # Methods routed through __js_call__ (keep in sync with its when-arms).
+    JS_METHOD_NAMES = %w[
+      fetch encodeURIComponent decodeURIComponent addEventListener removeEventListener
+      dispatchEvent setTimeout clearTimeout setInterval clearInterval requestAnimationFrame
+      cancelAnimationFrame queueMicrotask requestIdleCallback cancelIdleCallback
+      structuredClone matchMedia getComputedStyle
+    ].freeze
+    def __js_method_names__
+      JS_METHOD_NAMES
+    end
+
     def __js_call__(method, args)
       case method
       when "fetch"
@@ -336,7 +349,7 @@ module Dommy
       end
     end
 
-    def __event_parent__
+    def __internal_event_parent__
       nil
     end
 

data/lib/dommy/worker.rb

@@ -6,11 +6,11 @@ module Dommy
   #
   #   - `new Worker("/path/to/worker.js")` records the URL.
   #   - The script body is not executed. Tests install message
-  #     handlers on the worker-side via `worker.__on_message__ { ... }`
+  #     handlers on the worker-side via `worker.__test_on_message__ { ... }`
   #     to simulate behavior.
   #   - `worker.postMessage(data)` queues a microtask that delivers
   #     to the worker-side handler.
-  #   - The worker-side handler can call `worker.__post_to_main__(data)`
+  #   - The worker-side handler can call `worker.__test_post_to_main__(data)`
   #     to deliver a message back to the main side's `message` event.
   #
   # This is enough surface to test "the app correctly posts/receives
@@ -56,12 +56,12 @@ module Dommy
 
     # Register a callback that runs in the "worker side". Multiple
     # registrations stack.
-    def __on_message__(&block)
+    def __test_on_message__(&block)
       @worker_side_handlers << block
     end
 
     # Worker-side: deliver a message to the main-side `message` event.
-    def __post_to_main__(data)
+    def __test_post_to_main__(data)
       cloned = Dommy.structured_clone(data)
       @window.scheduler.queue_microtask(
         proc do
@@ -104,7 +104,7 @@ module Dommy
       end
     end
 
-    def __event_parent__
+    def __internal_event_parent__
       nil
     end
 

data/lib/dommy/xml_http_request.rb

@@ -117,6 +117,11 @@ module Dommy
 
     def abort
       return if @ready_state == UNSENT || @ready_state == DONE
+      # WHATWG: abort() is a no-op when in OPENED with the send()
+      # flag unset. Without this guard, `xhr.open(); xhr.abort()`
+      # would fire abort + loadend even though no request is
+      # in flight.
+      return if @ready_state == OPENED && !@sent
 
       @aborted = true
       @generation += 1
@@ -236,7 +241,7 @@ module Dommy
       end
     end
 
-    def __event_parent__
+    def __internal_event_parent__
       nil
     end
 
@@ -360,8 +365,10 @@ module Dommy
           nil
         end
 
-      when "arraybuffer", "blob"
-        body
+      when "arraybuffer"
+        body.bytes
+      when "blob"
+        Blob.new([body], "type" => response_content_type)
       when "document"
         parse_document(body)
       else
@@ -369,6 +376,14 @@ module Dommy
       end
     end
 
+    # Content-Type of the received response, read straight from
+    # `@response_headers` (not `get_response_header`, which gates on
+    # `readyState` — decode runs before that flag advances).
+    def response_content_type
+      hit = @response_headers.find { |k, _| k.to_s.downcase == "content-type" }
+      hit ? hit.last.to_s : ""
+    end
+
     def parse_document(body)
       DOMParser.new.parse_from_string(body, "text/html")
     rescue StandardError
@@ -416,7 +431,7 @@ module Dommy
       end
     end
 
-    def __event_parent__
+    def __internal_event_parent__
       nil
     end
   end

data/lib/dommy.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require "nokogiri"
 require "set"
 
 require_relative "dommy/version"
+require_relative "dommy/backend"
 require_relative "dommy/dom_exception"
 require_relative "dommy/node"
 require_relative "dommy/html_collection"
@@ -16,6 +16,7 @@ require_relative "dommy/data_transfer"
 require_relative "dommy/crypto"
 require_relative "dommy/text_codec"
 require_relative "dommy/internal/observable_callback"
+require_relative "dommy/internal/css_pseudo_handlers"
 require_relative "dommy/internal/punycode"
 require_relative "dommy/internal/idna"
 require_relative "dommy/internal/ipv4_parser"
@@ -73,7 +74,7 @@ module Dommy
   def self.parse(html)
     s = html.to_s
     if s.match?(/\A\s*(<!doctype|<html\b)/i)
-      Window.new(nil, nokogiri_doc: Nokogiri::HTML5(s))
+      Window.new(nil, nokogiri_doc: Backend.parse(s))
     else
       window = Window.new
       window.document.body.inner_html = s
@@ -81,6 +82,15 @@ module Dommy
     end
   end
 
+  # Convenience accessor: `Dommy.backend` / `Dommy.backend=`.
+  def self.backend
+    Backend.current
+  end
+
+  def self.backend=(new_backend)
+    Backend.current = new_backend
+  end
+
   # Build a fresh, empty Window (no host). Equivalent to opening a
   # blank document.
   def self.new_window

metadata

@@ -1,38 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: dommy
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - takahashim
 bindir: bin
 cert_chain: []
-date: 2026-05-22 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: nokogiri
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.15'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.15'
-description: |
-  A pure-Ruby DOM polyfill on top of Nokogiri::HTML5, a Ruby-side
-  analogue to JavaScript DOM libraries like happy-dom and jsdom.
-  It exposes browser-like DOM semantics — events, MutationObserver,
-  Custom Elements, Shadow DOM, the File API (Blob / File / FormData /
-  DataTransfer), URL, Promise, timers, and Storage — without spinning
-  up a real browser.
+date: 2026-05-29 00:00:00.000000000 Z
+dependencies: []
+description: 'A pure Ruby DOM polyfill built on Nokogiri::HTML5, inspired by happy-dom
+  and jsdom. It gives Ruby tests a browser style DOM with events, MutationObserver,
+  Custom Elements, Shadow DOM, the File API, timers, and Storage, without requiring
+  a real browser.
 
-  Aimed at testing Ruby code that emits or consumes HTML. Includes
-  drop-in RSpec matchers and Minitest assertions.
+  '
 email:
 - takahashimm@gmail.com
 executables: []
@@ -43,6 +25,9 @@ files:
 - lib/dommy.rb
 - lib/dommy/animation.rb
 - lib/dommy/attr.rb
+- lib/dommy/backend.rb
+- lib/dommy/backend/nokogiri_adapter.rb
+- lib/dommy/backend/nokolexbor_adapter.rb
 - lib/dommy/blob.rb
 - lib/dommy/bridge.rb
 - lib/dommy/compression_streams.rb
@@ -64,6 +49,7 @@ files:
 - lib/dommy/html_collection.rb
 - lib/dommy/html_elements.rb
 - lib/dommy/internal/cookie_jar.rb
+- lib/dommy/internal/css_pseudo_handlers.rb
 - lib/dommy/internal/dom_matching.rb
 - lib/dommy/internal/idna.rb
 - lib/dommy/internal/idna_data.rb