chop 0.38.7 → 0.38.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c453a9613684dc9598f926969f736b6dcf97f2e3ff15103ab1e41f6f73e19d6
-  data.tar.gz: 70e8130184d8e8a443b7fd8db27e19512963eb288b4db200e98665cfa040345b
+  metadata.gz: dd1b3c30a7783aa60c7110571a7e7a923cd611f954e7f4f99bb24957c685fb36
+  data.tar.gz: 13d01c3c911a879fb0e4e665df653f6bd2e11892cfee27e79ece48afffeb9736
 SHA512:
-  metadata.gz: cdbc3afa528f1608df517ab34eb4d215ea462608377ef4d1cf0b5e073303d961ab37264ecd5aa26789640b9da06f279c95ac0aea7869a87260f8b136af13138f
-  data.tar.gz: aa9e605301db184c994ad5220a9c8b5ca299fec728088fd7bbc3ebbb6b57cfdf625c66fd387da3024192b2762cd31e2d5aa8f5afef3eb7b154309197dc9f6319
+  metadata.gz: c17761d8ae82a8365f784ab32d87273d8e88715f54b5eff65d982d1082f4b6a6c9fc92521fb9d19b1ee36fbf7d1ea0cd6cbaa04d2d700351793a51a96862142b
+  data.tar.gz: 7ac7934e482106c3c7ce468e517d4697590a8d994baa0a6e61c73c7056bae69c2627fd19495432737eea6076652756ec847c9ebb5f5fbe16851c5083562f1481

data/CLAUDE.md

@@ -69,6 +69,20 @@ Diffing works by:
 3. Comparing against the expected table using `diff!` from Cucumber
 4. Supporting element-specific extraction logic (e.g., images in table cells)
 
+Every `diff!`, including `Chop::Form`'s, wraps the read in `synchronize` and
+re-reads until it matches or the timeout expires. Capybara's `synchronize` is not
+re-entrant, so finders inside that block get a single attempt each and their
+errors have to be retriable at the outer level. A block that post-processes
+`actual` should raise `Capybara::ElementNotFound` to request a re-read.
+
+When `Chop.atomic_diff` is on, an atomic read first waits for the page to go idle
+(`Diff#wait_for_idle!`), then disables script execution for the duration of the
+read. Idle means no in-flight network and no frame Turbo is actually fetching —
+lazy and disabled frames carry a `src` that is never fetched, so counting them
+would mean the page is never idle. The check has to hold for
+`IDLE_SAMPLES_REQUIRED` consecutive samples, since the gap between a click and
+the request it triggers also looks idle.
+
 ## Testing Patterns
 
 - Uses RSpec with `spec_helper.rb` configuring focus filtering

data/README.md

@@ -117,6 +117,31 @@ All these methods are implemented in terms of the following low-level methods, u
 * `#hash_transformation`: performs arbitrary transformations on an array of hashes constructed by assuming a header row. Hash keys are downcased and underscored.
 * `#transformation`: performs arbitrary transformations on the 2d array of Capybara nodes.
 
+### Diffing a `<form>`:
+
+Form diffs take a block that post-processes the rows before comparison:
+
+``` ruby
+table.diff! "#ticket_1", as: :form do |actual, root|
+  actual.insert 0, ["Owned by", root.all("owners-select option[selected]").map(&:text).join(" ")]
+end
+```
+
+Like every other `#diff!`, the read is retried until it matches or the timeout
+expires, so the block can be handed a form that is still rendering. Raise
+`Capybara::ElementNotFound` to ask for a re-read rather than working with what is
+there:
+
+``` ruby
+index = actual.index { |row| row.first == "Requested by" }
+raise Capybara::ElementNotFound, "no \"Requested by\" row yet" unless index
+```
+
+Reads inside the block should pass `minimum: 0` to Capybara's `#all`. Its default
+of `minimum: 1` waits out the whole timeout before conceding that a collection is
+legitimately empty, and the retry above already covers a collection that has not
+rendered yet.
+
 ### Block methods for `#fill_in!`:
 
 TODO: Does this make sense?

data/lib/chop/diff.rb

@@ -202,16 +202,30 @@ module Chop
       nil
     end
 
+    # The page has to look quiet for a continuous window before we believe it,
+    # since the gap between a click and the fetch it triggers also looks quiet.
+    # Widen this on slow or oversubscribed machines, where "quiet" more often
+    # means "descheduled" than "finished".
+    IDLE_POLL_INTERVAL = 0.05
+    IDLE_SAMPLES_REQUIRED = 10
+
+    # A `src` on a lazy or disabled frame is never fetched, so counting those as
+    # pending means the page never goes idle and every atomic diff burns its
+    # whole timeout. `busy` covers a lazy frame that has just come into view.
+    PENDING_FRAMES_SELECTOR = 'turbo-frame[busy], turbo-frame[src]:not([complete]):not([disabled]):not([loading="lazy"])'
+
     def wait_for_idle!
       return unless cdp_page
 
       start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      idle_samples = 0
       loop do
         break if Process.clock_gettime(Process::CLOCK_MONOTONIC) - start > timeout
-        pending_frames = session.evaluate_script("document.querySelectorAll('turbo-frame[src]:not([complete]), turbo-frame[busy]').length")
+        pending_frames = session.evaluate_script("document.querySelectorAll(#{PENDING_FRAMES_SELECTOR.inspect}).length")
         pending_network = session.driver.browser.network.pending_connections
-        break if pending_frames == 0 && pending_network == 0
-        sleep 0.05
+        idle_samples = (pending_frames == 0 && pending_network == 0) ? idle_samples + 1 : 0
+        break if idle_samples >= IDLE_SAMPLES_REQUIRED
+        sleep IDLE_POLL_INTERVAL
       end
     end
 

data/lib/chop/form.rb

@@ -7,7 +7,21 @@ module Chop
       new(table, session, path).fill_in!
     end
 
-    def self.diff! selector, table, session: Capybara.current_session, &block
+    # Capybara's #synchronize is not re-entrant, so the finds below get a single
+    # attempt each and have to retry out here instead — hence ElementNotFound in
+    # the error list. A block that post-processes `actual` should raise
+    # Capybara::ElementNotFound to ask for a re-read of a half-rendered form.
+    def self.diff! selector, table, session: Capybara.current_session, timeout: nil, &block
+      errors = session.driver.invalid_element_errors + [
+        Cucumber::MultilineArgument::DataTable::Different,
+        Capybara::ElementNotFound,
+      ]
+      session.document.synchronize timeout || Capybara.default_max_wait_time, errors: errors do
+        diff_once! selector, table, session: session, &block
+      end
+    end
+
+    def self.diff_once! selector, table, session:, &block
       root = begin
         if selector.is_a?(Capybara::Node::Element)
           selector
@@ -28,7 +42,7 @@ module Chop
       block.call(actual, root) if block_given?
       table.diff! actual, surplus_row: false, misplaced_col: false
     end
-
+    private_class_method :diff_once!
 
     def fill_in!
       table.rows_hash.each do |label, value|

data/lib/chop/version.rb

@@ -1,3 +1,3 @@
 module Chop
-  VERSION = "0.38.7"
+  VERSION = "0.38.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chop
 version: !ruby/object:Gem::Version
-  version: 0.38.7
+  version: 0.38.8
 platform: ruby
 authors:
 - Micah Geisel
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-03 00:00:00.000000000 Z
+date: 2026-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord