chop 0.35.2 → 0.36.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88bedb7f454adc2966b82d3c5748b88ca81498d6de9f46de02f5ee0256b9c641
-  data.tar.gz: a727470df4d49a8f170724367891caa6f8cd380ef637af75f867b5666924163b
+  metadata.gz: 8af1c5a00064df8f6b191c22e8724dcea6f4be1cf6ba940d7976a316efdd9b18
+  data.tar.gz: 4c04d4ec5e3ef08fad6f2b7b4534bd182d353427f630526d40d3b2987a7c2912
 SHA512:
-  metadata.gz: aa9383445e2c7333c58a107a00c570b20c3bc4f59e47a1b08bbc55682af675af05f9af0a45c61821e04142f99fe6c9a2244ff6c8fa4ab554d77ef5eb2f1e102d
-  data.tar.gz: 2c1b982d7f1a30cf2a2603927e98cb32b496efbe8c6eb83f3e5c14434f1a8061c33f42a5d50b882e914d55f80c9bd18cadfd4e51a66126f5bfd08bc4a6aa49cd
+  metadata.gz: 75c8391e2783ca33dbe20f19e8a0cb0d4f46923c36ea3a0941d4a726f93817b89abcf3c0f33ff2fa40f3a5a8aeaf7eea3bfea563b0453e513360c7c0634659cf
+  data.tar.gz: fbd050596b406cd0624e1dd20daf058c713251604103685d678a5a7fd652445fd1f91239dcb901104e7e38f3c8a1cfe302a70c63f0d2d1d5bf2544aac3c3faa2

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,6 +2,7 @@ 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)
@@ -27,6 +28,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 +69,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 +153,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.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chop
 version: !ruby/object:Gem::Version
-  version: 0.35.2
+  version: 0.36.0
 platform: ruby
 authors:
 - Micah Geisel
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-09-03 00:00:00.000000000 Z
+date: 2025-11-06 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