minitest-holdify 1.0.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a833738964de4fd5b67fbb6c68a1238e62077ed8716c4c37016e430234280a9
-  data.tar.gz: bf3e156990631e915295f4109b3bacd6f3e4553e3f155a5d0559ea9172421e42
+  metadata.gz: c91100bb90de5695419fdb279520529462f67f37d2e580ce6d61c496cf43cbcb
+  data.tar.gz: 48b9d63b74bdea68de55c7a2790e8fb1fef59dc1eb956bce96b02d7ef0b141b3
 SHA512:
-  metadata.gz: 7cdf43d2f02bbf34a5011d8808b27d0ca8ec1f9619d7c1caefc01a9e8b68f4176bd7ff1cfe5c301ec93d9176925c9ea2033374f7753b57b629846c4c69abc2aa
-  data.tar.gz: a1db8f0d6d12bf7b68fca7144a073dfc6ad55676452bb187003c9c4dced2a6a910db9156cb86eadd2b393859a5f7a12ddc0845b783a0094e750994a24c29823c
+  metadata.gz: c17c6cfea957cbad41b2f272da130226a1c878546b46559ec80ccb1f939cb8c395c3b91a91e98ada8a1760bf3b661568364f6ca22f2e34ac957961c6011b4a40
+  data.tar.gz: 89f7c53a3ae05ef7e302efff24398e1579067d246a913c2ca91029185e08af9d8b4dae35da3a6686def351ce6fa89b0b9da1a34d388526dfa1455f5a5950e170

data/lib/holdify/hold.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Holdify
+  # The *_hold statement (Assertion/Expectation)
+  class Hold
+    attr_reader :forced
+
+    def initialize(test)
+      @test    = test
+      @path,   = test.method(test.name).source_location
+      @store   = Holdify.stores[@path] ||= Store.new(@path)
+      @session = Hash.new { |h, k| h[k] = [] } # { lineno => [values] }
+      @forced  = []                            # [ "file:lineno" ]
+      @added   = []                            # [ "file:lineno" ]
+      @index   = {}                            # { lineno => index }
+      @counts  = Hash.new(0)                   # { id => count }
+    end
+
+    def call(actual, force: false)
+      location = find_location
+      lineno   = location.lineno
+      id       = @store.id_at(lineno)
+      raise "Could not find holdify statement at line #{lineno}" unless id
+
+      unless @index.key?(lineno)
+        @index[lineno] = @counts[id]
+        @counts[id] += 1
+      end
+      index = @index[lineno]
+
+      @session[lineno] << actual
+      @forced << "#{location.path}:#{lineno}" if force
+
+      return actual if force || Holdify.reconcile
+
+      stored = @store.stored(id, index)
+      index  = @session[lineno].size - 1
+      return stored[index] if stored && index < stored.size
+
+      @added << "#{location.path}:#{lineno}"
+      actual
+    end
+
+    def save
+      return unless @test.failures.empty?
+
+      @added.each { |loc| warn "[holdify] Held new value for #{loc}" } unless Holdify.quiet
+      @session.each do |lineno, values|
+        id    = @store.id_at(lineno)
+        index = @index[lineno]
+        @store.update(lineno, id, values, index)
+      end
+      @store.save
+    end
+
+    def find_location
+      caller_locations.find do |location|
+        next unless location.path == @path
+
+        label = location.base_label
+        label == @test.name || label == '<top (required)>' || label == '<main>' || label.start_with?('<class:', '<module:')
+      end
+    end
+  end
+end

data/lib/holdify/pretty.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'tempfile'
+require 'open3'
+
+module Holdify
+  # Generates a pretty diff using git
+  module Pretty
+    RESET    = "\e[0m"
+    RED_FG   = "\e[31m"
+    GREEN_FG = "\e[32m"
+
+    G_BASE = "\e[100m #{RESET} ".freeze
+    G_EXP  = "\e[41m\e[97m\e[1m-#{RESET} ".freeze
+    G_ACT  = "\e[42m\e[97m\e[1m+#{RESET} ".freeze
+
+    class << self
+      def call(expected, actual)
+        exp_file = create_tempfile(expected)
+        act_file = create_tempfile(actual)
+
+        cmd = %W[git diff --no-index --word-diff=porcelain --unified=1000 #{exp_file.path} #{act_file.path}]
+        stdout, _stderr, _status = Open3.capture3(*cmd)
+
+        return nil if stdout.empty?
+
+        format(stdout)
+      rescue Errno::ENOENT
+        nil
+      ensure
+        exp_file&.close!
+        act_file&.close!
+      end
+
+      private
+
+      def format(diff)
+        lines = diff.lines.map(&:chomp)
+        start = lines.index { |l| l.start_with?('@@') }
+        return nil unless start
+
+        output  = ["#{G_EXP}#{RED_FG}Held (Expected)#{RESET}", "#{G_ACT}#{GREEN_FG}Current (Actual)#{RESET}"]
+        exp_buf = +''
+        act_buf = +''
+
+        lines[(start + 1)..].each do |line|
+          char = line[0]
+          text = line[1..]
+
+          # :nocov:
+          case char
+          # :nocov:
+          when ' '
+            exp_buf << text
+            act_buf << text
+          when '-'
+            exp_buf << RED_FG << text << RESET
+          when '+'
+            act_buf << GREEN_FG << text << RESET
+          when '~'
+            flush_buffers(output, exp_buf, act_buf)
+            exp_buf.clear
+            act_buf.clear
+          end
+        end
+
+        flush_buffers(output, exp_buf, act_buf) unless exp_buf.empty? && act_buf.empty?
+
+        output.join("\n")
+      end
+
+      def flush_buffers(output, exp, act)
+        if exp == act
+          output << "#{G_BASE}#{exp}"
+        else
+          output << "#{G_EXP}#{exp}"
+          output << "#{G_ACT}#{act}"
+        end
+      end
+
+      def create_tempfile(obj)
+        Tempfile.new(%w[holdify .yaml]).tap do |file|
+          file.write(YAML.dump(obj, line_width: 78)) # Ensure 80 columns (including gutter)
+          file.flush
+        end
+      end
+    end
+  end
+end

data/lib/holdify/store.rb

@@ -2,8 +2,9 @@
 
 require 'yaml'
 require 'fileutils'
+require 'digest/sha1'
 
-class Holdify
+module Holdify
   # A simple Hash-based store that syncs with a static source map
   class Store
     def initialize(source_path)
@@ -16,38 +17,52 @@ class Holdify
         @source[lineno] = Digest::SHA1.hexdigest(content) unless content.empty?
       end
 
+      @index = Hash.new { |h, k| h[k] = [] }                              # { id => ["L123 id", "L124 id"] }
       @data  = (File.exist?(@path) && YAML.unsafe_load_file(@path)) || {} # { key => [values] }
-      @index = {} # { id => "L123 id" }
 
-      valid_ids = @source.values
-      @data.keep_if do |key, _|
-        id = key.split.last
-        next false unless valid_ids.include?(id)
-
-        @index[id] = key
-        true
-      end
+      organize_data
     end
 
-    def id_at(lineno) = @source[lineno]
-    def stored(id)    = @data[@index[id]]
+    def id_at(lineno)     = @source[lineno]
+    def stored(id, index) = @data[@index[id][index]]
 
     # Overwrite the entry for a given ID with a new list of values
-    def update(id, values)
-      new_key = "L#{@source.key(id)} #{id}"
-      old_key = @index[id]
+    def update(lineno, id, values, index)
+      new_key = "L#{lineno} #{id}"
+      old_key = @index[id][index]
       @data.delete(old_key) if old_key && old_key != new_key
-      @data[@index[id] = new_key] = values
+      @data[new_key] = values
+      @index[id][index] = new_key
     end
 
     def save
       return FileUtils.rm_f(@path) if @data.empty?
 
       sorted  = @data.sort_by { |k, _| k[/\d+/].to_i }.to_h
-      content = YAML.dump(sorted, line_width: -1)
+      content = YAML.dump(sorted, line_width: 78)
       return if File.exist?(@path) && File.read(@path) == content
 
       File.write(@path, content)
     end
+
+    private
+
+    def organize_data
+      source_counts = @source.values.tally
+      sorted_keys   = @data.keys.sort_by { |k| k[/\d+/].to_i }
+
+      sorted_keys.each do |key|
+        id = key.split.last
+        next unless source_counts[id]
+
+        if @index[id].size < source_counts[id]
+          @index[id] << key
+        else
+          @data.delete(key)
+        end
+      end
+
+      @data.keep_if { |key, _| source_counts[key.split.last] }
+    end
   end
 end

data/lib/holdify.rb

@@ -1,69 +1,24 @@
 # frozen_string_literal: true
 
-require 'digest/sha1'
 require_relative 'holdify/store'
+require_relative 'holdify/hold'
 
 # Add description
-class Holdify
-  VERSION = '1.0.2'
+module Holdify
+  VERSION = '1.1.0'
   CONFIG  = { ext: '.yaml' }.freeze
 
   class << self
     attr_accessor :reconcile, :quiet
+    attr_writer :pretty
 
     def stores = @stores ||= {}
-  end
-
-  attr_reader :forced
-
-  def initialize(test)
-    @test    = test
-    @path,   = test.method(test.name).source_location
-    @store   = self.class.stores[@path] ||= Store.new(@path)
-    @session = Hash.new { |h, k| h[k] = [] }
-    @forced  = []
-  end
-
-  def hold(actual, force: false)
-    location = find_location
-    id       = @store.id_at(location.lineno)
-    raise "Could not find holdify statement at line #{location.lineno}" unless id
-
-    @session[id] << actual
-    @forced << "#{location.path}:#{location.lineno}" if force
-
-    return actual if force || self.class.reconcile
-
-    stored = @store.stored(id)
-    index  = @session[id].size - 1
-    return stored[index] if stored && index < stored.size
-
-    # :nocov:
-    warn "[holdify] Held new value for #{location.path}:#{location.lineno}" unless self.class.quiet
-    # :nocov:
-    actual
-  end
-
-  def save
-    return unless @test.failures.empty?
-
-    @session.each { |id, values| @store.update(id, values) }
-    @store.save
-  end
-
-  def find_location
-    caller_locations.find do |location|
-      next unless location.path == @path
 
-      label = location.base_label
-      # :nocov:
-      label = ::Regexp.last_match(1) if label.start_with?('block ') && label =~ / in (.+)$/
-      # :nocov:
+    def pretty
+      return @pretty unless @pretty.nil?
 
-      label == @test.name ||
-        label == '<top (required)>' ||
-        label == '<main>' ||
-        label.start_with?('<class:', '<module:')
+      @pretty = $stdout.tty? && !ENV.key?('NO_COLOR') && ENV['TERM'] != 'dumb' &&
+                system('git --version', out: File::NULL, err: File::NULL)
     end
   end
 end

data/lib/minitest/holdify_plugin.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'holdify'
+require 'holdify/pretty'
 
 # Implement the minitest plugin
 module Minitest
@@ -10,30 +11,25 @@ module Minitest
       Holdify.reconcile = true
       Holdify.quiet     = true
     end
-    # :nocov:
     opts.on '--holdify-quiet', 'Skip the warning on storing a new value' do
       Holdify.quiet = true
     end
-    # :nocov:
+    opts.on '--holdify-pretty', 'Format the stored values with pretty print' do
+      Holdify.pretty = true
+    end
   end
 
   # Reopen the minitest class
   class Test
-    # Create the @holdify instance for each test
-    def after_setup
-      super
-      @holdify ||= Holdify.new(self)   # rubocop:disable Naming/MemoizedInstanceVariableName
-    end
-
     # Ensure store is tidied and saved after the test runs
     def before_teardown
       super
-      @holdify&.save
-      return unless @holdify&.forced&.any? && failures.empty?
+      @hold&.save
+      return unless @hold&.forced&.any? && failures.empty?
 
       msg = <<~MSG.chomp
         [holdify] the value has been stored: remove the "!" suffix to pass the test
-        #{@holdify.forced.uniq.map { |l| "  #{l}" }.join("\n")}
+        #{@hold.forced.uniq.map { |l| "  #{l}" }.join("\n")}
       MSG
       raise Minitest::Assertion, msg
     end
@@ -42,38 +38,47 @@ module Minitest
   # Reopen the minitest module
   module Assertions
     # Main assertion
-    def assert_hold(actual, *args)
-      @holdify ||= Holdify.new(self)
+    def assert_hold(actual, *args, inspect: false, **)
+      @hold ||= Holdify::Hold.new(self)
       assertion, message = args
       assertion, message = message, assertion unless assertion.nil? || assertion.is_a?(Symbol)
+      expected = @hold.(actual, **)
+
+      begin
+        if actual.nil?
+          assert_nil expected, message
+        else
+          send(assertion || :assert_equal, expected, actual, message)
+        end
+      rescue Minitest::Assertion
+        raise unless Holdify.pretty
+
+        diff = Holdify::Pretty.call(expected, actual)
+        raise unless diff
 
-      expected = @holdify.hold(actual)
-      if actual.nil?
-        assert_nil expected, message
-      else
-        send(assertion || :assert_equal, expected, actual, message)
+        msg = message ? "#{message}\n#{diff}" : diff
+        raise Minitest::Assertion, msg
       end
+
+      if inspect
+        location = @hold.find_location
+        warn "[holdify] The value from #{location.path}:#{location.lineno} is:\n[holdify] => #{actual.inspect}"
+      end
+
+      expected
     end
 
     # Temporarily used to store the actual value, useful for reconciliation of expected changed values
-    def assert_hold!(actual, *)
-      @holdify ||= Holdify.new(self)
-      @holdify.hold(actual, force: true)
-    end
+    def assert_hold!(*, **) = assert_hold(*, **, force: true)
 
     # Temporarily used for development feedback to print to STDERR the actual value
-    def assert_hold_?(actual, *)
-      @holdify ||= Holdify.new(self)
-      location = @holdify.find_location
-      warn "[holdify] Actual value from: #{location.path}:#{location.lineno}\n=> #{actual.inspect}"
-      @holdify.hold(actual)
-    end
+    def assert_hold?(*, **) = assert_hold(*, **, inspect: true)
   end
 
   # Register expectations only if minitest/spec is loaded; ensure the right class in 6.0 and < 6.0
   # :nocov:
   if (expectation_class = defined?(Spec) && (defined?(Expectation) ? Expectation : Expectations))
-    %w[hold hold! hold_?].each do |suffix|
+    %w[hold hold! hold?].each do |suffix|
       expectation_class.infect_an_assertion :"assert_#{suffix}", :"must_#{suffix}", :reverse
       expectation_class.alias_method :"to_#{suffix}", :"must_#{suffix}"
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minitest-holdify
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.0
 platform: ruby
 authors:
 - Domizio Demichelis
@@ -33,6 +33,8 @@ extra_rdoc_files: []
 files:
 - LICENSE.txt
 - lib/holdify.rb
+- lib/holdify/hold.rb
+- lib/holdify/pretty.rb
 - lib/holdify/store.rb
 - lib/minitest-holdify.rb
 - lib/minitest/holdify_plugin.rb
@@ -58,7 +60,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Hardcoded values suck! Holdify them.
 test_files: []