dommy 0.5.0 → 0.7.0

data/lib/dommy/{router.rb → location.rb}

@@ -5,7 +5,7 @@ require "uri"
 module Dommy
   # `window.location` polyfill. The Window owns one Location and one
   # History instance, and they share the same underlying state. Hash
-  # / pushState / replaceState all flow through `__set_url__`.
+  # / pushState / replaceState all flow through `__internal_set_url__`.
   class Location
     def initialize(window, origin: "http://localhost", pathname: "/", search: "", hash: "")
       @window = window
@@ -41,7 +41,7 @@ module Dommy
     def __js_set__(key, value)
       case key
       when "href"
-        __set_url__(value.to_s)
+        __internal_set_url__(value.to_s)
       when "hash"
         new_hash = value.to_s
         new_hash = "##{new_hash}" unless new_hash.empty? || new_hash.start_with?("#")
@@ -68,7 +68,7 @@ module Dommy
     def __js_call__(method, args)
       case method
       when "assign", "replace"
-        __set_url__(args[0].to_s)
+        __internal_set_url__(args[0].to_s)
       when "reload"
         nil
       when "toString"
@@ -83,12 +83,16 @@ module Dommy
     # Internal — accepts an absolute or relative URL string and
     # updates pathname / search / hash. Called by History pushState /
     # replaceState and by `location.href = ...`.
-    def __set_url__(raw)
+    def __internal_set_url__(raw)
       previous_hash = @hash
       if raw.start_with?("#")
         @hash = raw
       else
         uri = URI.join(@origin + @pathname + @search + @hash, raw) rescue URI(raw)
+        # An absolute URL (carrying scheme + host) navigates to a new
+        # origin; a relative URL inherits the current origin from the
+        # join base, so rebuilding with the same parts is a no-op.
+        rebuild_origin(scheme: uri.scheme, host: uri.host, port: uri.port) if uri.scheme && uri.host
         @pathname = uri.path.to_s == "" ? "/" : uri.path
         @search = uri.query ? "?#{uri.query}" : ""
         @hash = uri.fragment ? "##{uri.fragment}" : ""
@@ -134,142 +138,4 @@ module Dommy
       rebuild_origin(scheme: scheme, host: parts[:host], port: parts[:port])
     end
   end
-
-  # `window.history` polyfill. Stack-based; back/forward move the
-  # cursor. pushState appends; replaceState mutates the current entry.
-  # Each entry is `{ state:, url: }`. Popstate fires when back /
-  # forward triggers a different cursor (not on pushState per spec).
-  class History
-    def initialize(window, location)
-      @window = window
-      @location = location
-      # Initial entry mirrors the live Location. Bookmark URL is
-      # resynthesized lazily from Location each time we read it.
-      @stack = [{state: nil, url: nil}]
-      @cursor = 0
-      @scroll_restoration = "auto"
-    end
-
-    def __js_get__(key)
-      case key
-      when "length"
-        @stack.size
-      when "state"
-        @stack[@cursor][:state]
-      when "scrollRestoration"
-        @scroll_restoration
-      end
-    end
-
-    def __js_set__(key, value)
-      case key
-      when "scrollRestoration"
-        # Per spec, only "auto" and "manual" are accepted. Invalid
-        # values silently retain the current value.
-        v = value.to_s
-        @scroll_restoration = v if %w[auto manual].include?(v)
-      end
-
-      nil
-    end
-
-    def __js_call__(method, args)
-      case method
-      when "pushState"
-        push(args[0], args[2])
-      when "replaceState"
-        replace(args[0], args[2])
-      when "back"
-        go(-1)
-      when "forward"
-        go(1)
-      when "go"
-        go((args[0] || 0).to_i)
-      end
-    end
-
-    private
-
-    def push(state, url)
-      @stack = @stack[0..@cursor]
-      @location.__set_url__(url.to_s) if url
-      @stack << {state: state, url: nil}
-      @cursor = @stack.size - 1
-    end
-
-    def replace(state, url)
-      @location.__set_url__(url.to_s) if url
-      @stack[@cursor] = {state: state, url: nil}
-    end
-
-    def go(delta)
-      target = @cursor + delta
-      return if target < 0 || target >= @stack.size
-
-      @cursor = target
-      @window.fire_popstate(@stack[@cursor][:state])
-    end
-  end
-
-  # `URL` constructor — Ruby `URI` wrap. Browser URL API surface:
-  # `[:origin]`, `[:pathname]`, `[:search]`, `[:hash]`, `[:href]`.
-  # Supports the two-arg form `new URL(raw, base)`.
-  class Url
-    def initialize(raw, base = nil)
-      uri = if base && !base.empty?
-        URI.join(base, raw)
-      else
-        URI(raw.to_s)
-      end
-
-      @origin = origin_of(uri)
-      @pathname = uri.path.to_s == "" ? "/" : uri.path
-      @search = uri.query ? "?#{uri.query}" : ""
-      @hash = uri.fragment ? "##{uri.fragment}" : ""
-      @href = uri.to_s
-    rescue URI::InvalidURIError, ArgumentError
-      @origin = ""
-      @pathname = ""
-      @search = ""
-      @hash = ""
-      @href = raw.to_s
-    end
-
-    def __js_get__(key)
-      case key
-      when "origin"
-        @origin
-      when "pathname"
-        @pathname
-      when "search"
-        @search
-      when "hash"
-        @hash
-      when "href"
-        @href
-      when "toString"
-        @href
-      end
-    end
-
-    def __js_set__(_key, _value)
-      nil
-    end
-
-    def __js_call__(method, _args)
-      method == "toString" ? @href : nil
-    end
-
-    private
-
-    def origin_of(uri)
-      scheme = uri.scheme
-      host = uri.host
-      return "" unless scheme && host
-
-      port = uri.port
-      default = (scheme == "https" ? 443 : 80)
-      port == default ? "#{scheme}://#{host}" : "#{scheme}://#{host}:#{port}"
-    end
-  end
 end

data/lib/dommy/media_query_list.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Dommy
+  # `MediaQueryList` — what `window.matchMedia(query)` returns.
+  #
+  # Dommy has no layout / viewport, so `matches` is `false` by default.
+  # Tests drive media query changes via `__test_set_matches__(bool)`, which
+  # flips the boolean and fires a `change` event — exactly the surface
+  # libraries like Material-UI / Bootstrap / @testing-library consult.
+  #
+  # Spec: https://drafts.csswg.org/cssom-view/#mediaquerylist
+  class MediaQueryList
+    include EventTarget
+
+    attr_reader :media
+
+    def initialize(window, query)
+      @window = window
+      @media = query.to_s
+      @matches = false
+      @onchange = nil
+    end
+
+    def matches
+      @matches
+    end
+
+    alias matches? matches
+
+    # Spec aliases for legacy support.
+    def add_listener(callback)
+      add_event_listener("change", callback)
+    end
+
+    alias addListener add_listener
+
+    def remove_listener(callback)
+      remove_event_listener("change", callback)
+    end
+
+    alias removeListener remove_listener
+
+    # Test seam: flip the match state and dispatch a `change` event so
+    # subscribers re-render.
+    def __test_set_matches__(value)
+      return if @matches == !!value
+
+      @matches = !!value
+      dispatch_event(MediaQueryListEvent.new("change", "matches" => @matches, "media" => @media))
+      nil
+    end
+
+    def __js_get__(key)
+      case key
+      when "media"
+        @media
+      when "matches"
+        @matches
+      when "onchange"
+        @onchange
+      end
+    end
+
+    def __js_set__(key, value)
+      case key
+      when "onchange"
+        remove_event_listener("change", @onchange) if @onchange
+        @onchange = value
+        add_event_listener("change", value) if value
+      end
+
+      nil
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "matches"
+        @matches
+      when "addListener"
+        add_listener(args[0])
+      when "removeListener"
+        remove_listener(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
+  end
+
+  # `MediaQueryListEvent` — the `change` event payload.
+  class MediaQueryListEvent < Event
+    def initialize(type, init = nil)
+      super
+      @matches = !!read_init(init, "matches")
+      @media = (read_init(init, "media") || "").to_s
+    end
+
+    attr_reader :matches, :media
+
+    def __js_get__(key)
+      case key
+      when "matches"
+        @matches
+      when "media"
+        @media
+      else
+        super
+      end
+    end
+  end
+end

data/lib/dommy/message_channel.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+module Dommy
+  # `MessageChannel` — creates a pair of `MessagePort`s connected to
+  # each other. `port1.postMessage(x)` queues a microtask that fires
+  # a `message` event on `port2`, and vice versa.
+  #
+  # Spec: https://html.spec.whatwg.org/multipage/web-messaging.html
+  class MessageChannel
+    attr_reader :port1, :port2
+
+    def initialize(window)
+      @port1 = MessagePort.new(window)
+      @port2 = MessagePort.new(window)
+      @port1.__internal_entangle__(@port2)
+      @port2.__internal_entangle__(@port1)
+    end
+
+    def __js_get__(key)
+      case key
+      when "port1"
+        @port1
+      when "port2"
+        @port2
+      end
+    end
+  end
+
+  # `MessagePort` — one end of a MessageChannel. `postMessage(value)`
+  # dispatches a `MessageEvent` on the entangled port asynchronously.
+  class MessagePort
+    include EventTarget
+
+    def initialize(window)
+      @window = window
+      @entangled = nil
+      @onmessage = nil
+      @started = false
+      @pending = []
+    end
+
+    def __internal_entangle__(other)
+      @entangled = other
+    end
+
+    def post_message(data)
+      port = @entangled
+      return unless port
+
+      @window.scheduler.queue_microtask(
+        proc do
+          evt = MessageEvent.new("message", "data" => Dommy.structured_clone(data))
+          if port.__internal_started?
+            port.dispatch_event(evt)
+          else
+            port.__internal_enqueue__(evt)
+          end
+        end
+      )
+
+      nil
+    end
+
+    alias postMessage post_message
+
+    def start
+      @started = true
+      flush = @pending
+      @pending = []
+      flush.each { |evt| dispatch_event(evt) }
+      nil
+    end
+
+    def close
+      @entangled = nil
+      nil
+    end
+
+    def __internal_started?
+      @started || !@inline_message_handler.nil?
+    end
+
+    def __internal_enqueue__(event)
+      @pending << event
+    end
+
+    def __js_get__(key)
+      case key
+      when "onmessage"
+        @onmessage
+      end
+    end
+
+    def __js_set__(key, value)
+      case key
+      when "onmessage"
+        # Setting onmessage implicitly starts the port per spec.
+        remove_event_listener("message", @onmessage) if @onmessage
+        @onmessage = value
+        @inline_message_handler = value
+        add_event_listener("message", value) if value
+        start if value
+      end
+
+      nil
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "postMessage"
+        post_message(args[0])
+      when "start"
+        start
+      when "close"
+        close
+      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
+
+  # `MessageEvent` — payload of `message` events on MessagePort /
+  # BroadcastChannel / WebSocket / EventSource.
+  class MessageEvent < Event
+    def initialize(type, init = nil)
+      super
+      @data = read_init(init, "data")
+      @origin = (read_init(init, "origin") || "").to_s
+      @last_event_id = (read_init(init, "lastEventId") || "").to_s
+      @source = read_init(init, "source")
+      @ports = read_init(init, "ports") || []
+    end
+
+    attr_reader :data, :origin, :last_event_id, :source, :ports
+
+    def __js_get__(key)
+      case key
+      when "data"
+        @data
+      when "origin"
+        @origin
+      when "lastEventId"
+        @last_event_id
+      when "source"
+        @source
+      when "ports"
+        @ports
+      else
+        super
+      end
+    end
+  end
+
+  # `BroadcastChannel` — same-origin pub/sub. Dommy keeps a per-window
+  # channel registry; sending posts to all other peers on the same
+  # name within the same Window.
+  class BroadcastChannel
+    include EventTarget
+
+    @@registries = Hash.new { |h, w| h[w] = Hash.new { |c, n| c[n] = [] } }
+
+    attr_reader :name
+
+    def initialize(window, name)
+      @window = window
+      @name = name.to_s
+      @closed = false
+      @onmessage = nil
+      @@registries[window][@name] << self
+    end
+
+    def post_message(data)
+      return if @closed
+
+      peers = @@registries[@window][@name].reject { |p| p.equal?(self) || p.closed? }
+      cloned = Dommy.structured_clone(data)
+      peers.each do |peer|
+        @window.scheduler.queue_microtask(
+          proc do
+            peer.dispatch_event(MessageEvent.new("message", "data" => cloned))
+          end
+        )
+      end
+
+      nil
+    end
+
+    alias postMessage post_message
+
+    def close
+      return if @closed
+
+      @closed = true
+      @@registries[@window][@name].delete(self)
+      nil
+    end
+
+    def closed?
+      @closed
+    end
+
+    def __js_get__(key)
+      case key
+      when "name"
+        @name
+      when "onmessage"
+        @onmessage
+      end
+    end
+
+    def __js_set__(key, value)
+      case key
+      when "onmessage"
+        remove_event_listener("message", @onmessage) if @onmessage
+        @onmessage = value
+        add_event_listener("message", value) if value
+      end
+
+      nil
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "postMessage"
+        post_message(args[0])
+      when "close"
+        close
+      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/{observer.rb → mutation_observer.rb}

@@ -148,17 +148,27 @@ module Dommy
         raise TypeError, "MutationObserver.observe: at least one of childList, attributes, characterData must be true"
       end
 
-      @observed <<
-        {
-          target: target,
-          child_list: child_list_on,
-          subtree: truthy_option(opts, "subtree"),
-          attributes: attributes_on,
-          attribute_filter: attribute_filter,
-          attribute_old_value: truthy_option(opts, "attributeOldValue"),
-          character_data: character_data_on,
-          character_data_old_value: truthy_option(opts, "characterDataOldValue")
-        }
+      entry = {
+        target: target,
+        child_list: child_list_on,
+        subtree: truthy_option(opts, "subtree"),
+        attributes: attributes_on,
+        attribute_filter: attribute_filter,
+        attribute_old_value: truthy_option(opts, "attributeOldValue"),
+        character_data: character_data_on,
+        character_data_old_value: truthy_option(opts, "characterDataOldValue")
+      }
+
+      # WHATWG MutationObserver §observe: if `target` is already
+      # observed, replace the existing registration's options
+      # (don't merge or stack).
+      existing_index = @observed.index { |e| e[:target].equal?(target) }
+      if existing_index
+        @observed[existing_index] = entry
+      else
+        @observed << entry
+      end
+
       @document.register_observer(self)
       nil
     end