dommy 0.6.0 → 0.8.0

data/lib/dommy/crypto.rb

@@ -62,6 +62,8 @@ module Dommy
       end
     end
 
+    include Bridge::Methods
+    js_methods %w[randomUUID getRandomValues]
     def __js_call__(method, args)
       case method
       when "randomUUID"
@@ -99,7 +101,9 @@ module Dommy
         hasher = ALGORITHMS[name]
         raise ArgumentError, "unsupported algorithm: #{name}" unless hasher
 
-        hasher.call(coerce_bytes(data)).bytes
+        # WHATWG: digest() resolves to an ArrayBuffer — wrap so it crosses the
+        # JS boundary as a bare ArrayBuffer (not a plain Array).
+        Bridge::ArrayBuffer.new(hasher.call(coerce_bytes(data)).bytes)
       end
     end
 
@@ -182,7 +186,7 @@ module Dommy
         raise ArgumentError, "HMAC key required" unless key.is_a?(CryptoKey) && key.algorithm_name == "HMAC"
         raise ArgumentError, "key.usages must include 'sign'" unless key.usages.include?("sign")
 
-        OpenSSL::HMAC.digest(openssl_digest_name(key.hash_name), key.__bytes__, coerce_bytes(data)).bytes
+        OpenSSL::HMAC.digest(openssl_digest_name(key.hash_name), key.__dommy_bytes__, coerce_bytes(data)).bytes
       end
     end
 
@@ -192,7 +196,7 @@ module Dommy
         raise ArgumentError, "HMAC key required" unless key.is_a?(CryptoKey) && key.algorithm_name == "HMAC"
         raise ArgumentError, "key.usages must include 'verify'" unless key.usages.include?("verify")
 
-        expected = OpenSSL::HMAC.digest(openssl_digest_name(key.hash_name), key.__bytes__, coerce_bytes(data))
+        expected = OpenSSL::HMAC.digest(openssl_digest_name(key.hash_name), key.__dommy_bytes__, coerce_bytes(data))
         sig_bytes = coerce_bytes(signature)
         if expected.bytesize == sig_bytes.bytesize
           OpenSSL.fixed_length_secure_compare(expected, sig_bytes)
@@ -230,6 +234,8 @@ module Dommy
       end
     end
 
+    include Bridge::Methods
+    js_methods %w[digest generateKey importKey sign verify encrypt decrypt]
     def __js_call__(method, args)
       case method
       when "digest"
@@ -327,7 +333,7 @@ module Dommy
     end
 
     def build_gcm_cipher(direction, algorithm, key)
-      raw_key = key.is_a?(CryptoKey) ? key.__bytes__ : coerce_bytes(key)
+      raw_key = key.is_a?(CryptoKey) ? key.__dommy_bytes__ : coerce_bytes(key)
       raise ArgumentError, "AES-GCM key must be 16/24/32 bytes" unless [16, 24, 32].include?(raw_key.bytesize)
 
       iv = algorithm.is_a?(Hash) ? (algorithm["iv"] || algorithm[:iv]) : nil
@@ -359,9 +365,9 @@ module Dommy
   end
 
   # `CryptoKey` — opaque key handle returned by SubtleCrypto.
-  # `extractable: false` keys reject export attempts; the
-  # `__bytes__` accessor stays internal-only (`__double_underscore__`
-  # convention) so production code paths can't read the raw bytes.
+  # `extractable: false` keys reject export attempts; the raw bytes are
+  # reachable only through the `__dommy_bytes__` ecosystem accessor, never
+  # the public (Web-mirroring) API.
   class CryptoKey
     attr_reader :type, :algorithm_name, :hash_name, :usages, :extractable
 
@@ -374,8 +380,9 @@ module Dommy
       @usages = usages.map(&:to_s).freeze
     end
 
-    # Test / internal seam — production callers should not reach in.
-    def __bytes__
+    # Low-level ecosystem accessor (see __dommy_ convention) — the public
+    # Web API never exposes raw key bytes.
+    def __dommy_bytes__
       @bytes
     end
 

data/lib/dommy/css.rb

@@ -63,7 +63,7 @@ module Dommy
       idx = index.nil? ? @css_rules.length : index.to_i
       raise DOMException::IndexSizeError, "out of range" if idx < 0 || idx > @css_rules.length
 
-      @css_rules.__insert__(idx, CSSRule.new(rule_text.to_s, self))
+      @css_rules.__internal_insert__(idx, CSSRule.new(rule_text.to_s, self))
       idx
     end
 
@@ -71,17 +71,17 @@ module Dommy
       idx = index.to_i
       raise DOMException::IndexSizeError, "out of range" if idx < 0 || idx >= @css_rules.length
 
-      @css_rules.__delete_at__(idx)
+      @css_rules.__internal_delete_at__(idx)
       nil
     end
 
     # `replaceSync(text)` — replace all rules with a single rule blob
     # (no parsing — we keep it as one opaque entry).
     def replace_sync(text)
-      @css_rules.__clear__
+      @css_rules.__internal_clear__
       return nil if text.to_s.empty?
 
-      @css_rules.__insert__(0, CSSRule.new(text.to_s, self))
+      @css_rules.__internal_insert__(0, CSSRule.new(text.to_s, self))
       nil
     end
 
@@ -125,6 +125,8 @@ module Dommy
       nil
     end
 
+    include Bridge::Methods
+    js_methods %w[insertRule deleteRule replaceSync replace]
     def __js_call__(method, args)
       case method
       when "insertRule"
@@ -173,15 +175,15 @@ module Dommy
       @rules.dup
     end
 
-    def __insert__(index, rule)
+    def __internal_insert__(index, rule)
       @rules.insert(index, rule)
     end
 
-    def __delete_at__(index)
+    def __internal_delete_at__(index)
       @rules.delete_at(index)
     end
 
-    def __clear__
+    def __internal_clear__
       @rules.clear
     end
 
@@ -196,6 +198,8 @@ module Dommy
       end
     end
 
+    include Bridge::Methods
+    js_methods %w[item]
     def __js_call__(method, args)
       case method
       when "item"
@@ -280,4 +284,46 @@ module Dommy
       nil
     end
   end
+
+  # `window.CSS` namespace object — `escape()` for safe selector building
+  # (used by Turbo and friends) and a `supports()` stub (no CSS engine).
+  class CSSNamespace
+    def __js_get__(_key) = nil
+    def __js_set__(_key, _value) = Bridge::UNHANDLED
+
+    include Bridge::Methods
+    js_methods %w[escape supports]
+    def __js_call__(method, args)
+      case method
+      when "escape"
+        self.class.escape(args[0])
+      when "supports"
+        false
+      end
+    end
+
+    # CSSOM `CSS.escape` — escape a string for use as an identifier in a
+    # selector. Follows the spec's char rules closely enough for selectors.
+    def self.escape(value)
+      str = value.to_s
+      out = +""
+      str.each_char.with_index do |ch, i|
+        code = ch.ord
+        if code.zero?
+          out << "\uFFFD"
+        elsif (code >= 0x01 && code <= 0x1F) || code == 0x7F ||
+              (i.zero? && code >= 0x30 && code <= 0x39) ||
+              (i == 1 && code >= 0x30 && code <= 0x39 && str[0] == "-")
+          out << "\\#{code.to_s(16)} "
+        elsif code >= 0x80 || code == 0x2D || code == 0x5F ||
+              (code >= 0x30 && code <= 0x39) ||
+              (code >= 0x41 && code <= 0x5A) || (code >= 0x61 && code <= 0x7A)
+          out << ch
+        else
+          out << "\\#{ch}"
+        end
+      end
+      out
+    end
+  end
 end

data/lib/dommy/custom_elements.rb

@@ -10,7 +10,21 @@ module Dommy
   #
   # Names must contain a hyphen per the HTML spec (e.g., `my-button`).
   class CustomElementRegistry
-    NAME_RE = /\A[a-z][a-z0-9-]*-[a-z0-9-]*\z/
+    # https://html.spec.whatwg.org/#valid-custom-element-name
+    # PCENChar — the characters allowed after the first (ASCII-lower) char: a
+    # superset of [-._0-9a-z] plus wide Unicode ranges. A valid name is
+    # `[a-z] PCENChar* - PCENChar*` (i.e. lower-alpha start + at least one "-").
+    PCEN = "\\-._0-9a-z\\u00B7\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u037D" \
+           "\\u037F-\\u1FFF\\u200C-\\u200D\\u203F-\\u2040\\u2070-\\u218F" \
+           "\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\u{10000}-\\u{EFFFF}"
+    NAME_RE = Regexp.new("\\A[a-z][#{PCEN}]*-[#{PCEN}]*\\z")
+
+    # Hyphenated names that the HTML spec reserves (SVG / MathML elements), so
+    # they are NOT valid custom element names even though they match NAME_RE.
+    RESERVED_NAMES = %w[
+      annotation-xml color-profile font-face font-face-src font-face-uri
+      font-face-format font-face-name missing-glyph
+    ].to_set.freeze
 
     def initialize(window)
       @window = window
@@ -23,7 +37,10 @@ module Dommy
     def define(name, klass, _options = nil)
       key = name.to_s
       unless key.match?(NAME_RE)
-        raise DOMException::SyntaxError, "name must be a hyphenated string, got #{name.inspect}"
+        raise DOMException::SyntaxError, "#{name.inspect} is not a valid custom element name"
+      end
+      if RESERVED_NAMES.include?(key)
+        raise DOMException::SyntaxError, "#{name.inspect} is a reserved element name"
       end
 
       raise DOMException::NotSupportedError, "#{key} already defined" if @definitions.key?(key)
@@ -64,16 +81,16 @@ module Dommy
     # registered; fires `connectedCallback` for each upgraded node
     # that's currently attached to a document tree.
     def upgrade(root)
-      return nil unless root.respond_to?(:__node__)
+      return nil unless root.respond_to?(:__dommy_backend_node__)
 
-      walk_descendants(root.__node__) do |nk|
+      walk_descendants(root.__dommy_backend_node__) do |nk|
         next unless nk.element?
         next unless @definitions.key?(nk.name)
 
         # Force re-wrap by clearing the document's cached wrapper.
-        @window.document.__reset_wrapper__(nk)
+        @window.document.__internal_reset_wrapper__(nk)
         wrapped = @window.document.wrap_node(nk)
-        @window.document.__notify_connected__(wrapped) if wrapped
+        @window.document.__internal_notify_connected__(wrapped) if wrapped
       end
 
       nil
@@ -83,6 +100,8 @@ module Dommy
       nil
     end
 
+    include Bridge::Methods
+    js_methods %w[define get whenDefined upgrade]
     def __js_call__(method, args)
       case method
       when "define"
@@ -108,10 +127,15 @@ module Dommy
     # new class and fire connectedCallback.
     def upgrade_existing(name)
       doc = @window.document
-      doc.nokogiri_doc.css(name).each do |nk|
-        doc.__reset_wrapper__(nk)
+      # Match by tag name rather than interpolating `name` into a CSS selector:
+      # a spec-valid custom element name may contain "." (a CSS class selector
+      # char) or other metacharacters, which would corrupt the query.
+      doc.nokogiri_doc.css("*").each do |nk|
+        next unless nk.name == name
+
+        doc.__internal_reset_wrapper__(nk)
         wrapped = doc.wrap_node(nk)
-        doc.__notify_connected__(wrapped) if wrapped
+        doc.__internal_notify_connected__(wrapped) if wrapped
       end
     end
 

data/lib/dommy/data_transfer.rb

@@ -64,11 +64,15 @@ module Dommy
         @drop_effect = value.to_s
       when "effectAllowed"
         @effect_allowed = value.to_s
+      else
+        return Bridge::UNHANDLED
       end
 
       nil
     end
 
+    include Bridge::Methods
+    js_methods %w[getData setData clearData]
     def __js_call__(method, args)
       case method
       when "getData"