henitai 0.2.0 → 0.3.0

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.
@@ -22,22 +23,29 @@ module Henitai
     # @param names  [Array<String>] reporter names from configuration
     # @param result [Result]
     # @param config [Configuration]
-    def self.run_all(names:, result:, config:)
+    # @param history_store [MutantHistoryStore, nil] persistence store the JSON
+    #   reporter reads trend data from; supplied by the composition root so the
+    #   reporter does not build infrastructure itself.
+    def self.run_all(names:, result:, config:, history_store: nil)
       names.each do |name|
-        reporter_class(name).new(config:).report(result)
+        reporter_class(name).new(config:, history_store:).report(result)
       end
     end
 
     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.
     class Base
-      def initialize(config:)
+      # @param history_store [MutantHistoryStore, nil] accepted by every
+      #   reporter for a uniform factory signature; only the JSON reporter uses
+      #   it. Ignored elsewhere.
+      def initialize(config:, history_store: nil)
         @config = config
+        @history_store = history_store
       end
 
       # @param result [Result]
@@ -47,7 +55,22 @@ module Henitai
 
       private
 
-      attr_reader :config
+      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.
@@ -61,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
@@ -81,6 +109,8 @@ module Henitai
 
       private
 
+      attr_reader :color_enabled
+
       def report_lines(result)
         lines = summary_lines(result)
         detail_lines = survived_detail_lines(result)
@@ -105,8 +135,42 @@ 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)
+        ].compact
+      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)
@@ -160,19 +224,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)
@@ -219,7 +307,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
@@ -243,7 +331,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
@@ -251,9 +339,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)
@@ -292,17 +379,18 @@ 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
-        path = File.join(config.reports_dir, Henitai::HISTORY_STORE_FILENAME)
-        history_store = MutantHistoryStore.new(path:)
-        return unless File.exist?(path)
+        store = history_store || default_history_store
+        return unless File.exist?(store.path)
 
         FileUtils.mkdir_p(File.dirname(history_report_path))
-        File.write(history_report_path, JSON.pretty_generate(history_store.trend_report))
+        File.write(history_report_path, JSON.pretty_generate(store.trend_report))
+      end
+
+      def default_history_store
+        MutantHistoryStore.new(
+          path: File.join(config.reports_dir, Henitai::HISTORY_STORE_FILENAME)
+        )
       end
 
       def history_report_path
@@ -313,8 +401,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
@@ -323,7 +415,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">
@@ -335,7 +427,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
@@ -347,19 +439,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?
 
@@ -368,8 +579,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
@@ -401,7 +624,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]
@@ -415,38 +638,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
@@ -454,64 +645,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

data/lib/henitai/reports_directory_lock.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "time"
+
+module Henitai
+  # Coordinates exclusive access to a reports directory across processes.
+  class ReportsDirectoryLock
+    LOCK_FILENAME = ".henitai-run.lock"
+
+    def initialize(reports_dir:)
+      @reports_dir = File.expand_path(reports_dir)
+    end
+
+    def synchronize
+      FileUtils.mkdir_p(@reports_dir)
+      File.open(lock_path, File::RDWR | File::CREAT, 0o644) do |file|
+        acquire(file)
+        write_owner(file)
+        yield
+      end
+    end
+
+    private
+
+    def lock_path
+      File.join(@reports_dir, LOCK_FILENAME)
+    end
+
+    def acquire(file)
+      return if file.flock(File::LOCK_EX | File::LOCK_NB)
+
+      raise ConcurrentRunError, contention_message(owner_pid(file))
+    end
+
+    def owner_pid(file)
+      file.rewind
+      metadata = JSON.parse(file.read)
+      pid = metadata["pid"] if metadata.is_a?(Hash)
+      pid.is_a?(Integer) ? pid : "unknown"
+    rescue JSON::ParserError, IOError, SystemCallError
+      "unknown"
+    end
+
+    def contention_message(pid)
+      message = "another henitai run is active in #{@reports_dir} " \
+                "(pid #{pid}); use a separate reports_dir or wait"
+      return message unless dead_owner?(pid)
+
+      "#{message}. The recorded owner pid #{pid} is not running — an " \
+        "orphaned child may still hold the lock " \
+        "(check: lsof #{lock_path})"
+    end
+
+    # True only when the recorded owner pid provably no longer exists. EPERM
+    # means the process is alive but owned by someone else — treated as alive.
+    def dead_owner?(pid)
+      return false unless pid.is_a?(Integer)
+
+      Process.kill(0, pid)
+      false
+    rescue Errno::ESRCH
+      true
+    rescue StandardError
+      false
+    end
+
+    def write_owner(file)
+      file.rewind
+      file.truncate(0)
+      file.write(JSON.generate(pid: Process.pid, started_at: Time.now.iso8601))
+      file.flush
+    end
+  end
+end