tdd-guard-minitest 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7094ecd33f1d7f2ea05de6193fe1ad6bf7bb38bc8e990b6670c4844e0df29892
+  data.tar.gz: d7fd5b92ee9ed72fd5f82efe2ba7496637389e0080f4b1e279a8963ebdc6fa53
+SHA512:
+  metadata.gz: 8063e1b3dca4a7a27caaddb1d2ee3078b8216847097772348f0f607e95d4985eb521d8352e8efdad6055e789429b6e570f589a3d411dd90402f10c774d39bef7
+  data.tar.gz: 4852220c5f486143695c117b342f7161572af18babfdeedd8b5be341134473edd015c914232e4f0c4681e9070cc56ef48fa17ef8a9da7b112608c7f93cbebe66

data/lib/minitest/tdd_guard_plugin.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "tdd_guard_minitest/reporter"
+
+module Minitest
+  def self.plugin_tdd_guard_init(options)
+    # Guard against double initialization. In Minitest 5, load_plugins
+    # may register "tdd_guard" in extensions even when autorun.rb has
+    # already done so, causing init_plugins to call this method twice.
+    return if reporter.reporters.any? { |r| r.is_a?(TddGuardMinitest::Reporter) }
+
+    reporter << TddGuardMinitest::Reporter.new(options[:io], options)
+  end
+end

data/lib/tdd_guard_minitest/autorun.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+# Entry point used to guarantee that the tdd-guard-minitest reporter is in
+# place before the user's test file is loaded.
+#
+# Three hooks are registered here, ordered by when they *fire* (LIFO):
+#
+# 1. Load-error at_exit (registered last, fires first):
+#    Intercepts unhandled exceptions raised while loading the user's test
+#    file (typically a LoadError from a missing require).
+#
+# 2. Minitest's own at_exit hooks (registered by require "minitest/autorun"):
+#    Outer hook runs tests and calls reporter.report.
+#    Inner hook (registered during the outer hook) runs after_run blocks.
+#
+# 3. Post-after_run at_exit (registered first, fires last):
+#    If any wrapped after_run blocks raised, patches test.json with the
+#    captured unhandledErrors.
+#
+# Between hooks 1 and 3, Minitest.after_run is patched so that each
+# user-registered block is wrapped in a begin/rescue that captures
+# exceptions into TddGuardMinitest.unhandled_errors before re-raising.
+#
+# Usage:
+#
+#   ruby -rtdd_guard_minitest/autorun path/to/test.rb
+#
+# or from test/test_helper.rb:
+#
+#   require "tdd_guard_minitest/autorun"
+
+require "tdd_guard_minitest/reporter"
+
+# Hook 3 (fires last): patch test.json with any captured after_run errors.
+# Registered before Minitest's at_exit so it fires after all Minitest hooks.
+at_exit do
+  errors = TddGuardMinitest.unhandled_errors
+  next if errors.empty?
+
+  TddGuardMinitest::Reporter.append_unhandled_errors(errors)
+end
+
+require "minitest/autorun"
+
+# Ensure the plugin is registered even when Minitest does not call
+# load_plugins automatically (Minitest 6+). In Minitest 5, load_plugins
+# is called during Minitest.run and discovers the plugin via
+# Gem.find_files; this explicit registration is harmless in that case
+# because init_plugins skips duplicate names.
+require "minitest/tdd_guard_plugin"
+Minitest.extensions << "tdd_guard" unless Minitest.extensions.include?("tdd_guard")
+
+# Wrap Minitest.after_run so that each block registered by user code or
+# plugins is intercepted. Captured exceptions are stored for the post-
+# after_run at_exit hook above while still re-raising to preserve
+# Minitest's default behavior.
+original_after_run = Minitest.method(:after_run)
+Minitest.define_singleton_method(:after_run) do |&block|
+  original_after_run.call do
+    begin
+      block.call
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      TddGuardMinitest.unhandled_errors << e unless e.is_a?(SystemExit)
+      raise
+    end
+  end
+end
+
+# Hook 1 (fires first): capture load errors before Minitest runs.
+at_exit do
+  exc = $!
+  next if exc.nil?
+  next if exc.is_a?(SystemExit)
+
+  TddGuardMinitest::Reporter.handle_load_error(exc)
+end

data/lib/tdd_guard_minitest/reporter.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "minitest"
+
+module TddGuardMinitest
+  @unhandled_errors = []
+
+  class << self
+    attr_reader :unhandled_errors
+  end
+
+  # Minitest reporter that captures test results for TDD Guard validation.
+  # Mirrors the RSpec reporter's single-class architecture.
+  class Reporter < Minitest::StatisticsReporter
+    DEFAULT_DATA_DIR = ".claude/tdd-guard/data"
+
+    def initialize(io = $stdout, options = {})
+      super
+      @test_results = []
+      @expected_count = 0
+      @storage_dir = determine_storage_dir
+    end
+
+    def start
+      super
+      @expected_count = compute_expected_count
+    end
+
+    # Writes a synthetic failed-test JSON for an exception raised before
+    # Minitest had a chance to run (typically a LoadError from a missing
+    # require at the top of a test file). Called from the autorun entry
+    # point's at_exit hook when $! is set.
+    #
+    # Injects a synthetic entry into @test_results and writes the JSON
+    # through the normal report path. Skips if test.json already exists
+    # to avoid clobbering real results.
+    def self.handle_load_error(exception)
+      new(StringIO.new).handle_load_error(exception)
+    end
+
+    # Reads the existing test.json, merges in the unhandledErrors field,
+    # and re-writes it. Called from the post-after_run at_exit hook in
+    # autorun.rb after Minitest.after_run blocks have completed.
+    def self.append_unhandled_errors(errors)
+      new(StringIO.new).append_unhandled_errors(errors)
+    end
+
+    def append_unhandled_errors(errors)
+      json_path = File.join(@storage_dir, "test.json")
+      return unless File.exist?(json_path)
+
+      data = JSON.parse(File.read(json_path))
+      data["unhandledErrors"] = errors.map { |e| build_unhandled_error(e) }
+      File.write(json_path, JSON.pretty_generate(data))
+    end
+
+    def handle_load_error(exception)
+      return if File.exist?(File.join(@storage_dir, "test.json"))
+
+      add_load_error(exception)
+      report
+    end
+
+    def record(result)
+      state = if result.skipped?
+                "skipped"
+              elsif result.passed?
+                "passed"
+              else
+                "failed"
+              end
+
+      file_path = extract_file_path(result)
+      test = {
+        "name" => result.name,
+        "fullName" => "#{file_path}::#{result.klass}##{result.name}",
+        "state" => state
+      }
+
+      if state == "failed" && result.failures.any?
+        test["errors"] = result.failures.map { |failure| build_error(failure) }
+      end
+
+      @test_results << test
+    end
+
+    def report
+      modules_map = {}
+      @test_results.each do |test|
+        module_path = test["fullName"].split("::").first
+        modules_map[module_path] ||= { "moduleId" => module_path, "tests" => [] }
+        modules_map[module_path]["tests"] << test
+      end
+
+      has_failures = @test_results.any? { |t| t["state"] == "failed" }
+      reason = if has_failures
+                 "failed"
+               elsif @expected_count > 0 && @test_results.length < @expected_count
+                 "interrupted"
+               else
+                 "passed"
+               end
+      result = {
+        "testModules" => modules_map.values,
+        "reason" => reason
+      }
+
+      FileUtils.mkdir_p(@storage_dir)
+      File.write(File.join(@storage_dir, "test.json"), JSON.pretty_generate(result))
+    end
+
+    def passed?
+      @test_results.none? { |t| t["state"] == "failed" }
+    end
+
+    private
+
+    def compute_expected_count
+      filter = options[:filter]
+      Minitest::Runnable.runnables.sum do |klass|
+        if filter
+          klass.methods_matching(filter).size
+        else
+          klass.runnable_methods.size
+        end
+      end
+    end
+
+    def build_unhandled_error(exception)
+      name = exception.class.name || "(anonymous error class)"
+      error = { "name" => name, "message" => exception.message }
+      stack = extract_relevant_stack(exception.backtrace)
+      error["stack"] = stack if stack
+      error
+    end
+
+    def build_error(failure)
+      if failure.is_a?(Minitest::UnexpectedError)
+        exception = failure.error
+        error = { "message" => exception.message }
+        stack = extract_relevant_stack(exception.backtrace)
+      else
+        error = { "message" => failure.message }
+        stack = extract_relevant_stack(failure.backtrace)
+      end
+      error["stack"] = stack if stack
+      error
+    end
+
+    def extract_relevant_stack(backtrace)
+      return nil unless backtrace
+
+      frame = backtrace.find do |line|
+        (line.include?("test/") || line.include?("spec/")) && !line.include?("/gems/")
+      end
+      return nil unless frame
+
+      frame.sub(%r{^.*/(?=test/|spec/)}, "").sub(%r{^\./}, "")
+    end
+
+    def extract_file_path(result)
+      source = result.source_location
+      return "unknown" unless source
+
+      path = source.first
+      # Convert absolute path to relative path from cwd
+      cwd = "#{Dir.pwd}/"
+      path = path.delete_prefix(cwd) if path.start_with?(cwd)
+      path.sub(%r{^\./}, "")
+    end
+
+    def determine_storage_dir
+      project_root = ENV["TDD_GUARD_PROJECT_ROOT"]
+      return DEFAULT_DATA_DIR unless project_root && !project_root.empty?
+      return DEFAULT_DATA_DIR unless absolute_path?(project_root)
+      return DEFAULT_DATA_DIR unless cwd_within?(project_root)
+
+      File.join(project_root, DEFAULT_DATA_DIR)
+    end
+
+    def absolute_path?(path)
+      File.absolute_path?(path)
+    end
+
+    def cwd_within?(root)
+      expanded = File.expand_path(root)
+      cwd = Dir.pwd
+      cwd == expanded || cwd.start_with?("#{expanded}/")
+    end
+
+    # Injects a synthetic failed test entry derived from an exception raised
+    # before Minitest could run.
+    def add_load_error(exception)
+      frame = first_user_frame(exception.backtrace)
+      file_path = frame ? frame.split(":", 2).first.to_s.sub(%r{^\./}, "") : "unknown"
+      name = "#{exception.class}: #{exception.message.lines.first.to_s.strip}"
+      message = build_load_error_message(exception, frame)
+
+      @test_results << {
+        "name" => name,
+        "fullName" => "#{file_path}::#{name}",
+        "state" => "failed",
+        "errors" => [{ "message" => message }]
+      }
+    end
+
+    def first_user_frame(backtrace)
+      return nil unless backtrace
+
+      backtrace.find do |line|
+        (line.include?("_test.rb") || line.include?("_spec.rb")) && !line.include?("/gems/")
+      end
+    end
+
+    def build_load_error_message(exception, frame)
+      header = "#{exception.class}: #{exception.message}"
+      return header unless frame
+
+      "#{header}\n    #{frame.sub(%r{^\./}, '')}"
+    end
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: tdd-guard-minitest
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Hiro-Chiba
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-04-13 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'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: climate_control
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Minitest reporter that captures test results for TDD Guard validation.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/minitest/tdd_guard_plugin.rb
+- lib/tdd_guard_minitest/autorun.rb
+- lib/tdd_guard_minitest/reporter.rb
+homepage: https://github.com/nizos/tdd-guard
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Minitest reporter for TDD Guard - enforces Test-Driven Development principles
+test_files: []