minitest-holdify 1.0.3 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 06f80be32b494ec786f8d873556a8046d6e051854ce38051c1f9a41ecce91fe7
-  data.tar.gz: 95efd3e040696f2eacdbcf61b378db9c51bb33889f73b54c418d8bb0417e6244
+  metadata.gz: 48b28eeeaa320f75630822394f0f4b91a3025e081f085e39dee88ce264a5b2ab
+  data.tar.gz: fbc6c3b837a70c44d7359495c1e58809376022a6a458f504db4d7f06ff8585ae
 SHA512:
-  metadata.gz: 3174aad64ba870444147f629ca38dddbbafce4b57d94d72d32febc1c32afdc56c6f2415337e43fab7be44a45a7d7edae7197aabc06f5ea82504bc868ca3ab123
-  data.tar.gz: a336655be1c76832e50c00b919bbb7ecc8a735b1b49e8067a8df3506fa7a6ef2f7b1553b10356bca2fd54025a0fb22a936bdc70f390eaaa124e244f978407df9
+  metadata.gz: 0accd428f401a337bbdbd8f9537b952c42e40508425d3353213b9795d2b0ecd4b617087d41f0abb79af508e156e7aa7149a6fe30e9cdff7b135c062f3b3caf32
+  data.tar.gz: c71c3caff7e00b1f8fb40ec5e871d3697cec7925a76559b1c8064a512bcc5a9285c150836a013edfa3c33325da9e3256096dfc27161251467ca817cfffbf8c19

data/lib/holdify/hold.rb

@@ -9,37 +9,39 @@ module Holdify
       @test    = test
       @path,   = test.method(test.name).source_location
       @store   = Holdify.stores[@path] ||= Store.new(@path)
-      @session = Hash.new { |h, k| h[k] = [] }
-      @forced  = []
-      @added   = []
+      @session = Hash.new { |h, k| h[k] = [] } # { line => [values] }
+      @forced  = []                            # [ "file:line" ]
+      @added   = []                            # [ "file:line" ]
     end
 
     def call(actual, force: false)
       location = find_location
-      id       = @store.id_at(location.lineno)
-      raise "Could not find holdify statement at line #{location.lineno}" unless id
+      line     = location.lineno
+      raise "Could not find holdify statement at line #{line}" unless @store.sha_at(line)
 
-      @session[id] << actual
-      @forced << "#{location.path}:#{location.lineno}" if force
+      @session[line] << actual
+      @forced << "#{@path}:#{line}" if force
 
       return actual if force || Holdify.reconcile
 
-      stored = @store.stored(id)
-      index  = @session[id].size - 1
-      return stored[index] if stored && index < stored.size
+      # Expected value
+      values = @store.get(line)
+      index  = @session[line].size - 1
+      return values[index] if values && index < values.size
 
-      @added << "#{location.path}:#{location.lineno}"
+      @added << "#{@path}:#{line}"
       actual
     end
 
     def save
       return unless @test.failures.empty?
 
-      @added.each { |loc| warn "[holdify] Held new value for #{loc}" } unless Holdify.quiet
-      @session.each { |id, values| @store.update(id, values) }
+      @added.each   { |loc| warn "[holdify] Held new value for #{loc}" } unless Holdify.quiet
+      @session.each { |line, values| @store.set(line, values) }
       @store.save
     end
 
+    # Find the location in the test that triggered the hold
     def find_location
       caller_locations.find do |location|
         next unless location.path == @path

data/lib/holdify/ledger.rb

@@ -0,0 +1,60 @@
+# 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
+      File.delete(@path) if Holdify.reconcile && File.exist?(@path)
+      @data = load_and_align
+    end
+
+    def get(line) = @data[line]
+
+    def set(line, values) = (@data[line] = values)
+
+    def save
+      return FileUtils.rm_f(@path) if @data.empty?
+
+      output = {}
+      @data.keys.sort.each do |line|
+        sha = @source.sha_at(line)
+        next unless sha
+
+        output["L#{line} #{sha}"] = @data[line]
+      end
+
+      content = YAML.dump(output, line_width: 78) # Ensure 80 columns (including pretty gutter)
+      return if File.exist?(@path) && File.read(@path) == content
+
+      File.write(@path, content)
+    end
+
+    private
+
+    def load_and_align
+      {}.tap do |aligned|
+        raw_data = (File.exist?(@path) && YAML.unsafe_load_file(@path)) || {}
+        raw_data.group_by { |k, _| k.split.last }.each do |sha, entries|
+          target_lines = @source.lines_with(sha)
+          next if target_lines.empty?
+
+          # Old data
+          candidates   = entries.map { |key, values| { line: key[/\d+/].to_i, values: values } }
+          exact, moved = candidates.partition { |c| target_lines.include?(c[:line]) }
+          moved.sort_by! { |c| c[:line] }
+
+          # New aligned data
+          target_lines.each do |line|
+            match = exact.find { |c| c[:line] == line } || moved.shift
+            aligned[line] = match[:values] if match
+          end
+        end
+      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 pretty gutter)
+          file.flush
+        end
+      end
+    end
+  end
+end

data/lib/holdify/source.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'digest/sha1'
+
+module Holdify
+  # Represents the current state of the source file
+  class Source
+    def initialize(path) = (@line_sha, @sha_lines = parse(path))
+
+    def sha_at(line) = @line_sha[line]
+
+    def lines_with(sha) = @sha_lines[sha]
+
+    private
+
+    def parse(path)
+      line_sha  = {}
+      sha_lines = Hash.new { |h, k| h[k] = [] }
+
+      File.foreach(path).with_index(1) do |text, line|
+        content = text.strip
+        next if content.empty?
+
+        sha = Digest::SHA1.hexdigest(content)
+        line_sha[line] = sha
+        sha_lines[sha] << line
+      end
+
+      [line_sha, sha_lines]
+    end
+  end
+end

data/lib/holdify/store.rb

@@ -1,54 +1,20 @@
 # frozen_string_literal: true
 
-require 'yaml'
-require 'fileutils'
-require 'digest/sha1'
+require 'forwardable'
+require_relative 'source'
+require_relative 'ledger'
 
 module Holdify
-  # A simple Hash-based store that syncs with a static source map
+  # Interface to the Source (code) and the Ledger (data)
   class Store
-    def initialize(source_path)
-      @path = "#{source_path}#{CONFIG[:ext]}"
-      File.delete(@path) if Holdify.reconcile && File.exist?(@path)
+    extend Forwardable
 
-      @source = {} # { lineno => id }
-      File.foreach(source_path).with_index(1) do |line, lineno|
-        content = line.strip
-        @source[lineno] = Digest::SHA1.hexdigest(content) unless content.empty?
-      end
-
-      @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
+    def initialize(path)
+      @source = Source.new(path)
+      @ledger = Ledger.new(path, @source)
     end
 
-    def id_at(lineno) = @source[lineno]
-    def stored(id)    = @data[@index[id]]
-
-    # 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]
-      @data.delete(old_key) if old_key && old_key != new_key
-      @data[@index[id] = new_key] = values
-    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)
-      return if File.exist?(@path) && File.read(@path) == content
-
-      File.write(@path, content)
-    end
+    def_delegator  :@source, :sha_at
+    def_delegators :@ledger, :get, :set, :save
   end
 end

data/lib/holdify.rb

@@ -3,14 +3,22 @@
 require_relative 'holdify/store'
 require_relative 'holdify/hold'
 
-# Add description
+# The container module
 module Holdify
-  VERSION = '1.0.3'
+  VERSION = '1.1.1'
   CONFIG  = { ext: '.yaml' }.freeze
 
   class << self
     attr_accessor :reconcile, :quiet
+    attr_writer :pretty
 
     def stores = @stores ||= {}
+
+    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
 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,6 +11,11 @@ module Minitest
       Holdify.reconcile = true
       Holdify.quiet     = true
     end
+
+    opts.on '--holdify-pretty', 'Format the stored values with pretty print' do
+      Holdify.pretty = true
+    end
+
     opts.on '--holdify-quiet', 'Skip the warning on storing a new value' do
       Holdify.quiet = true
     end
@@ -40,10 +46,20 @@ module Minitest
       assertion, message = message, assertion unless assertion.nil? || assertion.is_a?(Symbol)
       expected = @hold.(actual, **)
 
-      if actual.nil?
-        assert_nil expected, message
-      else
-        send(assertion || :assert_equal, expected, actual, message)
+      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
+
+        msg = message ? "#{message}\n#{diff}" : diff
+        raise Minitest::Assertion, msg
       end
 
       if inspect
@@ -54,10 +70,10 @@ module Minitest
       expected
     end
 
-    # Temporarily used to store the actual value, useful for reconciliation of expected changed values
+    # Force store the current value
     def assert_hold!(*, **) = assert_hold(*, **, force: true)
 
-    # Temporarily used for development feedback to print to STDERR the actual value
+    # Print to STDERR the actual value
     def assert_hold?(*, **) = assert_hold(*, **, inspect: true)
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minitest-holdify
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.1
 platform: ruby
 authors:
 - Domizio Demichelis
@@ -34,6 +34,9 @@ files:
 - LICENSE.txt
 - lib/holdify.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
 - lib/minitest/holdify_plugin.rb
@@ -59,7 +62,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: []