henitai 0.2.1 → 0.3.1

data/lib/henitai/per_test_coverage_selector.rb

@@ -2,6 +2,11 @@
 
 module Henitai
   # Narrows candidate test files using the per-test coverage report.
+  #
+  # The intersection check itself lives in {PerTestCoverage}; this class only
+  # adds the selection policy: when no candidate provably covers the mutant
+  # (or the map / location is unavailable), it falls back to all candidates —
+  # over-selection costs time, never correctness.
   class PerTestCoverageSelector
     def initialize(coverage_report_reader: CoverageReportReader.new)
       @coverage_report_reader = coverage_report_reader
@@ -10,49 +15,22 @@ module Henitai
     def filter(tests, mutant, reports_dir:)
       candidates = Array(tests)
       return candidates if candidates.empty?
-      return candidates unless location_available?(mutant)
-      return candidates unless per_test_coverage_available?(reports_dir)
 
+      coverage = per_test_coverage(reports_dir)
       covered_tests = candidates.select do |test|
-        covers_mutant?(test, mutant, reports_dir)
+        coverage.covers?(test, mutant)
       end
       covered_tests.empty? ? candidates : covered_tests
     end
 
     private
 
-    def location_available?(mutant)
-      mutant.respond_to?(:location) &&
-        mutant.location.is_a?(Hash) &&
-        mutant.location[:file] &&
-        mutant.location[:start_line] &&
-        mutant.location[:end_line]
-    end
-
-    def covers_mutant?(test, mutant, reports_dir)
-      covered_lines = coverage_lines_for(test, mutant, reports_dir)
-      mutant_lines(mutant).any? { |line| covered_lines.include?(line) }
-    end
-
-    def coverage_lines_for(test, mutant, reports_dir)
-      source_map = per_test_coverage(reports_dir)[test.to_s] || {}
-      Array(source_map[File.expand_path(mutant.location[:file])]).uniq
-    end
-
-    def mutant_lines(mutant)
-      (mutant.location[:start_line]..mutant.location[:end_line]).to_a
-    end
-
     def per_test_coverage(reports_dir)
       @per_test_coverage ||= {}
-      @per_test_coverage[reports_dir] ||= begin
-        path = File.join(reports_dir, "henitai_per_test.json")
-        coverage_report_reader.test_lines_by_file(path)
-      end
-    end
-
-    def per_test_coverage_available?(reports_dir)
-      !per_test_coverage(reports_dir).empty?
+      @per_test_coverage[reports_dir] ||= PerTestCoverage.new(
+        reports_dir:,
+        coverage_report_reader:
+      )
     end
 
     attr_reader :coverage_report_reader

data/lib/henitai/reporter/dashboard_metadata_provider.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "open3"
+require "uri"
+
+module Henitai
+  module Reporter
+    # Resolves the Stryker Dashboard project/version/api-key coordinates for
+    # {Dashboard}. Isolated behind injectable +env+/+git_executor+ seams so
+    # callers (and specs) never have to touch real ENV or shell out to git.
+    class DashboardMetadataProvider
+      def initialize(dashboard_config:, env: ENV, git_executor: Open3)
+        @dashboard_config = dashboard_config || {}
+        @env = env
+        @git_executor = git_executor
+      end
+
+      def project
+        @project ||= dashboard_config[:project] || project_from_git_remote
+      end
+
+      def version
+        @version ||= env_version || git_branch_name
+      end
+
+      def api_key
+        env.fetch("STRYKER_DASHBOARD_API_KEY", nil)
+      end
+
+      class << self
+        def project_from_git_url(url)
+          normalized = normalize_git_url(url)
+          return nil if normalized.nil?
+
+          return project_from_uri_url(normalized) if normalized.include?("://")
+          return project_from_ssh_url(normalized) if normalized.include?("@")
+
+          normalized
+        rescue URI::InvalidURIError
+          nil
+        end
+
+        def normalize_git_url(url)
+          return nil if url.nil? || url.strip.empty?
+
+          url.strip.sub(/\.git\z/, "")
+        end
+
+        def project_from_uri_url(normalized)
+          uri = URI.parse(normalized)
+          path = uri.path.to_s.sub(%r{^/}, "")
+          [uri.host, path].compact.reject(&:empty?).join("/")
+        end
+
+        def project_from_ssh_url(normalized)
+          _, host_and_path = normalized.split("@", 2)
+          return nil if host_and_path.nil?
+
+          host, path = host_and_path.split(":", 2)
+          return nil unless host && path
+
+          "#{host}/#{path}"
+        end
+      end
+
+      private
+
+      attr_reader :dashboard_config, :env, :git_executor
+
+      def env_version
+        ref_name = env.fetch("GITHUB_REF_NAME", nil)
+        return ref_name unless blank?(ref_name)
+
+        ref = env.fetch("GITHUB_REF", nil)
+        return ref_without_prefix(ref) unless ref.nil? || blank?(ref)
+
+        env.fetch("GITHUB_SHA", nil)
+      end
+
+      def ref_without_prefix(ref)
+        return nil if blank?(ref)
+
+        ref.to_s.sub(%r{^refs/(heads|tags|pull)/}, "")
+      end
+
+      def project_from_git_remote
+        self.class.project_from_git_url(git_remote_url)
+      end
+
+      def git_remote_url
+        stdout, status = git_executor.capture2("git", "remote", "get-url", "origin")
+        return stdout.strip if status.success?
+
+        nil
+      rescue Errno::ENOENT
+        nil
+      end
+
+      def git_branch_name
+        stdout, status = git_executor.capture2("git", "rev-parse", "--abbrev-ref", "HEAD")
+        return stdout.strip if status.success? && !stdout.strip.empty?
+
+        nil
+      rescue Errno::ENOENT
+        nil
+      end
+
+      def blank?(value)
+        value.nil? || value.strip.empty?
+      end
+    end
+  end
+end

data/lib/henitai/reporter.rb

@@ -6,6 +6,7 @@ require "net/http"
 require "open3"
 require "uri"
 require_relative "unparse_helper"
+require_relative "reporter/dashboard_metadata_provider"
 
 module Henitai
   # Namespace for result reporters.
@@ -34,7 +35,7 @@ module Henitai
     def self.reporter_class(name)
       const_get(name.capitalize)
     rescue NameError
-      raise ArgumentError, "Unknown reporter: #{name}. Valid reporters: terminal, json, html, dashboard"
+      raise ArgumentError, "Unknown reporter: #{name}. Valid reporters: terminal, json, html, dashboard, github"
     end
 
     # Base class for all reporters.
@@ -55,6 +56,21 @@ module Henitai
       private
 
       attr_reader :config, :history_store
+
+      # Authoritative (full) runs fully replace the canonical report;
+      # scoped/partial runs merge into it (CanonicalReportMerger) so
+      # findings for files outside this run's scope aren't lost.
+      def authoritative?(result)
+        return true unless result.respond_to?(:authoritative?)
+
+        result.authoritative?
+      end
+
+      # The merge source of truth is always the JSON canonical report, even
+      # for the HTML reporter, which embeds the same merged schema.
+      def canonical_path
+        File.join(config.reports_dir, "mutation-report.json")
+      end
     end
 
     # Terminal reporter.
@@ -68,6 +84,11 @@ module Henitai
         ignored: "I"
       }.freeze
 
+      def initialize(config:, history_store: nil, color_enabled: !ENV.key?("NO_COLOR"))
+        super(config:, history_store:)
+        @color_enabled = color_enabled
+      end
+
       def report(result)
         puts report_lines(result)
       end
@@ -88,6 +109,8 @@ module Henitai
 
       private
 
+      attr_reader :color_enabled
+
       def report_lines(result)
         lines = summary_lines(result)
         detail_lines = survived_detail_lines(result)
@@ -112,8 +135,52 @@ module Henitai
           format_row("Survived", count_status(result, :survived)),
           format_row("Timeout", count_status(result, :timeout)),
           format_row("No coverage", count_status(result, :no_coverage)),
-          format_row("Duration", format_duration(result.duration))
-        ]
+          format_row("Duration", format_duration(result.duration)),
+          reused_verdicts_line(result),
+          executed_only_score_line(result),
+          empty_since_scope_line(result)
+        ].compact
+      end
+
+      # A zero-mutant summary with every counter at 0 and n/a scores is
+      # baffling without its cause; name it when the run was scoped by --since.
+      def empty_since_scope_line(result)
+        return nil unless result.mutants.empty?
+        return nil unless result.respond_to?(:since) && result.since
+
+        "No mutants: no configured source files changed since #{result.since}."
+      end
+
+      def reused_verdicts_line(result)
+        reused = reused_mutants(result)
+        return nil if reused.empty?
+
+        format(
+          "%<reused>d of %<total>d verdicts reused from history (%<killed>d killed, %<survived>d survived)",
+          reused: reused.size,
+          total: result.mutants.size,
+          killed: reused.count { |mutant| mutant.status == :killed },
+          survived: reused.count { |mutant| mutant.status == :survived }
+        )
+      end
+
+      def reused_mutants(result)
+        result.mutants.select { |mutant| mutant.respond_to?(:from_cache?) && mutant.from_cache? }
+      end
+
+      # Cached verdicts make the combined MS/MSI partly synthetic; the
+      # executed-only pair keeps this run's own signal visible.
+      def executed_only_score_line(result)
+        return nil unless result.respond_to?(:executed_scoring_summary)
+
+        summary = result.executed_scoring_summary # : Hash[Symbol, untyped]?
+        return nil unless summary
+
+        format(
+          "Executed-only MS %<score>s | MSI %<indicator>s",
+          score: format_percent(summary[:mutation_score]),
+          indicator: format_percent(summary[:mutation_score_indicator])
+        )
       end
 
       def partial_summary_lines(result)
@@ -167,19 +234,43 @@ module Henitai
       end
 
       def mutated_line(mutant)
-        format("+ %s", display_unparse(mutant.mutated_node))
+        format("+ %s", display_mutated_source(mutant))
+      end
+
+      # Prefer the mutant's memoized unparse (shared with the JSON reporter);
+      # string literals keep the visible-escape rendering below.
+      def display_mutated_source(mutant)
+        node = mutant.mutated_node
+        return node.children.first.inspect if str_node?(node)
+        return mutant.mutated_source if mutant.respond_to?(:mutated_source)
+
+        display_unparse(node)
       end
 
       # Like safe_unparse but makes invisible characters visible in terminal
       # output. For string literal nodes the inner value is shown via #inspect
-      # so that e.g. "" vs " " vs "\n" are unambiguous. Other nodes unparse
-      # normally.
+      # so that e.g. "" vs " " vs "\n" are unambiguous. Nodes parsed from real
+      # source render their original source slice — unparsing is expensive and
+      # this path runs once per survivor; synthetic nodes unparse as before.
       def display_unparse(node)
-        if node.respond_to?(:type) && node.respond_to?(:children) && node.type == :str
-          node.children.first.inspect
-        else
-          safe_unparse(node)
-        end
+        return node.children.first.inspect if str_node?(node)
+
+        source_slice(node) || safe_unparse(node)
+      end
+
+      def str_node?(node)
+        node.respond_to?(:type) && node.respond_to?(:children) && node.type == :str
+      end
+
+      # Single-line original source of a parsed node; nil for synthetic nodes
+      # or multi-line slices (those fall back to normalized unparsing).
+      def source_slice(node)
+        return nil unless node.respond_to?(:location)
+
+        source = node.location&.expression&.source
+        source unless source.nil? || source.include?("\n")
+      rescue StandardError
+        nil
       end
 
       def score_line(result)
@@ -226,7 +317,7 @@ module Henitai
       end
 
       def colorize(text, color)
-        return text if ENV.key?("NO_COLOR")
+        return text unless color_enabled
 
         "\e[#{color}m#{text}\e[0m"
       end
@@ -250,7 +341,7 @@ module Henitai
     class Json < Base
       def report(result)
         schema = result.to_stryker_schema
-        write_canonical(schema)
+        write_canonical(schema, authoritative: authoritative?(result))
         write_session_snapshot(schema)
         write_activation_recipes(result)
         write_history_report
@@ -258,9 +349,8 @@ module Henitai
 
       private
 
-      def write_canonical(schema)
-        FileUtils.mkdir_p(File.dirname(canonical_path))
-        File.write(canonical_path, JSON.pretty_generate(schema))
+      def write_canonical(schema, authoritative:)
+        CanonicalReportWriter.write(schema, path: canonical_path, authoritative:)
       end
 
       def write_session_snapshot(schema)
@@ -299,10 +389,6 @@ module Henitai
         File.join(config.reports_dir, "sessions", session_id, SurvivorActivationCache::FILENAME)
       end
 
-      def canonical_path
-        File.join(config.reports_dir, "mutation-report.json")
-      end
-
       def write_history_report
         store = history_store || default_history_store
         return unless File.exist?(store.path)
@@ -325,8 +411,12 @@ module Henitai
     # HTML reporter.
     class Html < Base
       def report(result)
+        report_schema(schema_for(result))
+      end
+
+      def report_schema(schema)
         FileUtils.mkdir_p(File.dirname(report_path))
-        File.write(report_path, html_document(result))
+        File.write(report_path, html_document(schema))
       end
 
       private
@@ -335,7 +425,7 @@ module Henitai
         File.join(config.reports_dir, "mutation-report.html")
       end
 
-      def html_document(result)
+      def html_document(schema)
         <<~HTML
           <!DOCTYPE html>
           <html lang="en">
@@ -347,7 +437,7 @@ module Henitai
             <body>
               <mutation-test-report-app titlePostfix="Henitai"></mutation-test-report-app>
               <script src="https://www.unpkg.com/mutation-testing-elements"></script>
-              <script type="application/json" id="henitai-report-data">#{escaped_report_json(result)}</script>
+              <script type="application/json" id="henitai-report-data">#{escaped_report_json(schema)}</script>
               <script>
                 const report = JSON.parse(
                   document.getElementById("henitai-report-data").textContent
@@ -359,19 +449,138 @@ module Henitai
         HTML
       end
 
-      def escaped_report_json(result)
-        JSON.pretty_generate(result.to_stryker_schema)
+      def schema_for(result)
+        schema = result.to_stryker_schema
+        return schema if authoritative?(result)
+
+        CanonicalReportMerger.merge(schema, canonical_path, prune_missing: true)
+      end
+
+      def escaped_report_json(schema)
+        JSON.pretty_generate(schema)
             .gsub("&", "\\u0026")
             .gsub("<", "\\u003c")
             .gsub(">", "\\u003e")
       end
     end
 
-    # Dashboard reporter.
+    # Dry-run listing: prints the post-filter mutant set (Gates 0–3) without
+    # any execution results. Used internally by the runner for `--dry-run`;
+    # not part of the `reporters:` configuration surface.
+    class DryRun < Base
+      def initialize(config:, history_store: nil, io: $stdout)
+        super(config:, history_store:)
+        @io = io
+      end
+
+      def report(result)
+        io.puts(listing_lines(result.mutants))
+      end
+
+      private
+
+      attr_reader :io
+
+      def listing_lines(mutants)
+        header = ["Dry run: #{mutants.size} mutants (no mutants executed)"]
+        return header + ["", summary_line(mutants)] if mutants.empty?
+
+        header + grouped_lines(mutants) + ["", summary_line(mutants)]
+      end
+
+      def grouped_lines(mutants)
+        mutants.group_by { |mutant| subject_label(mutant) }.flat_map do |label, subject_mutants|
+          ["", label] + subject_mutants.map { |mutant| mutant_line(mutant) }
+        end
+      end
+
+      def subject_label(mutant)
+        subject = mutant.subject
+        return subject.expression if subject.respond_to?(:expression) && subject.expression
+
+        mutant.location.fetch(:file, "(unknown subject)")
+      end
+
+      def mutant_line(mutant)
+        line = format(
+          "  %<operator>s — %<description>s  %<file>s:%<line>d  [%<status>s]",
+          operator: mutant.operator,
+          description: mutant.description,
+          file: mutant.location.fetch(:file),
+          line: mutant.location.fetch(:start_line),
+          status: mutant.status
+        )
+        reason = ignore_reason_for(mutant)
+        reason ? "#{line} #{reason}" : line
+      end
+
+      def ignore_reason_for(mutant)
+        return nil unless mutant.respond_to?(:ignore_reason)
+
+        reason = mutant.ignore_reason
+        reason ? "(#{reason})" : nil
+      end
+
+      def summary_line(mutants)
+        counts = mutants.group_by(&:status).transform_values(&:size)
+        summary = counts.map { |status, count| "#{status} #{count}" }.join(" | ")
+        "Summary: #{summary.empty? ? 'no mutants' : summary}"
+      end
+    end
+
+    # GitHub Actions annotation reporter. Prints one `::warning` workflow
+    # command per survived mutant so survivors show up inline on the PR diff.
+    # Killed/ignored/no-coverage/timeout mutants stay silent.
+    class Github < Base
+      def initialize(config:, history_store: nil, io: $stdout)
+        super(config:, history_store:)
+        @io = io
+      end
+
+      def report(result)
+        result.mutants.select(&:survived?).each do |mutant|
+          io.puts(annotation_line(mutant))
+        end
+      end
+
+      private
+
+      attr_reader :io
+
+      def annotation_line(mutant)
+        format(
+          "::warning file=%<file>s,line=%<line>d::%<message>s",
+          file: relative_path(mutant.location.fetch(:file)),
+          line: mutant.location.fetch(:start_line),
+          message: escape_message("Survived mutant: #{mutant.operator} — #{mutant.description}")
+        )
+      end
+
+      def relative_path(file)
+        pathname = Pathname.new(file)
+        return file unless pathname.absolute?
+
+        pathname.relative_path_from(Dir.pwd).to_s
+      end
+
+      # GitHub workflow-command message payload escaping: only `%`, LF and CR
+      # are significant; everything else is parsed literally.
+      def escape_message(message)
+        message.gsub("%", "%25").gsub("\n", "%0A").gsub("\r", "%0D")
+      end
+    end
+
+    # Dashboard reporter. Delegates project/version/api-key resolution to
+    # {DashboardMetadataProvider} so it never touches real ENV or git itself.
     class Dashboard < Base
       DEFAULT_BASE_URL = "https://dashboard.stryker-mutator.io"
       HTTP_TIMEOUT_SECONDS = 30
 
+      def initialize(config:, history_store: nil, metadata_provider: nil)
+        super(config:, history_store:)
+        @metadata_provider = metadata_provider || DashboardMetadataProvider.new(dashboard_config: config.dashboard)
+      end
+
       def report(result)
         return unless ready?
 
@@ -380,8 +589,20 @@ module Henitai
         send_request(uri, request)
       end
 
+      class << self
+        def project_from_git_url(url)
+          DashboardMetadataProvider.project_from_git_url(url)
+        end
+      end
+
       private
 
+      attr_reader :metadata_provider
+
+      def project = metadata_provider.project
+      def version = metadata_provider.version
+      def api_key = metadata_provider.api_key
+
       def ready?
         !project.nil? && !version.nil? && !api_key.nil?
       end
@@ -413,7 +634,7 @@ module Henitai
       def dashboard_uri
         uri = URI.parse(base_url)
         # @type var segments: Array[String]
-        base_path = uri.path.to_s.chomp("/")
+        base_path = uri.path.to_s.chomp("/").delete_prefix("/")
         segments = []
         segments << base_path unless base_path.empty?
         segments += ["api", "reports", project_path, encoded_version]
@@ -427,38 +648,6 @@ module Henitai
         config.dashboard[:base_url] || DEFAULT_BASE_URL
       end
 
-      def project
-        @project ||= config.dashboard[:project] || project_from_git_remote
-      end
-
-      def version
-        @version ||= env_version || git_branch_name
-      end
-
-      def env_version
-        ref_name = ENV.fetch("GITHUB_REF_NAME", nil)
-        return ref_name unless blank?(ref_name)
-
-        ref = ENV.fetch("GITHUB_REF", nil)
-        return ref_without_prefix(ref) unless ref.nil? || blank?(ref)
-
-        ENV.fetch("GITHUB_SHA", nil)
-      end
-
-      def ref_without_prefix(ref)
-        return nil if blank?(ref)
-
-        ref.to_s.sub(%r{^refs/(heads|tags|pull)/}, "")
-      end
-
-      def project_from_git_remote
-        self.class.project_from_git_url(git_remote_url)
-      end
-
-      def api_key
-        ENV.fetch("STRYKER_DASHBOARD_API_KEY", nil)
-      end
-
       def project_path
         project.to_s.split("/").map { |segment| URI.encode_www_form_component(segment) }.join("/")
       end
@@ -466,64 +655,6 @@ module Henitai
       def encoded_version
         URI.encode_www_form_component(version.to_s)
       end
-
-      def blank?(value)
-        value.nil? || value.strip.empty?
-      end
-
-      def git_remote_url
-        stdout, status = Open3.capture2("git", "remote", "get-url", "origin")
-        return stdout.strip if status.success?
-
-        nil
-      rescue Errno::ENOENT
-        nil
-      end
-
-      def git_branch_name
-        stdout, status = Open3.capture2("git", "rev-parse", "--abbrev-ref", "HEAD")
-        return stdout.strip if status.success? && !stdout.strip.empty?
-
-        nil
-      rescue Errno::ENOENT
-        nil
-      end
-
-      class << self
-        def project_from_git_url(url)
-          normalized = normalize_git_url(url)
-          return nil if normalized.nil?
-
-          return project_from_uri_url(normalized) if normalized.include?("://")
-          return project_from_ssh_url(normalized) if normalized.include?("@")
-
-          normalized
-        rescue URI::InvalidURIError
-          nil
-        end
-
-        def normalize_git_url(url)
-          return nil if url.nil? || url.strip.empty?
-
-          url.strip.sub(/\.git\z/, "")
-        end
-
-        def project_from_uri_url(normalized)
-          uri = URI.parse(normalized)
-          path = uri.path.to_s.sub(%r{^/}, "")
-          [uri.host, path].compact.reject(&:empty?).join("/")
-        end
-
-        def project_from_ssh_url(normalized)
-          _, host_and_path = normalized.split("@", 2)
-          return nil if host_and_path.nil?
-
-          host, path = host_and_path.split(":", 2)
-          return nil unless host && path
-
-          "#{host}/#{path}"
-        end
-      end
     end
   end
 end