dommy 0.5.0

data/lib/dommy/bridge.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Dommy
+  # `Dommy::Bridge` — adapter classes for JS-style bridges (wasm
+  # embedders that route DOM method calls and constructor `new` ops
+  # through the `__js_get__` / `__js_set__` / `__js_call__` /
+  # `__js_new__` protocol).
+  #
+  # CRuby users writing happy-dom-style tests can ignore everything
+  # in this namespace; it's only relevant when integrating Dommy
+  # with an external runtime (such as an mruby-on-wasm host) that
+  # constructs callbacks / events / promises via the bridge view.
+  #
+  # The protocol contract:
+  #   - `__js_get__(name)` reads a JS-style property by string name
+  #   - `__js_set__(name, value)` writes one
+  #   - `__js_call__(method, args)` invokes a method with positional
+  #     args (Array)
+  #   - `__js_new__(args)` invokes the value as a JS constructor
+  module Bridge
+    # Wraps an external callback handle (registered in a host-side
+    # callback table) so the JS bridge can resolve / invoke it. The
+    # external host that creates these is responsible for honoring
+    # `invoke_callback(callback_id, args)`.
+    #
+    # The `__callback_id__` key on this object exposes the integer
+    # id to JS-side code that needs to round-trip it (e.g. for
+    # release / introspection).
+    class Callback
+      ID_KEY = "__callback_id__"
+
+      def initialize(host, callback_id)
+        @host = host
+        @callback_id = callback_id
+        @props = {}
+      end
+
+      def __js_get__(key)
+        if key == ID_KEY
+          @props.fetch(key, @callback_id)
+        else
+          @props[key]
+        end
+      end
+
+      def __js_set__(key, value)
+        @props[key] = value
+        nil
+      end
+
+      def __js_call__(method, args)
+        case method
+        when "call"
+          @host.invoke_callback(@callback_id, args)
+        end
+      end
+    end
+
+    # Block-as-constructor adapter — invoking `__js_new__(args)`
+    # calls the wrapped block with `args` and returns whatever the
+    # block produces. Used by Window to wire up `new Event(init)`,
+    # `new CustomEvent(init)`, etc. without hand-rolling a class
+    # for each constructor.
+    class Constructor
+      def initialize(&block)
+        @block = block
+        @class_methods = {}
+      end
+
+      def __js_new__(args)
+        @block.call(args)
+      end
+
+      # Register a class-level method (e.g. `URL.createObjectURL`)
+      # that JS bridges resolve via `__js_call__` on the constructor
+      # itself. Returns self for chaining.
+      def define_class_method(name, &block)
+        @class_methods[name.to_s] = block
+        self
+      end
+
+      def __js_call__(method, args)
+        handler = @class_methods[method.to_s]
+        handler&.call(args)
+      end
+    end
+
+    # `JS.global[:Promise]` view. Implements the `resolve` / `reject`
+    # class methods plus `new Promise(executor)` via `__js_new__`.
+    class PromiseConstructor
+      def initialize(window)
+        @window = window
+      end
+
+      def __js_call__(method, args)
+        case method
+        when "resolve"
+          PromiseValue.resolve(@window, args[0])
+        when "reject"
+          PromiseValue.reject(@window, args[0])
+        end
+      end
+
+      # `new Promise(executor)` — runs executor synchronously with
+      # (resolve, reject) callbacks.
+      def __js_new__(args)
+        executor = args[0]
+        promise = PromiseValue.new(@window)
+        resolve = PromiseSettler.new(promise, fulfilled: true)
+        reject = PromiseSettler.new(promise, fulfilled: false)
+        if executor.respond_to?(:__js_call__)
+          executor.__js_call__("call", [resolve, reject])
+        elsif executor.respond_to?(:call)
+          executor.call(resolve, reject)
+        end
+
+        promise
+      end
+    end
+
+    # Adapter so a Ruby-side executor can deliver resolve/reject
+    # through the same `__js_call__("call", args)` interface that
+    # the scheduler and JS bridge use for callbacks.
+    class PromiseSettler
+      def initialize(promise, fulfilled:)
+        @promise = promise
+        @fulfilled = fulfilled
+      end
+
+      def __js_call__(_method, args)
+        if @fulfilled
+          @promise.fulfill(args[0])
+        else
+          @promise.reject(args[0])
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/dommy/css.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+module Dommy
+  # `CSSStyleSheet` — stub implementation. Dommy has no CSS parser
+  # nor a render tree, so we don't interpret rule text; the sheet
+  # acts as an ordered list of opaque `CSSRule`-like wrappers.
+  #
+  # Useful for code that does:
+  #
+  #   sheet.insertRule("p { color: red }", 0);
+  #   for (const r of sheet.cssRules) console.log(r.cssText);
+  #
+  # `disabled` is honored as state. `href`, `media`, `title`, `type`
+  # mirror the owner node's attributes when present.
+  class CSSStyleSheet
+    attr_reader :owner_node, :css_rules
+
+    def initialize(owner_node:, href: nil, media: nil, title: nil, type: "text/css")
+      @owner_node = owner_node
+      @href = href
+      @media = media
+      @title = title
+      @type = type
+      @disabled = false
+      @css_rules = CSSRuleList.new
+    end
+
+    def disabled
+      @disabled
+    end
+
+    def disabled=(v)
+      @disabled = !!v
+    end
+
+    def href
+      @href
+    end
+
+    def title
+      @title
+    end
+
+    def type
+      @type
+    end
+
+    def media
+      @media.to_s
+    end
+
+    def parent_style_sheet
+      nil
+    end
+
+    def owner_rule
+      nil
+    end
+
+    # `insertRule(rule_text, index)` — appends an opaque CSSRule at the
+    # given position (default: end). Returns the index used.
+    def insert_rule(rule_text, index = nil)
+      idx = index.nil? ? @css_rules.length : index.to_i
+      raise DOMException::IndexSizeError, "out of range" if idx < 0 || idx > @css_rules.length
+
+      @css_rules.__insert__(idx, CSSRule.new(rule_text.to_s, self))
+      idx
+    end
+
+    def delete_rule(index)
+      idx = index.to_i
+      raise DOMException::IndexSizeError, "out of range" if idx < 0 || idx >= @css_rules.length
+
+      @css_rules.__delete_at__(idx)
+      nil
+    end
+
+    # `replaceSync(text)` — replace all rules with a single rule blob
+    # (no parsing — we keep it as one opaque entry).
+    def replace_sync(text)
+      @css_rules.__clear__
+      return nil if text.to_s.empty?
+
+      @css_rules.__insert__(0, CSSRule.new(text.to_s, self))
+      nil
+    end
+
+    # `replace(text)` — spec returns a Promise resolved with self.
+    # We can't return a JS-bridge Promise from here without a Window,
+    # so we mirror the sync behavior and return self.
+    def replace(text)
+      replace_sync(text)
+      self
+    end
+
+    def __js_get__(key)
+      case key
+      when "cssRules", "rules"
+        @css_rules
+      when "disabled"
+        @disabled
+      when "href"
+        @href
+      when "media"
+        media
+      when "title"
+        @title
+      when "type"
+        @type
+      when "ownerNode"
+        @owner_node
+      when "parentStyleSheet"
+        parent_style_sheet
+      when "ownerRule"
+        owner_rule
+      end
+    end
+
+    def __js_set__(key, value)
+      case key
+      when "disabled"
+        self.disabled = value
+      end
+
+      nil
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "insertRule"
+        insert_rule(args[0], args[1])
+      when "deleteRule"
+        delete_rule(args[0])
+      when "replaceSync"
+        replace_sync(args[0])
+      when "replace"
+        replace(args[0])
+      end
+    end
+  end
+
+  # `CSSRuleList` — indexed list of CSSRule, returned by
+  # `sheet.cssRules`. Live: mutations to the owning sheet are visible.
+  class CSSRuleList
+    include Enumerable
+
+    def initialize
+      @rules = []
+    end
+
+    def length
+      @rules.length
+    end
+
+    alias size length
+
+    def item(index)
+      i = index.to_i
+      return nil if i < 0 || i >= @rules.length
+
+      @rules[i]
+    end
+
+    def [](index)
+      item(index)
+    end
+
+    def each(&blk)
+      @rules.each(&blk)
+    end
+
+    def to_a
+      @rules.dup
+    end
+
+    def __insert__(index, rule)
+      @rules.insert(index, rule)
+    end
+
+    def __delete_at__(index)
+      @rules.delete_at(index)
+    end
+
+    def __clear__
+      @rules.clear
+    end
+
+    def __js_get__(key)
+      case key
+      when "length"
+        length
+      else
+        if key.is_a?(Integer) || key.to_s.match?(/\A\d+\z/)
+          item(key.to_i)
+        end
+      end
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "item"
+        item(args[0])
+      end
+    end
+  end
+
+  # `CSSRule` — opaque wrapper over the raw rule text. Real engines
+  # have a subclass hierarchy (CSSStyleRule, CSSMediaRule, etc.), but
+  # without a CSS parser we keep one minimal type that round-trips
+  # the source text.
+  class CSSRule
+    STYLE_RULE = 1
+    CHARSET_RULE = 2
+    IMPORT_RULE = 3
+    MEDIA_RULE = 4
+    FONT_FACE_RULE = 5
+    PAGE_RULE = 6
+    KEYFRAMES_RULE = 7
+    KEYFRAME_RULE = 8
+
+    attr_reader :parent_style_sheet
+
+    def initialize(css_text, parent_style_sheet = nil)
+      @css_text = css_text.to_s
+      @parent_style_sheet = parent_style_sheet
+    end
+
+    def css_text
+      @css_text
+    end
+
+    def css_text=(v)
+      @css_text = v.to_s
+    end
+
+    # We don't parse, so report the generic STYLE_RULE type.
+    def type
+      STYLE_RULE
+    end
+
+    def parent_rule
+      nil
+    end
+
+    def __js_get__(key)
+      case key
+      when "cssText"
+        @css_text
+      when "type"
+        type
+      when "parentStyleSheet"
+        @parent_style_sheet
+      when "parentRule"
+        parent_rule
+      when "STYLE_RULE"
+        STYLE_RULE
+      when "MEDIA_RULE"
+        MEDIA_RULE
+      when "IMPORT_RULE"
+        IMPORT_RULE
+      when "FONT_FACE_RULE"
+        FONT_FACE_RULE
+      when "PAGE_RULE"
+        PAGE_RULE
+      when "KEYFRAMES_RULE"
+        KEYFRAMES_RULE
+      when "KEYFRAME_RULE"
+        KEYFRAME_RULE
+      when "CHARSET_RULE"
+        CHARSET_RULE
+      end
+    end
+
+    def __js_set__(key, value)
+      case key
+      when "cssText"
+        self.css_text = value
+      end
+
+      nil
+    end
+  end
+end

data/lib/dommy/custom_elements.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Dommy
+  # `window.customElements` — registry mapping custom element tag
+  # names to Ruby classes that extend `HTMLElement`. Lifecycle
+  # callbacks (`connected_callback` / `disconnected_callback` /
+  # `attribute_changed_callback` / `adopted_callback`) are invoked by
+  # the document's mutation pipeline when registered elements are
+  # added, removed, or have observed attributes mutated.
+  #
+  # Names must contain a hyphen per the HTML spec (e.g., `my-button`).
+  class CustomElementRegistry
+    NAME_RE = /\A[a-z][a-z0-9-]*-[a-z0-9-]*\z/
+
+    def initialize(window)
+      @window = window
+      # name → klass
+      @definitions = {}
+      # name → Array<{ resolve, reject }>
+      @pending_promises = {}
+    end
+
+    def define(name, klass, _options = nil)
+      key = name.to_s
+      unless key.match?(NAME_RE)
+        raise DOMException::SyntaxError, "name must be a hyphenated string, got #{name.inspect}"
+      end
+
+      raise DOMException::NotSupportedError, "#{key} already defined" if @definitions.key?(key)
+
+      @definitions[key] = klass
+      # Resolve any pending whenDefined() promises and re-wrap
+      # already-existing nodes (upgrade).
+      resolve_pending(key, klass)
+      upgrade_existing(key)
+      nil
+    end
+
+    def get(name)
+      @definitions[name.to_s]
+    end
+
+    def get_name(klass)
+      @definitions.each { |k, v| return k if v == klass }
+      nil
+    end
+
+    # Returns a Dommy::PromiseValue that resolves with the registered
+    # constructor when `name` is defined (immediately if already so).
+    def when_defined(name)
+      key = name.to_s
+      promise = PromiseValue.new(@window)
+      if (klass = @definitions[key])
+        promise.fulfill(klass)
+      else
+        @pending_promises[key] ||= []
+        @pending_promises[key] << promise
+      end
+
+      promise
+    end
+
+    # Walk `root`'s subtree and re-wrap any nodes whose tag is now
+    # registered; fires `connectedCallback` for each upgraded node
+    # that's currently attached to a document tree.
+    def upgrade(root)
+      return nil unless root.respond_to?(:__node__)
+
+      walk_descendants(root.__node__) do |nk|
+        next unless nk.element?
+        next unless @definitions.key?(nk.name)
+
+        # Force re-wrap by clearing the document's cached wrapper.
+        @window.document.__reset_wrapper__(nk)
+        wrapped = @window.document.wrap_node(nk)
+        @window.document.__notify_connected__(wrapped) if wrapped
+      end
+
+      nil
+    end
+
+    def __js_get__(_key)
+      nil
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "define"
+        define(args[0], args[1], args[2])
+      when "get"
+        get(args[0])
+      when "whenDefined"
+        when_defined(args[0])
+      when "upgrade"
+        upgrade(args[0])
+      end
+    end
+
+    private
+
+    def resolve_pending(name, klass)
+      list = @pending_promises.delete(name)
+      list&.each { |p| p.fulfill(klass) }
+    end
+
+    # When define() lands after the matching element is already in
+    # the document, those nodes need upgrading: re-wrap them with the
+    # new class and fire connectedCallback.
+    def upgrade_existing(name)
+      doc = @window.document
+      doc.nokogiri_doc.css(name).each do |nk|
+        doc.__reset_wrapper__(nk)
+        wrapped = doc.wrap_node(nk)
+        doc.__notify_connected__(wrapped) if wrapped
+      end
+    end
+
+    def walk_descendants(node, &blk)
+      yield node
+      return unless node.respond_to?(:children)
+
+      node.children.each { |c| walk_descendants(c, &blk) }
+    end
+  end
+end

data/lib/dommy/data_transfer.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Dommy
+  # `DataTransfer` — the payload object on a DragEvent. Holds the
+  # files being dragged plus arbitrary string-keyed data per MIME
+  # format. Tests build one explicitly to simulate drag-and-drop:
+  #
+  #   dt = Dommy::DataTransfer.new(files: [file])
+  #   ev = Dommy::DragEvent.new("drop", "dataTransfer" => dt, "bubbles" => true)
+  #   target.dispatch_event(ev)
+  #
+  # Spec: https://html.spec.whatwg.org/multipage/dnd.html#datatransfer
+  class DataTransfer
+    attr_reader :files
+
+    def initialize(files: [], data: {})
+      @files = files.is_a?(FileList) ? files : FileList.new(Array(files))
+      @data = data.transform_keys { |k| normalize_format(k) }
+      @drop_effect = "none"
+      @effect_allowed = "uninitialized"
+    end
+
+    def types
+      @data.keys
+    end
+
+    def get_data(format)
+      @data[normalize_format(format)].to_s
+    end
+
+    def set_data(format, data)
+      @data[normalize_format(format)] = data.to_s
+      nil
+    end
+
+    def clear_data(format = nil)
+      if format
+        @data.delete(normalize_format(format))
+      else
+        @data.clear
+      end
+
+      nil
+    end
+
+    attr_accessor :drop_effect, :effect_allowed
+
+    def __js_get__(key)
+      case key
+      when "files"
+        @files
+      when "types"
+        types
+      when "dropEffect"
+        @drop_effect
+      when "effectAllowed"
+        @effect_allowed
+      end
+    end
+
+    def __js_set__(key, value)
+      case key
+      when "dropEffect"
+        @drop_effect = value.to_s
+      when "effectAllowed"
+        @effect_allowed = value.to_s
+      end
+
+      nil
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "getData"
+        get_data(args[0])
+      when "setData"
+        set_data(args[0], args[1])
+      when "clearData"
+        clear_data(args[0])
+      end
+    end
+
+    private
+
+    # Per spec, "text" maps to "text/plain" and "url" maps to
+    # "text/uri-list"; otherwise lowercase the MIME format.
+    def normalize_format(format)
+      case format.to_s.downcase
+      when "text"
+        "text/plain"
+      when "url"
+        "text/uri-list"
+      else
+        format.to_s.downcase
+      end
+    end
+  end
+end