active_mutator 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60c123ba92745825d5041728a14144e2cad95ba814d54fcb72bba40e1d5c0089
-  data.tar.gz: b7f96c322c455aa01d4ef19e04aa017f61fecb82347b1da7e315cfdc4316708e
+  metadata.gz: a334e2726728421ba66d6a08db715587b8e0439b934489857b70d746912e89b8
+  data.tar.gz: cdce7a7856fd4b1f68b4cbf9dc5a62d58a1926555b203a01474d64aa95b6fbbe
 SHA512:
-  metadata.gz: 134766964d548d79002d0364046d6a46cb9a3b3d14b334c7d7ee67b3581865c31f10184bd7666d59f5732122dbc74f8c8ffdd7ee14664cd610c38ba64675fc31
-  data.tar.gz: 22bd7813d2a1d061a045a3bc3c7cc2d21c31b3d34f6c8b26e0f2433921b131c124f0f652e3367657bfcc26e987dd7416763c33e05d3e074cfa688703047ec8e2
+  metadata.gz: d1cfeffd4210a83fcd974a3b175eabf0da02a54b7d253664e3252ed5fc0487fd60fcf4ad3db54d29d12e53363842e0a5116e0602c6ce83a971813e8895a84dbf
+  data.tar.gz: d21dae9ed1a6e6b668517ad99130a7a6e2d7de6d6f9ebf4f620de5ce7e0690bc81d105e8f3d78aff72c288034a2366ae6a0dced6a35d2101b63421fde0ef1da0

data/README.md

@@ -138,8 +138,8 @@ every status at `0` and no `Mutation score:` line (JSON: `score` is `null`,
 `exit_reason` is `empty_plan`), then warns with the cause and exits `1`
 unless `--allow-empty` is given. The count block is printed on every run,
 whatever the exit code, so log-scraping never has to handle a missing block.
-`--allow-empty` forgives the empty plan only when the `--since` diff touched
-no candidate source file; see [Empty plans in CI](#empty-plans-in-ci).
+`--allow-empty` forgives the empty plan only when the `--since` diff changed
+no code in a candidate source file; see [Empty plans in CI](#empty-plans-in-ci).
 
 When survivors exist, the summary also prints a per-operator table showing
 how often each operator's mutants survive, to help spot likely-equivalent
@@ -263,8 +263,12 @@ itself whether that emptiness is fine:
 - **Exit 0** with `--no-class-level` when every changed line in the
   candidate files falls inside class-body code that flag dropped. The
   warning names `--no-class-level` as the reason.
-- **Exit 1** otherwise. A candidate source file changed but produced no
-  mutants, and the warning lists the file(s). A comment-only edit in `lib/`
+- **Exit 0** when the only changes in the candidate files are comments or
+  blank lines, added or deleted. A magic comment such as
+  `# frozen_string_literal: true` counts as code, and so does a file that
+  fails to parse.
+- **Exit 1** otherwise. A candidate file's code changed but produced no
+  mutants, and the warning lists the file(s). A deletion-only code edit
   counts as a real change here.
 - With `--subject` and no `--since` there is no diff to judge, so
   `--allow-empty` exits `0` unconditionally.
@@ -284,7 +288,7 @@ projects used to tell a docs-only PR from a broken `--since` range.
 | `--exclude PAT` | none | skip files matching glob during subject discovery (repeatable, gitignore-like) |
 | `--max-mutants N` | none | deterministic sample of the first N mutants (quick smoke run on huge scopes; accepted/uncovered mutants count against N) |
 | `--debug-plan` | off | print planned mutants as JSON and exit without running |
-| `--allow-empty` | off | forgive an empty `--since`/`--subject` plan, but only when the `--since` diff touched no candidate source file (default: warn and exit 1) |
+| `--allow-empty` | off | forgive an empty `--since`/`--subject` plan, but only when the `--since` diff changed no code in a candidate source file (default: warn and exit 1) |
 | `--format terminal\|json\|stryker-json\|github` | terminal | report format |
 | `--accept-survivors` | off | record survivors to the acceptance ledger |
 | `--force-baseline` | off | ignore cached coverage map |

data/lib/active_mutator/baseline_hooks.rb

@@ -9,11 +9,16 @@ module ActiveMutator
     RECORDS = {}
     TIMES = {}
 
-    def self.diff_coverage(before, after, root, spec_paths: ["spec"])
+    def self.diff_coverage(before, after, root, spec_paths: ["spec"], gem_dirs: [])
       prefixes = spec_paths.map { |sp| "/#{sp}/" }
+      gem_prefixes = gem_dirs.map { |dir| File.join(dir, "") }
       hits = []
       after.each do |path, data|
         next unless path.start_with?(root)
+        # Gems installed under the root (e.g. `bundle config path
+        # vendor/bundle` on CI) would otherwise be recorded per example and
+        # blow up the map's memory.
+        next if gem_prefixes.any? { |p| path.start_with?(p) }
 
         # Relative to root, not a global substring check: `root` itself may
         # contain "/spec/" (e.g. a fixture nested under this gem's own
@@ -33,6 +38,20 @@ module ActiveMutator
       hits
     end
 
+    # Computed per example, not at load: this file loads via RUBYOPT before
+    # Bundler sets up its install path.
+    def self.gem_dirs
+      dirs = Gem.path.dup
+      if defined?(Bundler)
+        begin
+          dirs << Bundler.bundle_path.to_s
+        rescue Bundler::BundlerError
+          # No Gemfile, so Gem.path covers it.
+        end
+      end
+      dirs.uniq
+    end
+
     def self.build_payload(records, times, expected_examples: nil)
       payload = { "version" => 2, "records" => records, "times" => times }
       payload["expected_examples"] = expected_examples if expected_examples
@@ -56,7 +75,10 @@ if ENV["ACTIVE_MUTATOR_BASELINE_OUT"]
       root = ENV.fetch("ACTIVE_MUTATOR_ROOT")
       spec_paths = ENV.fetch("ACTIVE_MUTATOR_SPEC_PATHS", "spec").split(":")
       ActiveMutator::BaselineHooks::RECORDS[example.id] =
-        ActiveMutator::BaselineHooks.diff_coverage(before, after, root, spec_paths: spec_paths)
+        ActiveMutator::BaselineHooks.diff_coverage(
+          before, after, root,
+          spec_paths: spec_paths, gem_dirs: ActiveMutator::BaselineHooks.gem_dirs
+        )
       # NOT example.execution_result.run_time: that is nil until after
       # around hooks complete.
       ActiveMutator::BaselineHooks::TIMES[example.id] = elapsed

data/lib/active_mutator/cli.rb

@@ -67,8 +67,8 @@ module ActiveMutator
         o.on("--max-mutants N", Integer, "Deterministically sample the first N mutants") { |v| options[:max_mutants] = v }
         o.on("--debug-plan", "Print the planned mutant list as JSON and exit") { options[:debug_plan] = true }
         o.on("--allow-empty",
-             "Exit 0 when --since/--subject plan no mutants and the --since diff touched no mutable " \
-             "source file (default: exit 1)") { options[:allow_empty] = true }
+             "Exit 0 when --since/--subject plan no mutants and the --since diff changed no code " \
+             "in a mutable source file (default: exit 1)") { options[:allow_empty] = true }
         o.on("--fail-at SCORE", Float, "Exit 0 if mutation score >= SCORE even with survivors (default: any survivor fails)") do |v|
           raise OptionParser::InvalidArgument, "--fail-at must be within 0..100" unless (0..100).cover?(v)
           options[:fail_at] = v

data/lib/active_mutator/runner.rb

@@ -6,8 +6,9 @@ module ActiveMutator
     # root-relative source files after path expansion and excludes, minus
     # spec_paths; `since_candidates` are the --since diff's files among them;
     # `since_matched_all` are the since-covered subjects before --no-class-level
-    # drops class bodies. The last two feed the --allow-empty verdict (#46).
-    Discovery = Data.define(:subjects, :scanned_files, :since_candidates, :since_matched_all)
+    # drops class bodies; `since_filter` is the --since SinceFilter (nil
+    # without --since). The last three feed the --allow-empty verdict (#46).
+    Discovery = Data.define(:subjects, :scanned_files, :since_candidates, :since_matched_all, :since_filter)
 
     def initialize(config, reporter: nil)
       @config = config
@@ -177,15 +178,22 @@ module ActiveMutator
     end
 
     # --allow-empty forgives an empty plan only when the --since diff touched no
-    # candidate source file (docs-only, spec-only, excluded paths). A changed
-    # candidate that planned nothing is the case worth failing on, unless the
-    # only code it touched is class-body code that --no-class-level dropped.
-    # --subject alone has no diff to judge, so it stays an unconditional 0.
+    # candidate source file (docs-only, spec-only, excluded paths) or changed
+    # only comments in them. A candidate whose code changed but planned
+    # nothing is the case worth failing on, unless the only code it touched
+    # is class-body code that --no-class-level dropped. --subject alone has no
+    # diff to judge, so it stays an unconditional 0.
     def allow_empty_exit(discovery)
       return 0 unless @config.since
+      return 0 if discovery.since_candidates.empty?
 
-      candidates = discovery.since_candidates
-      return 0 if candidates.empty?
+      # Checked only here, on the empty-plan path: it runs `git show` per file.
+      candidates = discovery.since_candidates.reject { |file| discovery.since_filter.comment_only?(file) }
+      if candidates.empty?
+        warn "active_mutator: forgiving empty plan: only comments changed in " \
+             "#{discovery.since_candidates.join(", ")}"
+        return 0
+      end
 
       if !@config.class_level && class_body_only?(discovery.since_matched_all, candidates)
         warn "active_mutator: forgiving empty plan: changed lines are class-body code and --no-class-level is set"
@@ -322,7 +330,8 @@ module ActiveMutator
       since_matched_all = subjects
       subjects = subjects.reject(&:class_body?) unless @config.class_level
       Discovery.new(subjects: subjects, scanned_files: scanned_files,
-                    since_candidates: since_candidates, since_matched_all: since_matched_all)
+                    since_candidates: since_candidates, since_matched_all: since_matched_all,
+                    since_filter: filter)
     end
 
     def relative(file) = file.delete_prefix(@config.root.chomp("/") + "/")

data/lib/active_mutator/since_filter.rb

@@ -29,7 +29,36 @@ module ActiveMutator
       end.uniq
     end
 
+    # Tokens that never change what the code does.
+    NOISE = %i[IGNORED_NEWLINE EMBDOC_BEGIN EMBDOC_LINE EMBDOC_END EOF].freeze
+
+    # True when two sources differ only in comments and blank lines. Magic
+    # comments (`# frozen_string_literal: true`) change behavior, so they
+    # count as code; so does anything that fails to parse.
+    def self.same_code?(old_source, new_source)
+      old_code = code_of(old_source)
+      !old_code.nil? && old_code == code_of(new_source)
+    end
+
+    def self.code_of(source)
+      result = Prism.parse_lex(source)
+      return nil if result.failure?
+
+      # A trailing comment swallows its line's newline, so comments become a
+      # newline instead of vanishing; runs of newlines collapse to one.
+      tokens = result.value.last.filter_map do |token, _state|
+        next if NOISE.include?(token.type)
+
+        %i[COMMENT NEWLINE].include?(token.type) ? :NEWLINE : [token.type, token.value]
+      end
+      tokens = tokens.chunk_while { |a, b| a == :NEWLINE && b == :NEWLINE }.map(&:first)
+      tokens.shift if tokens.first == :NEWLINE
+      tokens.pop if tokens.last == :NEWLINE
+      [tokens, result.magic_comments.map { |c| [c.key, c.value] }]
+    end
+
     def initialize(ref:, root:)
+      @ref = ref
       @root = root
       diff = IO.popen(
         ["git", "-C", root, "diff", "--unified=0", ref, "--", "*.rb"], &:read
@@ -53,6 +82,15 @@ module ActiveMutator
     # further git calls.
     def changed_files = @touched
 
+    # Whether a changed file's edits since the ref are only comments. Reads
+    # the old side with `git show`; a file missing there (untracked, renamed)
+    # prints nothing, so it compares against an empty source and any code in
+    # it counts.
+    def comment_only?(path)
+      old_source = IO.popen(["git", "-C", @root, "show", "#{@ref}:#{path}"], err: File::NULL, &:read)
+      self.class.same_code?(old_source, File.read(File.join(@root, path)))
+    end
+
     def cover?(subject)
       lines = @changed[subject.file.delete_prefix("#{@root}/")]
       return false unless lines

data/lib/active_mutator/version.rb

@@ -1,3 +1,3 @@
 module ActiveMutator
-  VERSION = "0.6.0"
+  VERSION = "0.6.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_mutator
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Daniel John