dommy 0.14.0 → 0.16.0

data/lib/dommy/callable_invoker.rb

@@ -7,14 +7,20 @@ module Dommy
   module CallableInvoker
     module_function
 
-    # Invoke `callback` with `args`. A JS-bridged callable goes through
-    # `__js_call__("call", args)`; a Ruby callable through `call(*args)`. A nil
-    # or non-callable callback is a no-op (returns nil).
-    def invoke(callback, *args)
-      return if callback.nil?
+    # A callback the page passed from JS — a function, or a NodeFilter
+    # object. Told by type, not by answering __js_call__: every host object
+    # answers that, for its own methods.
+    def js_callable?(callback) = callback.is_a?(Js::Callable)
 
-      if callback.respond_to?(:__js_call__)
-        callback.__js_call__("call", args)
+    # Something #invoke can call: a JS callable, or a Ruby one.
+    def callable?(callback) = js_callable?(callback) || callback.respond_to?(:call)
+
+    # Invoke `callback` with `args`, a JS throw swallowed by the bridge. `this:`
+    # is the receiver a JS function sees (a Ruby callable has none). A nil or
+    # non-callable callback is a no-op (returns nil).
+    def invoke(callback, *args, this: nil)
+      if js_callable?(callback)
+        callback.__js_invoke__(args, this: this)
       elsif callback.respond_to?(:call)
         callback.call(*args)
       end
@@ -23,41 +29,31 @@ module Dommy
     # Invoke `callback` so a JS throw SURFACES as a Ruby exception instead of
     # being swallowed by the bridge. WHATWG requires a task's exception to be
     # reported at the global ("report an exception") rather than silently
-    # dropped, so the entry points that own a task — a timer / rAF callback —
-    # invoke this form and report whatever comes out. The plain `invoke` keeps
-    # the swallowing behavior for callers that handle their own errors.
-    def invoke_raising(callback, *args)
-      return if callback.nil?
+    # dropped, so the entry points that own a task — a timer / rAF callback, a
+    # promise reaction, a NodeFilter — invoke this form and handle whatever
+    # comes out. A Ruby callable raises naturally.
+    def invoke_raising(callback, *args, this: nil)
+      return callback.__js_invoke__(args, this: this, raising: true) if js_callable?(callback)
 
-      if callback.respond_to?(:__js_invoke__)
-        callback.__js_invoke__(args, raising: true)
-      else
-        invoke(callback, *args)
-      end
+      invoke(callback, *args)
     end
 
     # Invoke a DOM event listener per the EventTarget rule: an object with
-    # `handle_event`, else a Ruby callable, else a JS-bridged callable (tried in
-    # that order). A JS function listener's `this` must be the event's
-    # currentTarget (the node the listener is attached to), so pass it through
-    # when the bridge supports an explicit receiver.
-    # `args:` overrides the single-event argument list — the special error
-    # event handler (`window.onerror`) is called with (message, filename,
-    # lineno, colno, error) instead of the event. An EventListener object's
-    # handleEvent always receives the event.
+    # `handle_event`, else a Ruby callable, else a JS function (tried in that
+    # order). A JS function listener's `this` is the event's currentTarget,
+    # and its throw surfaces so the dispatch reports it as a window `error`
+    # event. `args:` overrides the single-event argument list — the special
+    # error event handler (`window.onerror`) is called with (message,
+    # filename, lineno, colno, error) instead of the event. An EventListener
+    # object's handleEvent always receives the event.
     def invoke_listener(listener, event, current_target = nil, args: nil)
       args ||= [event]
       if listener.respond_to?(:handle_event)
         listener.handle_event(event)
       elsif listener.respond_to?(:call) && !listener.is_a?(Module)
         listener.call(*args)
-      elsif listener.respond_to?(:__js_invoke__)
-        # A JS function listener: `this` is the currentTarget, and a thrown value
-        # surfaces (as a ThrowValue) so the dispatch reports it as a window
-        # `error` event instead of swallowing it.
+      elsif js_callable?(listener)
         listener.__js_invoke__(args, this: current_target, raising: true)
-      elsif listener.respond_to?(:__js_call__)
-        listener.__js_call__("call", args)
       end
     end
   end

data/lib/dommy/character_data.rb

@@ -89,9 +89,10 @@ module Dommy
       @__node__.content
     end
 
+    # Assigning `data`, `nodeValue` or `textContent` is "replace data" over
+    # the whole node, so a live range boundary inside it clamps to the start
+    # rather than dangling past the end.
     def data=(value)
-      # Assigning `data` is "replace data" over the whole node, so a live range
-      # boundary inside it clamps to the start rather than dangling past the end.
       old_length = utf16_length(@__node__.content)
       write_data(value)
       @document.__internal_ranges_replaced_data__(self, 0, old_length, utf16_length(@__node__.content))
@@ -102,7 +103,7 @@ module Dommy
     end
 
     def node_value=(value)
-      write_data(value)
+      self.data = value
     end
 
     def text_content
@@ -110,9 +111,16 @@ module Dommy
     end
 
     def text_content=(value)
-      write_data(value)
+      self.data = value
+    end
+
+    # Node.isConnected: whether the shadow-including root is a Document.
+    def is_connected?
+      Internal::NodeTraversal.connected?(@__node__, @document)
     end
 
+    alias connected? is_connected?
+
     def remove
       @document.remove_node_with_notify(@__node__)
       nil
@@ -178,29 +186,13 @@ module Dommy
     def substring_data(offset, count)
       s = @__node__.content
       len = utf16_length(s)
-      o = to_uint32(offset)
+      o = Internal::WebIDL.unsigned_long(offset)
       raise DOMException::IndexSizeError, "offset out of bounds" if o > len
 
-      c = [to_uint32(count), len - o].min
+      c = [Internal::WebIDL.unsigned_long(count), len - o].min
       utf16_slice(s, o, c)
     end
 
-    # ECMAScript ToUint32 — WebIDL `unsigned long` conversion for a data offset
-    # or count: ToNumber (a non-numeric string is NaN), truncate toward zero,
-    # then take modulo 2**32 (so -1 wraps to 4294967295, 0x100000000+2 to 2).
-    def to_uint32(value)
-      num =
-        case value
-        when Integer then value
-        when Numeric then value
-        when nil then 0 # JS null -> 0
-        else Float(value.to_s) rescue Float::NAN
-        end
-      return 0 unless num.respond_to?(:finite?) ? num.finite? : true
-
-      num.to_i % (2**32)
-    end
-
     def append_data(value)
       write_data(@__node__.content + dom_string(value))
     end
@@ -222,10 +214,10 @@ module Dommy
     def replace_data(offset, count, value)
       s = @__node__.content
       len = utf16_length(s)
-      o = to_uint32(offset)
+      o = Internal::WebIDL.unsigned_long(offset)
       raise DOMException::IndexSizeError, "offset out of bounds" if o > len
 
-      c = [to_uint32(count), len - o].min
+      c = [Internal::WebIDL.unsigned_long(count), len - o].min
       inserted = dom_string(value)
       write_data(utf16_slice(s, 0, o) + inserted + utf16_slice(s, o + c, len - (o + c)))
       # Live ranges whose boundary sits in (or past) the replaced run follow it.
@@ -256,6 +248,8 @@ module Dommy
         next_sibling
       when "previousSibling"
         previous_sibling
+      when "isConnected"
+        is_connected?
       when "childNodes"
         # CharacterData is a leaf node: childNodes is always an empty (but
         # present and iterable) NodeList, and firstChild/lastChild are null.
@@ -276,7 +270,7 @@ module Dommy
     # element's shadow tree; a closed shadow tree hides the assignment (null).
     def assigned_slot
       parent = @__node__.parent
-      return nil unless parent.respond_to?(:element?) && parent.element?
+      return nil unless parent&.element?
 
       host = @document.wrap_node(parent)
       return nil unless host.respond_to?(:shadow_root)
@@ -293,7 +287,7 @@ module Dommy
     def __js_set__(key, value)
       case key
       when "textContent", "data", "nodeValue"
-        write_data(value)
+        self.data = value
       end
 
       nil
@@ -312,8 +306,7 @@ module Dommy
         false
       when "contains"
         # A leaf node contains only itself (no descendants).
-        args[0].respond_to?(:__dommy_backend_node__) &&
-          args[0].__dommy_backend_node__ == @__node__
+        args[0].is_a?(Node) && args[0].__dommy_backend_node__ == @__node__
       when "appendChild"
         append_child(args[0])
       when "insertBefore"

data/lib/dommy/class_list.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "internal/infra"
+
 module Dommy
   # DOMTokenList (`classList`, `relList`) and DOMStringMap (`dataset`) —
   # the two live views over one attribute's text.
@@ -10,9 +12,13 @@ module Dommy
 
     # `attribute` is the content attribute this token list reflects ("class" for
     # `classList`, "rel" for `relList`, "sandbox", "sizes", "for", …).
-    def initialize(element, attribute = "class")
+    # `supported_tokens` is what DOM calls the element and attribute name's
+    # supported tokens (lowercase), or nil when they define none — see
+    # Internal::SupportedTokens.
+    def initialize(element, attribute = "class", supported_tokens = nil)
       @element = element
       @attribute = attribute
+      @supported_tokens = supported_tokens
     end
 
     def length
@@ -29,11 +35,11 @@ module Dommy
     end
 
     def value
-      @element.__dommy_backend_node__[@attribute].to_s
+      associated_value.to_s
     end
 
     def value=(new_value)
-      @element.set_attribute(@attribute, new_value.to_s)
+      write(new_value.to_s)
     end
 
     # Spec: contains() does NOT validate (no SyntaxError on empty).
@@ -49,6 +55,16 @@ module Dommy
       class_tokens.include?(token.to_s)
     end
 
+    # DOMTokenList's supports(token), which runs the validation steps: a
+    # TypeError when the element and attribute define no supported tokens
+    # (`classList.supports("x")`), else whether the token, ASCII-lowercased,
+    # is one of them (`a.relList.supports("NoOpener")` is true).
+    def supports?(token)
+      raise Bridge::TypeError, "DOMTokenList has no supported tokens" if @supported_tokens.nil?
+
+      @supported_tokens.include?(stringify_token(token).downcase(:ascii))
+    end
+
     def add(*tokens)
       update_tokens { |existing| existing | normalize_tokens(tokens) }
       nil
@@ -79,7 +95,7 @@ module Dommy
       # raw attribute string, which would then hand stale tokens to later reads).
       updated = tokens.dup
       updated[idx] = new_s
-      @element.set_attribute(@attribute, updated.uniq.join(" "))
+      write(updated.uniq.join(" "))
       true
     end
 
@@ -130,10 +146,7 @@ module Dommy
     end
 
     include Bridge::Methods
-    # NOTE: `supports` is intentionally absent — for the class attribute's token
-    # list it must throw a TypeError, which `list.supports(...)` (not a function)
-    # already does.
-    js_methods %w[add remove contains toggle replace item toString]
+    js_methods %w[add remove contains toggle replace item supports toString]
     def __js_call__(method, args)
       case method
       when "add"
@@ -146,11 +159,13 @@ module Dommy
         # contains() does not validate; null coerces to the string "null".
         class_tokens.include?(stringify_token(args[0]))
       when "toggle"
-        toggle(args[0], args[1])
+        toggle(args[0], args.fetch(1, Bridge::UNDEFINED))
       when "replace"
         replace(args[0], args[1])
       when "item"
         item(args[0])
+      when "supports"
+        supports?(args[0])
       when "toString"
         value
       else
@@ -160,16 +175,18 @@ module Dommy
 
     private
 
-    def toggle(token, force)
+    # `optional boolean force`: missing (or undefined) toggles; anything
+    # else, null included, is a boolean read with ToBoolean.
+    def toggle(token, force = Bridge::UNDEFINED)
       name = validate_token(token)
       present = class_tokens.include?(name)
-      force_given = !(force.nil? || force.equal?(Bridge::UNDEFINED))
+      force_given = !force.equal?(Bridge::UNDEFINED)
 
       # Spec: toggle runs the update steps only when it actually adds or removes.
       # With an explicit force that already matches the current state it's a
       # no-op — the attribute is left byte-for-byte untouched (no re-serialize).
       if force_given
-        want = !!force
+        want = Internal::WebIDL.boolean(force)
         return want if want == present
 
         update_tokens { |tokens| want ? tokens | [name] : tokens - [name] }
@@ -207,7 +224,7 @@ module Dommy
     # item, iteration, and contains all operate on this set; `value`/`toString`
     # return the raw attribute. ASCII whitespace per the spec is space/tab/LF/FF/CR.
     def class_tokens
-      raw = @element.__dommy_backend_node__[@attribute].to_s
+      raw = associated_value.to_s
       # Cache the parsed token list keyed by the raw attribute string: a class
       # selector match re-reads this for every element on every querySelector,
       # and the split/reject/uniq dominated heavy-SPA load profiles. The key is
@@ -216,7 +233,7 @@ module Dommy
       cached = @token_cache
       return cached[1] if cached && cached[0] == raw
 
-      tokens = raw.split(/[ \t\n\f\r]+/).reject(&:empty?).uniq
+      tokens = Internal::Infra.split_on_ascii_whitespace(raw).uniq
       @token_cache = [raw, tokens]
       tokens
     end
@@ -227,9 +244,22 @@ module Dommy
     # (per spec) is an empty set with no existing attribute — don't create one.
     def update_tokens
       tokens = yield(class_tokens)
-      return if tokens.empty? && !@element.__dommy_backend_node__.key?(@attribute)
+      return if tokens.empty? && associated_value.nil?
+
+      write(tokens.join(" "))
+    end
+
+    # The associated attribute is the one of that local name in no namespace
+    # (DOM's "get an attribute by namespace and local name"): a `class` set
+    # with setAttributeNS("urn:x", "class") is not the element's classes.
+    def associated_value
+      Backend.no_namespace_attribute_value(@element.__dommy_backend_node__, @attribute)
+    end
 
-      @element.set_attribute(@attribute, tokens.join(" "))
+    # The same attribute, written as every other reflection writes one: its
+    # name is a fixed, valid local name, so there is nothing to validate.
+    def write(value)
+      @element.__internal_set_attribute_value__(@attribute, value)
     end
   end
 
@@ -247,7 +277,7 @@ module Dommy
 
       # A missing data-* attribute reads as JS `undefined` (and `"foo" in dataset`
       # is false), per DOMStringMap semantics.
-      value = @element.__dommy_backend_node__[attr_name(name)]
+      value = @element.__internal_attribute_value__(attr_name(name))
       value.nil? ? Bridge::ABSENT : value
     end
 
@@ -260,7 +290,7 @@ module Dommy
         raise DOMException::InvalidCharacterError, "#{attribute.inspect} is not a valid attribute name"
       end
 
-      @element.set_attribute(attribute, value.to_s)
+      @element.__internal_set_attribute_value__(attribute, value.to_s)
       nil
     end
 
@@ -271,7 +301,7 @@ module Dommy
       name = key.to_s
       return true unless supported_name?(name)
 
-      @element.remove_attribute(attr_name(name))
+      @element.remove_attribute_ns(nil, attr_name(name))
       true
     end
 
@@ -280,12 +310,14 @@ module Dommy
     end
 
     # WebIDL "supported property names" for DOMStringMap: each `data-*`
-    # attribute's name with the `data-` prefix stripped and `-x` sequences
-    # camel-cased (`data-date-of-birth` → `dateOfBirth`, `data-` → ``).
+    # attribute in no namespace, its name with the `data-` prefix stripped
+    # and `-x` sequences camel-cased (`data-date-of-birth` → `dateOfBirth`,
+    # `data-` → ``).
     def __js_named_props__
       Backend.attribute_nodes(@element.__dommy_backend_node__).filter_map do |a|
-        name = Backend.attribute_ns_info(a)[:qualified_name]
-        next unless name.start_with?("data-")
+        info = Backend.attribute_ns_info(a)
+        name = info[:local_name]
+        next unless info[:namespace_uri].nil? && name.start_with?("data-")
 
         name.sub(/\Adata-/, "").gsub(/-([a-z])/) { ::Regexp.last_match(1).upcase }
       end