dommy 0.5.0

data/lib/dommy/fetch.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Dommy
+  # `fetch` polyfill. No real network — instead consults
+  # `JS.global[:__fetchy_stub__]` (a Hash{url => entry}) installed by
+  # the test. Mirrors the same fixture protocol that `test_fetchy.rb`'s
+  # JavaScript installer uses, so tests don't need a JS engine to drive
+  # the stub.
+  #
+  # Each entry in the stub hash supports:
+  #   "status" / "statusText" / "body" / "contentType" /
+  #   "headers" (Hash) / "delay" (ms)
+  # plus AbortController signal propagation when `init[:signal]` is
+  # passed.
+  class FetchFn
+    def initialize(window)
+      @window = window
+    end
+
+    # JS calls `fetch(url, init)` end up here via either Window-level
+    # `__js_call__("fetch", ...)` or as a callable handle. Both routes
+    # delegate to `call(args)` so behavior is identical.
+    def __js_call__(_method, args)
+      url = args[0].to_s
+      init = normalize_init(args[1] || {})
+
+      # Each spec file installs its stub under its own global name.
+      # `test_fetchy.rb` uses `__fetchy_stub__`; `test_resource*.rb`
+      # use `__resource_fetch_stub__` and `__inject_fetch_stub__`.
+      # Check them in order — only one should be set at a time.
+      stub_map = @window.globals["__fetchy_stub__"] ||
+        @window.globals["__resource_fetch_stub__"] ||
+        @window.globals["__inject_fetch_stub__"] ||
+        {}
+      # `js_eval`'s JS installer increments these globals; mirror so
+      # specs that probe `__fetch_count__` / `__last_url__` / etc.
+      # observe the same state shape they'd see from a real injector.
+      @window.globals["__fetch_count__"] = (@window.globals["__fetch_count__"] || 0).to_i + 1
+      @window.globals["__last_url__"] = url
+      @window.globals["__last_init__"] = init
+      @window.globals["__last_body__"] = init["body"] if init.is_a?(Hash)
+
+      entry = stub_map[url] if stub_map.is_a?(Hash)
+      promise = PromiseValue.new(@window)
+
+      if entry.nil?
+        response = Response.new(@window, body: "not found", status: 404, status_text: "Not Found")
+        promise.fulfill(response)
+        return promise
+      end
+
+      body = entry["body"]
+      status = (entry["status"] || 200).to_i
+      status_text = entry["statusText"] || ""
+      content_type = entry["contentType"] || "text/plain"
+      headers = entry["headers"] || {"Content-Type" => content_type}
+
+      delay = entry["delay"]
+      if delay
+        install_delayed_resolve(promise, body, status, status_text, headers, init, delay)
+      else
+        promise.fulfill(
+          Response.new(@window, body: body, status: status, status_text: status_text, headers: headers, url: url)
+        )
+      end
+
+      promise
+    end
+
+    private
+
+    # Coerce `init` into a Hash with string keys so the rest of the
+    # pipeline (and the `__last_init__` globals) sees a uniform shape.
+    # When the body is a Blob/File, fill in `Content-Type` from the
+    # blob's type unless the caller already provided a header for it.
+    def normalize_init(init)
+      return init unless init.is_a?(Hash)
+
+      h = init.transform_keys(&:to_s)
+      body = h["body"]
+      return h unless body.is_a?(Blob)
+
+      headers = (h["headers"] || {}).dup
+      content_type_set = headers.any? { |k, _| k.to_s.downcase == "content-type" }
+      headers["Content-Type"] = body.type if !content_type_set && !body.type.empty?
+      h["headers"] = headers
+      h
+    end
+
+    def install_delayed_resolve(promise, body, status, status_text, headers, init, delay_ms)
+      # AbortController cancellation: when init.signal is present and
+      # `.abort()` fires before the timer, reject with an AbortError.
+      # The timer is cleared in that path so it doesn't leak through
+      # the test scheduler's drain loop.
+      cancelled = [false]
+      timer_id = @window.scheduler.set_timeout(
+        lambda do |*_args|
+          next if cancelled[0]
+
+          promise.fulfill(Response.new(@window, body: body, status: status, status_text: status_text, headers: headers))
+        end,
+        delay_ms.to_i
+      )
+      signal = init.is_a?(Hash) ? init["signal"] : nil
+      return unless signal.respond_to?(:__js_call__)
+
+      window_ref = @window
+      abort_cb = lambda do |*_args|
+        cancelled[0] = true
+        window_ref.scheduler.clear_timeout(timer_id)
+        err = ErrorValue.new("aborted", name: "AbortError")
+        promise.reject(err)
+      end
+
+      signal.__js_call__("addEventListener", ["abort", abort_cb])
+    end
+  end
+
+  # `Response` polyfill — just enough surface for Fetchy:
+  # `[:status]` / `[:ok]` / `[:url]` / `[:headers]` (with
+  # `.entries()` / `.get(name)`) and `.text()` / `.json()` / `.body`
+  # / `.arrayBuffer()` which all return Promise-like values.
+  class Response
+    def initialize(window, body:, status: 200, status_text: "", headers: nil, url: "")
+      @window = window
+      @body = body.to_s
+      @status = status
+      @status_text = status_text.to_s
+      @headers = Headers.new(headers || {})
+      @url = url.to_s
+    end
+
+    def __js_get__(key)
+      case key
+      when "status"
+        @status
+      when "ok"
+        @status >= 200 && @status < 300
+      when "statusText"
+        @status_text
+      when "url"
+        @url
+      when "headers"
+        @headers
+      when "body"
+        @body
+      end
+    end
+
+    def __js_set__(_key, _value)
+      nil
+    end
+
+    def __js_call__(method, _args)
+      case method
+      when "text"
+        immediate(@body)
+      when "json"
+        begin
+          immediate(JSON.parse(@body))
+        rescue JSON::ParserError => e
+          err = ErrorValue.new("JSON parse: #{e.message}")
+          rejected(err)
+        end
+
+      when "arrayBuffer", "blob"
+        immediate(@body)
+      when "clone"
+        Response.new(
+          @window,
+          body: @body,
+          status: @status,
+          status_text: @status_text,
+          headers: @headers.to_h,
+          url: @url
+        )
+      end
+    end
+
+    private
+
+    def immediate(value)
+      PromiseValue.resolve(@window, value)
+    end
+
+    def rejected(value)
+      PromiseValue.reject(@window, value)
+    end
+  end
+
+  # Minimal `Headers` proxy. Consumer code typically calls
+  # `headers.call(:entries)` and iterates via `Array.from(...)`, so
+  # we just need `entries` and `get`.
+  class Headers
+    def initialize(hash)
+      @hash = hash.is_a?(Hash) ? hash.transform_keys(&:to_s) : {}
+    end
+
+    def to_h
+      @hash.dup
+    end
+
+    def __js_get__(_key)
+      nil
+    end
+
+    def __js_set__(_key, _value)
+      nil
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "get"
+        name = args[0].to_s
+        @hash[name] || @hash[Headers.canonical(name)]
+      when "entries"
+        @hash.to_a
+      when "has"
+        @hash.key?(args[0].to_s)
+      when "forEach"
+        # Browser API: forEach(callback) — callback(value, key)
+        cb = args[0]
+        @hash.each do |k, v|
+          if cb.respond_to?(:__js_call__)
+            cb.__js_call__("call", [v, k])
+          elsif cb.respond_to?(:call)
+            cb.call(v, k)
+          end
+        end
+
+        nil
+      end
+    end
+
+    def self.canonical(name)
+      name.split("-").map(&:capitalize).join("-")
+    end
+  end
+end

data/lib/dommy/form_data.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module Dommy
+  # `FormData` — collects name/value entries from an `<form>` (or
+  # programmatically), preserving insertion order. Values are
+  # stringified per spec; `File` values are passed through as-is
+  # (Dommy has no File class, so this only matters for embedders
+  # that supply their own).
+  #
+  # Usage:
+  #   fd = Dommy::FormData.new(form)
+  #   fd.get("email")          # "alice@x.test"
+  #   fd.append("tag", "ruby")
+  #   fd.entries               # [["email", "..."], ["tag", "ruby"]]
+  class FormData
+    include Enumerable
+
+    def initialize(form = nil)
+      @pairs = []
+      collect_from(form) if form
+    end
+
+    def append(name, value, _filename = nil)
+      @pairs << [name.to_s, stringify(value)]
+      nil
+    end
+
+    def set(name, value, _filename = nil)
+      key = name.to_s
+      v = stringify(value)
+      replaced = false
+      @pairs = @pairs.flat_map do |k, existing|
+        if k == key
+          if replaced
+            []
+          else
+            replaced = true
+            [[key, v]]
+          end
+        else
+          [[k, existing]]
+        end
+      end
+
+      @pairs << [key, v] unless replaced
+      nil
+    end
+
+    def get(name)
+      pair = @pairs.find { |k, _| k == name.to_s }
+      pair && pair[1]
+    end
+
+    def get_all(name)
+      @pairs.select { |k, _| k == name.to_s }.map { |_, v| v }
+    end
+
+    alias getAll get_all
+
+    def has(name)
+      @pairs.any? { |k, _| k == name.to_s }
+    end
+
+    alias has? has
+
+    def delete(name)
+      @pairs.reject! { |k, _| k == name.to_s }
+      nil
+    end
+
+    def keys
+      @pairs.map { |k, _| k }
+    end
+
+    def values
+      @pairs.map { |_, v| v }
+    end
+
+    def entries
+      @pairs.dup
+    end
+
+    def for_each(&block)
+      @pairs.each { |k, v| block.call(v, k, self) }
+      nil
+    end
+
+    alias forEach for_each
+
+    def each(&block)
+      @pairs.each(&block)
+    end
+
+    def size
+      @pairs.length
+    end
+
+    alias length size
+
+    def to_s
+      @pairs.map { |k, v| "#{k}=#{v}" }.join("&")
+    end
+
+    def __js_get__(key)
+      case key
+      when "size", "length"
+        size
+      end
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "append"
+        append(args[0], args[1], args[2])
+      when "set"
+        set(args[0], args[1], args[2])
+      when "get"
+        get(args[0])
+      when "getAll"
+        get_all(args[0])
+      when "has"
+        has(args[0])
+      when "delete"
+        delete(args[0])
+      when "keys"
+        keys
+      when "values"
+        values
+      when "entries"
+        entries
+      when "forEach"
+        for_each(&args[0])
+      end
+    end
+
+    private
+
+    # Collect submittable name/value pairs from a form element.
+    # Per spec, the submitter (clicked button) is included only when
+    # the user passes it explicitly; we don't model that here.
+    def collect_from(form)
+      form.elements.each do |el|
+        next unless el.respond_to?(:name)
+
+        name = el.name.to_s
+        next if name.empty?
+        next if disabled?(el)
+
+        case el.__node__.name
+        when "input"
+          collect_input(el, name)
+        when "select"
+          collect_select(el, name)
+        when "textarea", "button", "output"
+          @pairs << [name, el.value.to_s] if el.respond_to?(:value)
+        end
+      end
+    end
+
+    def collect_input(el, name)
+      type = el.type.to_s.downcase
+      case type
+      when "submit", "reset", "button", "image"
+        # submit/button: only the activated submitter is included (skip).
+        nil
+      when "file"
+        # Each File in the input's FileList becomes its own entry, per
+        # the HTML "constructing the entry list" spec. An empty list
+        # contributes a single empty File-like entry so name= survives.
+        files = el.respond_to?(:files) ? el.files : nil
+        if files && !files.empty?
+          files.each { |f| @pairs << [name, f] }
+        else
+          @pairs << [name, File.new([], "", "type" => "application/octet-stream")]
+        end
+
+      when "checkbox", "radio"
+        @pairs << [name, (el.value.to_s.empty? ? "on" : el.value.to_s)] if el.checked
+      else
+        @pairs << [name, el.value.to_s]
+      end
+    end
+
+    def collect_select(el, name)
+      if el.multiple
+        el.selected_options.each { |opt| @pairs << [name, opt.value.to_s] }
+      else
+        opt = el.selected_options[0]
+        @pairs << [name, opt ? opt.value.to_s : ""]
+      end
+    end
+
+    def disabled?(el)
+      el.respond_to?(:disabled) && el.disabled
+    end
+
+    def stringify(value)
+      # File / Blob values pass through unchanged (multipart form
+      # encoding handles them); other values are stringified per spec.
+      return value if value.is_a?(Blob)
+      # Backward-compat: embedders' own file-marker objects.
+      return value if value.respond_to?(:__file_marker__)
+      return "" if value.nil?
+
+      value.to_s
+    end
+  end
+end

data/lib/dommy/html_collection.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+module Dommy
+  # `HTMLCollection` — live, ordered set of Element nodes. Distinct
+  # from `NodeList` in two ways:
+  #
+  #   - Always element-only (Node types other than Element are skipped)
+  #   - Supports `namedItem(name)` lookup by `id` or `name` attribute
+  #
+  # Live behavior: pass an evaluator block (called `&compute`) that
+  # returns the current element list on every access. Each query
+  # re-evaluates, so mutations to the parent tree are reflected
+  # immediately.
+  #
+  # Intentionally NOT a subclass of Array; spec semantics demand
+  # `Array.isArray(html_collection) === false` in real browsers, and
+  # mirroring that here helps tests written against MDN behavior.
+  class HTMLCollection
+    include Enumerable
+
+    def initialize(&compute)
+      @compute = compute
+    end
+
+    def length
+      to_a.length
+    end
+
+    alias size length
+
+    def empty?
+      to_a.empty?
+    end
+
+    def item(index)
+      i = index.to_i
+      return nil if i < 0
+
+      to_a[i]
+    end
+
+    # `namedItem(name)` returns the first element whose `id` or
+    # `name` attribute equals `name`. Returns nil if no match.
+    def named_item(name)
+      key = name.to_s
+      return nil if key.empty?
+
+      to_a.find do |el|
+        next false unless el.respond_to?(:__node__)
+
+        el.__node__["id"].to_s == key || el.__node__["name"].to_s == key
+      end
+    end
+
+    # `[]` supports both integer index (`coll[0]`, `coll[-1]`) and
+    # string name (`coll["myId"]`). Negative indices are interpreted
+    # Ruby-style (offset from the end), even though the spec's
+    # `item(i)` is positive-only.
+    def [](key)
+      case key
+      when Integer
+        to_a[key]
+      when /\A-?\d+\z/
+        to_a[key.to_i]
+      else
+        named_item(key)
+      end
+    end
+
+    def first(n = nil)
+      n.nil? ? to_a.first : to_a.first(n)
+    end
+
+    def last(n = nil)
+      n.nil? ? to_a.last : to_a.last(n)
+    end
+
+    def each(&blk)
+      to_a.each(&blk)
+    end
+
+    def to_a
+      @compute.call
+    end
+
+    def __js_get__(key)
+      case key
+      when "length"
+        length
+      when Integer
+        item(key)
+      else
+        s = key.to_s
+        if s.match?(/\A\d+\z/)
+          item(s.to_i)
+        else
+          named_item(s) || (s == "length" ? length : nil)
+        end
+      end
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "item"
+        item(args[0])
+      when "namedItem"
+        named_item(args[0])
+      end
+    end
+  end
+
+  # `HTMLOptionsCollection` — specialized `<select>.options` collection.
+  # Adds `add(option, before?)`, `remove(index)`, the `selectedIndex`
+  # getter/setter, and a `length=` setter that truncates or extends.
+  #
+  # Live, like the parent class. Constructed by `HTMLSelectElement`
+  # and passed its owner; mutations route through the owner's tree.
+  class HTMLOptionsCollection < HTMLCollection
+    def initialize(owner, &compute)
+      super(&compute)
+      @owner = owner
+    end
+
+    # Append (or insert before `before`) an option element. `before`
+    # accepts either another option (insert before that node) or an
+    # integer index. Strings/`null` append.
+    def add(option, before = nil)
+      return nil unless option.respond_to?(:__node__)
+
+      case before
+      when nil
+        @owner.append_child(option)
+      when Integer
+        anchor = item(before)
+        anchor ? @owner.insert_before(option, anchor) : @owner.append_child(option)
+      else
+        if before.respond_to?(:__node__)
+          @owner.insert_before(option, before)
+        else
+          @owner.append_child(option)
+        end
+      end
+
+      nil
+    end
+
+    def remove(index)
+      target = item(index)
+      target&.remove
+      nil
+    end
+
+    def selected_index
+      @owner.selected_index
+    end
+
+    def selected_index=(value)
+      @owner.selected_index = value
+    end
+
+    # Setter mirrors `<select>.options.length = n` — destructive resize.
+    # Shrinks by removing trailing options, grows by appending blank
+    # `<option>`s. Real browsers do the same.
+    def length=(new_length)
+      n = new_length.to_i
+      current = to_a
+      if n < current.length
+        current[n..].each(&:remove)
+      elsif n > current.length
+        (n - current.length).times { @owner.append_child(@owner.document.create_element("option")) }
+      end
+
+      n
+    end
+
+    def __js_get__(key)
+      case key
+      when "selectedIndex"
+        selected_index
+      else
+        super
+      end
+    end
+
+    def __js_set__(key, value)
+      case key
+      when "selectedIndex"
+        self.selected_index = value
+      when "length"
+        self.length = value
+      end
+
+      nil
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "add"
+        add(args[0], args[1])
+      when "remove"
+        remove(args[0])
+      else
+        super
+      end
+    end
+  end
+end