henitai 0.1.2 → 0.1.3

data/lib/henitai/operators/assignment_expression.rb

@@ -4,13 +4,14 @@ require_relative "../parser_current"
 
 module Henitai
   module Operators
-    # Mutates compound assignments and reduces ||= to a plain assignment.
+    # Reduces ||= to a plain assignment, removing the memoization guard.
+    #
+    # Arithmetic compound assignments (+=, -=, *=, /=) are covered by
+    # UpdateOperator, which also handles the logical pair swap (||= ↔ &&=).
+    # AssignmentExpression is intentionally scoped to or_asgn reduction only
+    # to avoid emitting duplicate mutants in the full operator set.
     class AssignmentExpression < Henitai::Operator
-      NODE_TYPES = %i[op_asgn or_asgn].freeze
-      OPERATOR_MAP = {
-        :+ => :-,
-        :- => :+
-      }.freeze
+      NODE_TYPES = %i[or_asgn].freeze
 
       def self.node_types
         NODE_TYPES
@@ -18,8 +19,6 @@ module Henitai
 
       def mutate(node, subject:)
         case node.type
-        when :op_asgn
-          mutate_compound_assignment(node, subject:)
         when :or_asgn
           # Memoization-style ||= is usually filtered earlier by AridNodeFilter.
           mutate_coalesce_assignment(node, subject:)
@@ -30,21 +29,6 @@ module Henitai
 
       private
 
-      def mutate_compound_assignment(node, subject:)
-        left, operator, right = node.children
-        replacement = OPERATOR_MAP[operator]
-        return [] unless replacement
-
-        [
-          build_mutant(
-            subject:,
-            original_node: node,
-            mutated_node: Parser::AST::Node.new(:op_asgn, [left, replacement, right]),
-            description: "replaced #{operator} with #{replacement}"
-          )
-        ]
-      end
-
       def mutate_coalesce_assignment(node, subject:)
         left, right = node.children
         mutated_node = assignment_node(left, right)

data/lib/henitai/operators/conditional_expression.rb

@@ -74,13 +74,7 @@ module Henitai
       end
 
       def case_children(children)
-        return [[], nil] if children.empty?
-
-        if children.last&.type == :when
-          [children, nil]
-        else
-          [children[0...-1], children.last]
-        end
+        [children[0...-1], children.last]
       end
 
       def condition_variants(node, subject:, condition:)

data/lib/henitai/operators/method_chain_unwrap.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../parser_current"
+
+module Henitai
+  module Operators
+    # Removes individual links from a method chain by replacing the outer
+    # send node with its receiver.
+    #
+    # Only fires when the immediate receiver is itself a :send node, which
+    # naturally excludes block-receiver chains (list.select { }.count) and
+    # standalone calls.
+    #
+    # Example: array.uniq.sort.first
+    #   → array.uniq.sort  (removed .first)
+    #   → array.uniq       (removed .sort)
+    #   → array            (removed .uniq) — via the :uniq node
+    class MethodChainUnwrap < Henitai::Operator
+      NODE_TYPES = %i[send].freeze
+
+      def self.node_types
+        NODE_TYPES
+      end
+
+      def mutate(node, subject:)
+        receiver = node.children[0]
+        return [] unless receiver.is_a?(Parser::AST::Node) && receiver.type == :send
+
+        method_name = node.children[1]
+        [
+          build_mutant(
+            subject:,
+            original_node: node,
+            mutated_node: receiver,
+            description: "removed .#{method_name} from chain"
+          )
+        ]
+      end
+    end
+  end
+end

data/lib/henitai/operators/regex_mutator.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative "../parser_current"
+
+module Henitai
+  module Operators
+    # Mutates regular expression literals by altering quantifiers, anchors,
+    # and character-class negation.
+    #
+    # Each applicable transformation yields a separate mutant. Invalid
+    # results (unparseable regex) are discarded before emission.
+    # Anchor removal and character-class negation are intentionally one-way:
+    # they reduce noisy patterns rather than mirroring a full edit matrix.
+    class RegexMutator < Henitai::Operator
+      NODE_TYPES = %i[regexp].freeze
+
+      def self.node_types
+        NODE_TYPES
+      end
+
+      def mutate(node, subject:)
+        source, opts_node = extract_parts(node)
+        return [] unless source
+
+        transformations(source).filter_map do |new_source, description|
+          build_regex_mutant(node, opts_node, new_source, source, description, subject:)
+        end
+      end
+
+      private
+
+      def extract_parts(node)
+        str_child  = node.children.find { |c| c.is_a?(Parser::AST::Node) && c.type == :str }
+        opts_node  = node.children.find { |c| c.is_a?(Parser::AST::Node) && c.type == :regopt }
+        return nil unless str_child
+
+        [str_child.children[0], opts_node]
+      end
+
+      def build_regex_mutant(node, opts_node, new_source, original, description, subject:) # rubocop:disable Metrics/ParameterLists
+        return if new_source == original
+        return unless valid_regex?(new_source)
+
+        children = [Parser::AST::Node.new(:str, [new_source]), opts_node]
+        mutated = Parser::AST::Node.new(:regexp, children)
+        build_mutant(subject:, original_node: node, mutated_node: mutated, description:)
+      end
+
+      def transformations(source)
+        [
+          *quantifier_swaps(source),
+          *anchor_removals(source),
+          *char_class_negations(source)
+        ]
+      end
+
+      def quantifier_swaps(source)
+        # Quantifier swaps are symmetric. The other transforms are intentionally
+        # one-way because they model reductions instead of reversible edits.
+        [
+          [source.gsub(/(?<=[^*+?\\])\+/, "*"), "replaced + quantifier with *"],
+          [source.gsub(/(?<=[^*+?\\])\*/, "+"), "replaced * quantifier with +"]
+        ]
+      end
+
+      def anchor_removals(source)
+        # Anchors are removed, not added back. The mutation is deliberately
+        # asymmetric because "restoring" anchors would just recreate the input.
+        [
+          [source.sub("^", ""), "removed ^ anchor"],
+          [source.sub(/\$$/, ""), "removed $ anchor"]
+        ]
+      end
+
+      def char_class_negations(source)
+        # Negation only flips a positive class into a negated one. We do not
+        # emit the reverse mutation because that would mirror the same edit.
+        [[source.gsub(/\[(?!\^)/, "[^"), "negated character class"]]
+      end
+
+      def valid_regex?(source)
+        Regexp.new(source)
+        true
+      rescue RegexpError
+        false
+      end
+    end
+  end
+end

data/lib/henitai/operators/unary_operator.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../parser_current"
+
+module Henitai
+  module Operators
+    # Removes unary prefix operators by replacing the send node with its receiver.
+    #
+    # Covers :-@ (unary minus) and :~ (bitwise NOT).
+    # Unary negation (!) is intentionally excluded — BooleanLiteral owns that.
+    class UnaryOperator < Henitai::Operator
+      NODE_TYPES = %i[send].freeze
+      UNARY_METHODS = %i[-@ ~].freeze
+
+      def self.node_types
+        NODE_TYPES
+      end
+
+      def mutate(node, subject:)
+        receiver, method_name, *arguments = node.children
+        return [] unless UNARY_METHODS.include?(method_name)
+        return [] unless arguments.empty?
+        return [] unless receiver
+
+        [
+          build_mutant(
+            subject:,
+            original_node: node,
+            mutated_node: receiver,
+            description: "removed unary #{method_name.to_s.delete('@')}"
+          )
+        ]
+      end
+    end
+  end
+end

data/lib/henitai/operators/update_operator.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "../parser_current"
+
+module Henitai
+  module Operators
+    # Swaps compound assignment operators with their inverses.
+    #
+    # Covers arithmetic pairs (+=/-=, *=/=) via :op_asgn and
+    # logical pairs (||=/&&=) via :or_asgn/:and_asgn. Exponent and modulo
+    # compound assignments are intentionally excluded: they are not part of the
+    # supported swap matrix and are already covered by other operator families
+    # when appropriate.
+    class UpdateOperator < Henitai::Operator
+      NODE_TYPES = %i[op_asgn or_asgn and_asgn].freeze
+      ARITHMETIC_SWAPS = {
+        :+ => :-,
+        :- => :+,
+        :* => :/,
+        :/ => :*
+      }.freeze
+
+      def self.node_types
+        NODE_TYPES
+      end
+
+      def mutate(node, subject:)
+        case node.type
+        when :op_asgn
+          mutate_arithmetic(node, subject:)
+        when :or_asgn
+          mutate_logical(node, subject:, from: "||=", to: :and_asgn, to_op: "&&=")
+        when :and_asgn
+          mutate_logical(node, subject:, from: "&&=", to: :or_asgn, to_op: "||=")
+        else
+          []
+        end
+      end
+
+      private
+
+      def mutate_arithmetic(node, subject:)
+        target, operator, value = node.children
+        replacement = ARITHMETIC_SWAPS[operator]
+        return [] unless replacement
+
+        [
+          build_mutant(
+            subject:,
+            original_node: node,
+            mutated_node: Parser::AST::Node.new(:op_asgn, [target, replacement, value]),
+            description: "replaced #{operator}= with #{replacement}="
+          )
+        ]
+      end
+
+      def mutate_logical(node, subject:, from:, to:, to_op:)
+        target, value = node.children
+        [
+          build_mutant(
+            subject:,
+            original_node: node,
+            mutated_node: Parser::AST::Node.new(to, [target, value]),
+            description: "replaced #{from} with #{to_op}"
+          )
+        ]
+      end
+    end
+  end
+end

data/lib/henitai/operators.rb

@@ -21,5 +21,9 @@ module Henitai
     autoload :BlockStatement, "henitai/operators/block_statement"
     autoload :MethodExpression, "henitai/operators/method_expression"
     autoload :AssignmentExpression, "henitai/operators/assignment_expression"
+    autoload :MethodChainUnwrap,    "henitai/operators/method_chain_unwrap"
+    autoload :RegexMutator,         "henitai/operators/regex_mutator"
+    autoload :UnaryOperator,        "henitai/operators/unary_operator"
+    autoload :UpdateOperator,       "henitai/operators/update_operator"
   end
 end

data/lib/henitai/parallel_execution_runner.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Runs pending mutants across worker threads with signal and stdin handling.
+  class ParallelExecutionRunner
+    ParallelExecutionContext = Struct.new(
+      :queue, :integration, :config, :progress_reporter,
+      :mutex, :state, :old_handlers, :stdin_watcher
+    )
+
+    def initialize(worker_count:)
+      @worker_count = worker_count
+    end
+
+    def run(mutants, integration, config, progress_reporter, options = {})
+      context = build_parallel_context(
+        mutants,
+        integration,
+        config,
+        progress_reporter
+      )
+      execute_parallel_execution(
+        context,
+        stdin_pipe: options.fetch(:stdin_pipe, false),
+        process_mutant: options.fetch(:process_mutant)
+      )
+    end
+
+    def execute_parallel_execution(context, stdin_pipe:, process_mutant:)
+      install_parallel_signal_traps(context)
+      start_parallel_stdin_watcher(context, stdin_pipe)
+      parallel_workers(context, process_mutant).each(&:join)
+    ensure
+      stop_parallel_stdin_watcher(context)
+      restore_parallel_signal_traps(context)
+      raise context.state[:error] if context&.state&.fetch(:error, nil)
+      raise Interrupt if context&.state&.fetch(:stopping, false)
+    end
+
+    private
+
+    attr_reader :worker_count
+
+    def build_parallel_queue(mutants)
+      Queue.new.tap { |queue| mutants.each { |mutant| queue << mutant } }
+    end
+
+    def build_parallel_context(mutants, integration, config, progress_reporter)
+      ParallelExecutionContext.new(
+        build_parallel_queue(mutants),
+        integration,
+        config,
+        progress_reporter,
+        Mutex.new,
+        { stopping: false }
+      )
+    end
+
+    def install_parallel_signal_traps(context)
+      context.old_handlers = {
+        int: trap(:INT) { stop_parallel_execution(context) },
+        term: trap(:TERM) { stop_parallel_execution(context) },
+        hup: trap(:HUP) { stop_parallel_execution(context) }
+      }
+    end
+
+    def stop_parallel_execution(context)
+      context.state[:stopping] = true
+      context.queue.clear
+    end
+
+    def start_parallel_stdin_watcher(context, stdin_pipe)
+      return unless stdin_pipe
+      # CI runners expose stdin as a non-interactive pipe, so EOF there should
+      # not be treated as a user disconnect.
+      return if ci_environment?
+
+      context.stdin_watcher = Thread.new do
+        $stdin.read
+        stop_parallel_execution(context)
+      rescue IOError, Errno::EBADF
+        nil
+      end
+    end
+
+    def parallel_workers(context, process_mutant)
+      Array.new(worker_count) { Thread.new { process_parallel_worker(context, process_mutant) } }
+    end
+
+    def process_parallel_worker(context, process_mutant)
+      loop do
+        break if context.state[:stopping]
+
+        process_mutant.call(
+          context.queue.pop(true),
+          context.integration,
+          context.config,
+          context.progress_reporter,
+          context.mutex
+        )
+      rescue ThreadError
+        break
+      rescue StandardError => e
+        record_parallel_error(context, e)
+        break
+      end
+    end
+
+    def stop_parallel_stdin_watcher(context)
+      context&.stdin_watcher&.kill
+    end
+
+    def restore_parallel_signal_traps(context)
+      handlers = context&.old_handlers
+      return unless handlers
+
+      trap(:INT, handlers[:int] || "DEFAULT")
+      trap(:TERM, handlers[:term] || "DEFAULT")
+      trap(:HUP, handlers[:hup] || "DEFAULT")
+    end
+
+    def record_parallel_error(context, error)
+      context.mutex.synchronize do
+        context.state[:error] ||= error
+        context.state[:stopping] = true
+        context.queue.clear
+      end
+    end
+
+    def ci_environment?
+      value = ENV.fetch("CI", nil)
+      value && !%w[0 false].include?(value.downcase)
+    end
+  end
+end

data/lib/henitai/per_test_coverage_selector.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Henitai
+  # Narrows candidate test files using the per-test coverage report.
+  class PerTestCoverageSelector
+    def initialize(coverage_report_reader: CoverageReportReader.new)
+      @coverage_report_reader = coverage_report_reader
+    end
+
+    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)
+
+      covered_tests = candidates.select do |test|
+        covers_mutant?(test, mutant, reports_dir)
+      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?
+    end
+
+    attr_reader :coverage_report_reader
+  end
+end

data/lib/henitai/result.rb

@@ -11,13 +11,15 @@ module Henitai
     include UnparseHelper
 
     SCHEMA_VERSION = "1.0"
+    DEFAULT_THRESHOLDS = { high: 80, low: 60 }.freeze
 
-    attr_reader :mutants, :started_at, :finished_at
+    attr_reader :mutants, :started_at, :finished_at, :thresholds
 
-    def initialize(mutants:, started_at:, finished_at:)
+    def initialize(mutants:, started_at:, finished_at:, thresholds: nil)
       @mutants     = mutants
       @started_at  = started_at
       @finished_at = finished_at
+      @thresholds  = DEFAULT_THRESHOLDS.merge(thresholds || {})
     end
 
     # @return [Integer] number of killed mutants
@@ -88,7 +90,7 @@ module Henitai
     def to_stryker_schema
       {
         schemaVersion: SCHEMA_VERSION,
-        thresholds: { high: 80, low: 60 },
+        thresholds: thresholds,
         files: build_files_section
       }
     end
@@ -119,7 +121,17 @@ module Henitai
         status: stryker_status(mutant.status),
         description: mutant.description,
         duration: duration_for(mutant)
-      }.compact
+      }.compact.merge(coverage_schema(mutant))
+    end
+
+    def coverage_schema(mutant)
+      covered_by = Array(mutant.covered_by).compact
+      return {} if covered_by.empty?
+
+      {
+        coveredBy: covered_by,
+        testsCompleted: mutant.tests_completed || covered_by.size
+      }
     end
 
     def replacement_for(mutant)

data/lib/henitai/runner.rb

@@ -35,18 +35,24 @@ module Henitai
     end
 
     # Entry point — runs the full pipeline and returns a Result.
+    #
+    # Coverage bootstrap (Gate 0) runs in a background thread so that Gate 1
+    # (subject resolution) and Gate 2 (mutant generation) proceed concurrently.
+    # The thread is joined before Gate 3 (static filtering), which is the first
+    # phase that requires coverage data.
+    #
+    # For targeted runs (`subjects:` provided), the bootstrap is further scoped
+    # to the spec files that cover the requested subjects rather than the full
+    # suite, reducing the baseline run time proportionally.
+    #
     # @return [Result]
     def run
       started_at = Time.now
       source_files = self.source_files
-      bootstrap_coverage(source_files)
       subjects = resolve_subjects(source_files)
-      mutants = generate_mutants(subjects)
-      mutants = filter_mutants(mutants)
-      mutants = execute_mutants(mutants)
-      finished_at = Time.now
+      mutants = execute_mutants(mutants_for(subjects, source_files))
 
-      build_result(mutants, started_at, finished_at)
+      build_result(mutants, started_at, Time.now)
     end
 
     private
@@ -69,6 +75,29 @@ module Henitai
       static_filter.apply(mutants, config)
     end
 
+    def mutants_for(subjects, source_files)
+      bootstrap_thread = bootstrap_mutants(source_files, subjects)
+      mutants = generate_mutants(subjects)
+      bootstrap_thread.value
+
+      filtered_mutants = filter_mutants(mutants)
+      return filtered_mutants unless targeted_run?
+
+      refresh_coverage_for_targeted_run(filtered_mutants, source_files)
+    end
+
+    def refresh_coverage_for_targeted_run(mutants, source_files)
+      return mutants unless retry_full_bootstrap?(mutants)
+
+      bootstrap_coverage(source_files)
+      filter_mutants(mutants)
+    end
+
+    def bootstrap_mutants(source_files, subjects)
+      scoped_tests = scoped_bootstrap_test_files(subjects)
+      Thread.new { bootstrap_coverage(source_files, scoped_tests) }
+    end
+
     def execute_mutants(mutants)
       execution_engine.run(
         mutants,
@@ -94,13 +123,33 @@ module Henitai
       @result = Result.new(
         mutants:,
         started_at:,
-        finished_at:
+        finished_at:,
+        thresholds: result_thresholds
       )
       persist_history(@result, finished_at)
       report(@result)
       @result
     end
 
+    # Returns the spec files to use for the coverage bootstrap.
+    #
+    # For full runs (no subject pattern given), returns nil so the bootstrapper
+    # falls back to the integration's full test-file list.
+    #
+    # For targeted runs, returns the union of test files selected for each
+    # resolved subject. Falls back to nil (all tests) if the selection is empty,
+    # so the bootstrapper always has a non-empty file list.
+    def scoped_bootstrap_test_files(subjects)
+      return nil if pattern_subjects.empty?
+
+      files = subjects.flat_map { |subject| integration.select_tests(subject) }.uniq
+      files.empty? ? nil : files
+    end
+
+    def bootstrap_coverage(source_files, test_files = nil)
+      coverage_bootstrapper.ensure!(source_files:, config:, integration:, test_files:)
+    end
+
     def subject_resolver
       @subject_resolver ||= SubjectResolver.new
     end
@@ -125,10 +174,6 @@ module Henitai
       @coverage_bootstrapper ||= CoverageBootstrapper.new
     end
 
-    def bootstrap_coverage(source_files)
-      coverage_bootstrapper.ensure!(source_files:, config:, integration:)
-    end
-
     def integration
       @integration ||= Integration.for(config.integration).new
     end
@@ -172,6 +217,19 @@ module Henitai
       Array(@subjects)
     end
 
+    def targeted_run?
+      !pattern_subjects.empty?
+    end
+
+    def retry_full_bootstrap?(mutants)
+      executable_mutants = Array(mutants).reject do |mutant|
+        %i[ignored compile_error equivalent].include?(mutant.status)
+      end
+      return false if executable_mutants.empty?
+
+      executable_mutants.all? { |mutant| mutant.status == :no_coverage }
+    end
+
     def unique_subjects(subjects)
       subjects.uniq { |subject| [subject.expression, subject.source_file] }
     end
@@ -179,5 +237,11 @@ module Henitai
     def normalize_path(path)
       File.expand_path(path)
     end
+
+    def result_thresholds
+      return nil unless config.respond_to?(:thresholds)
+
+      config.thresholds
+    end
   end
 end