chop 0.38.6 → 0.38.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e55a9db560d2e4f808db771f98097313401c1b39564098a2685533ed9b783119
-  data.tar.gz: 4aeefe8cb8d741e4f1f8ae3038e4d610ef830434b9a631c404617ea1fbbc0ed4
+  metadata.gz: dd1b3c30a7783aa60c7110571a7e7a923cd611f954e7f4f99bb24957c685fb36
+  data.tar.gz: 13d01c3c911a879fb0e4e665df653f6bd2e11892cfee27e79ece48afffeb9736
 SHA512:
-  metadata.gz: 61e92ad1946a9af3ea7b1671850e701d3a162d75cfbd3cd4fc559071c051bdabbc0e6bbaa3c61460e7a44240c833e5664a3e991b2f6b512259cc370525653086
-  data.tar.gz: 432c28698fa79a792159c3da0dc02a590e99be644fdb60becf5a7d51c1e04b995a1c4d7ce38d5ffb192f367452808694f5b83b128df5855d26959cf09bc905b8
+  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

@@ -59,7 +59,7 @@ module Chop
         end
       else
         if block.arity.zero?
-          @new_header = yield
+          @new_header_block = block
         else
           header_transformation do |row|
             yield(row)
@@ -130,6 +130,7 @@ module Chop
     def to_a
       wait_for_idle! if @atomic
       freeze_page_scripts! if @atomic
+      @new_header = @new_header_block.call if @new_header_block
       rows = rows_finder.call(root).map { |row| cells_finder.call(row).to_a }
       rows = normalize(rows)
 
@@ -201,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.6"
+  VERSION = "0.38.8"
 end

metadata

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