mutineer 1.2.0 → 1.4.0

data/lib/mutineer/reporter.rb

@@ -35,11 +35,13 @@ module Mutineer
     # or to `out`. Diagnostics always go to `err`. `scoped` marks a diff-scoped
     # (`--since`) run; the JSON report records it so a consumer (or a later
     # `--baseline` load) knows the score covers only the changed-line mutants.
+    # `legacy_id_matches` (`{ignore:, baseline:}`) counts stored ids still in the
+    # old format (#126); only the JSON report records it (`summary.legacy_id_matches`).
     def report(out: $stdout, err: $stderr, threshold: 0.0, format: "human", output: nil,
-               baseline: nil, scoped: false)
+               baseline: nil, scoped: false, legacy_id_matches: { ignore: 0, baseline: 0 })
       rendered =
         if format == "json"
-          json_report(baseline, scoped: scoped)
+          json_report(baseline, scoped: scoped, legacy_id_matches: legacy_id_matches)
         elsif format == "html"
           html_report
         else
@@ -131,8 +133,11 @@ module Mutineer
     # @param baseline [Mutineer::Baseline::Delta, nil] baseline delta.
     # @param scoped [Boolean] the run was diff-scoped (`--since`), so its score
     #   covers only the changed-line mutants (additive `summary.scoped` key).
+    # @param legacy_id_matches [Hash{Symbol => Integer}] `{ignore:, baseline:}`:
+    #   old-format ignore entries that matched, and survivors matched in an
+    #   old-format baseline only through their old id (#126).
     # @return [String] JSON text.
-    def json_report(baseline = nil, scoped: false)
+    def json_report(baseline = nil, scoped: false, legacy_id_matches: { ignore: 0, baseline: 0 })
       killed = @agg.killed_count
       survived = @agg.survived_count
       # null (not 0.0) on an empty denominator, matching the nil-vs-0.0
@@ -141,7 +146,7 @@ module Mutineer
       score = @agg.mutation_score
 
       doc = {
-        schema_version: "1.3",
+        schema_version: "1.4",
         summary: {
           total: @agg.total, killed: killed, survived: survived,
           no_coverage: @agg.no_coverage_count,
@@ -155,7 +160,15 @@ module Mutineer
           # Additive: true when the run was diff-scoped (--since). The score then
           # covers only the changed-line mutants, so it is not comparable to a
           # full-run score; Baseline#diff reads this to skip the score-drop gate.
-          scoped: scoped
+          scoped: scoped,
+          # Additive (1.4, #126): ids hash the project-relative file path. A
+          # baseline without this key stores old-format ids; Baseline#diff then
+          # also matches on old ids.
+          id_format: 2,
+          # Additive (1.4, #126): stored ids still in the old format. `ignore` is
+          # the number of old-format ignore entries that matched; `baseline` the
+          # survivors matched in the baseline only through their old id.
+          legacy_id_matches: legacy_id_matches
         },
         survivors: @agg.surviving_mutants.map { |r| survivor_json(r) }
                        .sort_by { |h| [h[:file], h[:line], h[:operator]] },

data/lib/mutineer/result.rb

@@ -28,8 +28,8 @@ module Mutineer
   # `subject`, `mutation`, and `id` are nil when the Result is built by
   # Isolation/Runner (which only know the outcome); the orchestrator attaches
   # them afterwards via `result.with(subject:, mutation:, id:)` so the Reporter
-  # can render survivor diffs and emit the stable id. `id` is the content-based
-  # MutantId.
+  # can render survivor diffs and emit the id. `id` is the content-based
+  # MutantId (it includes the project-relative file path).
   Result = Data.define(:status, :details, :subject, :mutation, :id) do
     # Builds a killed result.
     #

data/lib/mutineer/runner.rb

@@ -13,6 +13,7 @@ require_relative "mutator_registry"
 require_relative "worker_pool"
 require_relative "progress"
 require_relative "mutant_id"
+require_relative "project_path"
 require_relative "file_swap"
 require_relative "external_backend"
 require_relative "daemon_backend"
@@ -31,15 +32,18 @@ module Mutineer
   class Runner
     # Full orchestration: resolve operators, discover subjects, build the
     # coverage map, run every mutation, and aggregate. Returns
-    # [AggregateResult, source_map]. The CLI then reports + applies the exit code;
-    # the integration test asserts directly on the AggregateResult.
+    # [AggregateResult, source_map, extras], where extras is the hash
+    # {.collect_jobs} returns (`:legacy_ignore_matches`, `:id_map`), unchanged.
+    # The CLI then reports + applies the exit code; the integration test asserts
+    # directly on the AggregateResult.
     #
     # The parent process `require`s each source file so its classes exist; forked
     # children inherit them, so a covering test file's own require_relative of the
     # source is a no-op and does not clobber the mutated `load` (spec §7).
     #
     # @param config [Mutineer::Config] run configuration.
-    # @return [Array(Mutineer::AggregateResult, Hash<String, String>)] aggregate and source map.
+    # @return [Array(Mutineer::AggregateResult, Hash<String, String>, Hash)] aggregate,
+    #   source map, and run extras.
     def self.execute(config)
       operator_classes = MutatorRegistry.resolve(config.operators || MutatorRegistry::DEFAULT_NAMES)
 
@@ -109,7 +113,7 @@ module Mutineer
       abort_if_unclean!(coverage_map)
 
       # Collect every (subject, mutation) up front so the pool can fan them out.
-      jobs, ignored_results, source_map = collect_jobs(config, operator_classes)
+      jobs, ignored_results, source_map, extras = collect_jobs(config, operator_classes)
 
       jobs = filter_since(jobs, source_map, config) if config.since
 
@@ -144,40 +148,75 @@ module Mutineer
           sweep_orphans(dirs)
         end
 
-      [AggregateResult.new(results + ignored_results), source_map]
+      [AggregateResult.new(results + ignored_results), source_map, extras]
     end
 
     # Collect every (subject, mutation, id) up front so a backend can run them.
     # A mutant the user marked known-equivalent (inline disable-line comment or
     # .mutineer.yml ignore id) is classified :ignored here and NEVER run. It is
     # removed from the killed+survived denominator so a strong file reaches 100%.
-    # The stable id is computed per subject (occurrence needs the full list) and
-    # carried on every job so the parent can reattach it after the run. Shared by
-    # the in-process, external, and daemon backends so job selection can never drift.
+    # The id is computed per subject (occurrence needs the full list), keyed on
+    # the file path relative to config.project_root, and carried on every job so
+    # the parent can reattach it after the run. Shared by the in-process,
+    # external, and daemon backends so job selection can never drift.
     #
-    # @return [Array(Array, Array<Result>, Hash<String,String>)] jobs, ignored, source_map.
+    # Each mutant also gets its old-format id ({MutantId.legacy_for}), so an ignore
+    # entry stored before ids carried the path still suppresses it. Prints nothing:
+    # the extras hash returns, as data, `legacy_ignore_matches` (each old-format
+    # ignore entry that matched a mutant through its old-format id => one
+    # `{id:, file:, subject:}` hash per matched mutant, in collection order: its
+    # new id, its project-relative file and its subject's qualified name;
+    # recorded even when a new id is also listed, since the old entry still
+    # over-matches other files) and `id_map` (every new id => its old-format id).
+    #
+    # Subjects sharing a qualified name in one file (two owner-less `def index`
+    # in two DSL blocks) get a per-file ordinal in discovery order, so their ids
+    # differ; the first one's ordinal is 0 and leaves its id unchanged.
+    #
+    # @param config [Mutineer::Config] run configuration.
+    # @param operator_classes [Array<Class>] resolved operators.
+    # @return [Array(Array, Array<Result>, Hash<String,String>, Hash{Symbol => Hash})]
+    #   jobs, ignored, source_map, and extras (`:legacy_ignore_matches`, `:id_map`).
     def self.collect_jobs(config, operator_classes)
       source_map = {}
       disabled_map = {}
+      id_paths = {}
+      # [file, qualified_name] => { declaration offset => ordinal }: keyed by the
+      # declaration, so the same file discovered twice (two path spellings) reuses
+      # its ordinal instead of minting a second id for the same mutant.
+      name_decls = Hash.new { |h, k| h[k] = {} }
       ignore_set = config.ignore.to_set
       jobs = []
       ignored_results = []
+      legacy_ignore_matches = {}
+      id_map = {}
       Project.discover(config.sources, only: config.only).each do |subject|
         source = (source_map[subject.file] ||= File.read(subject.file))
         disabled = (disabled_map[subject.file] ||= suppress_map(source, subject.file))
         mutations = operator_classes.flat_map { |klass| klass.new.mutations_for(subject, source) }
-        ids = MutantId.for_subject(subject, source, mutations)
+        id_path = (id_paths[subject.file] ||= ProjectPath.relative(subject.file, config.project_root))
+        decls = name_decls[[id_path, subject.qualified_name]]
+        ordinal = (decls[subject.def_node.location.start_offset] ||= decls.size)
+        ids = MutantId.for_subject(subject, source, mutations, path: id_path, subject_ordinal: ordinal)
+        legacy_ids = MutantId.legacy_for_subject(subject, source, mutations)
         mutations.each_with_index do |mutation, i|
           id = ids[i]
+          legacy = legacy_ids[i]
+          id_map[id] = legacy
+          # An old entry still over-matches other files even when the new id is
+          # listed too, so every old-entry match is reported for migration.
+          if ignore_set.include?(legacy)
+            (legacy_ignore_matches[legacy] ||= []) << { id: id, file: id_path, subject: subject.qualified_name }
+          end
           line = source.byteslice(0, mutation.start_offset).count("\n") + 1
-          if suppressed?(mutation.operator, line, id, disabled, ignore_set)
+          if suppressed?(mutation.operator, line, [id, legacy], disabled, ignore_set)
             ignored_results << Result.ignored.with(subject: subject, mutation: mutation, id: id)
           else
             jobs << [subject, mutation, id]
           end
         end
       end
-      [jobs, ignored_results, source_map]
+      [jobs, ignored_results, source_map, { legacy_ignore_matches: legacy_ignore_matches, id_map: id_map }]
     end
 
     # External backend orchestration. Runs each mutant's whole-file mutation on
@@ -189,7 +228,8 @@ module Mutineer
     #
     # @param config [Mutineer::Config] run configuration (test_command set).
     # @param operator_classes [Array<Class>] resolved operators.
-    # @return [Array(Mutineer::AggregateResult, Hash<String,String>)] aggregate and source map.
+    # @return [Array(Mutineer::AggregateResult, Hash<String,String>, Hash)] aggregate,
+    #   source map, and the {.collect_jobs} extras.
     def self.execute_external(config, operator_classes)
       abs_tests = config.tests.map { |t| File.expand_path(t, config.project_root) }
       sources   = config.sources.map { |s| FileSwap.canonical_path(File.expand_path(s, config.project_root)) }
@@ -205,12 +245,12 @@ module Mutineer
         # source. Heal first, then discover jobs from the clean tree.
         FileSwap.restore_orphans(dirs)
 
-        jobs, ignored_results, source_map = collect_jobs(config, operator_classes)
+        jobs, ignored_results, source_map, extras = collect_jobs(config, operator_classes)
         jobs = filter_since(jobs, source_map, config) if config.since
 
         # Nothing to mutate: return before the smoke check, which runs the whole
         # --test set to calibrate a timeout no mutant would use (#76).
-        next [AggregateResult.new(ignored_results), source_map] if jobs.empty?
+        next [AggregateResult.new(ignored_results), source_map, extras] if jobs.empty?
 
         # Calibrate the per-mutant timeout from the clean run (a real suite far
         # outlasts the 10s in-process fork budget), and abort if it is not green.
@@ -234,7 +274,7 @@ module Mutineer
           FileSwap.restore_orphans(dirs)
         end
 
-        [AggregateResult.new(results + ignored_results), source_map]
+        [AggregateResult.new(results + ignored_results), source_map, extras]
       end
     end
 
@@ -331,10 +371,14 @@ module Mutineer
     end
 
     # True when this mutant is suppressed: its line bears a disable-line marker
-    # (bare, or scoped to its operator), OR its stable id is in the config ignore
-    # list. Checked at job-build time so a suppressed mutant is never forked.
-    def self.suppressed?(operator, line, id, disabled, ignore_set)
-      return true if ignore_set.include?(id)
+    # (bare, or scoped to its operator), OR its new or old-format id is in the
+    # config ignore list. Checked at job-build time so a suppressed mutant is
+    # never forked.
+    #
+    # @param ids [Array<String>, String] the mutant's new id and its old-format
+    #   id, or a single id (the pre-#126 call shape).
+    def self.suppressed?(operator, line, ids, disabled, ignore_set)
+      return true if Array(ids).any? { |id| ignore_set.include?(id) }
 
       case (entry = disabled[line])
       when :all then true

data/lib/mutineer/subject.rb

@@ -4,8 +4,11 @@ module Mutineer
   # One discoverable method and its AST node.
   #
   # Location, namespace context, and the live Prism::DefNode are kept together
-  # because mutators walk the def node directly.
-  Subject = Struct.new(:file, :namespace, :name, :singleton, :def_node, keyword_init: true) do
+  # because mutators walk the def node directly. `namespace` names the owner
+  # (`module ::X` inside `Outer` owns into `X`); `lexical` is the class/module
+  # chain as written (`["Outer", "::X"]`), which the redefine strategy needs to
+  # rebuild the same Module.nesting as a whole-file reload (#145).
+  Subject = Struct.new(:file, :namespace, :name, :singleton, :def_node, :lexical, keyword_init: true) do
     # Returns the fully-qualified subject name.
     #
     # @return [String] namespaced method name like `Billing::Invoice#total`.
@@ -13,6 +16,14 @@ module Mutineer
       namespace.join("::") + (singleton ? "." : "#") + name.to_s
     end
 
+    # Class/module chain as written in the source, for textual wrappers. Falls
+    # back to `namespace` for subjects built without one.
+    #
+    # @return [Array<String>] names; a root-anchored element keeps its `::`.
+    def lexical_namespace
+      lexical || namespace
+    end
+
     # Returns the body location for the subject, if any.
     #
     # @return [Prism::Location, nil] body location or nil for empty methods.

data/lib/mutineer/version.rb

@@ -2,5 +2,5 @@
 
 module Mutineer
   # Current Mutineer release version.
-  VERSION = "1.2.0"
+  VERSION = "1.4.0"
 end

data/lib/mutineer.rb

@@ -31,6 +31,8 @@ require_relative "mutineer/mutators/negation_removal"
 require_relative "mutineer/mutators/chain_link"
 require_relative "mutineer/mutators/operand_removal"
 require_relative "mutineer/mutators/array_literal"
+require_relative "mutineer/mutators/condition_forcing"
+require_relative "mutineer/mutators/operator_assignment"
 require_relative "mutineer/mutator_registry"
 require_relative "mutineer/worker_pool"
 require_relative "mutineer/progress"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mutineer
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.4.0
 platform: ruby
 authors:
 - David Teren
@@ -77,10 +77,12 @@ files:
 - lib/mutineer/mutators/chain_link.rb
 - lib/mutineer/mutators/collection_method.rb
 - lib/mutineer/mutators/comparison.rb
+- lib/mutineer/mutators/condition_forcing.rb
 - lib/mutineer/mutators/condition_negation.rb
 - lib/mutineer/mutators/literal_mutation.rb
 - lib/mutineer/mutators/negation_removal.rb
 - lib/mutineer/mutators/operand_removal.rb
+- lib/mutineer/mutators/operator_assignment.rb
 - lib/mutineer/mutators/range_literal.rb
 - lib/mutineer/mutators/regex_literal.rb
 - lib/mutineer/mutators/return_nil.rb
@@ -91,6 +93,7 @@ files:
 - lib/mutineer/parser.rb
 - lib/mutineer/progress.rb
 - lib/mutineer/project.rb
+- lib/mutineer/project_path.rb
 - lib/mutineer/rails_worker_db.rb
 - lib/mutineer/reporter.rb
 - lib/mutineer/result.rb