dommy 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 217a4ff53f58e6c12e424951b057cc0d3cbab3b898fdb85d5fd69ca7c34cd3c5
-  data.tar.gz: bedaba24772a900d85e62a27729b8e62f8db8a18e0b48360f1717799108432f8
+  metadata.gz: 7ce9aec097da24f1f6a44792f44615605a1405483b6c6c5183031757d11a0853
+  data.tar.gz: cf7c0e05839c313763590fcdb4d134459f5b1fe91ed1b479f819b18181cf1058
 SHA512:
-  metadata.gz: 3a9687cf21dde61fa2c65cd47ca90f18e4d65da61912ffdbd8366cbf75f1110a96da52c43a27abee498dc9f2a19ffc306a491e14bb6aa4d985f7dd74fec88816
-  data.tar.gz: 201bb5b9217bc0373923f89e36cc968cb55328f249d902acdfa973f9f01179d9912463b5ee9d165c8c5e862fb7ff3f40ed531db9f2ee811432e6f77db8c42faa
+  metadata.gz: 0db6e083fb62dd609fd719264a4d35e6bcadd6b97ce8515d08a8a8a53028e1f3f870224ef40ca33240688ddaf782d41e09d261c079c145144fe7b47b83288ef6
+  data.tar.gz: d33e89e420bf0f93c2e478c93dd9241643ee47c40efa40927ff77714f20b92af561330b2cbedcaa287951cd07aab4ecfb899e24371fe8d6e2b20f289f6973b53

data/README.md

@@ -177,6 +177,7 @@ Implemented:
 
 - Core DOM (Document, Element, Text/Comment/Fragment, NodeList, Attr)
 - 26 specialized HTMLElement subclasses
+- SVG: SVGElement base + ~63 specialized subclasses covering shapes, gradients, marker / mask, the full set of standard filter primitives (Gaussian blur, offset, blend, color matrix, flood, composite, merge, component transfer, tile, morphology, image, drop shadow, turbulence, displacement map, convolve matrix, diffuse / specular lighting + light sources), `<a>` / `<textPath>` / `<view>` / `<switch>` / `<metadata>`, and SMIL animation (`<animate>` / `<animateTransform>` / `<animateMotion>` / `<set>` / `<mpath>` / `<discard>`) — with case-sensitive attribute round-trip
 - events with composedPath / AbortSignal
 - MutationObserver (childList / attributes / characterData / subtree)
 - Custom Elements lifecycle
@@ -184,12 +185,36 @@ Implemented:
 - form validation
 - Scheduler (timers + microtasks with `advance_time`)
 - Promise
-- Location / History / URL
+- Location / History / URL (WHATWG-leaning parsing with whitespace/tab/newline stripping, percent-encoding of unsafe path chars, `\` → `/` conversion for special schemes, `./` and `../` resolution, IPv4 number forms normalization, ws/wss default port stripping, Punycode hostname encoding, full UTS #46 IDNA with RFC 5893 Bidi and RFC 5892 ContextJ/ContextO)
 - Storage
-- fetch (stub)
+- fetch (stub) / XMLHttpRequest (stub-driven, sync + async, shares the `__fetchy_stub__` fixture map)
+- WebSocket / EventSource — test seams (`__simulate_open__` / `__simulate_message__` / `__simulate_close__`) drive the streams
+- MessageChannel / MessagePort / BroadcastChannel — in-process pub/sub with `structuredClone`-on-transfer
+- FileReader (`readAsText` / `readAsDataURL` / `readAsArrayBuffer` / `readAsBinaryString`)
+- Notification (permission settable via `Notification.__set_permission__`)
+- Geolocation (mock position via `navigator.geolocation.__set_position__`)
+- `window.matchMedia` returning a `MediaQueryList` (`__set_matches__` flips and fires `change`)
+- `requestIdleCallback` / `cancelIdleCallback` (modelled on scheduler), `structuredClone` global
+- `crypto.subtle.digest` (SHA-1/256/384/512), HMAC sign/verify/import/generateKey, and AES-GCM encrypt/decrypt (128/256-bit with additionalData and tagLength options)
+- Streams API (`ReadableStream` / `WritableStream` / `TransformStream` + `TextEncoderStream` / `TextDecoderStream`)
+- `CompressionStream` / `DecompressionStream` (gzip / deflate / deflate-raw via Ruby `Zlib`)
+- Worker (inline-emulated — same-process message round-trip; tests register handlers via `worker.__on_message__`)
+- Performance User Timing (`performance.mark` / `measure` / `getEntriesByName`)
+- `cookieStore` (async Cookie Store API, backed by the same jar `document.cookie` uses)
+- Navigator extras: `share` / `vibrate` / `wakeLock.request` / `getBattery` / `locks` (Web Locks) / `storage.estimate` / `persist` / `persisted` (StorageManager)
+- Layout-adjacent stubs: `element.scrollIntoView` / `scrollTo` / scroll & client / offset metrics (return 0), `getComputedStyle` (inline style passthrough)
+- Popover API (`showPopover` / `hidePopover` / `togglePopover` with `beforetoggle` / `toggle` events)
+- Fullscreen API (`element.requestFullscreen` / `document.exitFullscreen` / `fullscreenchange`)
+- `URLPattern` (pattern matching for URL components — protocol, username, password, hostname, port, pathname, search, hash — with named capture groups and modifiers: `:id`, `*`, `:version+`, `:version?`)
+- `document.startViewTransition` (View Transitions API stub)
 - Navigator / Clipboard
 - TreeWalker / NodeIterator / NodeFilter
 - File API (Blob / File / FileList / FormData / DataTransfer)
+- Web Crypto (`crypto.randomUUID`, `getRandomValues`) / TextEncoder / TextDecoder
+- IntersectionObserver / ResizeObserver / PerformanceObserver (test-driven `__trigger__`)
+- Range / Selection (DOM-level only, no layout)
+- Web Animations API (Animation / KeyframeEffect; lifecycle via scheduler, finished/ready Promises)
+- Extended events: Touch / Clipboard / Composition / Wheel / Focus / BeforeUnload / Input / Pointer / Progress / Drag
 
 > [!IMPORTANT]
 > Out of scope:
@@ -198,8 +223,9 @@ Implemented:
 > - CSS scoping (`:host`, `::slotted`, computed styles)
 > - JS evaluation
 > - Canvas / WebGL / media playback
-> - layout-dependent Range / Selection
-> - SVG specialized classes
+> - layout-dependent Range / Selection geometry (`getBoundingClientRect` returns zero rects)
+> - SVG-specific value types (SVGAnimatedLength, SVGTransform, SVGMatrix)
+> - Web Animations: no actual value interpolation — `Animation` is a state machine (`idle` / `running` / `paused` / `finished`) for testing lifecycle and event wiring
 
 ## Running the tests
 

data/lib/dommy/animation.rb

@@ -0,0 +1,288 @@
+# frozen_string_literal: true
+
+module Dommy
+  # `KeyframeEffect` — wraps a target element + keyframes + timing.
+  # Dommy doesn't interpolate values (no layout / render); the
+  # effect is just a record of what the animation describes.
+  #
+  # Spec: https://drafts.csswg.org/web-animations/#keyframeeffect
+  class KeyframeEffect
+    attr_reader :target, :keyframes
+
+    def initialize(target, keyframes, options = nil)
+      @target = target
+      @keyframes = case keyframes
+      when nil
+        []
+      when Array
+        keyframes
+      else
+        [keyframes]
+      end
+
+      @timing = normalize_timing(options)
+    end
+
+    def get_timing
+      @timing.dup
+    end
+
+    alias getTiming get_timing
+
+    def update_timing(timing)
+      @timing.merge!(timing.transform_keys(&:to_s))
+      nil
+    end
+
+    alias updateTiming update_timing
+
+    def duration_ms
+      d = @timing["duration"]
+      d.is_a?(Numeric) ? d.to_i : 0
+    end
+
+    def __js_get__(key)
+      case key
+      when "target"
+        @target
+      end
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "getTiming"
+        get_timing
+      when "updateTiming"
+        update_timing(args[0] || {})
+      end
+    end
+
+    private
+
+    def normalize_timing(input)
+      case input
+      when nil
+        {"duration" => 0}
+      when Numeric
+        {"duration" => input.to_i}
+      when Hash
+        h = input.transform_keys(&:to_s)
+        h["duration"] = (h["duration"] || 0).is_a?(Numeric) ? h["duration"].to_i : 0
+        h
+      else
+        {"duration" => 0}
+      end
+    end
+  end
+
+  # `Animation` — represents a running animation, mirroring the Web
+  # Animations API's lifecycle and event surface. Dommy doesn't
+  # interpolate any property values; the animation transitions
+  # through "idle" → "running" → "finished" by either virtual time
+  # (`scheduler.advance_time`) or by an explicit `finish()` call.
+  #
+  # Spec: https://drafts.csswg.org/web-animations/#animation
+  class Animation
+    include EventTarget
+
+    attr_accessor :id
+    attr_reader :effect, :timeline, :play_state
+
+    def initialize(effect = nil, timeline = nil, window: nil)
+      @effect = effect
+      @timeline = timeline
+      @window = window
+      @play_state = "idle"
+      @playback_rate = 1.0
+      @current_time = nil
+      @start_time = nil
+      @id = ""
+      @finished_promise = nil
+      @ready_promise = nil
+      @scheduled_finish_id = nil
+    end
+
+    def current_time
+      @current_time
+    end
+
+    def current_time=(value)
+      @current_time = value
+    end
+
+    def start_time
+      @start_time
+    end
+
+    def start_time=(value)
+      @start_time = value
+    end
+
+    def playback_rate
+      @playback_rate
+    end
+
+    def playback_rate=(value)
+      @playback_rate = value.to_f
+    end
+
+    # Start (or resume) the animation. Returns self.
+    def play
+      return self if @play_state == "running"
+
+      previous = @play_state
+      @play_state = "running"
+      @start_time ||= @window&.scheduler&.now_ms || 0
+      ensure_ready_resolved
+      schedule_auto_finish if previous != "paused"
+      self
+    end
+
+    def pause
+      cancel_scheduled_finish
+      @play_state = "paused" unless @play_state == "idle"
+      self
+    end
+
+    def cancel
+      cancel_scheduled_finish
+      @play_state = "idle"
+      @current_time = nil
+      reject_finished_with_abort
+      dispatch_event(Event.new("cancel"))
+      self
+    end
+
+    def finish
+      cancel_scheduled_finish
+      @play_state = "finished"
+      @current_time = effect_duration_ms
+      resolve_finished
+      dispatch_event(Event.new("finish"))
+      self
+    end
+
+    def reverse
+      @playback_rate = -@playback_rate
+      play if @play_state == "idle"
+      self
+    end
+
+    # PromiseValue that resolves when the animation finishes.
+    # Rejected (with AbortError-style RuntimeError) on cancel.
+    def finished
+      @finished_promise ||= PromiseValue.new(@window)
+    end
+
+    # PromiseValue that resolves once the animation is ready to play
+    # (immediately in Dommy — there's no render-thread handoff).
+    def ready
+      @ready_promise ||= if @window
+        PromiseValue.resolve(@window, self)
+      else
+        PromiseValue.new(@window)
+      end
+    end
+
+    def __js_get__(key)
+      case key
+      when "playState"
+        @play_state
+      when "playbackRate"
+        @playback_rate
+      when "currentTime"
+        @current_time
+      when "startTime"
+        @start_time
+      when "effect"
+        @effect
+      when "timeline"
+        @timeline
+      when "finished"
+        finished
+      when "ready"
+        ready
+      when "id"
+        @id
+      end
+    end
+
+    def __js_set__(key, value)
+      case key
+      when "currentTime"
+        @current_time = value
+      when "startTime"
+        @start_time = value
+      when "playbackRate"
+        @playback_rate = value.to_f
+      when "id"
+        @id = value.to_s
+      end
+
+      nil
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "play"
+        play
+      when "pause"
+        pause
+      when "cancel"
+        cancel
+      when "finish"
+        finish
+      when "reverse"
+        reverse
+      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
+
+    # Event bubbling stops at Animation — it isn't part of the DOM tree.
+    def __event_parent__
+      nil
+    end
+
+    private
+
+    def effect_duration_ms
+      @effect ? @effect.duration_ms : 0
+    end
+
+    def schedule_auto_finish
+      return unless @window&.scheduler
+      return if effect_duration_ms <= 0
+
+      @scheduled_finish_id = @window.scheduler.set_timeout(
+        proc { finish if @play_state == "running" },
+        effect_duration_ms
+      )
+    end
+
+    def cancel_scheduled_finish
+      return unless @scheduled_finish_id && @window&.scheduler
+
+      @window.scheduler.clear_timeout(@scheduled_finish_id)
+      @scheduled_finish_id = nil
+    end
+
+    def ensure_ready_resolved
+      ready.fulfill(self) if ready.respond_to?(:fulfill)
+    end
+
+    def resolve_finished
+      finished.fulfill(self)
+    end
+
+    def reject_finished_with_abort
+      return unless @finished_promise
+
+      @finished_promise.reject(RuntimeError.new("AbortError: animation cancelled"))
+    end
+  end
+end

data/lib/dommy/compression_streams.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "zlib"
+require "stringio"
+
+module Dommy
+  # `CompressionStream` / `DecompressionStream` — wrap `TransformStream`
+  # over Ruby's `Zlib` to gzip/deflate/raw-deflate byte chunks. Each
+  # `write(chunk)` accumulates into an internal buffer; `close()`
+  # finalizes and emits the compressed/decompressed bytes downstream.
+  #
+  # Spec: https://wicg.github.io/compression/
+  class CompressionStream
+    SUPPORTED = %w[gzip deflate deflate-raw].freeze
+
+    attr_reader :readable, :writable
+
+    def initialize(window, format)
+      raise ArgumentError, "unsupported format #{format.inspect}" unless SUPPORTED.include?(format.to_s)
+
+      @buffer = +""
+      compressor = build_compressor(format.to_s)
+
+      @readable = ReadableStream.new(window)
+      controller = TransformStreamDefaultController.new(@readable)
+
+      @writable = WritableStream.new(
+        window,
+        {
+          "write" => proc { |chunk| @buffer << coerce(chunk) },
+          "close" => proc do
+            compressed = compressor.call(@buffer)
+            controller.enqueue(compressed)
+            @readable.__close__
+          end,
+          "abort" => proc { |r| @readable.__error__(r) }
+        }
+      )
+    end
+
+    def __js_get__(key)
+      case key
+      when "readable"
+        @readable
+      when "writable"
+        @writable
+      end
+    end
+
+    private
+
+    def coerce(chunk)
+      chunk.is_a?(Array) ? chunk.pack("C*") : chunk.to_s
+    end
+
+    def build_compressor(format)
+      case format
+      when "gzip"
+        proc do |data|
+          io = StringIO.new
+          gz = Zlib::GzipWriter.new(io)
+          gz.write(data)
+          gz.close
+          io.string.bytes
+        end
+
+      when "deflate"
+        proc { |data| Zlib::Deflate.deflate(data).bytes }
+      when "deflate-raw"
+        proc do |data|
+          z = Zlib::Deflate.new(Zlib::DEFAULT_COMPRESSION, -Zlib::MAX_WBITS)
+          out = z.deflate(data, Zlib::FINISH)
+          z.close
+          out.bytes
+        end
+      end
+    end
+  end
+
+  class DecompressionStream
+    SUPPORTED = %w[gzip deflate deflate-raw].freeze
+
+    attr_reader :readable, :writable
+
+    def initialize(window, format)
+      raise ArgumentError, "unsupported format #{format.inspect}" unless SUPPORTED.include?(format.to_s)
+
+      @buffer = +""
+      decompressor = build_decompressor(format.to_s)
+
+      @readable = ReadableStream.new(window)
+      controller = TransformStreamDefaultController.new(@readable)
+
+      @writable = WritableStream.new(
+        window,
+        {
+          "write" => proc { |chunk| @buffer << coerce(chunk) },
+          "close" => proc do
+            plain = decompressor.call(@buffer)
+            controller.enqueue(plain)
+            @readable.__close__
+          end,
+          "abort" => proc { |r| @readable.__error__(r) }
+        }
+      )
+    end
+
+    def __js_get__(key)
+      case key
+      when "readable"
+        @readable
+      when "writable"
+        @writable
+      end
+    end
+
+    private
+
+    def coerce(chunk)
+      chunk.is_a?(Array) ? chunk.pack("C*") : chunk.to_s
+    end
+
+    def build_decompressor(format)
+      case format
+      when "gzip"
+        proc do |data|
+          io = StringIO.new(data)
+          gz = Zlib::GzipReader.new(io)
+          out = gz.read
+          gz.close
+          out.bytes
+        end
+
+      when "deflate"
+        proc { |data| Zlib::Inflate.inflate(data).bytes }
+      when "deflate-raw"
+        proc do |data|
+          z = Zlib::Inflate.new(-Zlib::MAX_WBITS)
+          out = z.inflate(data)
+          z.finish
+          z.close
+          out.bytes
+        end
+      end
+    end
+  end
+end

data/lib/dommy/cookie_store.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Dommy
+  # `cookieStore` — the asynchronous Cookie Store API. Reads and
+  # writes go through the existing `Document#cookie_jar`, so values
+  # set via `document.cookie = ...` round-trip via `cookieStore.get`.
+  #
+  # Spec: https://wicg.github.io/cookie-store/
+  class CookieStore
+    include EventTarget
+
+    def initialize(window)
+      @window = window
+    end
+
+    def get(name_or_options)
+      name = name_or_options.is_a?(Hash) ? (name_or_options["name"] || name_or_options[:name]) : name_or_options
+      raw = cookie_jar.cookies[name.to_s]
+      raw ? PromiseValue.resolve(@window, build_record(name.to_s, raw)) : PromiseValue.resolve(@window, nil)
+    end
+
+    def get_all(name = nil)
+      records = cookie_jar.cookies.map { |k, v| build_record(k, v) }
+      records = records.select { |r| r["name"] == name.to_s } if name
+      PromiseValue.resolve(@window, records)
+    end
+
+    alias getAll get_all
+
+    def set(name_or_options, value = nil)
+      if name_or_options.is_a?(Hash)
+        opts = name_or_options.transform_keys(&:to_s)
+        name = opts["name"]
+        value = opts["value"]
+      else
+        name = name_or_options
+      end
+
+      cookie_jar.set_cookie("#{name}=#{value}")
+      dispatch_event(
+        CookieChangeEvent.new(
+          "change",
+          "changed" => [build_record(name.to_s, value.to_s)],
+          "deleted" => []
+        )
+      )
+      PromiseValue.resolve(@window, nil)
+    end
+
+    def delete(name_or_options)
+      name = name_or_options.is_a?(Hash) ? (name_or_options["name"] || name_or_options[:name]) : name_or_options
+      cookie_jar.cookies.delete(name.to_s)
+      dispatch_event(
+        CookieChangeEvent.new(
+          "change",
+          "changed" => [],
+          "deleted" => [build_record(name.to_s, "")]
+        )
+      )
+      PromiseValue.resolve(@window, nil)
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "get"
+        get(args[0])
+      when "getAll"
+        get_all(args[0])
+      when "set"
+        set(args[0], args[1])
+      when "delete"
+        delete(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 __event_parent__
+      nil
+    end
+
+    private
+
+    def cookie_jar
+      # `document.cookie_jar` is private; we reach the same backing
+      # store via the public `document.cookie` round-trip. Easier: use
+      # instance_variable_get on the document.
+      @window.document.instance_variable_get(:@cookie_jar)
+    end
+
+    def build_record(name, value)
+      {
+        "name" => name.to_s,
+        "value" => value.to_s,
+        "domain" => nil,
+        "path" => "/",
+        "expires" => nil,
+        "secure" => false,
+        "sameSite" => "strict"
+      }
+    end
+  end
+
+  class CookieChangeEvent < Event
+    def initialize(type, init = nil)
+      super
+      @changed = Array(read_init(init, "changed") || [])
+      @deleted = Array(read_init(init, "deleted") || [])
+    end
+
+    attr_reader :changed, :deleted
+
+    def __js_get__(key)
+      case key
+      when "changed"
+        @changed
+      when "deleted"
+        @deleted
+      else
+        super
+      end
+    end
+  end
+end