dommy 0.5.0 → 0.7.0

data/lib/dommy/event_source.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Dommy
+  # `EventSource` (Server-Sent Events). Like `WebSocket`, dommy
+  # provides simulation seams instead of network IO:
+  #
+  #   es.__test_simulate_open__
+  #   es.__test_simulate_message__(data, event: "msg", id: "1")
+  #   es.__test_simulate_error__
+  #
+  # Auto-opens on a microtask after construction, mirroring real
+  # browser behavior.
+  #
+  # Spec: https://html.spec.whatwg.org/multipage/server-sent-events.html
+  class EventSource
+    include EventTarget
+
+    CONNECTING = 0
+    OPEN = 1
+    CLOSED = 2
+
+    INLINE_HANDLERS = %w[open message error].freeze
+
+    attr_reader :url, :ready_state, :with_credentials
+
+    def initialize(window, url, options = nil)
+      @window = window
+      @url = url.to_s
+      @ready_state = CONNECTING
+      opts = options.is_a?(Hash) ? options : {}
+      @with_credentials = !!(opts["withCredentials"] || opts[:withCredentials])
+      @inline_handlers = {}
+
+      @window.scheduler.queue_microtask(proc { __test_simulate_open__ })
+    end
+
+    def close
+      @ready_state = CLOSED
+      nil
+    end
+
+    # --- Test seams ------------------------------------------------
+
+    def __test_simulate_open__
+      return if @ready_state != CONNECTING
+
+      @ready_state = OPEN
+      dispatch_event(Event.new("open"))
+    end
+
+    def __test_simulate_message__(data, event: "message", id: nil, retry_ms: nil)
+      return if @ready_state != OPEN
+
+      payload = {"data" => data.to_s}
+      payload["lastEventId"] = id.to_s if id
+      payload["retry"] = retry_ms.to_i if retry_ms
+      dispatch_event(MessageEvent.new(event.to_s, payload))
+    end
+
+    def __test_simulate_error__
+      dispatch_event(Event.new("error"))
+    end
+
+    # --- JS bridge -------------------------------------------------
+
+    def __js_get__(key)
+      case key
+      when "url"
+        @url
+      when "readyState"
+        @ready_state
+      when "withCredentials"
+        @with_credentials
+      when "CONNECTING"
+        CONNECTING
+      when "OPEN"
+        OPEN
+      when "CLOSED"
+        CLOSED
+      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 "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
+
+    private
+
+    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
+end

data/lib/dommy/fetch.rb

@@ -118,6 +118,68 @@ module Dommy
     end
   end
 
+  # `Request` polyfill — minimal Fetch API Request object so callers
+  # constructing `new Request(url, init)` get a value with `.url`,
+  # `.method`, `.headers`, `.body`. The stub-based `fetch` doesn't
+  # consume it directly (it still takes `(url, init)`), but having
+  # Request available means JS code that constructs one before
+  # passing to fetch keeps working.
+  class Request
+    attr_reader :url, :method, :body
+
+    def initialize(url, init = nil)
+      opts = init.is_a?(Hash) ? init : {}
+      @url = url.to_s
+      @method = (opts["method"] || opts[:method] || "GET").to_s.upcase
+      @body = opts["body"] || opts[:body]
+      raw_headers = opts["headers"] || opts[:headers] || {}
+      @headers = Headers.new(raw_headers)
+      @credentials = (opts["credentials"] || opts[:credentials] || "same-origin").to_s
+      @mode = (opts["mode"] || opts[:mode] || "cors").to_s
+      @cache = (opts["cache"] || opts[:cache] || "default").to_s
+      @redirect = (opts["redirect"] || opts[:redirect] || "follow").to_s
+    end
+
+    attr_reader :headers, :credentials, :mode, :cache, :redirect
+
+    def __js_get__(key)
+      case key
+      when "url"
+        @url
+      when "method"
+        @method
+      when "headers"
+        @headers
+      when "body"
+        @body
+      when "credentials"
+        @credentials
+      when "mode"
+        @mode
+      when "cache"
+        @cache
+      when "redirect"
+        @redirect
+      end
+    end
+
+    def __js_call__(method, _args)
+      case method
+      when "clone"
+        Request.new(
+          @url,
+          "method" => @method,
+          "body" => @body,
+          "headers" => @headers.to_h,
+          "credentials" => @credentials,
+          "mode" => @mode,
+          "cache" => @cache,
+          "redirect" => @redirect
+        )
+      end
+    end
+  end
+
   # `Response` polyfill — just enough surface for Fetchy:
   # `[:status]` / `[:ok]` / `[:url]` / `[:headers]` (with
   # `.entries()` / `.get(name)`) and `.text()` / `.json()` / `.body`
@@ -165,8 +227,10 @@ module Dommy
           rejected(err)
         end
 
-      when "arrayBuffer", "blob"
-        immediate(@body)
+      when "arrayBuffer"
+        immediate(@body.bytes)
+      when "blob"
+        immediate(Blob.new([@body], "type" => @headers.__js_call__("get", ["content-type"]) || ""))
       when "clone"
         Response.new(
           @window,
@@ -218,15 +282,21 @@ module Dommy
       when "entries"
         @hash.to_a
       when "has"
-        @hash.key?(args[0].to_s)
+        # Match `get`'s case-insensitive lookup: try the raw name
+        # first, then the Title-Case canonical form. WHATWG defines
+        # header names as case-insensitive throughout the Headers API.
+        name = args[0].to_s
+        @hash.key?(name) || @hash.key?(Headers.canonical(name))
       when "forEach"
-        # Browser API: forEach(callback) — callback(value, key)
+        # WHATWG: forEach(callback) — callback(value, key, headers).
+        # Pass `self` as the third argument so consumers that read
+        # `(_, _, h) => h.get("Foo")` work the same as in a browser.
         cb = args[0]
         @hash.each do |k, v|
           if cb.respond_to?(:__js_call__)
-            cb.__js_call__("call", [v, k])
+            cb.__js_call__("call", [v, k, self])
           elsif cb.respond_to?(:call)
-            cb.call(v, k)
+            cb.call(v, k, self)
           end
         end
 

data/lib/dommy/file_reader.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Dommy
+  # `FileReader` — reads `Blob` / `File` instances into Strings, byte
+  # arrays, or data URLs. Asynchronous reads schedule a microtask that
+  # fires `load` + `loadend`; sync access (via `result` after the
+  # microtask drain) mirrors browser behavior.
+  #
+  # Spec: https://w3c.github.io/FileAPI/#APIASynch
+  class FileReader
+    include EventTarget
+
+    EMPTY = 0
+    LOADING = 1
+    DONE = 2
+
+    INLINE_HANDLERS = %w[loadstart progress load loadend abort error].freeze
+
+    attr_reader :ready_state, :result, :error
+
+    def initialize(window)
+      @window = window
+      @ready_state = EMPTY
+      @result = nil
+      @error = nil
+      @inline_handlers = {}
+      @aborted = false
+      @generation = 0
+    end
+
+    def read_as_text(blob, _encoding = "utf-8")
+      schedule_read(blob) { |raw| raw.dup.force_encoding("UTF-8") }
+    end
+
+    alias readAsText read_as_text
+
+    def read_as_data_url(blob)
+      schedule_read(blob) do |raw|
+        mime = blob.respond_to?(:type) ? blob.type.to_s : ""
+        mime = "application/octet-stream" if mime.empty?
+        "data:#{mime};base64,#{[raw].pack("m0")}"
+      end
+    end
+
+    alias readAsDataURL read_as_data_url
+
+    def read_as_array_buffer(blob)
+      schedule_read(blob) { |raw| raw.bytes }
+    end
+
+    alias readAsArrayBuffer read_as_array_buffer
+
+    def read_as_binary_string(blob)
+      schedule_read(blob) { |raw| raw.dup.force_encoding("ASCII-8BIT") }
+    end
+
+    alias readAsBinaryString read_as_binary_string
+
+    def abort
+      return if @ready_state != LOADING
+
+      @aborted = true
+      @generation += 1
+      @ready_state = DONE
+      @result = nil
+      dispatch_event(Event.new("abort"))
+      dispatch_event(Event.new("loadend"))
+      nil
+    end
+
+    def __js_get__(key)
+      case key
+      when "readyState"
+        @ready_state
+      when "result"
+        @result
+      when "error"
+        @error
+      when "EMPTY"
+        EMPTY
+      when "LOADING"
+        LOADING
+      when "DONE"
+        DONE
+      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 "readAsText"
+        read_as_text(args[0], args[1])
+      when "readAsDataURL"
+        read_as_data_url(args[0])
+      when "readAsArrayBuffer"
+        read_as_array_buffer(args[0])
+      when "readAsBinaryString"
+        read_as_binary_string(args[0])
+      when "abort"
+        abort
+      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
+
+    def schedule_read(blob, &decoder)
+      @ready_state = LOADING
+      @result = nil
+      @aborted = false
+      @generation += 1
+      gen = @generation
+      dispatch_event(Event.new("loadstart"))
+
+      @window.scheduler.queue_microtask(
+        proc do
+          next unless @generation == gen && !@aborted
+
+          raw = extract_raw(blob)
+          @result = decoder.call(raw)
+          @ready_state = DONE
+          dispatch_event(Event.new("load"))
+          dispatch_event(Event.new("loadend"))
+        end
+      )
+
+      nil
+    end
+
+    # Returns the blob's raw bytes as a binary String.
+    def extract_raw(blob)
+      if blob.respond_to?(:__dommy_bytes__)
+        blob.__dommy_bytes__.to_s
+      else
+        blob.to_s
+      end
+    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
+end

data/lib/dommy/form_data.rb

@@ -146,7 +146,7 @@ module Dommy
         next if name.empty?
         next if disabled?(el)
 
-        case el.__node__.name
+        case el.__dommy_backend_node__.name
         when "input"
           collect_input(el, name)
         when "select"
@@ -198,8 +198,6 @@ module Dommy
       # 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

data/lib/dommy/history.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Dommy
+  # `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.__internal_set_url__(url.to_s) if url
+      # WHATWG: pushState serializes the state via structured-clone
+      # so subsequent caller-side mutation of the original cannot
+      # affect history.state.
+      @stack << {state: Dommy.structured_clone(state), url: nil}
+      @cursor = @stack.size - 1
+    end
+
+    def replace(state, url)
+      @location.__internal_set_url__(url.to_s) if url
+      @stack[@cursor] = {state: Dommy.structured_clone(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
+end

data/lib/dommy/html_collection.rb

@@ -46,9 +46,9 @@ module Dommy
       return nil if key.empty?
 
       to_a.find do |el|
-        next false unless el.respond_to?(:__node__)
+        next false unless el.respond_to?(:__dommy_backend_node__)
 
-        el.__node__["id"].to_s == key || el.__node__["name"].to_s == key
+        el.__dommy_backend_node__["id"].to_s == key || el.__dommy_backend_node__["name"].to_s == key
       end
     end
 
@@ -125,7 +125,7 @@ module Dommy
     # 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__)
+      return nil unless option.respond_to?(:__dommy_backend_node__)
 
       case before
       when nil
@@ -134,7 +134,7 @@ module Dommy
         anchor = item(before)
         anchor ? @owner.insert_before(option, anchor) : @owner.append_child(option)
       else
-        if before.respond_to?(:__node__)
+        if before.respond_to?(:__dommy_backend_node__)
           @owner.insert_before(option, before)
         else
           @owner.append_child(option)