chop 0.35.2 → 0.36.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88bedb7f454adc2966b82d3c5748b88ca81498d6de9f46de02f5ee0256b9c641
-  data.tar.gz: a727470df4d49a8f170724367891caa6f8cd380ef637af75f867b5666924163b
+  metadata.gz: a932a3e8344d082e310dceec42f21dfbba56cd11264e330aa06245e66e6af07f
+  data.tar.gz: 0b904e3f1dbb926a0138614fee3b96e2d9aeb1363711c04b758058328904afd3
 SHA512:
-  metadata.gz: aa9383445e2c7333c58a107a00c570b20c3bc4f59e47a1b08bbc55682af675af05f9af0a45c61821e04142f99fe6c9a2244ff6c8fa4ab554d77ef5eb2f1e102d
-  data.tar.gz: 2c1b982d7f1a30cf2a2603927e98cb32b496efbe8c6eb83f3e5c14434f1a8061c33f42a5d50b882e914d55f80c9bd18cadfd4e51a66126f5bfd08bc4a6aa49cd
+  metadata.gz: 4010088d237ee4e02e40161da7d2f9d0caa049bf07b6b3d63267e08419a30ac5b2582e433e1176c79b6a07e885294e090b6d4f6c94c466eebe37479efc32fe30
+  data.tar.gz: c5a21854d4c7ca77e07edd9c3145679953ddf7bd52dd356777a2fc88cfdcea83af7048be55a5a2cacd064bf72792eab9b5e40e221a26514db3ccedd50cf1cb2c

data/CLAUDE.md

@@ -10,14 +10,17 @@ Chop is a Ruby gem that enhances Cucumber tables with three main methods: `#crea
 
 ### Testing
 - `rake spec` or `bundle exec rspec` - Run the full test suite
-- `rspec spec/chop/table_spec.rb` - Run a specific test file 
+- `rspec spec/chop/table_spec.rb` - Run a specific test file
 - `rspec spec/chop/table_spec.rb:42` - Run a specific test by line number
 
+Note: RSpec is configured to run only tests marked with `focus: true`. When no focused tests exist, all tests run automatically.
+
 ### Development Setup
 - `bin/setup` - Install dependencies after checkout
 - `bin/console` - Interactive console for experimentation
 
 ### Multi-Version Testing
+Tests must pass against Rails 7.0, 7.1, and 7.2 on Ruby 3.1, 3.2, and 3.3:
 - `bundle exec appraisal install` - Install gems for all Rails versions
 - `bundle exec appraisal rails-7.0 rspec` - Test against specific Rails version
 - `bundle exec appraisal rspec` - Test against all Rails versions
@@ -34,12 +37,13 @@ Chop is a Ruby gem that enhances Cucumber tables with three main methods: `#crea
 - **`Chop::Diff`** (lib/chop/diff.rb) - Base class for HTML element diffing with Capybara
 - **Element-specific diffing classes**:
   - `Chop::Table` - HTML table diffing
-  - `Chop::DefinitionList` - Definition list (`<dl>`) diffing  
+  - `Chop::DefinitionList` - Definition list (`<dl>`) diffing
+  - `Chop::DfnDl` - Definition list with `<dfn>` headings
   - `Chop::UnorderedList` - Unordered list (`<ul>`) diffing
   - `Chop::Form` - Form filling functionality
 
 ### Monkey-patching Strategy
-The gem extends `Cucumber::MultilineArgument::DataTable` by prepending a module that adds the three main methods. The DSL module can also be called directly as `Chop.create!`, `Chop.diff!`, `Chop.fill_in!` to avoid monkey-patching.
+The gem extends `Cucumber::MultilineArgument::DataTable` by prepending the DSL module, which adds the three main methods. The DSL module can also be called directly as `Chop.create!`, `Chop.diff!`, `Chop.fill_in!` to avoid monkey-patching entirely.
 
 ### Creation Strategies
 Supports pluggable creation strategies via `Chop::Create.register_creation_strategy`:
@@ -49,13 +53,25 @@ Supports pluggable creation strategies via `Chop::Create.register_creation_strat
 
 ### Transformation DSL
 The `#create!` method supports a rich DSL for transforming table data:
-- Field transformations: `file`, `files`, `has_one`, `has_many`, `default`, `copy`, `rename`, `delete`
-- Low-level: `field`, `transformation` for custom logic
-- Lifecycle hooks: `after` for post-creation logic
+- **Field transformations**: `file`, `files`, `has_one`, `has_many`, `default`, `copy`, `rename`, `delete`
+- **Low-level**: `field`, `transformation` for custom logic
+- **Lifecycle hooks**: `after` for post-creation logic, `create` to override creation strategy
+
+The `#diff!` method also supports transformations:
+- **Capybara finders**: `rows`, `cells`, `text` to override default element selection
+- **High-level transforms**: `image` to extract image filenames, `allow_not_found` for optional elements
+- **Low-level**: `header`, `field`, `hash_transformation`, `transformation` for custom logic
+
+### Diffing Architecture
+Diffing works by:
+1. Selecting HTML elements using Capybara finders (customizable via `rows`, `cells` blocks)
+2. Extracting text content from those elements
+3. Comparing against the expected table using `diff!` from Cucumber
+4. Supporting element-specific extraction logic (e.g., images in table cells)
 
 ## Testing Patterns
 
-- Uses RSpec with `spec_helper.rb` configuring focus and run-all behavior
+- Uses RSpec with `spec_helper.rb` configuring focus filtering
 - Tests organized by component in `spec/chop/` matching `lib/chop/` structure
-- Tests cover both direct method calls and monkey-patched table behavior
-- Uses Capybara for integration testing of diffing functionality
+- Tests cover both direct DSL calls and monkey-patched table behavior
+- Uses Capybara for integration testing of diffing functionality with Cuprite headless browser

data/README.md

@@ -64,6 +64,48 @@ Overide Capybara finders:
 High-level declarative transformations:
 * `#image`: Replaces the specified cell with the filename of the first image within it, stripped of path and cachebusters.
 
+Regex templates (opt‑in):
+* `#regex(*fields)`: Enables embedded regex templates inside expected cells for flexible matching. By default applies to all fields; optionally whitelist columns by header name (symbol/string) or by 1‑based column index.
+
+  - Syntax: write literal text with embedded regex tokens using Ruby‑style interpolation markers: `#{/pattern/flags}`. Flags support `i`, `m`, `x`.
+  - Matching: builds a single anchored regex for the entire cell by escaping literal segments and splicing regex tokens. The whole cell must match.
+  - Multiple tokens: allowed; flags across tokens are OR’ed together.
+  - Escaping: write `\#{/…/}` to render a token literally (no matching). The backslash is removed before comparing.
+
+  Examples:
+
+  ```ruby
+  # All fields enabled (table header present)
+  expected = [
+    ["Attachments"],
+    ['attachment.jpg 23.4 KB browser-report.txt #{/1\.\d{2} KB/}']
+  ]
+  expected.diff!("table") { regex }
+
+  # Whitelist by header name (normalized like header keys used elsewhere)
+  expected = [
+    ["A", "B"],
+    ["foo 123", 'bar #{/\d{3}/}']
+  ]
+  expected.diff!("table") { regex :b }
+
+  # Whitelist by 1-based column index
+  expected = [
+    ["A", "B"],
+    ["foo 123", 'bar #{/\d{3}/}']
+  ]
+  expected.diff!("table") { regex 2 }
+
+  # Non-whitelisted columns treat tokens as literal
+  expected = [
+    ["A", "B"],
+    ['#{/\w+ \d{3}/}', "bar 456"]
+  ]
+  expect {
+    expected.diff!("table") { regex :b }
+  }.to raise_error(Cucumber::MultilineArgument::DataTable::Different)
+  ```
+
 All these methods are implemented in terms of the following low-level methods, useful for when you need more control over the transformation:
 * `#header`: add or transform the table header, depending on block arity.
 * `#header(key)`: transform the specified header column, specified either by numeric index, or by hash key.
@@ -169,4 +211,3 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/botand
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-

data/lib/chop/diff.rb

@@ -2,14 +2,27 @@ require "active_support/core_ext/string/inflections"
 require "active_support/core_ext/object/blank"
 require "active_support/core_ext/class/attribute"
 require "active_support/hash_with_indifferent_access"
+require "chop/regex_templates"
 
 module Chop
   class Diff < Struct.new(:selector, :table, :session, :timeout, :block)
     def self.diff! selector, table, session: Capybara.current_session, timeout: Capybara.default_max_wait_time, errors: [], **kwargs, &block
       errors += session.driver.invalid_element_errors
       errors += [Cucumber::MultilineArgument::DataTable::Different]
-      session.document.synchronize timeout, errors: errors do
-        new(selector, table, session, timeout, block).diff! **kwargs
+      synchronize_with_retry(session, timeout, errors) do
+        new(selector, table, session, timeout, block).diff!(**kwargs)
+      end
+    end
+
+    def self.synchronize_with_retry(session, timeout, errors)
+      interval = session.config.default_retry_interval
+      timer = Capybara::Helpers.timer(expire_in: timeout)
+      begin
+        yield
+      rescue *errors => e
+        raise e if timer.expired?
+        sleep interval
+        retry
       end
     end
 
@@ -27,6 +40,8 @@ module Chop
 
     attr_accessor :header_transformations, :transformations
 
+    attr_accessor :regex_templates_enabled, :regex_fields
+
     def initialize selector = nil, table = nil, session = Capybara.current_session, timeout = Capybara.default_max_wait_time, block = nil, &other_block
       super
       self.selector ||= default_selector
@@ -66,6 +81,13 @@ module Chop
       transformations << block
     end
 
+    # Enable embedded-regex templates within cells.
+    # Optionally restrict application to specific fields (by header name or 1-based index).
+    def regex *fields
+      self.regex_templates_enabled = true
+      self.regex_fields = fields unless fields.empty?
+    end
+
     def hash_transformation &block
       transformation do |rows|
         header = rows[0]
@@ -143,6 +165,9 @@ module Chop
       actual = to_a
       # FIXME should just delegate to Cucumber's #diff!. Cucumber needs to handle empty tables better.
       if !cucumber_table.raw.flatten.empty? && !actual.flatten.empty?
+        if regex_templates_enabled
+          cucumber_table = Chop::RegexTemplates.apply(cucumber_table, actual, regex_fields)
+        end
         cucumber_table.diff! actual, **kwargs
       elsif cucumber_table.raw.flatten != actual.flatten
         raise Cucumber::MultilineArgument::DataTable::Different.new(cucumber_table)

data/lib/chop/regex_templates.rb

@@ -0,0 +1,97 @@
+module Chop
+  module RegexTemplates
+    TOKEN = /
+      (?<!\\)       # not preceded by backslash
+      \#\{          # start of token
+      \/            # opening slash
+      (.*?)         # pattern (non-greedy)
+      \/            # closing slash
+      ([imx]*)      # optional flags
+      \}            # end of token
+    /mx
+
+    module_function
+
+    def apply(cucumber_table, actual, fields)
+      allowed_columns = columns_for(fields, cucumber_table.raw.first)
+
+      expected = cucumber_table.raw.map.with_index do |row, i|
+        row.map.with_index do |cell, j|
+          str = cell.to_s
+          # De-escape literal token markers so \#{/.../} becomes literal '#{...}'
+          deescaped = str.gsub('\\#{', '#{')
+
+          if allowed?(allowed_columns, j) && deescaped.include?('#{') && deescaped.match?(TOKEN)
+            regex = expand_template(deescaped)
+            actual_cell = (actual.dig(i, j) || "").to_s
+            if regex.match?(actual_cell)
+              actual_cell
+            else
+              deescaped
+            end
+          else
+            deescaped
+          end
+        end
+      end
+
+      Cucumber::MultilineArgument::DataTable.from(expected)
+    end
+
+    def columns_for(fields, expected_header)
+      return :all if fields.nil? || fields.empty?
+
+      idxs = []
+
+      fields.each do |f|
+        case f
+        when Integer
+          idxs << (f - 1)
+        when Symbol, String
+          next unless expected_header
+          normalized = f.to_s.parameterize.underscore
+          header_keys = expected_header.map.with_index do |text, idx|
+            t = text.to_s
+            key = t.parameterize.underscore
+            key = t if key.blank? && t.present?
+            key = (idx + 1).to_s if key.blank?
+            key
+          end
+          header_keys.each_with_index do |key, idx|
+            idxs << idx if key == normalized
+          end
+        end
+      end
+
+      idxs.uniq
+    end
+
+    def allowed?(allowed_columns, j)
+      return true if allowed_columns == :all
+      allowed_columns.include?(j)
+    end
+
+    def expand_template(str)
+      parts = []
+      last = 0
+
+      str.to_enum(:scan, TOKEN).each do
+        m = Regexp.last_match
+        literal = str[last...m.begin(0)]
+        parts << Regexp.escape(literal)
+        pattern, flags = m.captures
+        if flags.to_s.empty?
+          parts << "(?:#{pattern})"
+        else
+          parts << "(?#{flags}:#{pattern})"
+        end
+        last = m.end(0)
+      end
+
+      tail = str[last..-1] || ""
+      parts << Regexp.escape(tail)
+
+      Regexp.new("\\A(?:#{parts.join})\\z")
+    end
+  end
+end

data/lib/chop/version.rb

@@ -1,3 +1,3 @@
 module Chop
-  VERSION = "0.35.2"
+  VERSION = "0.36.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chop
 version: !ruby/object:Gem::Version
-  version: 0.35.2
+  version: 0.36.1
 platform: ruby
 authors:
 - Micah Geisel
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-09-03 00:00:00.000000000 Z
+date: 2025-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -153,6 +153,7 @@ files:
 - lib/chop/diff.rb
 - lib/chop/dsl.rb
 - lib/chop/form.rb
+- lib/chop/regex_templates.rb
 - lib/chop/table.rb
 - lib/chop/unordered_list.rb
 - lib/chop/version.rb
@@ -160,7 +161,7 @@ homepage: http://github.com/botandrose/chop
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -175,8 +176,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.6
-signing_key: 
+rubygems_version: 3.4.19
+signing_key:
 specification_version: 4
 summary: Slice and dice your cucumber tables with ease!
 test_files: []