mutaterb 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e60dd9f48be985c4852b318ee38410f6ce76cb924604c9d37f1f64004e2c27f6
-  data.tar.gz: 6ef1b8387ed290681db0ab7480021fe2536782cf57478834d56f1331b3676ecc
+  metadata.gz: 0fcfd443fe916c062548f30e91d88d26a3315995867ef5171ae65a59075a8f30
+  data.tar.gz: 349a834f109c1ab01cbf632ca042fa2850691c88ef77c61250c2d37d8e7def6b
 SHA512:
-  metadata.gz: 1f168ec32386423f8c2beb49856791fed45ce11c80f42d3d7284d1782577b9c55e7f3344b13360ecbcc2b1bbf22932e919d1b79d5af05529fc40d353445581ea
-  data.tar.gz: bf83a88519717178e2863c9ec85ef30acaeddb0dac5433ee0b467c4d2d7aa2f14d38ed657173903f74045a84446cb8e465002d7895d0ca69344cd780f72784ca
+  metadata.gz: c46d5fcaf78d48abde487f77f96803ec0748e011b20d6d00cfb9d00766ae69e94c3403b3dd9be35867f2ff854608cfb13e218cd82c5a94d7635b5077861b6df2
+  data.tar.gz: a7327b9f520ebae9231729c43b8f29cbb171e35f6781eef35889c63ff5502dc9cd3ce431833e7b77ae9b759065648cc805af39b7b2fb8f4b3c14c440e2be145e

data/README.md

@@ -1,8 +1,8 @@
 # MutateRB
 
 A mutation testing tool for Ruby and Ruby on Rails projects: it modifies code covered
-by your RSpec tests and checks whether the test suite catches the change. If a mutated
-test does not fail, that test is identified as weak.
+by your test suite and checks whether it catches the change. If a mutated test does not
+fail, that test is identified as weak. Supports both RSpec and Minitest.
 
 ## Installation
 
@@ -25,9 +25,16 @@ mutaterb
 ```
 
 Without flags, it automatically detects whether the project is pure Ruby or Rails,
-locates specs in `spec/`, applies mutations to covered code, and displays a summary:
-how many mutations were "killed" (caught by a test) and how many "survived" (no test
-caught them — weak tests), with file, line, and related test(s) for each survivor.
+which test framework it uses (RSpec if there's a `spec/` folder, Minitest if there's a
+`test/` folder — RSpec wins if both are present), applies mutations to covered code,
+and displays a summary: how many mutations were "killed" (caught by a test) and how
+many "survived" (no test caught them — weak tests), with file, line, and related
+test(s) for each survivor.
+
+While it runs, it prints the baseline status and a live counter of mutants processed
+so far out of the total, so a long run never looks stuck. Pass `--verbose` to replace
+that counter with one line per mutant (file, line, mutation type, and result) as it is
+evaluated.
 
 ### Main flags
 
@@ -37,8 +44,10 @@ caught them — weak tests), with file, line, and related test(s) for each survi
 | `--include PATHS` | Restrict analysis to these paths (comma-separated) |
 | `--exclude PATHS` | Exclude these paths (comma-separated) |
 | `--strictness LEVEL` | `low`, `default`, or `high` |
+| `--framework FRAMEWORK` | `auto`, `rspec`, or `minitest` — forces the test framework instead of auto-detecting it |
 | `--mutation-types TYPES` | Mutation types to apply, comma-separated |
 | `--exit-zero` | Do not fail (exit 0) even if "survived" mutations exist |
+| `--verbose` | Print one line per mutant as it runs, instead of the default counter |
 | `--json-output PATH` | Export the results summary to a JSON file |
 | `--config PATH` | Use a config file other than `.mutaterb.yml` |
 

data/lib/mutaterb/cli.rb

@@ -39,14 +39,16 @@ module MutateRB
       Signal.trap("INT") { interrupted = true }
 
       detection = ProjectDetector.new(config).detect
-      if detection.spec_files.empty?
+      if detection.test_files.empty?
         warn "mutaterb: no tests found in #{config.target_dir}"
         return EXIT_OPERATIONAL_ERROR
       end
+      warn_ambiguous_frameworks(detection)
 
-      test_suite = build_test_suite(config, detection)
+      progress = ProgressReporter.new(verbose: config.verbose)
+      test_suite = build_test_suite(config, detection, progress)
       run = MutationRun.new(config: config, test_suite: test_suite)
-      run_mutations(run, test_suite, config) { interrupted }
+      run_mutations(run, test_suite, config, progress) { interrupted }
 
       run.finished_at = Time.now
       run.interrupted = interrupted
@@ -57,18 +59,40 @@ module MutateRB
       run.exit_code
     end
 
-    def build_test_suite(config, detection)
-      test_runner = TestRunner.new(config: config, project_type: detection.project_type)
-      baseline_examples = test_runner.run_baseline(detection.spec_files)
-      TestSuite.from_baseline(project_type: detection.project_type, baseline_examples: baseline_examples)
+    # FR-002/SC-003: when both frameworks are present and none was forced
+    # explicitly, the choice must be visible, never silent.
+    def warn_ambiguous_frameworks(detection)
+      return unless detection.ambiguous_frameworks
+
+      warn "mutaterb: detected both RSpec and Minitest — using #{detection.test_framework} " \
+           "(force one explicitly with --framework)"
+    end
+
+    def build_test_suite(config, detection, progress)
+      test_runner = TestRunner.new(config: config, project_type: detection.project_type,
+                                   framework: detection.test_framework)
+      progress.start_baseline
+      baseline_examples = test_runner.run_baseline(detection.test_files)
+      progress.finish_baseline
+      TestSuite.from_baseline(project_type: detection.project_type, framework: detection.test_framework,
+                              baseline_examples: baseline_examples)
     end
 
-    def run_mutations(run, test_suite, config)
+    def run_mutations(run, test_suite, config, progress)
       mutator = Mutator.new(config: config, test_suite: test_suite)
+      total = mutator.total_mutants
+      if total.zero?
+        warn "mutaterb: no mutants to run for the given scope"
+        return
+      end
+
+      progress.start_mutants(total)
       mutator.each_mutant do |mutant|
         run.add_mutant(mutant)
+        progress.mutant_finished(mutant)
         break if yield
       end
+      progress.finish_mutants
     end
   end
 end

data/lib/mutaterb/config.rb

@@ -8,14 +8,17 @@ module MutateRB
   class Config
     ALL_MUTATION_TYPES = %i[conditional_boundary boolean_literal nil_literal arithmetic_comparison].freeze
     VALID_STRICTNESS = %i[low default high].freeze
+    VALID_TEST_FRAMEWORKS = %i[auto rspec minitest].freeze
     DEFAULT_FILE_NAME = ".mutaterb.yml"
 
     attr_accessor :target_dir, :include_paths, :exclude_paths, :strictness,
-                  :mutation_types, :exit_on_survivors, :json_output_path
+                  :mutation_types, :exit_on_survivors, :json_output_path, :test_framework,
+                  :verbose
 
     def initialize(target_dir: ".", include_paths: [], exclude_paths: [],
                    strictness: :default, mutation_types: ALL_MUTATION_TYPES.dup,
-                   exit_on_survivors: true, json_output_path: nil)
+                   exit_on_survivors: true, json_output_path: nil, test_framework: :auto,
+                   verbose: false)
       @target_dir = target_dir
       @include_paths = include_paths
       @exclude_paths = exclude_paths
@@ -23,6 +26,8 @@ module MutateRB
       @mutation_types = mutation_types
       @exit_on_survivors = exit_on_survivors
       @json_output_path = json_output_path
+      @test_framework = test_framework
+      @verbose = verbose
       validate!
     end
 
@@ -46,7 +51,7 @@ module MutateRB
 
     def self.attributes_from_yaml(raw)
       known_keys = %w[target_dir include_paths exclude_paths strictness mutation_types
-                      exit_on_survivors json_output_path]
+                      exit_on_survivors json_output_path test_framework verbose]
       raw.each_key do |key|
         warn "mutaterb: ignoring unknown config key #{key.inspect}" unless known_keys.include?(key)
       end
@@ -64,7 +69,9 @@ module MutateRB
                           ALL_MUTATION_TYPES.dup
                         end,
         exit_on_survivors: raw.fetch("exit_on_survivors", true),
-        json_output_path: raw["json_output_path"]
+        json_output_path: raw["json_output_path"],
+        test_framework: raw.key?("test_framework") ? symbolize(raw["test_framework"], "test_framework") : :auto,
+        verbose: raw.fetch("verbose", false)
       }
     end
     private_class_method :attributes_from_yaml
@@ -94,15 +101,28 @@ module MutateRB
       raise ConfigError, "target_dir #{target_dir.inspect} does not exist" unless Dir.exist?(target_dir)
       raise ConfigError, "include_paths must be an Array" unless include_paths.is_a?(Array)
       raise ConfigError, "exclude_paths must be an Array" unless exclude_paths.is_a?(Array)
-      unless VALID_STRICTNESS.include?(strictness)
-        raise ConfigError, "strictness must be one of #{VALID_STRICTNESS.join(', ')}, got #{strictness.inspect}"
-      end
+
+      validate_enum!(:strictness, strictness, VALID_STRICTNESS)
+      validate_enum!(:test_framework, test_framework, VALID_TEST_FRAMEWORKS)
       raise ConfigError, "mutation_types must be an Array" unless mutation_types.is_a?(Array)
 
       unknown = mutation_types - ALL_MUTATION_TYPES
       raise ConfigError, "unknown mutation_types: #{unknown.join(', ')}" unless unknown.empty?
       raise ConfigError, "exit_on_survivors must be true or false" unless [true, false].include?(exit_on_survivors)
+      raise ConfigError, "verbose must be true or false" unless [true, false].include?(verbose)
+
+      validate_json_output_path!
+    end
+
+    private
+
+    def validate_enum!(field, value, allowed)
+      return if allowed.include?(value)
+
+      raise ConfigError, "#{field} must be one of #{allowed.join(', ')}, got #{value.inspect}"
+    end
 
+    def validate_json_output_path!
       return unless json_output_path
 
       parent = File.dirname(File.expand_path(json_output_path))

data/lib/mutaterb/flag_parser.rb

@@ -35,6 +35,7 @@ module MutateRB
           flags[:exclude_paths] = v.split(",")
         end
         opts.on("--strictness LEVEL", "low|default|high") { |v| flags[:strictness] = v.to_sym }
+        opts.on("--framework FRAMEWORK", "auto|rspec|minitest") { |v| flags[:test_framework] = v.to_sym }
         opts.on("--mutation-types TYPES", "Mutation types to apply, comma-separated") do |v|
           flags[:mutation_types] = v.split(",").map(&:to_sym)
         end
@@ -47,6 +48,7 @@ module MutateRB
         opts.on("--config PATH", "Use a config file other than .mutaterb.yml") do |v|
           flags[:config_path] = v
         end
+        opts.on("--verbose", "Print one line per mutant as it runs") { flags[:verbose] = true }
         opts.on("-h", "--help", "Show this help") do
           puts opts
           exit 0

data/lib/mutaterb/mutator.rb

@@ -15,23 +15,34 @@ module MutateRB
     def initialize(config:, test_suite:, test_runner: nil)
       @config = config
       @test_suite = test_suite
-      @test_runner = test_runner || TestRunner.new(config: config, project_type: test_suite.project_type)
+      @test_runner = test_runner || TestRunner.new(config: config, project_type: test_suite.project_type,
+                                                   framework: test_suite.framework)
+    end
+
+    # Total number of mutants this run will process, known upfront without running any
+    # test (FR-002, FR-008) — memoized alongside `candidates` (research.md #3).
+    def total_mutants
+      candidates.size
     end
 
     # Yields each finished Mutant, one at a time.
     def each_mutant
-      source_files.each do |file|
-        candidates_for(file).each { |mutant| yield run_one(mutant) }
-      end
+      candidates.each { |mutant| yield run_one(mutant) }
     end
 
     private
 
     attr_reader :config, :test_suite, :test_runner
 
+    # Memoized: discovering candidates is pure parsing (no test execution), so computing
+    # it once upfront lets `total_mutants` be known before `each_mutant` starts (FR-002).
+    def candidates
+      @candidates ||= source_files.flat_map { |file| candidates_for(file) }
+    end
+
     def source_files
       Dir.glob(File.join(config.target_dir, "**", "*.rb"))
-         .reject { |f| f.include?("/spec/") || f.start_with?(File.join(config.target_dir, "spec")) }
+         .reject { |f| f.include?("/spec/") || f.include?("/test/") }
          .select { |f| in_scope?(f) }
     end
 
@@ -127,22 +138,26 @@ module MutateRB
       end
     end
 
-    # Convention-based coverage mapping: lib/foo/bar.rb -> spec/foo/bar_spec.rb.
+    # Convention-based coverage mapping: lib/foo/bar.rb -> spec/foo/bar_spec.rb
+    # (or test/foo/bar_test.rb for Minitest, feature 004 research.md #5).
     # ponytail: no real coverage tracking yet; falls back to the whole suite
-    # when no matching spec file exists. Upgrade path: integrate SimpleCov
+    # when no matching test file exists. Upgrade path: integrate SimpleCov
     # coverage data if this heuristic proves too coarse for real projects.
     def related_tests_for(source_file)
-      mapped = mapped_spec_file(source_file)
+      mapped = mapped_test_file(source_file)
       matches = test_suite.test_cases.select { |t| t.file_path == mapped }
       matches = test_suite.test_cases.dup if matches.empty?
       matches.reject(&:baseline_broken?)
     end
 
-    def mapped_spec_file(source_file)
+    def mapped_test_file(source_file)
       relative = source_file.sub(%r{\A#{Regexp.escape(config.target_dir)}/?}, "")
       relative = relative.sub(%r{\A(lib|app)/}, "")
-      spec_relative = relative.sub(/\.rb\z/, "_spec.rb")
-      File.join(config.target_dir, "spec", spec_relative)
+      if test_suite.framework == :minitest
+        File.join(config.target_dir, "test", relative.sub(/\.rb\z/, "_test.rb"))
+      else
+        File.join(config.target_dir, "spec", relative.sub(/\.rb\z/, "_spec.rb"))
+      end
     end
   end
 end

data/lib/mutaterb/progress_reporter.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module MutateRB
+  # Live feedback for a run in progress (FR-001 to FR-005, FR-007): mutaterb used to print
+  # nothing between start and the final summary, so a long run was indistinguishable from a
+  # hang. A background thread ticks a status line on a timer, independent of whether the
+  # baseline suite or a single mutant's tests have actually finished (FR-003a) — the real work
+  # happens inside an opaque, blocking subprocess call, so this is the only way to keep the
+  # terminal changing during a slow phase.
+  class ProgressReporter
+    SPINNER_FRAMES = %w[| / - \\].freeze
+    TTY_TICK_INTERVAL = 0.3
+    NON_TTY_TICK_INTERVAL = 5
+
+    def initialize(io: $stdout, verbose: false, tick_interval: nil)
+      @io = io
+      @verbose = verbose
+      @tick_interval = tick_interval || (io.tty? ? TTY_TICK_INTERVAL : NON_TTY_TICK_INTERVAL)
+      @mutex = Mutex.new
+      @phase = :idle
+      @processed = 0
+      @total = 0
+      @phase_started_at = nil
+      @ticker_thread = nil
+    end
+
+    def start_baseline
+      @mutex.synchronize do
+        @phase = :baseline
+        @phase_started_at = Time.now
+      end
+      @io.puts "Running baseline tests..."
+      start_ticker
+    end
+
+    def finish_baseline
+      stop_ticker
+    end
+
+    def start_mutants(total)
+      @mutex.synchronize do
+        @phase = :mutating
+        @processed = 0
+        @total = total
+        @phase_started_at = Time.now
+      end
+      start_ticker unless @verbose
+    end
+
+    # In verbose mode, this line IS the progress indicator for the mutant loop (FR-005):
+    # the bare counter/ticker never runs, so there is nothing to interleave with it.
+    def mutant_finished(mutant)
+      if @verbose
+        print_mutant_line(mutant)
+      else
+        @mutex.synchronize { @processed += 1 }
+      end
+    end
+
+    def finish_mutants
+      stop_ticker
+      @mutex.synchronize { @phase = :done }
+    end
+
+    private
+
+    def print_mutant_line(mutant)
+      @io.puts "#{mutant.file_path}:#{mutant.line} [#{mutant.operator_type}] " \
+               "'#{mutant.original_fragment}' -> '#{mutant.mutated_fragment}' => #{mutant.status}"
+    end
+
+    def start_ticker
+      @ticker_thread = Thread.new { tick_loop }
+    end
+
+    def stop_ticker
+      return unless @ticker_thread
+
+      @ticker_thread.kill
+      @ticker_thread.join
+      @ticker_thread = nil
+      @io.puts if @io.tty?
+    end
+
+    # Never lets a rendering bug abort the real mutation run (Principio V): worst case, the
+    # ticker just stops drawing and the run continues silently, exactly like before this
+    # feature existed.
+    def tick_loop
+      loop do
+        sleep @tick_interval
+        draw
+      end
+    rescue StandardError
+      nil
+    end
+
+    def draw
+      line = current_line
+      return unless line
+
+      if @io.tty?
+        @io.print "\r#{line}"
+        @io.flush
+      else
+        @io.puts line
+      end
+    end
+
+    def current_line
+      @mutex.synchronize do
+        next nil unless @phase_started_at
+
+        elapsed = Time.now - @phase_started_at
+        spinner = SPINNER_FRAMES[(elapsed / @tick_interval).to_i % SPINNER_FRAMES.size]
+        case @phase
+        when :baseline
+          "Running baseline tests... (#{spinner} #{elapsed.round}s)"
+        when :mutating
+          "Mutating... #{@processed}/#{@total} (#{spinner} #{elapsed.round}s)"
+        end
+      end
+    end
+  end
+end

data/lib/mutaterb/project_detector.rb

@@ -1,17 +1,19 @@
 # frozen_string_literal: true
 
 module MutateRB
-  # Detects whether the target project is Ruby or Rails and locates its RSpec
-  # files (FR-001, FR-002).
+  # Detects whether the target project is Ruby or Rails, which test framework
+  # it uses (RSpec and/or Minitest), and locates its test files (FR-001,
+  # FR-002, FR-003).
   class ProjectDetector
-    Detection = Struct.new(:project_type, :spec_files)
+    Detection = Struct.new(:project_type, :test_framework, :test_files, :ambiguous_frameworks)
 
     def initialize(config)
       @config = config
     end
 
     def detect
-      Detection.new(project_type, discover_spec_files)
+      framework, ambiguous = resolve_test_framework
+      Detection.new(project_type, framework, discover_test_files(framework), ambiguous)
     end
 
     private
@@ -24,9 +26,33 @@ module MutateRB
       File.exist?(rails_marker) || File.exist?(rails_bin) ? :rails : :ruby
     end
 
-    def discover_spec_files
-      pattern = File.join(config.target_dir, "spec", "**", "*_spec.rb")
-      apply_scope(Dir.glob(pattern))
+    # research.md #1: an explicit config.test_framework always wins; otherwise
+    # detect by which test files actually exist, RSpec winning when both do.
+    def resolve_test_framework
+      return [config.test_framework, false] unless config.test_framework == :auto
+
+      has_rspec = test_files?(:rspec)
+      has_minitest = test_files?(:minitest)
+      return [:rspec, true] if has_rspec && has_minitest
+      return [:minitest, false] if has_minitest && !has_rspec
+
+      [:rspec, false]
+    end
+
+    def test_files?(framework)
+      !Dir.glob(test_file_pattern(framework)).empty?
+    end
+
+    def discover_test_files(framework)
+      apply_scope(Dir.glob(test_file_pattern(framework)))
+    end
+
+    def test_file_pattern(framework)
+      if framework == :minitest
+        File.join(config.target_dir, "test", "**", "*_test.rb")
+      else
+        File.join(config.target_dir, "spec", "**", "*_spec.rb")
+      end
     end
 
     def apply_scope(files)

data/lib/mutaterb/reporter.rb

@@ -70,11 +70,13 @@ module MutateRB
       c = run.config
       {
         target_dir: c.target_dir,
+        framework: run.test_suite.framework.to_s,
         include_paths: c.include_paths,
         exclude_paths: c.exclude_paths,
         strictness: c.strictness.to_s,
         mutation_types: c.mutation_types.map(&:to_s),
-        exit_on_survivors: c.exit_on_survivors
+        exit_on_survivors: c.exit_on_survivors,
+        verbose: c.verbose
       }
     end
 

data/lib/mutaterb/test_adapters/minitest_adapter.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+module MutateRB
+  module TestAdapters
+    # Builds a Minitest invocation and parses its native `--verbose` output —
+    # no added dependency in the target project (FR-009, research.md #2/#4).
+    #
+    # Minitest's own runner only knows how to run one file's worth of tests
+    # per process, and its verbose line format doesn't name the source file,
+    # so this adapter spawns one process per file (joined with `&&` into a
+    # single shell command, so TestRunner still only tracks one pid) and
+    # emits a marker line between them to attribute each parsed example back
+    # to the file it came from.
+    class MinitestAdapter
+      LINE_PATTERN = /^(\S+)\s*=\s*([\d.]+)\s*s\s*=\s*([.FES])/
+      FILE_MARKER = "@@MUTATERB_FILE@@"
+
+      def self.command_for(files, project_type:)
+        files.map { |file| "echo #{FILE_MARKER}#{Shellwords.escape(file)} && #{run_one(file, project_type)}" }
+             .join(" && ")
+      end
+
+      def self.run_one(file, project_type)
+        runner = project_type == :rails ? "bin/rails test" : "bundle exec ruby -Itest -Ilib"
+        "#{runner} #{Shellwords.escape(file)} -v"
+      end
+      private_class_method :run_one
+
+      def self.parse(raw, files: [])
+        current_file = files.first
+        examples = []
+        raw.each_line do |line|
+          if (marker = line[/\A#{Regexp.escape(FILE_MARKER)}(.+)/, 1])
+            current_file = marker.strip
+            next
+          end
+
+          append_example(examples, line, current_file)
+        end
+        { status: :completed, examples: examples }
+      end
+
+      def self.append_example(examples, line, file)
+        match = line.match(LINE_PATTERN)
+        return unless match
+
+        result_char = match[3]
+        return if result_char == "S" # skipped: excluded, not passed/failed (research.md #2)
+
+        examples << {
+          id: match[1],
+          description: match[1],
+          file_path: file,
+          status: result_char == "." ? :passed : :failed,
+          duration: match[2].to_f
+        }
+      end
+      private_class_method :append_example
+    end
+  end
+end

data/lib/mutaterb/test_adapters/rspec_adapter.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "json"
+require "shellwords"
+
+module MutateRB
+  module TestAdapters
+    # Builds the `bundle exec rspec` command and parses its `--format json`
+    # output (extracted from TestRunner, research.md #3 of feature 004 —
+    # MutateRB never bundles its own RSpec, it shells out to the target
+    # project's own).
+    class RspecAdapter
+      def self.command_for(files, project_type:) # rubocop:disable Lint/UnusedMethodArgument
+        "bundle exec rspec --format json #{Shellwords.join(files)}"
+      end
+
+      def self.parse(raw, files: []) # rubocop:disable Lint/UnusedMethodArgument
+        data = JSON.parse(raw)
+        examples = data.fetch("examples", []).map do |example|
+          {
+            id: example["id"],
+            description: example["full_description"],
+            file_path: example["file_path"],
+            status: example["status"] == "passed" ? :passed : :failed,
+            duration: example["run_time"].to_f
+          }
+        end
+        { status: :completed, examples: examples }
+      rescue JSON::ParserError
+        { status: :error, examples: [] }
+      end
+    end
+  end
+end

data/lib/mutaterb/test_runner.rb

@@ -1,28 +1,34 @@
 # frozen_string_literal: true
 
-require "json"
 require "timeout"
 require "bundler"
 
 module MutateRB
-  # Runs the target project's own RSpec suite as a subprocess (research.md #2):
-  # MutateRB never bundles its own RSpec, it shells out to `bundle exec rspec`
-  # inside the target project so the project's own Gemfile.lock decides the
-  # RSpec version.
+  # Runs the target project's own test suite as a subprocess (research.md #2
+  # of feature 001): MutateRB never bundles its own RSpec/Minitest, it shells
+  # out to the target project's own. The actual command and output parsing
+  # are delegated to a framework-specific adapter (research.md #3 of feature
+  # 004); this class owns spawning, timeouts, and killing hung processes.
   class TestRunner
     MIN_TIMEOUT_SECONDS = 5
 
-    def initialize(config:, project_type:)
+    ADAPTERS = {
+      rspec: TestAdapters::RspecAdapter,
+      minitest: TestAdapters::MinitestAdapter
+    }.freeze
+
+    def initialize(config:, project_type:, framework: :rspec)
       @config = config
       @project_type = project_type
+      @adapter = ADAPTERS.fetch(framework)
     end
 
-    # Runs the given spec files once, unmutated, and returns one Hash per
-    # RSpec example: { id:, description:, file_path:, status:, duration: }.
+    # Runs the given test files once, unmutated, and returns one Hash per
+    # test example: { id:, description:, file_path:, status:, duration: }.
     # Used to build TestCase instances (FR-012's baseline_status) and as the
     # basis for the per-mutant timeout (FR-014).
-    def run_baseline(spec_files)
-      spawn_rspec(spec_files, timeout_seconds: nil).fetch(:examples, [])
+    def run_baseline(files)
+      spawn_test_command(files, timeout_seconds: nil).fetch(:examples, [])
     end
 
     # Runs the given test cases against a mutation. Timeout = 2x the slowest
@@ -35,82 +41,66 @@ module MutateRB
       slowest_baseline = test_cases.filter_map(&:baseline_duration_seconds).max || 0
       timeout_seconds = [slowest_baseline * 2, MIN_TIMEOUT_SECONDS].max
       files = test_cases.map(&:file_path).uniq
-      spawn_rspec(files, timeout_seconds: timeout_seconds)
+      spawn_test_command(files, timeout_seconds: timeout_seconds)
     end
 
     private
 
-    attr_reader :config, :project_type
+    attr_reader :config, :project_type, :adapter
 
     # Runs inside Bundler.with_unbundled_env (research.md #2): when `mutaterb`
     # itself is invoked via `bundle exec`, BUNDLE_GEMFILE/RUBYOPT point at
-    # MutateRB's own Gemfile and would otherwise leak into this child process,
-    # making `bundle exec rspec` resolve the target project's suite against
-    # the wrong bundle. with_unbundled_env restores the pre-bundler
-    # environment for the duration of the spawn.
-    def spawn_rspec(files, timeout_seconds:)
+    # MutateRB's own Gemfile and would otherwise leak into this child process.
+    # Spawned in its own process group (pgroup: true) so that when the
+    # adapter's command is a shell pipeline (Minitest's multi-file case joins
+    # several invocations with `&&`), killing the group also reaches the
+    # actual test process, not just the intermediate shell.
+    def spawn_test_command(files, timeout_seconds:)
       env = project_type == :rails ? { "RAILS_ENV" => "test" } : {}
+      command = adapter.command_for(files, project_type: project_type)
       stdout_read, stdout_write = IO.pipe
       pid = Bundler.with_unbundled_env do
-        Process.spawn(env, *rspec_command(files), out: stdout_write, err: File::NULL,
-                                                  chdir: File.expand_path(config.target_dir))
+        Process.spawn(env, command, out: stdout_write, err: File::NULL, pgroup: true,
+                                    chdir: File.expand_path(config.target_dir))
       end
       stdout_write.close
 
-      output = wait_with_timeout(pid, stdout_read, timeout_seconds)
+      output = wait_with_timeout(pid, stdout_read, timeout_seconds, files)
       stdout_read.close unless stdout_read.closed?
       output
     end
 
-    def wait_with_timeout(pid, stdout_read, timeout_seconds)
+    def wait_with_timeout(pid, stdout_read, timeout_seconds, files)
       if timeout_seconds
-        Timeout.timeout(timeout_seconds) { read_and_wait(pid, stdout_read) }
+        Timeout.timeout(timeout_seconds) { read_and_wait(pid, stdout_read, files) }
       else
-        read_and_wait(pid, stdout_read)
+        read_and_wait(pid, stdout_read, files)
       end
     rescue Timeout::Error
       kill(pid)
       { status: :timeout, examples: [] }
     end
 
-    def read_and_wait(pid, stdout_read)
+    def read_and_wait(pid, stdout_read, files)
       raw = stdout_read.read
       Process.wait(pid)
-      parse_output(raw)
+      adapter.parse(raw, files: files)
     end
 
-    # Kills a hung child process: TERM first, KILL if it ignores TERM for 1s
-    # (research.md #3 — Timeout alone never touches the child process).
+    # Kills a hung child process group: TERM first, KILL if it ignores TERM
+    # for 1s (research.md #3 of feature 001 — Timeout alone never touches the
+    # child process). Signals the whole process group (negative pid) so a
+    # shell-wrapped command's real child is reached too.
     def kill(pid)
-      Process.kill("TERM", pid)
+      Process.kill("TERM", -pid)
       begin
         Timeout.timeout(1) { Process.wait(pid) }
       rescue Timeout::Error
-        Process.kill("KILL", pid)
+        Process.kill("KILL", -pid)
         Process.wait(pid)
       end
     rescue Errno::ESRCH, Errno::ECHILD
       nil
     end
-
-    def rspec_command(files)
-      ["bundle", "exec", "rspec", "--format", "json", *files]
-    end
-
-    def parse_output(raw)
-      data = JSON.parse(raw)
-      examples = data.fetch("examples", []).map do |example|
-        {
-          id: example["id"],
-          description: example["full_description"],
-          file_path: example["file_path"],
-          status: example["status"] == "passed" ? :passed : :failed,
-          duration: example["run_time"].to_f
-        }
-      end
-      { status: :completed, examples: examples }
-    rescue JSON::ParserError
-      { status: :error, examples: [] }
-    end
   end
 end

data/lib/mutaterb/test_suite.rb

@@ -4,23 +4,25 @@ module MutateRB
   # The collection of tests detected for the target project (data-model.md).
   class TestSuite
     VALID_PROJECT_TYPES = %i[ruby rails].freeze
+    VALID_FRAMEWORKS = %i[rspec minitest].freeze
 
     attr_reader :framework, :project_type, :test_cases
 
-    def initialize(project_type:, test_cases: [])
+    def initialize(project_type:, framework: :rspec, test_cases: [])
       unless VALID_PROJECT_TYPES.include?(project_type)
         raise ArgumentError,
               "invalid project_type #{project_type.inspect}"
       end
+      raise ArgumentError, "invalid framework #{framework.inspect}" unless VALID_FRAMEWORKS.include?(framework)
 
-      @framework = :rspec
+      @framework = framework
       @project_type = project_type
       @test_cases = Array(test_cases)
     end
 
     # Builds a TestSuite from the raw example hashes returned by
     # TestRunner#run_baseline (FR-012's baseline_status comes from here).
-    def self.from_baseline(project_type:, baseline_examples:)
+    def self.from_baseline(project_type:, framework:, baseline_examples:)
       test_cases = baseline_examples.map do |example|
         TestCase.new(
           id: example.fetch(:id),
@@ -30,7 +32,7 @@ module MutateRB
           baseline_duration_seconds: example.fetch(:duration)
         )
       end
-      new(project_type: project_type, test_cases: test_cases)
+      new(project_type: project_type, framework: framework, test_cases: test_cases)
     end
 
     def find(id)

data/lib/mutaterb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MutateRB
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/mutaterb.rb

@@ -9,6 +9,8 @@ require_relative "mutaterb/config"
 require_relative "mutaterb/mutation_run"
 require_relative "mutaterb/flag_parser"
 require_relative "mutaterb/project_detector"
+require_relative "mutaterb/test_adapters/rspec_adapter"
+require_relative "mutaterb/test_adapters/minitest_adapter"
 require_relative "mutaterb/test_runner"
 require_relative "mutaterb/mutation_operators/base_operator"
 require_relative "mutaterb/mutation_operators/conditional_boundary_operator"
@@ -16,6 +18,7 @@ require_relative "mutaterb/mutation_operators/boolean_literal_operator"
 require_relative "mutaterb/mutation_operators/nil_literal_operator"
 require_relative "mutaterb/mutation_operators/arithmetic_comparison_operator"
 require_relative "mutaterb/mutator"
+require_relative "mutaterb/progress_reporter"
 require_relative "mutaterb/reporter"
 require_relative "mutaterb/cli"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mutaterb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - MarceloM47
@@ -76,8 +76,11 @@ files:
 - lib/mutaterb/mutation_operators/nil_literal_operator.rb
 - lib/mutaterb/mutation_run.rb
 - lib/mutaterb/mutator.rb
+- lib/mutaterb/progress_reporter.rb
 - lib/mutaterb/project_detector.rb
 - lib/mutaterb/reporter.rb
+- lib/mutaterb/test_adapters/minitest_adapter.rb
+- lib/mutaterb/test_adapters/rspec_adapter.rb
 - lib/mutaterb/test_case.rb
 - lib/mutaterb/test_runner.rb
 - lib/mutaterb/test_suite.rb