dommy 0.5.0 → 0.7.0

data/lib/dommy/navigator.rb

@@ -21,9 +21,51 @@ module Dommy
       @cookie_enabled = true
       @clipboard = Clipboard.new(window)
       @permissions = Permissions.new(window)
+      @geolocation = Geolocation.new(window)
+      @vibration_log = []
+      @wake_lock = WakeLock.new(window)
+      @locks = LockManager.new(window)
+      @storage = StorageManager.new(window)
     end
 
-    attr_reader :clipboard, :permissions
+    attr_reader :clipboard, :permissions, :geolocation, :wake_lock, :locks, :storage
+
+    # Web Share API. Returns a Promise; tests can inspect
+    # `__test_last_shared__` to verify what was offered.
+    def share(data = nil)
+      @last_shared = data
+      PromiseValue.resolve(@window, nil)
+    end
+
+    def can_share(_data = nil)
+      true
+    end
+
+    alias canShare can_share
+
+    # Vibration API. No-op in dommy, but the requested pattern is
+    # recorded so tests can assert "we asked to vibrate".
+    def vibrate(pattern)
+      list = pattern.is_a?(Array) ? pattern : [pattern]
+      @vibration_log << list.map(&:to_i)
+      true
+    end
+
+    def __test_vibration_log__
+      @vibration_log.dup
+    end
+
+    def __test_last_shared__
+      @last_shared
+    end
+
+    # Battery Status API stub. Returns a Promise resolving to a fixed
+    # `BatteryManager` snapshot.
+    def get_battery
+      PromiseValue.resolve(@window, BatteryManager.new)
+    end
+
+    alias getBattery get_battery
 
     def [](key)
       __js_get__(key.to_s)
@@ -53,6 +95,27 @@ module Dommy
         @clipboard
       when "permissions"
         @permissions
+      when "geolocation"
+        @geolocation
+      when "wakeLock"
+        @wake_lock
+      when "locks"
+        @locks
+      when "storage"
+        @storage
+      end
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "share"
+        share(args[0])
+      when "canShare"
+        can_share(args[0])
+      when "vibrate"
+        vibrate(args[0])
+      when "getBattery"
+        get_battery
       end
     end
 
@@ -130,7 +193,7 @@ module Dommy
       end
     end
 
-    def __event_parent__
+    def __internal_event_parent__
       nil
     end
   end
@@ -174,7 +237,7 @@ module Dommy
       @overrides[key] = state.to_s
       @statuses ||= {}
       status = @statuses[key]
-      status&.__set_state__(state.to_s)
+      status&.__internal_set_state__(state.to_s)
       nil
     end
 
@@ -223,7 +286,7 @@ module Dommy
       @onchange = nil
     end
 
-    def __set_state__(new_state)
+    def __internal_set_state__(new_state)
       return if @state == new_state
 
       @state = new_state
@@ -264,8 +327,305 @@ module Dommy
       end
     end
 
-    def __event_parent__
+    def __internal_event_parent__
+      nil
+    end
+  end
+
+  # `navigator.geolocation` — stub Geolocation API. Real implementations
+  # query the OS; dommy holds a mock position tests configure via
+  # `__test_set_position__(coords)` or `__test_set_error__(error_code)`.
+  #
+  # Spec: https://www.w3.org/TR/geolocation/
+  class Geolocation
+    DEFAULT_COORDS = {
+      "latitude" => 0.0,
+      "longitude" => 0.0,
+      "accuracy" => 0.0,
+      "altitude" => nil,
+      "altitudeAccuracy" => nil,
+      "heading" => nil,
+      "speed" => nil
+    }.freeze
+
+    def initialize(window)
+      @window = window
+      @position = nil
+      @error = nil
+      @watches = {}
+      @next_watch_id = 0
+    end
+
+    # Test seam: install a mock position.
+    def __test_set_position__(coords = {})
+      merged = DEFAULT_COORDS.merge(coords.transform_keys(&:to_s))
+      @position = {"coords" => merged, "timestamp" => @window.scheduler.now_ms}
+      @error = nil
+    end
+
+    # Test seam: install a permission/positioning error (code 1=PERMISSION_DENIED,
+    # 2=POSITION_UNAVAILABLE, 3=TIMEOUT).
+    def __test_set_error__(code, message = "")
+      @position = nil
+      @error = {"code" => code.to_i, "message" => message.to_s}
+    end
+
+    def get_current_position(success, failure = nil, _options = nil)
+      @window.scheduler.queue_microtask(proc { deliver(success, failure) })
+      nil
+    end
+
+    alias getCurrentPosition get_current_position
+
+    def watch_position(success, failure = nil, _options = nil)
+      id = (@next_watch_id += 1)
+      @watches[id] = [success, failure]
+      @window.scheduler.queue_microtask(proc { deliver(success, failure) })
+      id
+    end
+
+    alias watchPosition watch_position
+
+    def clear_watch(id)
+      @watches.delete(id)
+      nil
+    end
+
+    alias clearWatch clear_watch
+
+    def __js_call__(method, args)
+      case method
+      when "getCurrentPosition"
+        get_current_position(args[0], args[1], args[2])
+      when "watchPosition"
+        watch_position(args[0], args[1], args[2])
+      when "clearWatch"
+        clear_watch(args[0])
+      end
+    end
+
+    private
+
+    def deliver(success, failure)
+      if @position
+        invoke(success, @position)
+      else
+        invoke(failure, @error || {"code" => 2, "message" => "POSITION_UNAVAILABLE"})
+      end
+    end
+
+    def invoke(callback, payload)
+      return if callback.nil?
+
+      if callback.respond_to?(:__js_call__)
+        callback.__js_call__("call", [payload])
+      elsif callback.respond_to?(:call)
+        callback.call(payload)
+      end
+    end
+  end
+
+  # `navigator.wakeLock` — Screen Wake Lock API stub. `request(type)`
+  # returns a Promise of a `WakeLockSentinel` whose `release()` flips
+  # `released` and dispatches a `release` event.
+  #
+  # Spec: https://www.w3.org/TR/screen-wake-lock/
+  class WakeLock
+    def initialize(window)
+      @window = window
+    end
+
+    def request(type = "screen")
+      PromiseValue.resolve(@window, WakeLockSentinel.new(@window, type.to_s))
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "request"
+        request(args[0] || "screen")
+      end
+    end
+  end
+
+  class WakeLockSentinel
+    include EventTarget
+
+    attr_reader :type
+
+    def initialize(window, type)
+      @window = window
+      @type = type
+      @released = false
+    end
+
+    def released
+      @released
+    end
+
+    def release
+      return PromiseValue.resolve(@window, nil) if @released
+
+      @released = true
+      dispatch_event(Event.new("release"))
+      PromiseValue.resolve(@window, nil)
+    end
+
+    def __js_get__(key)
+      case key
+      when "type"
+        @type
+      when "released"
+        @released
+      end
+    end
+
+    def __js_call__(method, _args)
+      case method
+      when "release"
+        release
+      end
+    end
+
+    def __internal_event_parent__
+      nil
+    end
+  end
+
+  # `navigator.getBattery()` returns one of these. Fixed snapshot —
+  # tests that need different values can stub.
+  class BatteryManager
+    include EventTarget
+
+    attr_reader :charging, :charging_time, :discharging_time, :level
+
+    def initialize(charging: true, level: 1.0, charging_time: 0, discharging_time: Float::INFINITY)
+      @charging = charging
+      @level = level
+      @charging_time = charging_time
+      @discharging_time = discharging_time
+    end
+
+    def __js_get__(key)
+      case key
+      when "charging"
+        @charging
+      when "chargingTime"
+        @charging_time
+      when "dischargingTime"
+        @discharging_time
+      when "level"
+        @level
+      end
+    end
+
+    def __internal_event_parent__
       nil
     end
   end
+
+  # `navigator.locks` — Web Locks API. Locks are scoped to the
+  # Navigator instance; serial execution per name. Real browsers
+  # coordinate across tabs; dommy is single-process so it just
+  # serializes calls within the same Window.
+  #
+  # Spec: https://w3c.github.io/web-locks/
+  class LockManager
+    def initialize(window)
+      @window = window
+      @held = {}
+    end
+
+    def request(name, options_or_callback, callback = nil)
+      if options_or_callback.is_a?(Hash) || options_or_callback.nil?
+        options = options_or_callback || {}
+        cb = callback
+      else
+        options = {}
+        cb = options_or_callback
+      end
+
+      key = name.to_s
+      if @held[key] && options["ifAvailable"]
+        return invoke_with_lock(cb, nil)
+      end
+
+      lock = Lock.new(key, options["mode"] || "exclusive")
+      @held[key] = lock
+      result = invoke_with_lock(cb, lock)
+      @held.delete(key)
+      result
+    end
+
+    def query
+      held = @held.map { |name, lock| {"name" => name, "mode" => lock.mode, "clientId" => "dommy"} }
+      PromiseValue.resolve(@window, {"held" => held, "pending" => []})
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "request"
+        request(args[0], args[1], args[2])
+      when "query"
+        query
+      end
+    end
+
+    private
+
+    def invoke_with_lock(callback, lock)
+      value = if callback.respond_to?(:__js_call__)
+        callback.__js_call__("call", [lock])
+      elsif callback.respond_to?(:call)
+        callback.call(lock)
+      end
+
+      PromiseValue.resolve(@window, value)
+    end
+  end
+
+  Lock = Struct.new(:name, :mode) do
+    def __js_get__(key)
+      case key
+      when "name"
+        name
+      when "mode"
+        mode
+      end
+    end
+  end
+
+  # `navigator.storage` — StorageManager API. Returns fixed-value
+  # estimates; `persist`/`persisted` always resolve `true`.
+  #
+  # Spec: https://storage.spec.whatwg.org/
+  class StorageManager
+    def initialize(window)
+      @window = window
+      @persisted = false
+    end
+
+    def estimate
+      PromiseValue.resolve(@window, {"quota" => 1_073_741_824, "usage" => 0, "usageDetails" => {}})
+    end
+
+    def persist
+      @persisted = true
+      PromiseValue.resolve(@window, true)
+    end
+
+    def persisted
+      PromiseValue.resolve(@window, @persisted)
+    end
+
+    def __js_call__(method, _args)
+      case method
+      when "estimate"
+        estimate
+      when "persist"
+        persist
+      when "persisted"
+        persisted
+      end
+    end
+  end
 end

data/lib/dommy/node.rb

@@ -10,6 +10,12 @@ module Dommy
   # snapshots tree state at the time of the query, matching what
   # most happy-dom test patterns expect.
   class NodeList < Array
+    # Methods routed through __js_call__ (keep in sync with its when-arms).
+    JS_METHOD_NAMES = %w[item forEach entries keys values].freeze
+    def __js_method_names__
+      JS_METHOD_NAMES
+    end
+
     # Spec-compliant: out-of-range returns nil, not raise (Array#[] is
     # close but we make negative indices fail too — DOM `item(-1)` is
     # nil, not Array#[-1]'s last element).
@@ -88,6 +94,12 @@ module Dommy
   class LiveNodeList
     include Enumerable
 
+    # Methods routed through __js_call__ (keep in sync with its when-arms).
+    JS_METHOD_NAMES = %w[item forEach entries keys values].freeze
+    def __js_method_names__
+      JS_METHOD_NAMES
+    end
+
     def initialize(&block)
       @compute = block
     end

data/lib/dommy/notification.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Dommy
+  # `Notification` polyfill. Real browsers prompt the user; dommy
+  # exposes the permission state as a class-level slot tests can
+  # toggle via `Notification.__test_set_permission__("granted")`.
+  #
+  # Spec: https://notifications.spec.whatwg.org/
+  class Notification
+    include EventTarget
+
+    @permission = "default"
+
+    class << self
+      attr_reader :permission
+
+      def __test_set_permission__(value)
+        @permission = value.to_s
+      end
+
+      # Asynchronous spec API: returns a Promise (here a value that
+      # `.await`-able). Callbacks receive the current permission
+      # value.
+      def request_permission(window, callback = nil)
+        promise = PromiseValue.resolve(window, @permission)
+        if callback.respond_to?(:__js_call__)
+          callback.__js_call__("call", [@permission])
+        elsif callback.respond_to?(:call)
+          callback.call(@permission)
+        end
+
+        promise
+      end
+    end
+
+    attr_reader :title, :body, :icon, :tag, :data
+
+    def initialize(window, title, options = nil)
+      @window = window
+      @title = title.to_s
+      opts = options.is_a?(Hash) ? options : {}
+      @body = (opts["body"] || opts[:body] || "").to_s
+      @icon = (opts["icon"] || opts[:icon] || "").to_s
+      @tag = (opts["tag"] || opts[:tag] || "").to_s
+      @data = opts["data"] || opts[:data]
+      @closed = false
+    end
+
+    def close
+      return if @closed
+
+      @closed = true
+      dispatch_event(Event.new("close"))
+      nil
+    end
+
+    def __js_get__(key)
+      case key
+      when "title"
+        @title
+      when "body"
+        @body
+      when "icon"
+        @icon
+      when "tag"
+        @tag
+      when "data"
+        @data
+      end
+    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
+  end
+end

data/lib/dommy/parser.rb

@@ -1,28 +1,28 @@
 # frozen_string_literal: true
 
-require "nokogiri"
-
 module Dommy
-  # Thin wrapper around Nokogiri's HTML5 fragment parser. Pinned to
-  # `max_errors: 0` for silent recovery on malformed HTML (matching
-  # browser behavior).
+  # Thin wrapper around the backend's HTML5 fragment parser. Delegates
+  # to `Dommy::Backend.fragment` so backends can supply their own
+  # implementation.
   #
-  # Known quirks: `<table>`-only fragments wrap children in an
-  # implicit `<tbody>`; `<select>` reparents non-option children
-  # outside itself.
+  # Known quirks (vary by backend):
+  # - Nokogiri (libxml2): `<table>`-only fragments wrap children in
+  #   an implicit `<tbody>`; `<select>` reparents non-option children.
+  # - Nokolexbor (Lexbor): similar behavior, slightly different edge
+  #   cases for malformed input.
   #
   # `owner_doc` is critical: when a node parsed via a detached
   # fragment gets `add_child`'d into a Document with a different
-  # Nokogiri owner, libxml2 silently **copies** the node (new
-  # object_id) instead of moving it. That breaks identity-dependent
-  # caches (e.g. `Document#wrap_node` and any reconciler that keys
-  # off node identity). Always pass the destination document.
+  # owner, libxml2 silently **copies** the node (new object_id)
+  # instead of moving it. That breaks identity-dependent caches
+  # (e.g. `Document#wrap_node` and any reconciler that keys off
+  # node identity). Always pass the destination document.
   module Parser
     def self.fragment(html, owner_doc: nil)
       if owner_doc
         owner_doc.fragment(html.to_s)
       else
-        Nokogiri::HTML5.fragment(html.to_s, max_errors: 0)
+        Backend.fragment(html.to_s, owner_doc: nil)
       end
     end
   end

data/lib/dommy/performance.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Dommy
+  # `window.performance` — User Timing API (mark / measure) plus a
+  # virtual `now` clock backed by the deterministic scheduler.
+  #
+  # Spec:
+  #   - User Timing: https://www.w3.org/TR/user-timing/
+  #   - HRT (now):   https://www.w3.org/TR/hr-time/
+  class Performance
+    def initialize(window)
+      @window = window
+      @entries = []
+    end
+
+    def now
+      @window.scheduler.now_ms.to_f
+    end
+
+    def mark(name, options = nil)
+      start_time = options.is_a?(Hash) && options.key?("startTime") ? options["startTime"].to_f : now
+      detail = options.is_a?(Hash) ? options["detail"] : nil
+      entry = PerformanceEntry.new(
+        name: name.to_s,
+        entry_type: "mark",
+        start_time: start_time,
+        duration: 0.0,
+        detail: detail
+      )
+      @entries << entry
+      entry
+    end
+
+    def measure(name, start_or_options = nil, end_mark = nil)
+      if start_or_options.is_a?(Hash)
+        start = resolve_time(start_or_options["start"])
+        finish = resolve_time(start_or_options["end"])
+      else
+        start = resolve_time(start_or_options)
+        finish = resolve_time(end_mark)
+      end
+
+      start ||= 0.0
+      finish ||= now
+      entry = PerformanceEntry.new(
+        name: name.to_s,
+        entry_type: "measure",
+        start_time: start,
+        duration: finish - start
+      )
+      @entries << entry
+      entry
+    end
+
+    def clear_marks(name = nil)
+      @entries.reject! { |e| e.entry_type == "mark" && (name.nil? || e.name == name.to_s) }
+      nil
+    end
+
+    alias clearMarks clear_marks
+
+    def clear_measures(name = nil)
+      @entries.reject! { |e| e.entry_type == "measure" && (name.nil? || e.name == name.to_s) }
+      nil
+    end
+
+    alias clearMeasures clear_measures
+
+    def get_entries
+      @entries.dup
+    end
+
+    alias getEntries get_entries
+
+    def get_entries_by_name(name, entry_type = nil)
+      @entries.select { |e| e.name == name.to_s && (entry_type.nil? || e.entry_type == entry_type.to_s) }
+    end
+
+    alias getEntriesByName get_entries_by_name
+
+    def get_entries_by_type(entry_type)
+      @entries.select { |e| e.entry_type == entry_type.to_s }
+    end
+
+    alias getEntriesByType get_entries_by_type
+
+    def __js_get__(key)
+      case key
+      when "now"
+        now
+      when "timeOrigin"
+        0.0
+      end
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "now"
+        now
+      when "mark"
+        mark(args[0], args[1])
+      when "measure"
+        measure(args[0], args[1], args[2])
+      when "clearMarks"
+        clear_marks(args[0])
+      when "clearMeasures"
+        clear_measures(args[0])
+      when "getEntries"
+        get_entries
+      when "getEntriesByName"
+        get_entries_by_name(args[0], args[1])
+      when "getEntriesByType"
+        get_entries_by_type(args[0])
+      end
+    end
+
+    private
+
+    # Resolve a `mark name` or numeric timestamp to a `now`-relative time.
+    def resolve_time(value)
+      return nil if value.nil?
+      return value.to_f if value.is_a?(Numeric)
+
+      mark = @entries.reverse.find { |e| e.entry_type == "mark" && e.name == value.to_s }
+      mark ? mark.start_time : nil
+    end
+  end
+
+  # `PerformanceEntry` — common shape for User Timing marks/measures.
+  PerformanceEntry = Struct.new(:name, :entry_type, :start_time, :duration, :detail, keyword_init: true) do
+    def __js_get__(key)
+      case key
+      when "name"
+        name
+      when "entryType"
+        entry_type
+      when "startTime"
+        start_time
+      when "duration"
+        duration
+      when "detail"
+        detail
+      end
+    end
+  end
+end