active_mutator 0.2.0 → 0.4.0

data/lib/active_mutator/closure_reload.rb

@@ -0,0 +1,202 @@
+module ActiveMutator
+  # Fork-side insertion for class-body mutants. A def mutant can be
+  # class_eval'd over the live constant; class-level code cannot (re-running
+  # `validates` ADDS a validator, it doesn't replace one). So: remove the
+  # constant and re-eval the whole mutated file. Anything already attached to
+  # the OLD object — classes that include the module, subclasses, extend
+  # sites — would go stale, so they are removed and re-evaled too (pristine
+  # sources), dependency-first. The fork dies after the run; nothing is
+  # restored.
+  #
+  # Every guard failure raises Skip; the Worker reports the mutant as
+  # `skipped` with the reason. Skipping is honest: a mutant we cannot insert
+  # faithfully must not be counted as survived OR killed.
+  #
+  # Known limitations (inherent to remove-and-reload; accepted trade-offs):
+  #   - References that hold the target BY VALUE rather than by ancestry are
+  #     not discovered and keep pointing at the pre-remove_const object:
+  #     aliases (`ALIAS = MyClass`), arrays/registries the target was pushed
+  #     into, memoized instances, class variables captured at load time.
+  #   - `refine`-based modules are anonymous and do not appear in normal
+  #     `ancestors`, so refinements of the target are not discovered/reloaded.
+  #   - Re-evaling the target AND each attacher re-runs their class-body side
+  #     effects. Non-idempotent load-time effects (self-registration into a
+  #     global registry, DescendantsTracker-style hooks) therefore run twice; a
+  #     spec asserting such a count can see it doubled (false kill) or masked
+  #     (false survival).
+  #   - The re-eval order pins the target first (every attacher depends on it)
+  #     then sorts the rest by instance-ancestor depth. An `extend`
+  #     relationship BETWEEN two non-target attachers can still re-eval out of
+  #     order (rare); a full topological sort is deliberately not attempted.
+  class ClosureReload
+    Skip = Class.new(StandardError)
+
+    # The MUTATED target source could not be re-evaled — the mutation broke the
+    # class so it no longer loads. Every covering spec loads the class, so the
+    # suite would fail: the Worker maps this to a kill, not an error.
+    MutantLoadError = Class.new(StandardError)
+
+    DEFAULT_CAP = 10
+
+    class << self
+      # Assigned by Runner from config before scheduling; forks inherit it.
+      attr_writer :cap
+
+      def cap = @cap || DEFAULT_CAP
+    end
+
+    def initialize(subject, mutated_source)
+      @subject = subject
+      @mutated_source = mutated_source
+    end
+
+    def call(cap: self.class.cap)
+      target = resolve_target
+      closure = compute_closure(target)
+      if closure.size > cap
+        raise Skip, "reload closure (#{closure.size} constants) exceeds cap (#{cap})"
+      end
+
+      # Re-eval must load dependencies before dependents. Every closure member
+      # carries the target directly (single-pass discovery invariant), so the
+      # target must be re-eval'd first — pin it to the front. `ancestors.size`
+      # can't do this alone: an `extend` puts the target in the extender's
+      # SINGLETON ancestry, so a module that extends the target has an instance
+      # ancestry SMALLER than the target's and would sort before it (NameError
+      # on re-eval). For the remaining attachers, ascending instance-ancestor
+      # depth is a valid order among include/subclass relationships (a
+      # superclass before its subclass, an included module before its
+      # includer); depth is captured while the constants are still live, since
+      # it can't be read after remove_const.
+      rest = closure.reject { |m| m.equal?(target) }
+      ordered = [target, *rest.sort_by { |m| m.ancestors.size }]
+      sources = ordered.map { |mod| [mod.name, source_for(mod)] }
+      sources.each { |name, _| remove_constant(name) }
+      sources.each_with_index do |(_, (file, src)), idx|
+        eval(src, TOPLEVEL_BINDING, file, 1) # rubocop:disable Security/Eval
+      rescue ScriptError, StandardError => e
+        # idx.zero? is the MUTATED target, which by construction depends on
+        # nothing else in the closure (every other member carries the target,
+        # not vice versa). Its source failing to load is therefore the
+        # mutation's own doing — a kill, not a tool error.
+        #
+        # A PRISTINE dependent (idx > 0) failing means the ancestry-depth order
+        # couldn't satisfy a cross-attacher reference (see the ordering note
+        # above): we can't faithfully reinstate the closure, so this is an
+        # honest Skip, not a survived/killed verdict and not a bare error.
+        raise MutantLoadError, e.message if idx.zero?
+
+        raise Skip, "reload re-eval failed (#{e.message}); closure could not be reinstated in dependency order"
+      end
+      nil
+    end
+
+    private
+
+    def resolve_target
+      scope = @subject.constant_scope
+      target = begin
+        Object.const_get(scope)
+      rescue NameError
+        raise Skip, "constant #{scope} not loaded"
+      end
+      file, = Object.const_source_location(scope)
+      unless file && File.identical?(file, @subject.file)
+        raise Skip, "#{scope} defined at #{file || "?"}, not #{@subject.file} (reopened constant)"
+      end
+      target
+    end
+
+    # Single discovery pass. Ruby's `ancestors` is transitive, so one scan for
+    # everything carrying the target already yields every transitive attacher:
+    # an attacher-of-an-attacher (a subclass of an includer, an includer of an
+    # includer) carries the target directly too. No BFS/dedup is needed — the
+    # re-eval order is imposed later by pinning the target first and sorting the
+    # rest by ancestry depth (see #call), not by discovery order and not by a
+    # full topological sort (deliberately not attempted; see class docstring).
+    def compute_closure(target)
+      [target, *attachers(target)]
+    end
+
+    # Everything stale after removing `mod`: includers and subclasses carry
+    # it in `ancestors`; extend-sites carry it in their singleton class's
+    # ancestors, so singleton classes map back through attached_object. `.uniq`
+    # collapses a member found both ways (a class that both includes and
+    # extends the target).
+    def attachers(mod)
+      ObjectSpace.each_object(Module).filter_map do |m|
+        next if m.equal?(mod)
+        next unless carries?(m, mod)
+
+        if m.singleton_class?
+          m = m.attached_object
+          unless m.is_a?(Module)
+            raise Skip, "an object instance is extended with #{mod.name || mod.inspect}; not reloadable"
+          end
+        end
+
+        m
+      end.uniq
+    end
+
+    # ObjectSpace hands back every Module in the VM, including ones we cannot
+    # introspect — e.g. a module whose #ancestors is overridden to raise. A
+    # module we cannot read is not a reloadable dependency of the target, so
+    # treat it as unrelated rather than aborting the whole scan. Trade-off: a
+    # genuine attacher whose #ancestors raises would be silently dropped
+    # (acceptable — pathological).
+    #
+    # The rescue is deliberately broader than StandardError: #ancestors on a
+    # foreign object can raise Exception-level errors that are NOT StandardError
+    # — the canonical case is an expired RSpec verifying double
+    # (ExpiredTestDoubleError < MockExpectationError < Exception) left in
+    # ObjectSpace by another spec. Control-flow errors (a signal such as an
+    # interrupt, or an explicit exit) are re-raised so a run stays
+    # interruptible; everything else means "not a dependency, skip it".
+    def carries?(mod, target)
+      mod.ancestors.include?(target)
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      raise if e.is_a?(SignalException) || e.is_a?(SystemExit)
+
+      false
+    end
+
+    def source_for(mod)
+      name = mod.name
+      raise Skip, "anonymous #{mod.is_a?(Class) ? "class" : "module"} in reload closure" unless name
+
+      return [@subject.file, @mutated_source] if name == @subject.constant_scope
+
+      file, = Object.const_source_location(name)
+      raise Skip, "#{name}: no source file (native or dynamically defined)" unless file && File.exist?(file)
+
+      src = File.read(file)
+      unless single_constant_file?(src)
+        raise Skip, "#{name}: #{file} defines multiple top-level constants; not reloadable"
+      end
+
+      [file, src]
+    end
+
+    # Same Zeitwerk-shape rule the SubjectFinder gate applies to the target
+    # file: re-evaling a multi-constant file would re-run macros on constants
+    # that were NOT removed (accumulation bugs). Shared with SubjectFinder.
+    def single_constant_file?(source)
+      result = Prism.parse(source)
+      return false unless result.success?
+
+      ClassShape.single_top_level_constant?(result.value)
+    end
+
+    def remove_constant(name)
+      parts = name.split("::")
+      leaf = parts.pop
+      parent = parts.empty? ? Object : Object.const_get(parts.join("::"))
+      parent.send(:remove_const, leaf)
+    rescue NameError
+      # Either a parent namespace earlier in the closure was already removed
+      # (taking this nested constant with it), or the leaf is already gone.
+      # Nothing to remove — the re-eval pass reinstates it from its own file.
+    end
+  end
+end

data/lib/active_mutator/config.rb

@@ -3,7 +3,9 @@ require "etc"
 module ActiveMutator
   Config = Data.define(:paths, :since, :subject_filter, :jobs, :format, :requires,
                        :timeout_factor, :timeout_floor, :force_baseline, :root,
-                       :preload_helper, :serial_patterns, :browser_boot_seconds,
+                       :preload_helper, :serial_patterns, :spec_paths,
+                       :browser_boot_seconds,
                        :accept_survivors, :exclude, :max_mutants, :debug_plan,
-                       :fail_at, :adaptive_timeout, :operator_paths)
+                       :fail_at, :adaptive_timeout, :operators,
+                       :class_level, :class_level_closure_cap)
 end

data/lib/active_mutator/config_file.rb

@@ -19,15 +19,15 @@ module ActiveMutator
       "fail_at" => :score,
       "exclude" => :string_list,
       "serial_patterns" => :string_list,
+      "spec_paths" => :nonempty_string_list,
       "requires" => :string_list,
       "operators" => :string_list,
       "preload_helper" => :preload_helper,
-      "adaptive_timeout" => :boolean
+      "adaptive_timeout" => :boolean,
+      "class_level" => :boolean,
+      "class_level_closure_cap" => :positive_integer
     }.freeze
 
-    # YAML keys that don't match their Config member name.
-    RENAMES = { "operators" => :operator_paths }.freeze
-
     def self.load(root)
       path = File.join(root, FILENAME)
       return {} unless File.exist?(path)
@@ -40,7 +40,7 @@ module ActiveMutator
         validator = KEYS[key]
         raise Error, "#{FILENAME}: unknown config key: #{key}" unless validator
 
-        [RENAMES.fetch(key, key.to_sym), coerce(key, validator, value)]
+        [key.to_sym, coerce(key, validator, value)]
       end
     end
 
@@ -55,6 +55,10 @@ module ActiveMutator
       when :integer
         raise Error, "#{FILENAME}: #{key} must be an integer" unless value.is_a?(Integer)
         value
+      when :positive_integer
+        raise Error, "#{FILENAME}: #{key} must be an integer" unless value.is_a?(Integer)
+        raise Error, "#{FILENAME}: #{key} must be >= 1" unless value >= 1
+        value
       when :number
         raise Error, "#{FILENAME}: #{key} must be a number" unless value.is_a?(Numeric)
         value.to_f
@@ -72,6 +76,12 @@ module ActiveMutator
           raise Error, "#{FILENAME}: #{key} must be a list of strings"
         end
         value
+      when :nonempty_string_list
+        unless value.is_a?(Array) && value.all?(String)
+          raise Error, "#{FILENAME}: #{key} must be a list of strings"
+        end
+        raise Error, "#{FILENAME}: #{key} must not be empty" if value.empty?
+        value
       when :boolean
         unless [true, false].include?(value)
           raise Error, "#{FILENAME}: #{key} must be true or false"

data/lib/active_mutator/engine.rb

@@ -8,7 +8,9 @@ module ActiveMutator
       result = Prism.parse(source)
       raise Error, "#{subject.file} no longer parses" unless result.success?
 
-      def_node = find_def(result.value, subject.byte_range.begin)
+      return analyze_class_body(subject, source, result) if subject.class_body?
+
+      def_node = find_node(result.value, subject.byte_range.begin, Prism::DefNode)
       raise Error, "subject not found: #{subject.name}" unless def_node
 
       invalid = 0
@@ -22,16 +24,115 @@ module ActiveMutator
 
     private
 
-    def find_def(node, start_offset)
-      return node if node.is_a?(Prism::DefNode) && node.location.start_offset == start_offset
+    def analyze_class_body(subject, source, result)
+      class_node = find_node(result.value, subject.byte_range.begin, Prism::ClassNode, Prism::ModuleNode)
+      raise Error, "subject not found: #{subject.name}" unless class_node
+
+      invalid = 0
+      mutations = collect_class_body_edits(class_node).filter_map do |edit|
+        mutation, valid = build_class_body_mutation(subject, source, edit)
+        invalid += 1 unless valid
+        mutation
+      end
+      Analysis.new(mutations: mutations, invalid_count: invalid)
+    end
+
+    # Depth-first search for the node of one of `types` whose byte range starts
+    # at `start_offset`. Def-level and class-body subject location share this;
+    # only the node type(s) differ (DefNode vs Class/ModuleNode).
+    def find_node(node, start_offset, *types)
+      return node if types.any? { |t| node.is_a?(t) } && node.location.start_offset == start_offset
 
       node.compact_child_nodes.each do |child|
-        found = find_def(child, start_offset)
+        found = find_node(child, start_offset, *types)
         return found if found
       end
       nil
     end
 
+    # Class-level code only: defs, nested class/modules and `class << self`
+    # bodies are owned by other subjects. Lambdas (scope bodies, if: procs) ARE
+    # descended, as are the ActiveSupport::Concern DSL blocks (`included`,
+    # `prepended`, `class_methods`) whose bodies re-run as class-level code in
+    # the includer (issue #31). Every OTHER block (association extensions,
+    # custom DSLs that run in an unknown context) stays pruned — mutating those
+    # risks false survivors. Edits that would delete a whole owned statement
+    # (StatementDeletion sees the enclosing StatementsNode) are discarded.
+    # Owned ranges are collected recursively while walking, not just from the
+    # class body's direct children: a def can nest inside class-level control
+    # flow (`if`/`unless`/`begin`), and deleting it there is equally out of
+    # scope.
+    def collect_class_body_edits(class_node)
+      owned = []
+      edits = []
+      class_walk(class_node.body, owned) do |node|
+        @operators.each do |op|
+          edits.concat(op.edits(node))
+        rescue StandardError => e
+          raise Error, "operator #{op.class.name} failed on #{node.class.name}: #{e.message}"
+        end
+      end
+      edits.reject { |e| owned.include?(e.range) }
+    end
+
+    def owned_statement?(node) = ClassShape.owned_by_other_subject?(node)
+
+    # ActiveSupport::Concern DSL calls whose block body re-runs as class-level
+    # code in the includer, so it is in scope for class-body mutation.
+    CONCERN_BLOCK_CALLS = %i[included prepended class_methods].freeze
+
+    def concern_dsl_block?(node)
+      node.is_a?(Prism::CallNode) && node.receiver.nil? &&
+        CONCERN_BLOCK_CALLS.include?(node.name) && node.block.is_a?(Prism::BlockNode)
+    end
+
+    # No nil guard needed (unlike #walk): the entry node is the class body's
+    # StatementsNode, guaranteed present for a class-body subject, and
+    # compact_child_nodes never yields nil.
+    def class_walk(node, owned, &blk)
+      if owned_statement?(node)
+        owned << (node.location.start_offset...node.location.end_offset)
+      elsif node.is_a?(Prism::BlockNode)
+        # Pruned: a block's run-time context is unknown (see collect comment).
+      elsif concern_dsl_block?(node)
+        # Inside a concern block the statements have no subject of their own, so
+        # mutate everything (including nested def bodies) exactly like the
+        # def-level #walk — do NOT recurse via class_walk (it would prune the
+        # block) and do NOT mark the interior defs owned. The concern call node
+        # itself is not yielded: the whole-block deletion edit already comes
+        # from the enclosing StatementsNode, and no operator targets a bare
+        # receiverless call.
+        walk(node.block.body, &blk)
+      else
+        yield node
+        node.compact_child_nodes.each { |child| class_walk(child, owned, &blk) }
+      end
+    end
+
+    # The mutant is the whole file. The def-shaped fields are filled with the
+    # file source so the Mutation shape stays uniform; Worker routes
+    # class-body mutants through ClosureReload (whole-file re-eval), never
+    # through Inserter's class_eval.
+    def build_class_body_mutation(subject, source, edit)
+      original = source.byteslice(edit.range)
+      return [nil, true] if edit.replacement == original # no-op guard
+
+      mutated = Splicer.apply(source, [edit])
+      parsed = Prism.parse(mutated)
+      return [nil, false] unless parsed.success?
+      return [nil, false] unless find_node(parsed.value, subject.byte_range.begin, Prism::ClassNode, Prism::ModuleNode)
+
+      [Mutation.new(
+        subject: subject,
+        edit: edit,
+        original_snippet: original,
+        line: source.byteslice(0, edit.range.begin).count("\n") + 1,
+        mutated_file_source: mutated,
+        mutated_def_source: mutated,
+        mutated_def_line: 1
+      ), true]
+    end
+
     def collect_edits(def_node)
       edits = []
       walk(def_node.body) do |node|
@@ -71,7 +172,7 @@ module ActiveMutator
       parsed = Prism.parse(mutated)
       return [nil, false] unless parsed.success?
 
-      new_def = find_def(parsed.value, subject.byte_range.begin)
+      new_def = find_node(parsed.value, subject.byte_range.begin, Prism::DefNode)
       return [nil, false] unless new_def
 
       [Mutation.new(

data/lib/active_mutator/reporter/stryker_json.rb

@@ -13,7 +13,8 @@ module ActiveMutator
     class StrykerJson
       SCHEMA_URL = "https://git.io/mutation-testing-schema"
       STATUS = { killed: "Killed", survived: "Survived", timeout: "Timeout",
-                 error: "RuntimeError", uncovered: "NoCoverage", accepted: "Ignored" }.freeze
+                 error: "RuntimeError", uncovered: "NoCoverage", accepted: "Ignored",
+                 skipped: "Ignored" }.freeze
       ACCEPTED_REASON = "Accepted as equivalent in #{AcceptedLedger::FILENAME}".freeze
       REPORT_PATH = File.join(".active_mutator", "mutation-report.json")
 
@@ -87,7 +88,17 @@ module ActiveMutator
       def covered_by(result)
         return nil unless @coverage_map
 
-        @coverage_map.examples_for(result.mutation.subject.file, result.mutation.lines)
+        subject = result.mutation.subject
+        # Class-body lines execute at load time, so per-line coverage never
+        # attributes examples to them (see Runner#examples_for_mutation). Mirror
+        # the scheduling substitution — every example that loaded the file — so
+        # the viewer shows real test linkage instead of an empty coveredBy.
+        if subject.class_body?
+          examples = @coverage_map.examples_covering_file(subject.file)
+          return examples.empty? ? nil : examples.sort
+        end
+
+        @coverage_map.examples_for(subject.file, result.mutation.lines)
       end
 
       def referenced_examples(results)

data/lib/active_mutator/reporter/terminal.rb

@@ -1,7 +1,8 @@
 module ActiveMutator
   module Reporter
     class Terminal
-      CHARS = { killed: ".", survived: "S", timeout: "T", error: "E", uncovered: "U", accepted: "A" }.freeze
+      CHARS = { killed: ".", survived: "S", timeout: "T", error: "E", uncovered: "U", accepted: "A",
+                skipped: "-" }.freeze
 
       def initialize(out: $stdout)
         @out = out
@@ -21,6 +22,8 @@ module ActiveMutator
         @out.puts format("Mutation score: %.1f%%", score(counts) * 100)
         survivors = results.select { |r| r.status == :survived }
         print_survivors(survivors) unless survivors.empty?
+        skipped = results.select { |r| r.status == :skipped }
+        print_skipped(skipped) unless skipped.empty?
         stats = OperatorStats.call(results)
         noisy = stats.select { |_, s| s["survived"].positive? }
         print_operator_stats(noisy) unless noisy.empty?
@@ -54,6 +57,15 @@ module ActiveMutator
           @out.puts "    #{m.description}"
           @out.puts "    - #{m.original_snippet}"
           @out.puts "    + #{m.edit.replacement}"
+          @out.puts "    (#{result.details})" if result.details
+        end
+      end
+
+      def print_skipped(skipped)
+        @out.puts "", "Skipped mutants (not counted in the score):"
+        skipped.each do |result|
+          m = result.mutation
+          @out.puts "  #{m.subject.name} (#{m.subject.file}:#{m.line}): #{result.details}"
         end
       end
     end

data/lib/active_mutator/result.rb

@@ -1,5 +1,5 @@
 module ActiveMutator
-  # status: :killed | :survived | :timeout | :error | :uncovered | :accepted
+  # status: :killed | :survived | :timeout | :error | :uncovered | :accepted | :skipped
   Result = Data.define(:mutation, :status, :details) do
     def detected? = %i[killed timeout].include?(status)
   end