mutaterb 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e60dd9f48be985c4852b318ee38410f6ce76cb924604c9d37f1f64004e2c27f6
-  data.tar.gz: 6ef1b8387ed290681db0ab7480021fe2536782cf57478834d56f1331b3676ecc
+  metadata.gz: 71841b126edbdca7f12d77aaca2622dde361a8011a49fbd2973cde656737c134
+  data.tar.gz: 2c45a913486f515d16ab0217d331b35e98f84f620a43b9a6496ad8c94681c940
 SHA512:
-  metadata.gz: 1f168ec32386423f8c2beb49856791fed45ce11c80f42d3d7284d1782577b9c55e7f3344b13360ecbcc2b1bbf22932e919d1b79d5af05529fc40d353445581ea
-  data.tar.gz: bf83a88519717178e2863c9ec85ef30acaeddb0dac5433ee0b467c4d2d7aa2f14d38ed657173903f74045a84446cb8e465002d7895d0ca69344cd780f72784ca
+  metadata.gz: 1b716efda6a38584d538c4b76d82113be716dea2f466efd293afcef20d9b40aaf628a80ffd5aef8d3c8f80848314e3a6269bcb2877cf42d8c6c9b5bcb75dabe6
+  data.tar.gz: 24655446fcfc728007c10e89d7b8be5df414aaf99baf3d441f154add892c1dfcb59251570ca9747b132d606c167acb3ecb9e3ea71bcc230c8df6105dd912440c

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,11 @@ 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.
 
 ### Main flags
 
@@ -37,6 +39,7 @@ 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 |
 | `--json-output PATH` | Export the results summary to a JSON file |

data/lib/mutaterb/cli.rb

@@ -39,10 +39,11 @@ 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)
       run = MutationRun.new(config: config, test_suite: test_suite)
@@ -57,10 +58,21 @@ module MutateRB
       run.exit_code
     end
 
+    # 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)
-      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)
+      test_runner = TestRunner.new(config: config, project_type: detection.project_type,
+                                   framework: detection.test_framework)
+      baseline_examples = test_runner.run_baseline(detection.test_files)
+      TestSuite.from_baseline(project_type: detection.project_type, framework: detection.test_framework,
+                              baseline_examples: baseline_examples)
     end
 
     def run_mutations(run, test_suite, config)

data/lib/mutaterb/config.rb

@@ -8,14 +8,15 @@ 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
 
     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)
       @target_dir = target_dir
       @include_paths = include_paths
       @exclude_paths = exclude_paths
@@ -23,6 +24,7 @@ module MutateRB
       @mutation_types = mutation_types
       @exit_on_survivors = exit_on_survivors
       @json_output_path = json_output_path
+      @test_framework = test_framework
       validate!
     end
 
@@ -46,7 +48,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]
       raw.each_key do |key|
         warn "mutaterb: ignoring unknown config key #{key.inspect}" unless known_keys.include?(key)
       end
@@ -64,7 +66,8 @@ 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
       }
     end
     private_class_method :attributes_from_yaml
@@ -94,15 +97,27 @@ 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)
 
+      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

data/lib/mutaterb/mutator.rb

@@ -15,7 +15,8 @@ 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
 
     # Yields each finished Mutant, one at a time.
@@ -31,7 +32,7 @@ module MutateRB
 
     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 +128,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/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,6 +70,7 @@ 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,

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.2.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"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mutaterb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - MarceloM47
@@ -78,6 +78,8 @@ files:
 - lib/mutaterb/mutator.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