dommy 0.5.0 → 0.7.0

data/lib/dommy/worker.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Dommy
+  # `Worker` — inline-emulated. Dommy does NOT spin up a separate
+  # execution context (no JS engine, no Ruby Thread). Instead:
+  #
+  #   - `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.__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.__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
+  # via Worker" without a real worker runtime.
+  #
+  # Spec (real): https://html.spec.whatwg.org/multipage/workers.html
+  class Worker
+    include EventTarget
+
+    attr_reader :url
+
+    def initialize(window, url, _options = nil)
+      @window = window
+      @url = url.to_s
+      @inline_handlers = {}
+      @worker_side_handlers = []
+      @terminated = false
+    end
+
+    # Main-side: post a message to the worker.
+    def post_message(data)
+      return if @terminated
+
+      cloned = Dommy.structured_clone(data)
+      @window.scheduler.queue_microtask(
+        proc do
+          @worker_side_handlers.each { |h| invoke(h, [{"data" => cloned}]) }
+        end
+      )
+
+      nil
+    end
+
+    alias postMessage post_message
+
+    def terminate
+      @terminated = true
+      @worker_side_handlers.clear
+      nil
+    end
+
+    # --- Test seams (worker-side) ----------------------------------
+
+    # Register a callback that runs in the "worker side". Multiple
+    # registrations stack.
+    def __test_on_message__(&block)
+      @worker_side_handlers << block
+    end
+
+    # Worker-side: deliver a message to the main-side `message` event.
+    def __test_post_to_main__(data)
+      cloned = Dommy.structured_clone(data)
+      @window.scheduler.queue_microtask(
+        proc do
+          dispatch_event(MessageEvent.new("message", "data" => cloned))
+        end
+      )
+
+      nil
+    end
+
+    # --- JS bridge -------------------------------------------------
+
+    def __js_get__(key)
+      case key
+      when "url"
+        @url
+      else
+        @inline_handlers[inline_event_for(key)]
+      end
+    end
+
+    def __js_set__(key, value)
+      event = inline_event_for(key)
+      set_inline_handler(event, value) if event
+      nil
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "postMessage"
+        post_message(args[0])
+      when "terminate"
+        terminate
+      when "addEventListener"
+        add_event_listener(args[0], args[1], args[2])
+      when "removeEventListener"
+        remove_event_listener(args[0], args[1])
+      when "dispatchEvent"
+        dispatch_event(args[0])
+      end
+    end
+
+    def __internal_event_parent__
+      nil
+    end
+
+    private
+
+    INLINE_HANDLERS = %w[message error messageerror].freeze
+    INLINE_EVENT_MAP = INLINE_HANDLERS
+      .each_with_object({}) do |name, h|
+        h["on#{name}"] = name
+      end
+      .freeze
+
+    def inline_event_for(key)
+      INLINE_EVENT_MAP[key.to_s]
+    end
+
+    def set_inline_handler(event, handler)
+      previous = @inline_handlers[event]
+      remove_event_listener(event, previous) if previous
+      if handler.nil?
+        @inline_handlers.delete(event)
+      else
+        add_event_listener(event, handler)
+        @inline_handlers[event] = handler
+      end
+    end
+
+    def invoke(callback, args)
+      if callback.respond_to?(:__js_call__)
+        callback.__js_call__("call", args)
+      elsif callback.respond_to?(:call)
+        callback.call(*args)
+      end
+    end
+  end
+end

data/lib/dommy/xml_http_request.rb

@@ -0,0 +1,438 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Dommy
+  # `XMLHttpRequest` polyfill. Consults the same stub maps that
+  # `FetchFn` reads (`__fetchy_stub__` / `__resource_fetch_stub__` /
+  # `__inject_fetch_stub__`) so a single set of fixtures drives both
+  # `fetch(...)` and `new XMLHttpRequest()` style code.
+  #
+  # State transitions match the spec:
+  #   UNSENT(0) → OPENED(1) → HEADERS_RECEIVED(2) → LOADING(3) → DONE(4)
+  # Each transition fires `readystatechange`. `load` / `loadend` fire
+  # on completion; `error` / `timeout` / `abort` fire on the
+  # respective failure paths.
+  #
+  # Async requests resolve via the scheduler (a microtask, or a
+  # `setTimeout` for stubs with `delay:`); sync requests
+  # (`open(..., false)`) deliver inline so tests can read
+  # `xhr.responseText` immediately.
+  #
+  # Spec: https://xhr.spec.whatwg.org/
+  class XMLHttpRequest
+    include EventTarget
+
+    UNSENT = 0
+    OPENED = 1
+    HEADERS_RECEIVED = 2
+    LOADING = 3
+    DONE = 4
+
+    INLINE_HANDLERS = %w[
+      readystatechange
+      loadstart
+      load
+      loadend
+      progress
+      error
+      timeout
+      abort
+    ].freeze
+
+    attr_reader(
+      :ready_state,
+      :status,
+      :status_text,
+      :response_url,
+      :response_text,
+      :response_xml,
+      :response,
+      :upload
+    )
+
+    attr_accessor :timeout, :with_credentials, :response_type
+
+    def initialize(window)
+      @window = window
+      @timeout = 0
+      @with_credentials = false
+      @response_type = ""
+      @generation = 0
+      reset_state
+      @inline_handlers = {}
+      @upload = XMLHttpRequestUpload.new
+    end
+
+    # XHR §open. `method` is uppercased; `async` defaults to true.
+    def open(method, url, async = true, _user = nil, _password = nil)
+      reset_state
+      @method = method.to_s.upcase
+      @url = url.to_s
+      @async = async.nil? ? true : !!async
+      @request_headers = {}
+      transition(OPENED)
+      nil
+    end
+
+    def set_request_header(name, value)
+      raise Error, "setRequestHeader called before open" if @ready_state != OPENED
+
+      key = name.to_s
+      existing = @request_headers[key]
+      @request_headers[key] = existing ? "#{existing}, #{value}" : value.to_s
+      nil
+    end
+
+    alias setRequestHeader set_request_header
+
+    def send(body = nil)
+      raise Error, "send called before open" if @ready_state != OPENED
+
+      @request_body = body
+      @sent = true
+      @generation += 1
+      gen = @generation
+      dispatch_event(ProgressEvent.new("loadstart"))
+
+      entry = lookup_stub
+      track_globals
+
+      if entry.nil?
+        deliver(body: "not found", status: 404, status_text: "Not Found", headers: {})
+        return nil
+      end
+
+      delay = entry["delay"]
+      if delay && @async
+        schedule_delivery_with_delay(entry, delay.to_i, gen)
+      elsif @async
+        @window.scheduler.queue_microtask(proc { deliver_entry(entry) if active?(gen) })
+      else
+        deliver_entry(entry)
+      end
+
+      nil
+    end
+
+    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
+      @status = 0
+      @status_text = ""
+      transition(DONE)
+      dispatch_event(ProgressEvent.new("abort"))
+      dispatch_event(ProgressEvent.new("loadend"))
+      reset_state(keep_handlers: true, keep_generation: true)
+      nil
+    end
+
+    def get_response_header(name)
+      return nil if @ready_state < HEADERS_RECEIVED
+
+      key = name.to_s.downcase
+      hit = @response_headers.find { |k, _| k.to_s.downcase == key }
+      hit ? hit.last : nil
+    end
+
+    alias getResponseHeader get_response_header
+
+    def get_all_response_headers
+      return "" if @ready_state < HEADERS_RECEIVED
+
+      @response_headers.map { |k, v| "#{k}: #{v}\r\n" }.join
+    end
+
+    alias getAllResponseHeaders get_all_response_headers
+
+    def override_mime_type(mime)
+      @override_mime = mime.to_s
+      nil
+    end
+
+    alias overrideMimeType override_mime_type
+
+    # --- JS bridge ---------------------------------------------------
+
+    def __js_get__(key)
+      case key
+      when "readyState"
+        @ready_state
+      when "status"
+        @status
+      when "statusText"
+        @status_text
+      when "responseURL"
+        @response_url
+      when "response"
+        @response
+      when "responseText"
+        @response_text
+      when "responseXML"
+        @response_xml
+      when "responseType"
+        @response_type
+      when "timeout"
+        @timeout
+      when "withCredentials"
+        @with_credentials
+      when "upload"
+        @upload
+      when "UNSENT"
+        UNSENT
+      when "OPENED"
+        OPENED
+      when "HEADERS_RECEIVED"
+        HEADERS_RECEIVED
+      when "LOADING"
+        LOADING
+      when "DONE"
+        DONE
+      else
+        @inline_handlers[inline_event_for(key)]
+      end
+    end
+
+    def __js_set__(key, value)
+      case key
+      when "responseType"
+        @response_type = value.to_s
+      when "timeout"
+        @timeout = value.to_i
+      when "withCredentials"
+        @with_credentials = !!value
+      else
+        event = inline_event_for(key)
+        set_inline_handler(event, value) if event
+      end
+
+      nil
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "open"
+        open(args[0], args[1], args[2].nil? ? true : args[2], args[3], args[4])
+      when "send"
+        send(args[0])
+      when "setRequestHeader"
+        set_request_header(args[0], args[1])
+      when "abort"
+        abort
+      when "getResponseHeader"
+        get_response_header(args[0])
+      when "getAllResponseHeaders"
+        get_all_response_headers
+      when "overrideMimeType"
+        override_mime_type(args[0])
+      when "addEventListener"
+        add_event_listener(args[0], args[1], args[2])
+      when "removeEventListener"
+        remove_event_listener(args[0], args[1])
+      when "dispatchEvent"
+        dispatch_event(args[0])
+      end
+    end
+
+    def __internal_event_parent__
+      nil
+    end
+
+    class Error < StandardError
+    end
+
+    private
+
+    def reset_state(keep_handlers: false, keep_generation: false)
+      @ready_state = UNSENT
+      @status = 0
+      @status_text = ""
+      @response_url = ""
+      @response = nil
+      @response_text = ""
+      @response_xml = nil
+      @response_headers = {}
+      @request_headers = {}
+      @aborted = false unless keep_generation
+      @sent = false
+      @override_mime = nil
+      @method = nil
+      @url = nil
+      @async = true
+      @inline_handlers = {} unless keep_handlers
+      @generation = 0 unless keep_generation
+    end
+
+    # A queued delivery is "active" only if no abort / reopen has
+    # bumped the generation since its send() call.
+    def active?(gen)
+      @generation == gen && !@aborted
+    end
+
+    def transition(state)
+      @ready_state = state
+      dispatch_event(Event.new("readystatechange"))
+    end
+
+    def lookup_stub
+      stub_map = @window.globals["__fetchy_stub__"] ||
+        @window.globals["__resource_fetch_stub__"] ||
+        @window.globals["__inject_fetch_stub__"]
+      return nil unless stub_map.is_a?(Hash)
+
+      stub_map[@url]
+    end
+
+    # Bookkeeping that lets specs assert "fetch was called N times"
+    # uniformly across `fetch` and XHR (`FetchFn` writes the same
+    # globals; XHR mirrors them).
+    def track_globals
+      @window.globals["__fetch_count__"] = (@window.globals["__fetch_count__"] || 0).to_i + 1
+      @window.globals["__last_url__"] = @url
+      @window.globals["__last_method__"] = @method
+      @window.globals["__last_body__"] = @request_body
+    end
+
+    def schedule_delivery_with_delay(entry, delay_ms, gen)
+      timer = @window.scheduler.set_timeout(
+        proc { deliver_entry(entry) if active?(gen) },
+        delay_ms
+      )
+
+      return unless @timeout.to_i.positive?
+
+      @window.scheduler.set_timeout(
+        proc {
+          next unless active?(gen)
+          next if @ready_state == DONE
+
+          @window.scheduler.clear_timeout(timer)
+          fail_with("timeout")
+        },
+        @timeout
+      )
+    end
+
+    def deliver_entry(entry)
+      body = entry["body"].to_s
+      status = (entry["status"] || 200).to_i
+      status_text = entry["statusText"] || ""
+      headers = entry["headers"] || {"Content-Type" => entry["contentType"] || "text/plain"}
+      deliver(body: body, status: status, status_text: status_text, headers: headers)
+    end
+
+    def deliver(body:, status:, status_text:, headers:)
+      return if @aborted
+
+      @status = status
+      @status_text = status_text
+      @response_headers = headers
+      @response_url = @url
+      @response_text = body
+      @response = decode_response(body)
+
+      transition(HEADERS_RECEIVED)
+      transition(LOADING)
+      transition(DONE)
+      dispatch_event(ProgressEvent.new("load"))
+      dispatch_event(ProgressEvent.new("loadend"))
+    end
+
+    def fail_with(reason)
+      @status = 0
+      @status_text = ""
+      transition(DONE)
+      dispatch_event(ProgressEvent.new(reason))
+      dispatch_event(ProgressEvent.new("loadend"))
+    end
+
+    # Decode the body into `response` per `responseType`.
+    def decode_response(body)
+      case @response_type
+      when "", "text"
+        body
+      when "json"
+        begin
+          JSON.parse(body)
+        rescue JSON::ParserError
+          nil
+        end
+
+      when "arraybuffer"
+        body.bytes
+      when "blob"
+        Blob.new([body], "type" => response_content_type)
+      when "document"
+        parse_document(body)
+      else
+        body
+      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
+      nil
+    end
+
+    INLINE_EVENT_MAP = INLINE_HANDLERS
+      .each_with_object({}) do |name, h|
+        h["on#{name}"] = name
+      end
+      .freeze
+
+    def inline_event_for(key)
+      INLINE_EVENT_MAP[key.to_s]
+    end
+
+    def set_inline_handler(event, handler)
+      previous = @inline_handlers[event]
+      remove_event_listener(event, previous) if previous
+
+      if handler.nil?
+        @inline_handlers.delete(event)
+      else
+        add_event_listener(event, handler)
+        @inline_handlers[event] = handler
+      end
+    end
+  end
+
+  # `XMLHttpRequestUpload` — the upload-side event target. Real
+  # browsers fire `progress` here while uploading multipart bodies;
+  # dommy doesn't simulate upload, so this is an inert EventTarget
+  # the caller can still `addEventListener` against.
+  class XMLHttpRequestUpload
+    include EventTarget
+
+    def __js_call__(method, args)
+      case method
+      when "addEventListener"
+        add_event_listener(args[0], args[1], args[2])
+      when "removeEventListener"
+        remove_event_listener(args[0], args[1])
+      when "dispatchEvent"
+        dispatch_event(args[0])
+      end
+    end
+
+    def __internal_event_parent__
+      nil
+    end
+  end
+end

data/lib/dommy.rb

@@ -1,29 +1,58 @@
 # 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"
 require_relative "dommy/event"
 require_relative "dommy/scheduler"
-require_relative "dommy/observer"
+require_relative "dommy/mutation_observer"
 require_relative "dommy/promise"
 require_relative "dommy/blob"
 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"
+require_relative "dommy/intersection_observer"
+require_relative "dommy/resize_observer"
+require_relative "dommy/performance_observer"
+require_relative "dommy/internal/range_text_serializer"
+require_relative "dommy/range"
+require_relative "dommy/animation"
 require_relative "dommy/bridge"
 require_relative "dommy/storage"
 require_relative "dommy/fetch"
-require_relative "dommy/router"
+require_relative "dommy/xml_http_request"
+require_relative "dommy/file_reader"
+require_relative "dommy/media_query_list"
+require_relative "dommy/notification"
+require_relative "dommy/message_channel"
+require_relative "dommy/web_socket"
+require_relative "dommy/event_source"
+require_relative "dommy/performance"
+require_relative "dommy/cookie_store"
+require_relative "dommy/url_pattern"
+require_relative "dommy/streams"
+require_relative "dommy/compression_streams"
+require_relative "dommy/worker"
+require_relative "dommy/location"
+require_relative "dommy/history"
 require_relative "dommy/navigator"
 require_relative "dommy/parser"
 require_relative "dommy/attr"
-require_relative "dommy/world"
+require_relative "dommy/window"
 require_relative "dommy/document"
 require_relative "dommy/element"
+require_relative "dommy/internal/reflected_attributes"
 require_relative "dommy/html_elements"
+require_relative "dommy/svg_elements"
 require_relative "dommy/shadow_root"
 require_relative "dommy/custom_elements"
 require_relative "dommy/tree_walker"
@@ -45,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
@@ -53,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