capybara-simulated 0.0.5 → 0.0.7

data/vendor/js/entry.mjs

@@ -1,8 +1,23 @@
-// Bundle entry: brings happy-dom and an XPath engine into one IIFE that
-// exposes them on a single `__csim_bundle` global. happy-dom does not
-// implement document.evaluate, so we layer fontoxpath on top.
+// Bundle entry: brings happy-dom + wgxpath into one IIFE that exposes them
+// on a single `__csim_bundle` global. happy-dom does not implement
+// `document.evaluate`, so wgxpath layers it onto `Document.prototype`.
 import {Window} from 'happy-dom';
 import {URL, URLSearchParams} from 'whatwg-url';
-import {evaluateXPathToNodes} from 'fontoxpath';
+import wgxpath from 'wicked-good-xpath';
 
-export {Window, URL, URLSearchParams, evaluateXPathToNodes};
+// happy-dom 20's `document` is an `HTMLDocument` instance and the proto
+// chain doesn't include `Document.prototype` (where wgxpath plants
+// `evaluate` / `createExpression` / `createNSResolver`). Mirror the three
+// methods onto `HTMLDocument.prototype` so `document.evaluate` works.
+function installXPath(win) {
+  wgxpath.install(win, /* opt_force */ true);
+  if (win.HTMLDocument && win.Document) {
+    for (const m of ['evaluate', 'createExpression', 'createNSResolver']) {
+      if (win.Document.prototype[m] && !win.HTMLDocument.prototype[m]) {
+        win.HTMLDocument.prototype[m] = win.Document.prototype[m];
+      }
+    }
+  }
+}
+
+export {Window, URL, URLSearchParams, installXPath};

data/vendor/js/prelude.js

@@ -131,6 +131,7 @@
   globalThis.__csim_runTimers = function (ms) {
     const advance = (typeof ms === 'number') ? Math.max(0, ms) : Infinity;
     _virtualClock += advance;
+    let everFired = false;
     while (true) {
       let fired = false;
       const due = [];
@@ -141,10 +142,13 @@
         _timers.delete(id);
         try { t.fn(); } catch (_) {}
         fired = true;
+        everFired = true;
       }
       if (!fired) break;
     }
+    return everFired;
   };
+  globalThis.__csim_pendingTimerCount = function () { return _timers.size; };
   globalThis.__csim_clearTimers = function () {
     _timers.clear();
     _virtualClock = 0;

data/vendor/js/runtime.js

@@ -5,12 +5,25 @@
 
 (function () {
   const {Window, URL: WhatwgURL, URLSearchParams: WhatwgURLSearchParams,
-         evaluateXPathToNodes} = globalThis.__csim_bundle;
+         installXPath} = globalThis.__csim_bundle;
   if (!globalThis.URL) globalThis.URL = WhatwgURL;
   if (!globalThis.URLSearchParams) globalThis.URLSearchParams = WhatwgURLSearchParams;
 
   const handles = new Map();
   let nextHandleId = 0;
+
+  // Capybara's `have_text` matchers and several internal checks call into
+  // `visibleText` repeatedly against the same handle while polling. The
+  // text-collection walks happy-dom's textContent / styles each call, so
+  // re-running it 1000+ times per spec adds up. Cache by handle and drop
+  // the whole cache the moment any mutating runtime method runs (or
+  // `drainTimers` advances the virtual clock — Stimulus / Turbo timers
+  // may have rewritten the page). The cache is intentionally narrow:
+  // we measured a broader MutationObserver-driven cache as a wash, since
+  // the dispatch overhead ate the cache wins; pinning a bare `Map.clear()`
+  // to known-mutating call sites is much cheaper.
+  const visibleTextCache = new Map();
+  function clearReadCache() { if (visibleTextCache.size) visibleTextCache.clear(); }
   let currentWindow = null;
   let currentDocument = null;
   let activeHandleId = null;
@@ -47,6 +60,7 @@
       catch (_) {}
     }
     handles.clear();
+    visibleTextCache.clear();
     nextHandleId = 0;
     activeHandleId = null;
     modalQueue.length = 0;
@@ -170,6 +184,7 @@
     installValidationMessages(win);
     installMutationObserverPin(win);
     installAttrNodeValue(win);
+    installXPath(win);
   }
 
   // happy-dom 20's `Attr` class implements `value` / `textContent` / `name`
@@ -889,8 +904,9 @@
 
   function drainTimers(ms) {
     if (typeof globalThis.__csim_runTimers === 'function') {
-      try { globalThis.__csim_runTimers(ms); } catch (_) {}
+      try { return !!globalThis.__csim_runTimers(ms); } catch (_) {}
     }
+    return false;
   }
 
   // happy-dom has no layout engine, so getBoundingClientRect always returns
@@ -963,7 +979,6 @@
       patchWindowGlobals(win);
       installFetchShim(win);
       installCustomElementUpgrade(win);
-      installDocumentEvaluate(win.document);
       installHistoryTracking(win);
       currentWindow = win;
       currentDocument = win.document;
@@ -1257,11 +1272,14 @@
       const fast = tryFastXPath(xpath, root);
       if (fast) return fast.map(track);
       try {
-        const nodes = evaluateXPathToNodes(xpath, root, xpathDomFacade, null, {
-          // happy-dom places elements in the XHTML namespace.
-          namespaceResolver: () => 'http://www.w3.org/1999/xhtml'
-        });
-        return nodes.map(track);
+        const result = currentDocument.evaluate(
+          xpath, root, null,
+          /* UNORDERED_NODE_ITERATOR_TYPE */ 4, null
+        );
+        const ids = [];
+        let n;
+        while ((n = result.iterateNext())) ids.push(track(n));
+        return ids;
       } catch (e) {
         return findViaXPathFallback(xpath, root);
       }
@@ -1305,10 +1323,13 @@
     },
     allText(id)     { return String(lookup(id).textContent || ''); },
     visibleText(id) {
+      const cached = visibleTextCache.get(id);
+      if (cached !== undefined) return cached;
       const el = lookup(id);
       // If any ancestor of `el` is hidden, the element renders nothing.
-      if (!visibleAncestorChainOk(el)) return '';
-      return String(visibleTextOf(el));
+      const txt = visibleAncestorChainOk(el) ? String(visibleTextOf(el)) : '';
+      visibleTextCache.set(id, txt);
+      return txt;
     },
     path(id)        { return String(buildXPath(lookup(id))); },
     rect(id) {
@@ -1347,6 +1368,7 @@
     },
 
     setValue(id, value) {
+      clearReadCache();
       const el = lookup(id);
       const tag = (el.tagName || '').toUpperCase();
       const type = (el.type || (el.getAttribute && el.getAttribute('type')) || '').toLowerCase();
@@ -1454,6 +1476,7 @@
     },
 
     selectOption(id) {
+      clearReadCache();
       const opt = lookup(id);
       const select = opt.parentNode && (opt.parentNode.tagName === 'SELECT'
         ? opt.parentNode
@@ -1472,6 +1495,7 @@
       return true;
     },
     unselectOption(id) {
+      clearReadCache();
       const opt = lookup(id);
       const select = opt.closest && opt.closest('select');
       if (!select || !isMultipleSelect(select)) return false;
@@ -1518,8 +1542,8 @@
                           boolPropOrAttr(lookup(id), 'readonly'); },
     multiple(id) { return boolPropOrAttr(lookup(id), 'multiple'); },
 
-    focus(id)  { activeHandleId = id; lookup(id).dispatchEvent(makeEvent('focus', {bubbles: false})); return true; },
-    blur(id)   { lookup(id).dispatchEvent(makeEvent('blur', {bubbles: false})); if (activeHandleId === id) activeHandleId = null; return true; },
+    focus(id)  { clearReadCache(); activeHandleId = id; lookup(id).dispatchEvent(makeEvent('focus', {bubbles: false})); return true; },
+    blur(id)   { clearReadCache(); lookup(id).dispatchEvent(makeEvent('blur', {bubbles: false})); if (activeHandleId === id) activeHandleId = null; return true; },
     activeElement() {
       // Honour the JS-side `document.activeElement` first — happy-dom
       // updates it when scripts call `focus()` directly, which the
@@ -1531,14 +1555,22 @@
     },
 
     hover(id) {
+      clearReadCache();
       const el = lookup(id);
       el.dispatchEvent(makeEvent('mouseover'));
       el.dispatchEvent(makeEvent('mouseenter', {bubbles: false}));
       return true;
     },
-    trigger(id, name) { lookup(id).dispatchEvent(makeEvent(name)); return true; },
-
-    drainTimers(ms) { drainTimers(ms); return true; },
+    trigger(id, name) { clearReadCache(); lookup(id).dispatchEvent(makeEvent(name)); return true; },
+
+    drainTimers(ms) {
+      // Only clear the read cache if a timer actually fired — most
+      // `advance_virtual_clock` calls from Ruby have nothing to do but
+      // tick the wall clock. Without this the visibleText cache is
+      // invalidated on every cross-bridge call and never hits.
+      if (drainTimers(ms)) clearReadCache();
+      return true;
+    },
 
     consumeHistoryPushed() {
       const v = _historyPushed;
@@ -1561,6 +1593,7 @@
     },
 
     click(id, button, modifiers, skipDown) {
+      clearReadCache();
       const el = lookup(id);
       activeHandleId = id;
       const m = Object.assign({button: button || 0}, modifiers || {});
@@ -1707,6 +1740,7 @@
     },
 
     doubleClick(id, modifiers) {
+      clearReadCache();
       const el = lookup(id);
       const m = Object.assign({button: 0}, modifiers || {});
       applyClickOffset(el, m);
@@ -1720,6 +1754,7 @@
       return {action: 'none'};
     },
     rightClick(id, modifiers, skipDown) {
+      clearReadCache();
       const el = lookup(id);
       const m = Object.assign({button: 2}, modifiers || {});
       applyClickOffset(el, m);
@@ -1735,6 +1770,7 @@
     // exposes `DragEvent` as a plain `Event`, so we paste `dataTransfer`
     // onto each event before dispatch.
     drop(id, items) {
+      clearReadCache();
       const el = lookup(id);
       const win = currentWindow;
       const dt = new win.DataTransfer();
@@ -1761,9 +1797,10 @@
       return true;
     },
 
-    submit(id) { return submitDescriptor(lookup(id), null); },
+    submit(id) { clearReadCache(); return submitDescriptor(lookup(id), null); },
 
     sendKeys(id, keys) {
+      clearReadCache();
       const el = lookup(id);
       const editable = (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA');
       let formToSubmit = null;
@@ -1955,111 +1992,6 @@
     wrap('replaceState');
   }
 
-  // happy-dom does not implement `document.evaluate`. Capybara internals
-  // and user scripts both reach for it occasionally. Polyfill it on top of
-  // fontoxpath so callers see W3C XPathResult semantics.
-  function installDocumentEvaluate(doc) {
-    if (typeof doc.evaluate === 'function') return;
-    const ANY_TYPE = 0;
-    const NUMBER_TYPE = 1;
-    const STRING_TYPE = 2;
-    const BOOLEAN_TYPE = 3;
-    const UNORDERED_NODE_ITERATOR_TYPE = 4;
-    const ORDERED_NODE_ITERATOR_TYPE = 5;
-    const UNORDERED_NODE_SNAPSHOT_TYPE = 6;
-    const ORDERED_NODE_SNAPSHOT_TYPE = 7;
-    const ANY_UNORDERED_NODE_TYPE = 8;
-    const FIRST_ORDERED_NODE_TYPE = 9;
-
-    function makeResult(type, items) {
-      return {
-        resultType: type,
-        snapshotLength: items.length,
-        snapshotItem: (i) => items[i] || null,
-        get singleNodeValue() { return items[0] || null; },
-        iterateNext: (() => { let i = 0; return () => items[i++] || null; })()
-      };
-    }
-
-    doc.evaluate = function (xpath, contextNode, _resolver, type, _result) {
-      const root = contextNode || doc.documentElement || doc;
-      let nodes = [];
-      try {
-        nodes = evaluateXPathToNodes(xpath, root, xpathDomFacade, null, {
-          namespaceResolver: () => 'http://www.w3.org/1999/xhtml'
-        });
-      } catch (_) {
-        nodes = [];
-      }
-      switch (type) {
-        case FIRST_ORDERED_NODE_TYPE:
-        case ANY_UNORDERED_NODE_TYPE:
-          return makeResult(type, nodes.slice(0, 1));
-        case NUMBER_TYPE:
-        case STRING_TYPE:
-        case BOOLEAN_TYPE:
-          // We do not support primitive XPath results; callers fall back.
-          return makeResult(type, []);
-        default:
-          return makeResult(type || ORDERED_NODE_SNAPSHOT_TYPE, nodes);
-      }
-    };
-  }
-
-  // Custom DOM facade for fontoxpath that uses childNodes-based traversal
-  // so happy-dom quirks around sibling links don't break root-anchored
-  // queries. Mirrors the helper we built for linkedom.
-  // fontoxpath calls into this facade tens of thousands of times per
-  // traversal, so each method needs to delegate to happy-dom's native
-  // pointers rather than reconstructing them. Earlier revisions of
-  // getNextSibling / getPreviousSibling rebuilt childNodes via
-  // Array.from(parent.childNodes) and then indexOf'd the node — quadratic
-  // in tree size, and the dominant cost on any non-trivial page.
-  const xpathDomFacade = {
-    getAllAttributes(node) {
-      if (!node || node.nodeType !== 1 || !node.attributes) return [];
-      return Array.from(node.attributes);
-    },
-    getAttribute(node, name) {
-      return node && node.getAttribute ? node.getAttribute(name) : null;
-    },
-    getChildNodes(node) {
-      if (!node) return [];
-      if (node.childNodes) return Array.from(node.childNodes);
-      if (node.nodeType === 9 && node.documentElement) return [node.documentElement];
-      return [];
-    },
-    getData(node) {
-      if (!node) return '';
-      if (node.nodeType === 2) return node.value || '';
-      return node.data || '';
-    },
-    // happy-dom 20 has a quirk on `<template>`: `template.childNodes` is
-    // empty (the parsed content lives in `template.content`) but
-    // `template.firstChild` / `template.lastChild` still return the first
-    // text node of `template.content`. Walking into that ghost child
-    // makes fontoxpath traverse content as if it were a regular descendant,
-    // which scrambles every predicate downstream. Verify against
-    // childNodes.length before trusting firstChild / lastChild.
-    getFirstChild(node) {
-      const fc = node?.firstChild ?? null;
-      if (!fc) return null;
-      const cs = node.childNodes;
-      if (cs && cs.length === 0) return null;
-      return fc;
-    },
-    getLastChild(node) {
-      const lc = node?.lastChild ?? null;
-      if (!lc) return null;
-      const cs = node.childNodes;
-      if (cs && cs.length === 0) return null;
-      return lc;
-    },
-    getNextSibling(node)     { return node?.nextSibling     ?? null; },
-    getPreviousSibling(node) { return node?.previousSibling ?? null; },
-    getParentNode(node)      { return node?.parentNode      ?? null; }
-  };
-
   // Capybara's xpath gem produces a small set of stable XPath shapes for
   // its built-in selectors (link, button, link_or_button, select, option,
   // field, fillable_field, …). Even after the facade fix fontoxpath spends

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capybara-simulated
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.7
 platform: ruby
 authors:
 - Keita Urashima