rematch 4.1.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75263525e5c9f837c2308c800c6ddd0fa8efa1472dc32aaca3eab36d4ba20990
-  data.tar.gz: 734123f5f1ea481c6d1d8c31cddfa074483e5dbd7289e6f8965f33a724b0eb46
+  metadata.gz: 0e4d3db4927ef94c29b221307dd31182497a8c8b0fa8ab4776f7117effb1ea87
+  data.tar.gz: 0b96c12e598d65cb1b76198f1a0a962eb02b41e4cc1d86baaa8850afbf67fc44
 SHA512:
-  metadata.gz: 3c54c23fd47f85a99f53c3d7deead137ce5b5fcfaa2559ce957c440f2f142246091fde3aa1b6a0407029377519f28751c45ce0f42a8abd02c035843121a857d3
-  data.tar.gz: d3f5337a74934922e9d889564dc67f18be1a7371a2c24df4699cedb764df30c5278cca25b7872192235c4b4a93b4f044cfbe6393ef4e12bcfa769d7f06dda3bd
+  metadata.gz: bb9d8b792ae087b2e555f5d2260ab27ef795117d5636dc3d328a9abbf481bcbab4bc34100527bbf37ecab3df85fe961420a58f97f5ee0a44cd8d60d0839fd1ce
+  data.tar.gz: e6626b52c71bb840b320b99399bb601c6ad0650e63007b47a66e884a87caf7b2dceeb2c7ed3a82642f75c47a7b3c3a242a0a29d28e785b18b6c95253b038f1a8

data/lib/minitest/rematch_plugin.rb

@@ -24,32 +24,32 @@ module Minitest
       super
       @rematch = Rematch.new(self)
     end
+
+    # Ensure store is tidied and saved after the test runs
+    def before_teardown
+      super
+      @rematch&.save
+    end
   end
 
   # Reopen the minitest module
   module Assertions
     # Main assertion
     def assert_rematch(actual, *args)
-      # Extract options (id) if present
-      opts      = args.last.is_a?(Hash) && args.last.key?(:id) ? args.pop : {}
-      id        = opts[:id]
-      assertion = :assert_equal
-      message   = nil
-      args.each { |arg| arg.is_a?(Symbol) ? assertion = arg : message = arg }
-      if actual.nil?   # use specific assert_nil after deprecation of assert_equal nil
-        assert_nil @rematch.rematch(actual, id: id), message
-      else
-        # assert that the stored value is the same actual value
-        send assertion, @rematch.rematch(actual, id: id), actual, message
+      label = Rematch.extract_label(args)
+      assertion, message = args
+      assertion, message = message, assertion unless assertion.nil? || assertion.is_a?(Symbol)
+      if actual.nil? # use specific assert_nil after deprecation of assert_equal nil
+        assert_nil @rematch.rematch(actual, label:), message
+      else # assert that the stored value is the same actual value
+        send assertion || :assert_equal, @rematch.rematch(actual, label:), actual, message
       end
     end
 
     # Temporarily used to store the actual value, useful for reconciliation of expected changed values
     def store_assert_rematch(actual, *args)
-      opts = args.last.is_a?(Hash) && args.last.key?(:id) ? args.pop : {}
-      id   = opts[:id]
-
-      @rematch.rematch(actual, overwrite: true, id: id)
+      label = Rematch.extract_label(args)
+      @rematch.rematch(actual, overwrite: true, label:)
       # Always fail after storing, forcing the restore of the original assertion/expectation
       raise Minitest::Assertion, '[rematch] the value has been stored: remove the "store_" prefix to pass the test'
     end

data/lib/rematch/source.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require 'ripper'
+require 'digest/sha1'
+
+class Rematch
+  # Parses a Ruby source file to statically identify the context (path) and content of every line.
+  class Source
+    attr_reader :index
+
+    REMATCH_METHODS = %w[assert_rematch store_assert_rematch
+                         must_rematch to_rematch store_must_rematch store_to_rematch].freeze
+    IGNORED_TOKENS  = (REMATCH_METHODS + %w[expect value _]).freeze
+    DOT_TOKENS      = ['.', '&.'].freeze
+
+    def initialize(source)
+      @source   = source
+      @lines    = source.lines
+      @index    = Hash.new { |h, k| h[k] = [] } # { lineno => [id1, id2, ...] }
+      @context  = [] # Context stack
+      @contexts = {} # { lineno => context_array }
+      if (sexp = Ripper.sexp(@source))
+        walk(sexp)
+        build_index
+      end
+    end
+
+    private
+
+    def walk(node)
+      return unless node.is_a?(Array)
+
+      if (lineno = extract_line(node))
+        @contexts[lineno] ||= @context.dup
+      end
+      case node.first
+      when :class, :module
+        name = extract_name(node[1])
+        @context.push(name)
+        walk(node.last)
+        @context.pop
+      when :def
+        name = node[1][1]
+        @context.push(name)
+        walk(node[3]) # body
+        @context.pop
+      when :method_add_block
+        handle_block(node)
+      else
+        node.each { |child| walk(child) }
+      end
+    end
+
+    def handle_block(node)
+      call_node   = node[1]
+      block_node  = node[2]
+      method_name = extract_method_name(call_node)
+      if %w[describe context it specify].include?(method_name)
+        description = extract_arg_string(call_node)
+        @context.push(description)
+        walk(block_node)
+        @context.pop
+      else
+        walk(call_node)
+        walk(block_node)
+      end
+    end
+
+    def build_index
+      @lines.each_with_index do |line_content, i|
+        lineno = i + 1
+        tokens = tokenize(line_content)
+        next if tokens.empty?
+
+        context = @contexts[lineno] || [] # Use recorded context or fallback to empty (top-level)
+        @index[lineno] << Digest::SHA1.hexdigest("#{context.join('/')}#{tokens}")
+      end
+    end
+
+    def tokenize(line_content)
+      raw_tokens = Ripper.lex(line_content).reject { |t| t[1] == :on_comment || t[1] =~ /sp|nl/ }
+      tokens     = []
+      raw_tokens.each_with_index do |t, i|
+        token = t[2]
+        if DOT_TOKENS.include?(token)
+          next_token = raw_tokens[i + 1]
+          next if next_token && REMATCH_METHODS.include?(next_token[2]) # Ignore dot if rematch
+        end
+        next if IGNORED_TOKENS.include?(token)
+
+        tokens << token
+      end
+      tokens.join
+    end
+
+    # --- Extractors ---
+
+    def extract_line(node)
+      # Terminals like [:@ident, "name", [line, col]]
+      node.last[0] if node.first.is_a?(Symbol) &&
+                      node.first.to_s.start_with?('@') &&
+                      node.last.is_a?(Array) &&
+                      node.last.size == 2
+    end
+
+    def extract_name(node)
+      return '' unless node.is_a?(Array)
+
+      case node.first
+      when :const_path_ref then "#{extract_name(node[1])}::#{extract_name(node[2])}"
+      when :var_ref, :const_ref then extract_name(node[1])
+      when :call then "#{extract_name(node[1])}.#{extract_name(node[3])}"
+      when :@const, :@ident, :@op then node[1]
+      else 'Unknown'
+      end
+    end
+
+    def extract_method_name(node)
+      return nil unless node.is_a?(Array)
+
+      case node.first
+      when :command, :fcall then node[1][1]
+      when :call, :command_call then node[3][1]
+      when :method_add_arg, :method_add_block then extract_method_name(node[1])
+      end
+    end
+
+    def extract_arg_string(node)
+      args_node = case node.first
+                  when :command, :command_call then node[2]
+                  when :method_add_arg, :method_add_block then node[1][2]
+                  end
+
+      return 'anonymous' if args_node.nil? || args_node.empty?
+
+      args_list = args_node.first == :args_add_block ? args_node[1] : args_node
+      return 'anonymous' if args_list.nil? || args_list.empty?
+
+      arg = args_list.first
+      return 'anonymous' unless arg
+
+      case arg.first
+      when :string_literal
+        content_node = arg[1]
+        if content_node&.first == :string_content
+          content_node[1..].map { |p| p[1] if p.is_a?(Array) && p.first == :@tstring_content }.join
+        else
+          ''
+        end
+      when :symbol_literal
+        begin
+          arg[1][1][1]
+        rescue StandardError
+          'unknown_sym'
+        end
+      else extract_name(arg)
+      end
+    rescue StandardError
+      'unknown_arg'
+    end
+  end
+end

data/lib/rematch/store.rb

@@ -1,13 +1,45 @@
 # frozen_string_literal: true
 
-require 'yaml/store'
+require 'yaml'
 
 class Rematch
-  # Subclass of YAML::Store
-  class Store < YAML::Store
-    # Use unsafe load, because tests are trusted content
-    def load(content)
-      YAML.unsafe_load(content) || {}
+  # A simple Hash-based store that syncs with a static source map
+  class Store
+    attr_reader :path
+
+    def initialize(path, source_ids)
+      @path    = path
+      @entries = (File.exist?(path) && YAML.unsafe_load_file(path)) || {}
+      # Prune dead keys (id not present ANYWHERE in the current source)
+      @entries.select! { |key, _| source_ids.include?(key.split.last) }
+      # Build Index: id => [key1, key2...] (FIFO queue for duplicates)
+      @index = Hash.new { |h, k| h[k] = [] }
+      @entries.each_key { |key| @index[key.split.last] << key }
+      # Order the index queues by lineno to ensure FIFO claiming
+      @index.each_value { |keys| keys.sort_by! { |k| order_by_lineno(k) } }
+    end
+
+    def pull(id)    = @index[id].shift      # Remove and return the first key from the index id
+    def delete(key) = @entries.delete(key)
+    def [](key)     = @entries[key]
+
+    def []=(key, value)
+      @entries[key] = value
+    end
+
+    def save
+      return FileUtils.rm_f(@path) if @entries.empty?
+
+      sorted  = @entries.sort_by { |k, _| order_by_lineno(k) }.to_h
+      content = YAML.dump(sorted, line_width: -1)
+      return if File.exist?(@path) && File.read(@path) == content  # Return if unchanged (preserves mtime)
+
+      File.write(@path, content)
     end
+
+    private
+
+    # Order by L<num> and .<count> suffix
+    def order_by_lineno(key) = [key[/L(\d+)/, 1].to_i, key[/L\d+\.(\d+)/, 1].to_i]
   end
 end

data/lib/rematch.rb

@@ -1,22 +1,23 @@
 # frozen_string_literal: true
 
 require 'fileutils'
-require 'digest/sha1'
+require 'yaml'
+require_relative 'rematch/source'
 require_relative 'rematch/store'
 
-# Handles the key/value store for each test
+# Handles the key/value store for each test file
 class Rematch
-  VERSION = '4.1.0'
+  VERSION = '5.0.0'
   CONFIG  = { ext: '.yaml' }  # rubocop:disable Style/MutableConstant
 
-  @rebuild      = false  # rebuild the store?
-  @rebuilt      = []     # paths already rebuilt
+  @rebuild      = false
+  @rebuilt      = []
   @skip_warning = false
+  @cache        = {} # Cache per file path: { source: Source, store: Store }
 
   class << self
-    attr_accessor :rebuild, :skip_warning
+    attr_accessor :rebuild, :skip_warning, :cache
 
-    # Check whether path requires rebuild and do it if required
     def check_rebuild(path)
       return unless @rebuild && !@rebuilt.include?(path)
 
@@ -24,72 +25,55 @@ class Rematch
       @rebuilt << path
       puts "Rebuilt #{path}"
     end
-  end
 
-  # Instantiated at each test, stores the path and the unique id of the test being run
-  def initialize(test)
-    @path      = test.method(test.name).source_location.first
-    store_path = "#{@path}#{CONFIG[:ext]}"
-    self.class.check_rebuild(store_path)
-    @store     = Store.new(store_path, true)
-    @id        = test_uid(test.class.name, test.name)
-  end
+    # Utility used by the plugin to extract label from args (kept for compatibility)
+    def extract_label(args) = ((args.last.is_a?(Hash) && args.last.key?(:label) && args.pop) || {})[:label]
 
-  # Retrieve the stored value for the current assertion if its key is known; store the value otherwise
-  def rematch(value, overwrite: nil, id: nil)
-    key = assertion_key(id)
-    @store.transaction do |s|
-      if s.root?(key) && !overwrite       # there is the key and not overwrite
-        s[key]                            # return it
-      else                                # no such key or overwrite
-        s[key] = value                    # set it
-        tidy_store(s)                     # sort keys and cleanup orphans
-        store_warning(key) unless overwrite
-        value
-      end
-    end
-  end
-
-  def store_warning(key)
-    warn "Rematch stored new value for: #{key.inspect}\n#{@store.path}\n\n" unless Rematch.skip_warning
-  end
+    # Get source and store for the test file (cached because invoked for every test in the file)
+    def environment(path)
+      return cache[path] if cache[path]
 
-  protected
+      store_path = "#{path}#{CONFIG[:ext]}"
+      check_rebuild(store_path)
 
-  # Generate the unique id for the test (SHA1)
-  def test_uid(class_name, method_name)
-    Digest::SHA1.hexdigest("#{class_name}#{method_name}")
+      source      = Source.new(File.read(path))
+      source_ids  = source.index.values.flatten.to_set
+      store       = Store.new(store_path, source_ids)
+      cache[path] = { source: source, store: store }
+    end
   end
 
-  private
-
-  # Generate the key based on the line number, optional id, and test ID
-  def assertion_key(id)
-    line = caller_locations.find { |l| l.path == @path }&.lineno
-    %(L#{line}#{" [#{id}]" if id} #{@id})
+  def initialize(test)
+    @path   = test.method(test.name).source_location.first
+    @env    = self.class.environment(@path)
+    @counts = Hash.new(0) # Track rematch counts per line
   end
 
-  # Ensure the keys are sorted by the order of the tests in the file
-  # and remove keys that do not match any existing test (orphans)
-  def tidy_store(store)
-    # Optimization: only if Minitest is loaded
-    return unless defined?(Minitest::Runnable)
-
-    # Get all valid SHA1s from all runnables in this file
-    valid_ids = []
-    Minitest::Runnable.runnables.each do |runnable|
-      runnable.runnable_methods.each do |method_name|
-        file, = runnable.instance_method(method_name).source_location
-        next unless file == @path # @path is the test file path
-
-        valid_ids << test_uid(runnable.name, method_name)
-      end
+  # Retrieves the stored value for the current assertion, updating the store if the key is new or moved.
+  def rematch(value, overwrite: nil, label: nil)
+    lineno = caller_locations.find { |l| l.path == @path }&.lineno
+    ids    = @env[:source].index[lineno]
+    raise "Rematch Error: No code detected at #{@path}:#{lineno}. Please check syntax." if ids.empty? # never happen
+
+    count   = (@counts[lineno] += 1)
+    id      = ids[(count - 1) % ids.size]
+    new_key = %(L#{lineno}#{".#{count}" if count > 1}#{" [#{label}]" if label} #{id})
+    store   = @env[:store]
+    old_key = store.pull(id)
+    if old_key && old_key != new_key  # Reconcile Move first to ensure clean state
+      store[new_key] = store.delete(old_key)
+      old_key        = new_key   # Normalize so we only check the verwrite logic below
+    end
+    case
+    when !old_key
+      warn "Rematch stored new value generated by: #{@path}:#{lineno}\n" unless overwrite || self.class.skip_warning
+      store[new_key] = value
+    when overwrite
+      store[new_key] = value
+    else
+      store[new_key]
     end
-    # Extract all data
-    data = store.roots.to_h { |key| [key, store.delete(key)] }
-    # Re-add data in the correct order, filter orphans, and sort
-    data.select { |key, _| valid_ids.include?(key.split.last) }
-        .sort_by { |key, _| key[/L(\d+)/, 1].to_i }
-        .each { |key, value| store[key] = value }
   end
+
+  def save = @env[:store].save
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rematch
 version: !ruby/object:Gem::Version
-  version: 4.1.0
+  version: 5.0.0
 platform: ruby
 authors:
 - Domizio Demichelis
@@ -49,6 +49,7 @@ files:
 - LICENSE.txt
 - lib/minitest/rematch_plugin.rb
 - lib/rematch.rb
+- lib/rematch/source.rb
 - lib/rematch/store.rb
 homepage: https://github.com/ddnexus/rematch
 licenses: