henitai 0.1.0

data/lib/henitai/operators/string_literal.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "../parser_current"
+
+module Henitai
+  module Operators
+    # Replaces string literals with neutral alternatives.
+    class StringLiteral < Henitai::Operator
+      NODE_TYPES = %i[str dstr].freeze
+      REPLACEMENTS = ["", "Henitai was here"].freeze
+
+      def self.node_types
+        NODE_TYPES
+      end
+
+      def mutate(node, subject:)
+        case node.type
+        when :str
+          mutate_plain_string(node, subject:)
+        when :dstr
+          mutate_interpolated_string(node, subject:)
+        else
+          []
+        end
+      end
+
+      private
+
+      def mutate_plain_string(node, subject:)
+        REPLACEMENTS.map do |replacement|
+          build_mutant(
+            subject:,
+            original_node: node,
+            mutated_node: Parser::AST::Node.new(:str, [replacement]),
+            description: "replaced string with #{replacement.inspect}"
+          )
+        end
+      end
+
+      def mutate_interpolated_string(node, subject:)
+        replacement = static_string(node)
+
+        [
+          build_mutant(
+            subject:,
+            original_node: node,
+            mutated_node: Parser::AST::Node.new(:str, [replacement]),
+            description: "removed interpolation from string"
+          )
+        ]
+      end
+
+      def static_string(node)
+        # Fully interpolated strings collapse to an empty string, which still
+        # gives us a valid neutral mutation target.
+        node.children.each_with_object(+"") do |child, string|
+          next unless child.type == :str
+
+          string << child.children.first.to_s
+        end
+      end
+    end
+  end
+end

data/lib/henitai/operators.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Namespace for concrete mutation operators.
+  #
+  # Concrete operator classes are autoloaded so the registry stays lightweight
+  # until a specific operator is referenced.
+  module Operators
+    autoload :ArithmeticOperator, "henitai/operators/arithmetic_operator"
+    autoload :EqualityOperator, "henitai/operators/equality_operator"
+    autoload :LogicalOperator, "henitai/operators/logical_operator"
+    autoload :BooleanLiteral, "henitai/operators/boolean_literal"
+    autoload :ConditionalExpression, "henitai/operators/conditional_expression"
+    autoload :StringLiteral, "henitai/operators/string_literal"
+    autoload :ReturnValue, "henitai/operators/return_value"
+    autoload :ArrayDeclaration, "henitai/operators/array_declaration"
+    autoload :HashLiteral, "henitai/operators/hash_literal"
+    autoload :RangeLiteral, "henitai/operators/range_literal"
+    autoload :SafeNavigation, "henitai/operators/safe_navigation"
+    autoload :PatternMatch, "henitai/operators/pattern_match"
+    autoload :BlockStatement, "henitai/operators/block_statement"
+    autoload :MethodExpression, "henitai/operators/method_expression"
+    autoload :AssignmentExpression, "henitai/operators/assignment_expression"
+  end
+end

data/lib/henitai/parser_current.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "warning_silencer"
+
+Henitai::WarningSilencer.silence do
+  require "parser/current"
+end

data/lib/henitai/reporter.rb

@@ -0,0 +1,432 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "net/http"
+require "open3"
+require "uri"
+require_relative "unparse_helper"
+
+module Henitai
+  # Namespace for result reporters.
+  #
+  # Each reporter receives a Result object and writes output in its specific
+  # format. Reporters are selected via `reporters:` in .henitai.yml.
+  #
+  # Built-in reporters:
+  #   terminal  — coloured summary table to STDOUT
+  #   json      — mutation-testing-report-schema JSON file
+  #   html      — self-contained HTML using mutation-testing-elements web component
+  #   dashboard — POST to Stryker Dashboard REST API
+  module Reporter
+    # @param names  [Array<String>] reporter names from configuration
+    # @param result [Result]
+    # @param config [Configuration]
+    def self.run_all(names:, result:, config:)
+      names.each do |name|
+        reporter_class(name).new(config:).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"
+    end
+
+    # Base class for all reporters.
+    class Base
+      def initialize(config:)
+        @config = config
+      end
+
+      # @param result [Result]
+      def report(result)
+        raise NotImplementedError, "#{self.class}#report must be implemented"
+      end
+
+      private
+
+      attr_reader :config
+    end
+
+    # Terminal reporter.
+    class Terminal < Base
+      include UnparseHelper
+
+      PROGRESS_GLYPHS = {
+        killed: "·",
+        survived: "S",
+        timeout: "T",
+        ignored: "I"
+      }.freeze
+
+      def report(result)
+        puts report_lines(result)
+      end
+
+      def progress(mutant, scenario_result: nil)
+        glyph = PROGRESS_GLYPHS[mutant.status]
+        return unless glyph
+
+        print(glyph)
+        return flush unless should_show_logs?(scenario_result)
+
+        output = scenario_output(scenario_result)
+        print("\n")
+        print("log: #{scenario_result.log_path}\n")
+        print(output) unless output.empty?
+        $stdout.flush
+      end
+
+      private
+
+      def report_lines(result)
+        lines = summary_lines(result)
+        detail_lines = survived_detail_lines(result)
+        return lines if detail_lines.empty?
+
+        lines + [""] + detail_lines
+      end
+
+      def summary_lines(result)
+        [
+          "Mutation testing summary",
+          score_line(result),
+          format_row("Killed", count_status(result, :killed)),
+          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))
+        ]
+      end
+
+      def survived_detail_lines(result)
+        survivors = result.mutants.select(&:survived?)
+        return [] if survivors.empty?
+
+        ["Survived mutants"] + survivors.flat_map { |mutant| survived_mutant_lines(mutant) }
+      end
+
+      def survived_mutant_lines(mutant)
+        [
+          survived_mutant_header(mutant),
+          original_line(mutant),
+          mutated_line(mutant)
+        ]
+      end
+
+      def survived_mutant_header(mutant)
+        format(
+          "%<file>s:%<line>d %<operator>s",
+          file: mutant.location.fetch(:file),
+          line: mutant.location.fetch(:start_line),
+          operator: mutant.operator
+        )
+      end
+
+      def original_line(mutant)
+        format("- %s", safe_unparse(mutant.original_node))
+      end
+
+      def mutated_line(mutant)
+        format("+ %s", safe_unparse(mutant.mutated_node))
+      end
+
+      def score_line(result)
+        summary = result.scoring_summary
+        line = [
+          format("MS %s", format_percent(summary[:mutation_score])),
+          format("MSI %s", format_percent(summary[:mutation_score_indicator])),
+          format(
+            "Equivalence uncertainty %s",
+            summary[:equivalence_uncertainty] || "n/a"
+          )
+        ].join(" | ")
+        color = score_color(summary[:mutation_score])
+        color ? colorize(line, color) : line
+      end
+
+      def format_row(label, value)
+        format("%<label>-12s %<value>s", label:, value:)
+      end
+
+      def count_status(result, status)
+        result.mutants.count { |mutant| mutant.status == status }
+      end
+
+      def format_duration(duration)
+        format("%.2fs", duration)
+      end
+
+      def format_percent(value)
+        value.nil? ? "n/a" : format("%.2f%%", value)
+      end
+
+      def score_color(score)
+        return nil if score.nil?
+
+        thresholds = config.thresholds || {}
+        high = thresholds.fetch(:high, 80)
+        low = thresholds.fetch(:low, 60)
+
+        return "32" if score >= high
+        return "33" if score >= low
+
+        "31"
+      end
+
+      def colorize(text, color)
+        return text if ENV.key?("NO_COLOR")
+
+        "\e[#{color}m#{text}\e[0m"
+      end
+
+      def should_show_logs?(scenario_result)
+        return false unless scenario_result.respond_to?(:failure_tail)
+
+        scenario_result.should_show_logs?(all_logs: config.all_logs)
+      end
+
+      def scenario_output(scenario_result)
+        scenario_result.failure_tail(all_logs: config.all_logs)
+      end
+
+      def flush
+        $stdout.flush
+      end
+    end
+
+    # JSON reporter.
+    class Json < Base
+      def report(result)
+        FileUtils.mkdir_p(File.dirname(report_path))
+        File.write(report_path, JSON.pretty_generate(result.to_stryker_schema))
+        write_history_report
+      end
+
+      private
+
+      def report_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)
+
+        FileUtils.mkdir_p(File.dirname(history_report_path))
+        File.write(history_report_path, JSON.pretty_generate(history_store.trend_report))
+      end
+
+      def history_report_path
+        File.join(config.reports_dir, "mutation-history.json")
+      end
+    end
+
+    # HTML reporter.
+    class Html < Base
+      def report(result)
+        FileUtils.mkdir_p(File.dirname(report_path))
+        File.write(report_path, html_document(result))
+      end
+
+      private
+
+      def report_path
+        File.join(config.reports_dir, "mutation-report.html")
+      end
+
+      def html_document(result)
+        <<~HTML
+          <!DOCTYPE html>
+          <html lang="en">
+            <head>
+              <meta charset="utf-8">
+              <meta name="viewport" content="width=device-width, initial-scale=1">
+              <title>Henitai mutation report</title>
+            </head>
+            <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>
+                const report = JSON.parse(
+                  document.getElementById("henitai-report-data").textContent
+                );
+                document.querySelector("mutation-test-report-app").report = report;
+              </script>
+            </body>
+          </html>
+        HTML
+      end
+
+      def escaped_report_json(result)
+        JSON.pretty_generate(result.to_stryker_schema)
+            .gsub("&", "\\u0026")
+            .gsub("<", "\\u003c")
+            .gsub(">", "\\u003e")
+      end
+    end
+
+    # Dashboard reporter.
+    class Dashboard < Base
+      DEFAULT_BASE_URL = "https://dashboard.stryker-mutator.io"
+      HTTP_TIMEOUT_SECONDS = 30
+
+      def report(result)
+        return unless ready?
+
+        uri = dashboard_uri
+        request = build_request(result, uri)
+        send_request(uri, request)
+      end
+
+      private
+
+      def ready?
+        !project.nil? && !version.nil? && !api_key.nil?
+      end
+
+      def build_request(result, uri)
+        request = Net::HTTP::Put.new(uri.request_uri, request_headers)
+        request.body = JSON.generate(result.to_stryker_schema)
+        request
+      end
+
+      def request_headers
+        {
+          "Content-Type" => "application/json",
+          "X-Api-Key" => api_key.to_s
+        }
+      end
+
+      def send_request(uri, request)
+        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
+          http.open_timeout = HTTP_TIMEOUT_SECONDS
+          http.read_timeout = HTTP_TIMEOUT_SECONDS
+          http.request(request)
+        end
+      rescue StandardError => e
+        warn("Dashboard reporter upload failed: #{e.message}")
+        nil
+      end
+
+      def dashboard_uri
+        uri = URI.parse(base_url)
+        # @type var segments: Array[String]
+        base_path = uri.path.to_s.chomp("/")
+        segments = []
+        segments << base_path unless base_path.empty?
+        segments += ["api", "reports", project_path, encoded_version]
+        uri.path = "/#{segments.join('/')}"
+        uri
+      rescue URI::InvalidURIError
+        URI.parse(DEFAULT_BASE_URL)
+      end
+
+      def base_url
+        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
+
+      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/result.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require_relative "unparse_helper"
+
+module Henitai
+  # Aggregates the outcome of a complete mutation testing run.
+  #
+  # Provides metrics and the serialised Stryker mutation-testing-report-schema
+  # JSON payload. The schema version follows stryker-mutator/mutation-testing-elements.
+  class Result
+    include UnparseHelper
+
+    SCHEMA_VERSION = "1.0"
+
+    attr_reader :mutants, :started_at, :finished_at
+
+    def initialize(mutants:, started_at:, finished_at:)
+      @mutants     = mutants
+      @started_at  = started_at
+      @finished_at = finished_at
+    end
+
+    # @return [Integer] number of killed mutants
+    def killed   = mutants.count(&:killed?)
+
+    # @return [Integer] number of survived mutants
+    def survived = mutants.count(&:survived?)
+
+    # @return [Integer] number of confirmed equivalent mutants (excluded from MS)
+    def equivalent = mutants.count(&:equivalent?)
+
+    # Detected = killed + timeout + runtime_error (alle Zustände die einen Fehler beweisen)
+    # @return [Integer]
+    def detected
+      mutants.count { |m| %i[killed timeout runtime_error].include?(m.status) }
+    end
+
+    # Mutation Score (MS) — Architektur-Formel aus Abschnitt 6.1:
+    #
+    #   MS = detected / (total − ignored − no_coverage − compile_error − equivalent)
+    #
+    # Confirmed equivalent mutants werden aus BEIDEN Seiten der Gleichung entfernt:
+    # Sie sind weder im Zähler (nicht detektierbar) noch im Nenner (nicht testbar).
+    # Das ist der entscheidende Unterschied zum MSI.
+    #
+    # @return [Float, nil] 0.0–100.0, nil wenn kein valider Mutant vorhanden
+    def mutation_score
+      excluded = %i[ignored no_coverage compile_error equivalent]
+      valid = mutants.reject { |m| excluded.include?(m.status) }
+      return nil if valid.empty?
+
+      ((detected.to_f / valid.count) * 100.0).round(2).to_f
+    end
+
+    # Mutation Score Indicator (MSI) — naive Berechnung ohne Äquivalenz-Bereinigung:
+    #
+    #   MSI = killed / all_mutants
+    #
+    # MSI ist immer ≤ MS. Der Unterschied kommuniziert die Äquivalenz-Unsicherheit.
+    # Beide Werte MÜSSEN im Report zusammen ausgewiesen werden (Anti-Pattern: nur MS).
+    #
+    # @return [Float, nil]
+    def mutation_score_indicator
+      return nil if mutants.empty?
+
+      ((killed.to_f / mutants.count) * 100.0).round(2).to_f
+    end
+
+    # Compact public summary for reporters.
+    # The uncertainty note is intentionally qualitative: equivalent mutants are
+    # a known gray area, so the terminal report should communicate that
+    # uncertainty instead of pretending to be precise.
+    def scoring_summary
+      {
+        mutation_score: mutation_score,
+        mutation_score_indicator: mutation_score_indicator,
+        equivalence_uncertainty: equivalence_uncertainty
+      }
+    end
+
+    # @return [Float] duration in seconds
+    def duration
+      finished_at - started_at
+    end
+
+    # Serialise to Stryker mutation-testing-report-schema JSON (schema 1.0).
+    # @return [Hash]
+    def to_stryker_schema
+      {
+        schemaVersion: SCHEMA_VERSION,
+        thresholds: { high: 80, low: 60 },
+        files: build_files_section
+      }
+    end
+
+    private
+
+    def build_files_section
+      mutants.group_by { |m| m.location[:file] }.transform_values do |file_mutants|
+        source = begin
+          File.read(file_mutants.first.location[:file])
+        rescue StandardError
+          ""
+        end
+        {
+          language: "ruby",
+          source:,
+          mutants: file_mutants.map { |m| mutant_to_schema(m) }
+        }
+      end
+    end
+
+    def mutant_to_schema(mutant)
+      {
+        id: mutant.id,
+        mutatorName: mutant.operator,
+        replacement: replacement_for(mutant),
+        location: location_for(mutant),
+        status: stryker_status(mutant.status),
+        description: mutant.description,
+        duration: duration_for(mutant)
+      }.compact
+    end
+
+    def replacement_for(mutant)
+      safe_unparse(mutant.mutated_node)
+    end
+
+    def location_for(mutant)
+      {
+        start: line_column(mutant, :start),
+        end: line_column(mutant, :end)
+      }
+    end
+
+    def line_column(mutant, prefix)
+      # Stryker schema columns are 1-based; Parser locations are 0-based.
+      {
+        line: mutant.location.fetch(:"#{prefix}_line"),
+        column: mutant.location.fetch(:"#{prefix}_col") + 1
+      }
+    end
+
+    def duration_for(mutant)
+      mutant.duration&.then { |d| (d * 1000).round }
+    end
+
+    def equivalence_uncertainty
+      return nil if mutation_score.nil?
+
+      "~10-15% of live mutants"
+    end
+
+    def stryker_status(status)
+      # :equivalent wird als "Ignored" serialisiert — das Stryker-Schema kennt keinen
+      # Equivalent-Status. Die interne Unterscheidung (für MS vs. MSI) bleibt im Result-Objekt.
+      {
+        killed: "Killed",
+        survived: "Survived",
+        timeout: "Timeout",
+        no_coverage: "NoCoverage",
+        ignored: "Ignored",
+        equivalent: "Ignored",
+        compile_error: "CompileError",
+        runtime_error: "RuntimeError",
+        pending: "Pending"
+      }.fetch(status, "Pending")
+    end
+  end
+end