minitest-holdify 1.1.3 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7560a67982ab6acf747a90307f0fc5fca6ff30c4675aefaf92c973afaa01fe65
-  data.tar.gz: 928f88bd3d8711d13817c924a5c587117e9e61d1cb3a7301b2a097f7cfafb95a
+  metadata.gz: b2fecbc870f5205d62da0200a806adc5dc5d47b99a81e53c1af4d50f3f8aaa21
+  data.tar.gz: 06aed82a631a3632c531ef311a53f89e339a00d122fbc75eb31c52f1723e8d24
 SHA512:
-  metadata.gz: b2cb240ed6c9d90797003b00508b4640d694617b78661fd8ff59a7533eb771a58e12d1f24024cf09d71224c490446c92f325b3bc4b0217ee2c2774d3f78ab4f9
-  data.tar.gz: aa038a10daa87f5d4700d7778dd86e75049d06036f2435b769c455b2f4f37e08fac5a21a91d7a375f06a53dda9a5c2ac50858f4e26cdde27e4d2a6732976fa7c
+  metadata.gz: ebd7c7cbf15fc450a1a657affe961399ac916c3d57aafc74a89067638ba2d569c59ea134eecd811361d6970989a227dc6814bc1bec07673ee5ea2ca86ea5f877
+  data.tar.gz: c14c8219c1fbaaf1f10a6f28eef93f4696f71d59020090f85d96afe0ae431fa6a52db0a91d6f37f713ea266a6ef61369589bd85544a70c681f73c1902f0055eb

data/lib/holdify/feedback.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'tempfile'
+require 'open3'
+
+module Holdify
+  # Feedback report on failure
+  class Feedback
+    attr_reader :xxhi_ref
+
+    def initialize(hold, hold_ref, *args)
+      test_lno  = hold.test_loc.lineno
+      index     = hold.session[test_lno].size - 1   # current index
+      xxh       = hold.store.xxh(test_lno)
+      yaml_path = hold.store.path
+
+      @xxhi_ref = "<<< @xxh[i] --> #{xxh}[#{index}]"
+
+      @yaml_lno = find_yaml_lno(yaml_path, test_lno, xxh, index)
+      @yaml_ref = Holdify.relative("#{yaml_path}:#{@yaml_lno}")
+
+      @hold_ref = Holdify.relative(hold_ref)
+      test_ref  = Holdify.relative(hold.test_loc.to_s.sub(/:in .*$/, ''))
+      @test_ref = test_ref unless @hold_ref == test_ref
+
+      @expected, @actual, @message = *args
+
+      # Extend with features
+      extend(Color) if Holdify.color
+      return unless Holdify.git
+
+      extend GitDiff
+      extend(Color::GitDiff) if Holdify.color
+    end
+
+    def message = [@message, xxhi_ref, *file_refs, *diff, ''].join("\n")
+
+    def file_refs
+      ["--- @stored --> #{@yaml_ref}", "+++ @tested --> #{@hold_ref}"].tap do |refs|
+        refs << "            --> #{@test_ref}" if @test_ref
+      end
+    end
+
+    def diff = ["- #{@expected.inspect}", "+ #{@actual.inspect}"]
+
+    private
+
+    def find_yaml_lno(yaml_path, test_lno, xxh, index)
+      found = false
+      count = -1
+      File.foreach(yaml_path).with_index(1) do |line, ln|
+        if found
+          next unless line.start_with?('-')
+
+          count += 1
+          next unless count == index
+
+          return ln
+        else
+          found = line.match(/^L#{test_lno} #{xxh}:$/)
+        end
+      end
+    end
+
+    # Methods enabling the git-diff feedback (no-color)
+    module GitDiff
+      def git_command = "git diff --no-index --no-color --unified=1000 #{@exp_path} #{@act_path}"
+
+      def diff
+        @exp_path = create_tempfile(@expected).path
+        @act_path = create_tempfile(@actual).path
+
+        stdout, = Open3.capture3(git_command)
+        regex   = /\A[^@]*\r?\n/m   # cleanup git headers
+        lines   = stdout.sub(regex, '').split(/\r?\n/)
+
+        process_lines(lines)
+      ensure
+        # :nocov:
+        File.unlink(@exp_path) if @exp_path
+        File.unlink(@act_path) if @act_path
+        # :nocov:
+      end
+
+      def create_tempfile(obj)
+        Tempfile.create.tap do |file|
+          file.write(YAML.dump(obj))
+          file.close
+        end
+      end
+
+      def process_lines(lines)
+        width  = 0
+        lineno = [@yaml_lno - 1]
+        lines.map.with_index do |line, i|
+          if i.zero?            # @@ ... @@
+            w = line.scan(/,(\d+)/).flatten.map(&:to_i).max
+            width = (@yaml_lno + w).to_s.length
+            next line
+          end
+          next if i == 1        # ---
+
+          render_line(line, lineno, width)
+        end.compact
+      end
+
+      def render_line(line, lineno, width)
+        type   = line[0]
+        line   = line[1..]
+        gutter = if type == '+'
+                   ' ' * width
+                 else
+                   lineno[0] += 1
+                   lineno[0].to_s.rjust(width)
+                 end
+
+        "#{type}#{gutter} #{line}"
+      end
+    end
+
+    # Methods enabling ANSI feedback
+    module Color
+      SGR = { clear:   "\e[0m",
+              red:     "\e[31m",
+              green:   "\e[32m",
+              yellow:  "\e[33m",
+              magenta: "\e[35m" }.freeze
+
+      def wrap(color, string) = "#{SGR[color]}#{string}#{SGR[:clear]}"
+
+      def file_refs
+        refs = super
+        [wrap(:red, refs.shift), *refs.map { wrap(:green, _1) }]
+      end
+
+      def diff = [wrap(:red, "- #{@expected.inspect}"), wrap(:green, "+ #{@actual.inspect}")]
+
+      def xxhi_ref = wrap(:magenta, @xxhi_ref)
+
+      # Methods enabling the git-diff ANSI feedback
+      module GitDiff
+        def git_command = "git diff --no-index --color-words='[^ ]+|[ ]+' --unified=1000 #{@exp_path} #{@act_path}"
+
+        def render_line(line, lineno, width)
+          clean   = line.gsub(/\e\[(1|22|0)m/, '').lstrip
+          added   = clean.start_with?(SGR[:green]) && !line.include?(SGR[:red])
+          removed = clean.start_with?(SGR[:red]) && !line.include?(SGR[:green])
+          changed = line.include?(SGR[:red]) || line.include?(SGR[:green])
+
+          type, color = (added && ['+', :green]) || (removed && ['-', :red]) || (changed && ['~', :yellow])
+
+          sgr    = SGR[color].to_s if color
+          gutter = if added
+                     "#{sgr}#{type} #{' ' * width}#{SGR[:clear]}"
+                   else
+                     lineno[0] += 1
+                     "#{sgr}#{type || ' '}#{lineno[0].to_s.rjust(width)}#{SGR[:clear]}"
+                   end
+
+          "#{gutter} #{line}"
+        end
+      end
+    end
+  end
+end

data/lib/holdify/hold.rb

@@ -1,54 +1,60 @@
 # frozen_string_literal: true
 
 module Holdify
-  # The *_hold statement (Assertion/Expectation)
+  # The *_hold Assertion/Expectation
   class Hold
-    attr_reader :forced
+    attr_reader :forced, :store, :test_loc, :session
 
     def initialize(test)
       @test    = test
       @path,   = test.method(test.name).source_location
       @store   = Holdify.stores(@path)
-      @session = Hash.new { |h, k| h[k] = [] } # { line => [values] }
-      @forced  = []                            # [ line ]
-      @added   = []                            # [ line ]
+      @session = Hash.new { |h, k| h[k] = [] } # { lineno => [values] }
+      @forced  = []                            # [ lines ]
+      @added   = []                            # [ lines ]
     end
 
     def call(actual, force: false)
-      location = find_location
-      line     = location.lineno
-      raise "Could not find holdify statement at line #{line}" unless @store.xxh(line)
+      @test_loc = find_test_loc
+      lineno    = @test_loc.lineno
+      raise "Could not find holdify statement at lineno #{lineno}" unless @store.xxh(lineno)
 
-      @forced << line if force
+      @forced << lineno if force
 
-      values = @store.get(line)
-      index  = @session[line].size
+      values = @store.get_values(lineno)
+      index  = @session[lineno].size
       value  = if force || Holdify.reconcile
                  actual
                elsif values && index < values.size
                  values[index]
                else
-                 @added << line
+                 @added << lineno
                  actual
                end
 
-      @session[line] << value
+      @session[lineno] << value
       value
     end
 
     def save
-      @added.each   { |line| warn "[holdify] Held new value for #{@path}:#{line}" } unless Holdify.quiet
-      @session.each { |line, values| @store.set(line, values) }
+      @added.each   { |lineno| warn "[holdify] Held new value for #{Holdify.relative(@path)}:#{lineno}" } unless Holdify.quiet
+      @session.each { |lineno, values| @store.set_values(lineno, values) }
     end
 
-    # Find the location in the test that triggered the hold
-    def find_location
-      caller_locations.find do |location|
+    # Find the triggering LOC inside the test block/method
+    def find_test_loc
+      caller_locations(2).find do |location|
         next unless location.path == @path
 
-        label = location.base_label
+        label  = location.base_label
         label == @test.name || label == '<top (required)>' || label == '<main>' || label.start_with?('<class:', '<module:')
       end
     end
+
+    def warn_for(actual)
+      warn("[holdify] The value from #{Holdify.relative(@test_loc.path)}:#{@test_loc.lineno} is:\n[holdify] => #{actual.inspect}")
+    end
+
+    def feedback(*) = Feedback.new(self, *).message
   end
 end

data/lib/holdify/source.rb

@@ -7,7 +7,7 @@ module Holdify
   class Source
     def initialize(path) = (@line_xxh, @xxh_lines = parse(path))
 
-    def xxh(line) = @line_xxh[line]
+    def xxh(lineno) = @line_xxh[lineno]
 
     def lines(xxh) = @xxh_lines[xxh]
 
@@ -17,13 +17,13 @@ module Holdify
       line_xxh  = {}
       xxh_lines = Hash.new { |h, k| h[k] = [] }
 
-      File.foreach(path).with_index(1) do |text, line|
+      File.foreach(path).with_index(1) do |text, lineno|
         content = text.strip
         next if content.empty?
 
-        xxh            = Digest::XXH3_64bits.hexdigest(content)
-        line_xxh[line] = xxh
-        xxh_lines[xxh] << line
+        xxh = Digest::XXH3_64bits.hexdigest(content)
+        line_xxh[lineno] = xxh
+        xxh_lines[xxh] << lineno
       end
 
       [line_xxh, xxh_lines]

data/lib/holdify/store.rb

@@ -1,20 +1,73 @@
 # frozen_string_literal: true
 
+require 'yaml'
+require 'fileutils'
 require 'forwardable'
-require_relative 'source'
-require_relative 'ledger'
 
 module Holdify
   # Interface to the Source (code) and the Ledger (data)
   class Store
+    class NoAliasVisitor < Psych::Visitors::YAMLTree # :nodoc:
+      def register(target, obj); end
+    end
+
     extend Forwardable
 
+    def_delegator :@source, :xxh
+    attr_reader :path
+
     def initialize(path)
+      @path   = "#{path}#{Holdify.store_ext}"
       @source = Source.new(path)
-      @ledger = Ledger.new(path, @source)
+      FileUtils.rm_f(@path) if Holdify.reconcile
+      @data = File.exist?(@path) ? load_and_align : {}
+    end
+
+    def get_values(lineno) = @data[lineno]
+
+    def set_values(lineno, values) = (@data[lineno] = values)
+
+    def persist
+      return FileUtils.rm_f(@path) if @data.empty?
+
+      output = {}
+      @data.keys.sort.each do |lineno|
+        xxh = @source.xxh(lineno)
+        next unless xxh
+
+        output["L#{lineno} #{xxh}"] = @data[lineno]
+      end
+
+      File.write(@path, hold_dump(output))
+    end
+
+    private
+
+    def hold_dump(obj)
+      visitor = NoAliasVisitor.create
+      visitor << obj
+      visitor.tree.to_yaml
     end
 
-    def_delegator  :@source, :xxh
-    def_delegators :@ledger, :get, :set, :persist
+    def load_and_align
+      {}.tap do |aligned|
+        data = YAML.unsafe_load_file(@path) || {}
+        data.group_by { |k, _| k.split.last }.each do |xxh, entries|
+          lines = @source.lines(xxh)
+          next if lines.empty?
+
+          # Position of the held lines compared to the source lines
+          stayed, moved = entries.map { |key, values| { line: key[/\d+/].to_i, values: } }
+                                 .partition { lines.include?(_1[:line]) }
+          moved.sort_by! { _1[:line] }
+
+          # Align lines
+          lines.each do |lineno|
+            match           = stayed.find { _1[:line] == lineno } || moved.shift
+            aligned[lineno] = match[:values] if match
+          end
+        end
+      end
+    end
   end
 end

data/lib/holdify.rb

@@ -1,16 +1,24 @@
 # frozen_string_literal: true
 
-require_relative 'holdify/store'
 require_relative 'holdify/hold'
+require_relative 'holdify/feedback'
+require_relative 'holdify/source'
+require_relative 'holdify/store'
 
 # The container module
 module Holdify
-  VERSION = '1.1.3'
-  CONFIG  = { ext: '.yaml' }.freeze
+  VERSION = '1.3.0'
 
   class << self
-    attr_accessor :reconcile, :quiet
-    attr_writer :pretty
+    attr_accessor :reconcile, :quiet, :git, :pwd, :color, :rel_paths, :store_ext
+
+    def persist_all! = @stores&.each_value(&:persist)
+
+    def relative(path)
+      return path unless rel_paths
+
+      path.sub(%r{^#{pwd}/}, '')
+    end
 
     def stores(path = nil)
       return @stores unless path
@@ -19,17 +27,6 @@ module Holdify
         @stores[path] ||= Store.new(path)
       end
     end
-
-    def persist_all!
-      @stores&.each_value(&:persist)
-    end
-
-    def pretty
-      return @pretty unless @pretty.nil?
-
-      @pretty = $stdout.tty? && !ENV.key?('NO_COLOR') && ENV['TERM'] != 'dumb' &&
-                system('git --version', out: File::NULL, err: File::NULL)
-    end
   end
   @mutex  = Mutex.new
   @stores = {}

data/lib/minitest/holdify_plugin.rb

@@ -1,29 +1,43 @@
 # frozen_string_literal: true
 
 require 'holdify'
-require 'holdify/pretty'
 
 # Implement the minitest plugin
 module Minitest
-  # Register the after_run hook to persist all data
-  def self.plugin_holdify_init(_options)
-    Minitest.after_run { Holdify.persist_all! }
-  end
-
   # Set the Holdify options
-  def self.plugin_holdify_options(opts, _options)
-    opts.on '--holdify-reconcile', 'Reconcile the held values with the new ones' do
-      Holdify.reconcile = true
-      Holdify.quiet     = true
-    end
-
-    opts.on '--holdify-pretty', 'Format the stored values with pretty print' do
-      Holdify.pretty = true
+  def self.plugin_holdify_options(opts, options)
+    opts.on '--holdify-reconcile', 'Reconcile the held values with the new ones (enables quiet)' do
+      options[:holdify_reconcile] = true
+      options[:holdify_quiet]     = true
     end
-
     opts.on '--holdify-quiet', 'Skip the warning on storing a new value' do
-      Holdify.quiet = true
+      options[:holdify_quiet] = true
+    end
+    opts.on '--holdify-no-git-diff', 'Disable git-diff' do
+      options[:holdify_no_git_diff] = true
+    end
+    opts.on '--holdify-no-color', 'Disable colored output' do
+      options[:holdify_no_color] = true
+    end
+    opts.on '--holdify-no-rel-paths', 'Disable relative paths in file references' do
+      options[:holdify_no_rel_paths] = true
     end
+    opts.on '--holdify-store-ext EXT', 'The yaml store extension (default .yaml)' do |ext|
+      options[:holdify_store_ext] = ext
+    end
+  end
+
+  # Register the after_run hook to persist all data
+  def self.plugin_holdify_init(options)
+    Holdify.reconcile = options[:holdify_reconcile]
+    Holdify.quiet     = options[:holdify_quiet]
+    Holdify.git       = system('git --version', out: File::NULL, err: File::NULL) unless options[:holdify_no_git_diff]
+    Holdify.pwd       = Holdify.git ? `git rev-parse --show-toplevel`.strip : Dir.pwd
+    Holdify.color     = !ENV.key?('NO_COLOR') unless options[:holdify_no_color]
+    Holdify.rel_paths = true unless options[:holdify_no_rel_paths]
+    Holdify.store_ext = options[:holdify_store_ext] || '.yaml'
+
+    Minitest.after_run { Holdify.persist_all! }
   end
 
   # Reopen the minitest class
@@ -37,10 +51,9 @@ module Minitest
       return unless @hold.forced.any?
 
       path, = method(name).source_location
-      msg = <<~MSG.chomp
-        [holdify] the value has been stored: remove the "!" suffix to pass the test
-        #{@hold.forced.uniq.map { |l| "  #{path}:#{l}" }.join("\n")}
-      MSG
+      msg   = +%([holdify] the value has been stored: remove the "!" suffix to pass the test\n)
+      msg  << @hold.forced.uniq.map { |lineno| "  #{path}:#{lineno}" }.join("\n")
+
       raise Minitest::Assertion, msg
     end
   end
@@ -60,20 +73,11 @@ module Minitest
         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
-
-        msg = message ? "#{message}\n#{diff}" : diff
-        raise Minitest::Assertion, msg
+      rescue Minitest::Assertion => e
+        raise Minitest::Assertion, @hold.feedback(e.location, expected, actual, message)
       end
 
-      if inspect
-        location = @hold.find_location
-        warn "[holdify] The value from #{location.path}:#{location.lineno} is:\n[holdify] => #{actual.inspect}"
-      end
+      @hold.warn_for(actual) if inspect
 
       expected
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minitest-holdify
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.3.0
 platform: ruby
 authors:
 - Domizio Demichelis
@@ -47,9 +47,8 @@ extra_rdoc_files: []
 files:
 - LICENSE.txt
 - lib/holdify.rb
+- lib/holdify/feedback.rb
 - lib/holdify/hold.rb
-- lib/holdify/ledger.rb
-- lib/holdify/pretty.rb
 - lib/holdify/source.rb
 - lib/holdify/store.rb
 - lib/minitest-holdify.rb

data/lib/holdify/ledger.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-require 'fileutils'
-
-module Holdify
-  # Manages the persistence and alignment of stored values
-  class Ledger
-    def initialize(path, source)
-      @path   = "#{path}#{CONFIG[:ext]}"
-      @source = source
-      FileUtils.rm_f(@path) if Holdify.reconcile
-      @data = File.exist?(@path) ? load_and_align : {}
-    end
-
-    def get(line) = @data[line]
-
-    def set(line, values) = (@data[line] = values)
-
-    def persist
-      return FileUtils.rm_f(@path) if @data.empty?
-
-      output = {}
-      @data.keys.sort.each do |line|
-        xxh = @source.xxh(line)
-        next unless xxh
-
-        output["L#{line} #{xxh}"] = @data[line]
-      end
-
-      content = YAML.dump(output, line_width: 78) # Ensure 80 columns (including pretty gutter)
-      File.write(@path, content)
-    end
-
-    private
-
-    def load_and_align
-      {}.tap do |aligned|
-        data = YAML.unsafe_load_file(@path) || {}
-        data.group_by { |k, _| k.split.last }.each do |xxh, entries|
-          lines = @source.lines(xxh)
-          next if lines.empty?
-
-          # Position of the held lines compared to the source lines
-          stayed, moved = entries.map { |key, values| { line: key[/\d+/].to_i, values: values } }
-                                 .partition { |c| lines.include?(c[:line]) }
-          moved.sort_by! { |c| c[:line] }
-
-          # Align lines
-          lines.each do |line|
-            match         = stayed.find { |c| c[:line] == line } || moved.shift
-            aligned[line] = match[:values] if match
-          end
-        end
-      end
-    end
-  end
-end

data/lib/holdify/pretty.rb

@@ -1,90 +0,0 @@
-# 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 pretty gutter)
-          file.flush
-        end
-      end
-    end
-  end
-end