minitest-holdify 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cd9cfe38c2cb4dc5fb508261f9b89e107dcbcdb01902018ca30cd68f713bec4e
+  data.tar.gz: 487b7577edbeec62c7e2bd26f6dc7dc0af71fe6eae1915160265057c2efaf32e
+SHA512:
+  metadata.gz: b606c8de07fa255ee00025c26697b539092bd5ed44f5d01790ce96a115542186ab6371c3006eed5030f7f01c2f7264d9dcec4389964784daa112ada0ba61dbba
+  data.tar.gz: 2e448c696404d64f7a1491fb7fe6cdc90c4c4da7dc37df44f8a7e437d195b61d360bdc17b3751c61d4ceefcf3e38698aa64af4012406a8afa1731dec8e47e8dd

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Domizio Demichelis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/lib/holdify/store.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'fileutils'
+
+class Holdify
+  # A simple Hash-based store that syncs with a static source map
+  class Store
+    def initialize(source_path)
+      @path = "#{source_path}#{CONFIG[:ext]}"
+      File.delete(@path) if Holdify.rebuild && File.exist?(@path)
+
+      @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
+    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
+  end
+end

data/lib/holdify.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'digest/sha1'
+require_relative 'holdify/store'
+
+# Add description
+class Holdify
+  VERSION = '1.0.0'
+  CONFIG  = { ext: '.yaml' }.freeze
+
+  class << self
+    attr_accessor :rebuild, :quiet
+
+    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.rebuild
+
+    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:
+
+      label == @test.name ||
+        label == '<top (required)>' ||
+        label == '<main>' ||
+        label.start_with?('<class:', '<module:')
+    end
+  end
+end

data/lib/minitest/holdify_plugin.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'holdify'
+
+# Implement the minitest plugin
+module Minitest
+  # Set the Holdify options
+  def self.plugin_holdify_options(opts, _options)
+    opts.on '--holdify-rebuild', 'Rebuild the stores with the current entries/values' do
+      Holdify.rebuild = true
+      Holdify.quiet   = true
+    end
+    # :nocov:
+    opts.on '--holdify-quiet', 'Skip the warning on storing a new value' do
+      Holdify.quiet = true
+    end
+    # :nocov:
+  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?
+
+      msg = <<~MSG.chomp
+        [holdify] the value has been stored: remove the "!" suffix to pass the test
+        #{@holdify.forced.uniq.map { |l| "  #{l}" }.join("\n")}
+      MSG
+      raise Minitest::Assertion, msg
+    end
+  end
+
+  # Reopen the minitest module
+  module Assertions
+    # Main assertion
+    def assert_hold(actual, *args)
+      @holdify ||= Holdify.new(self)
+      assertion, message = args
+      assertion, message = message, assertion unless assertion.nil? || assertion.is_a?(Symbol)
+
+      expected = @holdify.hold(actual)
+      if actual.nil?
+        assert_nil expected, message
+      else
+        send(assertion || :assert_equal, expected, actual, message)
+      end
+    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
+
+    # 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 dumped from: #{location.path}:#{location.lineno}\n=> #{actual.inspect}"
+      @holdify.hold(actual)
+    end
+  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|
+      expectation_class.infect_an_assertion :"assert_#{suffix}", :"must_#{suffix}", :reverse
+      expectation_class.alias_method :"to_#{suffix}", :"must_#{suffix}"
+    end
+  end
+  # :nocov:
+end

data/lib/minitest-holdify.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "holdify"

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: minitest-holdify
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Domizio Demichelis
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+description: Holdify eliminates the burden of maintaining large expected values into
+  your test files. It behaves as if the expected value were hardcoded inline, but
+  keeps it stored externally. This ensures your values hold true without polluting
+  your test files, and allows for effortless updates when your code changes.
+email:
+- dd.nexus@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- lib/holdify.rb
+- lib/holdify/store.rb
+- lib/minitest-holdify.rb
+- lib/minitest/holdify_plugin.rb
+homepage: https://github.com/ddnexus/holdify
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/ddnexus/holdify
+  bug_tracker_uri: https://github.com/ddnexus/holdify/issues
+  changelog_uri: https://github.com/ddnexus/holdify/blob/master/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Hardcoded values suck! Hold them inline!
+test_files: []