mutant 0.15.1 → 0.16.2

data/lib/mutant/isolation.rb

@@ -21,6 +21,37 @@ module Mutant
       def valid_value?
         timeout.nil? && exception.nil? && (process_status.nil? || process_status.success?)
       end
+
+      dump = Transform::Success.new(
+        block: lambda do |object|
+          {
+            'exception'      => object.exception && Mutant::Result::Exception::CODEC.dump(object.exception).from_right,
+            'log'            => LogCapture::CODEC.dump(object.log).from_right,
+            'process_status' => object.process_status && Mutant::Result::ProcessStatus::CODEC.dump(object.process_status).from_right,
+            'timeout'        => object.timeout,
+            'value'          => object.value && Mutant::Result::Test::CODEC.dump(object.value).from_right
+          }
+        end
+      )
+
+      load = Transform::Sequence.new(
+        steps: [
+          Transform::Hash.new(
+            required: [
+              Transform::Hash::Key.new(value: 'exception',      transform: Transform::Nullable.new(transform: Mutant::Result::Exception::CODEC.load_transform)),
+              Transform::Hash::Key.new(value: 'log',            transform: LogCapture::CODEC.load_transform),
+              Transform::Hash::Key.new(value: 'process_status', transform: Transform::Nullable.new(transform: Mutant::Result::ProcessStatus::CODEC.load_transform)),
+              Transform::Hash::Key.new(value: 'timeout',        transform: Transform::Nullable.new(transform: Transform::FLOAT)),
+              Transform::Hash::Key.new(value: 'value',          transform: Transform::Nullable.new(transform: Mutant::Result::Test::CODEC.load_transform))
+            ],
+            optional: []
+          ),
+          Transform::Hash::Symbolize.new,
+          Transform::Success.new(block: method(:new).to_proc)
+        ]
+      )
+
+      CODEC = Transform::Codec.new(dump_transform: dump, load_transform: load)
     end # Result
 
     # Call block in isolation

data/lib/mutant/log_capture.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Mutant
+  # Captured log output from a worker or forked process.
+  #
+  # Raw worker log bytes may or may not be valid UTF-8 — they commonly contain
+  # terminal control sequences emitted by test frameworks. This class preserves
+  # those bytes unaltered for terminal emission while distinguishing UTF-8 text
+  # from arbitrary bytes in the codec representation.
+  class LogCapture
+    include AbstractType, Anima.new(:content)
+
+    # Build the appropriate subclass from raw bytes.
+    #
+    # Takes ownership of +bytes+; encoding is mutated in place.
+    #
+    # @param [::String] bytes
+    #
+    # @return [LogCapture]
+    def self.from_binary(bytes)
+      if bytes.force_encoding(Encoding::UTF_8).valid_encoding?
+        String.new(content: bytes)
+      else
+        Binary.new(content: bytes.force_encoding(Encoding::ASCII_8BIT))
+      end
+    end
+
+    # UTF-8 valid log capture
+    class String < self
+      TYPE = 'string'
+    end
+
+    # Non UTF-8 log capture, preserved as raw bytes
+    class Binary < self
+      TYPE = 'binary'
+    end
+
+    dump = Transform::Success.new(
+      block: lambda do |object|
+        case object
+        when String
+          { 'type' => String::TYPE, 'content' => object.content }
+        when Binary
+          { 'type' => Binary::TYPE, 'content' => [object.content].pack('m0') }
+        end
+      end
+    )
+
+    # Normalize legacy plain-string log representation into the tagged form.
+    # Session JSON files written before LogCapture store +log+ and +output+
+    # as plain strings; promote those to string-typed captures on load.
+    legacy = Transform::Block.capture('log_capture_legacy') do |input|
+      case input
+      when ::String
+        Either::Right.new('type' => String::TYPE, 'content' => input)
+      else
+        Either::Right.new(input)
+      end
+    end
+
+    load = Transform::Sequence.new(
+      steps: [
+        legacy,
+        Transform::Hash.new(
+          required: [
+            Transform::Hash::Key.new(value: 'type',    transform: Transform::STRING),
+            Transform::Hash::Key.new(value: 'content', transform: Transform::STRING)
+          ],
+          optional: []
+        ),
+        Transform::Block.capture('log_capture') do |hash|
+          type    = hash.fetch('type')
+          content = hash.fetch('content')
+
+          case type
+          when String::TYPE
+            Either::Right.new(String.new(content: content))
+          when Binary::TYPE
+            Either::Right.new(Binary.new(content: content.unpack1('m0').force_encoding(Encoding::ASCII_8BIT)))
+          else
+            Either::Left.new("Unknown log capture type: #{type.inspect}")
+          end
+        end
+      ]
+    )
+
+    CODEC = Transform::Codec.new(dump_transform: dump, load_transform: load)
+  end # LogCapture
+end # Mutant

data/lib/mutant/matcher/null.rb

@@ -4,7 +4,7 @@ module Mutant
   class Matcher
     # A null matcher, that does not match any subjects
     class Null < self
-      include Concord.new
+      include Equalizer.new
 
       # Enumerate subjects
       #

data/lib/mutant/mutation/runner/sink.rb

@@ -40,21 +40,30 @@ module Mutant
         # @param [Parallel::Response] response
         #
         # @return [self]
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/MethodLength
         def response(response)
           fail response.error if response.error
 
-          mutation_result = mutation_result(response.result)
-
-          subject = mutation_result.mutation.subject
+          mutation        = env.mutations.fetch(response.result.mutation_index)
+          subject         = mutation.subject
+          mutation_result = mutation_result(mutation, response.result)
 
           @subject_results[subject] = Result::Subject.new(
-            subject:,
-            coverage_results: previous_coverage_results(subject).dup << coverage_result(mutation_result),
-            tests:            env.selections.fetch(subject)
+            amount_mutations:  subject.mutations.length,
+            coverage_results:  previous_coverage_results(subject).dup << coverage_result(mutation_result),
+            expression_syntax: subject.expression.syntax,
+            identification:    subject.identification,
+            node:              subject.node,
+            source:            subject.source,
+            source_path:       subject.source_path.to_s,
+            tests:             env.selections.fetch(subject)
           )
 
           self
         end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
 
       private
 
@@ -65,11 +74,15 @@ module Mutant
           )
         end
 
-        def mutation_result(mutation_index_result)
+        def mutation_result(mutation, mutation_index_result)
           Result::Mutation.new(
-            isolation_result: mutation_index_result.isolation_result,
-            mutation:         env.mutations.fetch(mutation_index_result.mutation_index),
-            runtime:          mutation_index_result.runtime
+            isolation_result:        mutation_index_result.isolation_result,
+            mutation_diff:           mutation.diff.diff,
+            mutation_identification: mutation.identification,
+            mutation_node:           mutation.node,
+            mutation_source:         mutation.source,
+            mutation_type:           mutation.class::SYMBOL,
+            runtime:                 mutation_index_result.runtime
           )
         end
 

data/lib/mutant/mutation/runner.rb

@@ -18,6 +18,7 @@ module Mutant
         env
           .record(:analysis) { run_driver(reporter, async_driver(env)) }
           .tap { |result| env.record(:report) { reporter.report(result) } }
+          .tap { |result| Result::JSONWriter.new(env:, result:).call }
       end
       private_class_method :run_mutation_analysis
 

data/lib/mutant/mutation.rb

@@ -90,15 +90,6 @@ module Mutant
     # @return [String]
     def original_source = subject.source
 
-    # Test if mutation is killed by test reports
-    #
-    # @param [Result::Test] test_result
-    #
-    # @return [Boolean]
-    def self.success?(test_result)
-      self::TEST_PASS_SUCCESS.equal?(test_result.passed)
-    end
-
     # Insert mutated node
     #
     # @param kernel [Kernel]
@@ -126,25 +117,17 @@ module Mutant
 
     # Evil mutation that should case mutations to fail tests
     class Evil < self
-      SYMBOL            = 'evil'
-      TEST_PASS_SUCCESS = false
-
+      SYMBOL = 'evil'
     end # Evil
 
     # Neutral mutation that should not cause mutations to fail tests
     class Neutral < self
-
-      SYMBOL            = 'neutral'
-      TEST_PASS_SUCCESS = true
-
+      SYMBOL = 'neutral'
     end # Neutral
 
     # Noop mutation, special case of neutral
     class Noop < Neutral
-
-      SYMBOL            = 'noop'
-      TEST_PASS_SUCCESS = true
-
+      SYMBOL = 'noop'
     end # Noop
 
   end # Mutation

data/lib/mutant/mutator/node/literal/integer.rb

@@ -11,11 +11,72 @@ module Mutant
 
           children :value
 
+          # Integer overflow boundary probe zones.
+          #
+          # Each entry pairs a zone boundary with a safe prime sentinel
+          # value that falls within that zone. The literal is mutated to
+          # the sentinel of the next zone above its absolute value,
+          # probing whether consuming code handles values that cross the
+          # boundary of the next integer width.
+          #
+          # Safe primes (p = 2q + 1 where both p and q are prime) are
+          # chosen as sentinels because they cannot arise from simple
+          # arithmetic (multiplication, bit shifts, masking), providing
+          # strong guarantees against coincidental mutation kills. A
+          # mutation surviving against a safe prime is a strong signal
+          # of missing boundary validation for that integer width.
+          #
+          # Zone layout:
+          #
+          #   Zone   Boundary  Sentinel
+          #   int8   128       167
+          #   uint8  256       467
+          #   int16  32768     55_487
+          #   uint16 65536     108_503
+          #   int32  2^31      2_667_278_543
+          #   uint32 2^32      7_980_081_959
+          #   int64  2^63      15_508_464_536_481_899_903
+          #
+          # A literal snaps to the next zone above its absolute value.
+          # For example, a literal 100 (below int8 boundary 128) emits
+          # sentinel 167. A literal 200 (above int8, below uint8) emits
+          # sentinel 467. Values at or above 2^63 emit no sentinel as
+          # there is no higher zone to probe.
+          #
+          # Future versions of mutant will add infrastructure to explain
+          # alive mutations, including which overflow zone a surviving
+          # sentinel belongs to and what class of bug it indicates.
+          class OverflowZone
+            include Anima.new(:name, :boundary, :sentinel)
+          end
+
+          OVERFLOW_ZONES = [
+            OverflowZone.new(name: :int8,   boundary: 2**7,  sentinel: 167),
+            OverflowZone.new(name: :uint8,  boundary: 2**8,  sentinel: 467),
+            OverflowZone.new(name: :int16,  boundary: 2**15, sentinel: 55_487),
+            OverflowZone.new(name: :uint16, boundary: 2**16, sentinel: 108_503),
+            OverflowZone.new(name: :int32,  boundary: 2**31, sentinel: 2_667_278_543),
+            OverflowZone.new(name: :uint32, boundary: 2**32, sentinel: 7_980_081_959),
+            OverflowZone.new(name: :int64,  boundary: 2**63, sentinel: 15_508_464_536_481_899_903)
+          ].freeze
+
         private
 
           def dispatch
             emit_singletons
             emit_values
+            emit_overflow_sentinel
+          end
+
+          def emit_overflow_sentinel
+            absolute = value.abs
+
+            OVERFLOW_ZONES.each do |zone|
+              if absolute < zone.boundary
+                emit_type(zone.sentinel)
+                return
+              end
+            end
           end
 
           def values

data/lib/mutant/parallel/connection.rb

@@ -16,14 +16,12 @@ module Mutant
       class Reader
         include Anima.new(:deadline, :io, :marshal, :response_reader, :log_reader)
 
-        private(*anima.attribute_names)
-
         private_class_method :new
 
-        attr_reader :log
-
         def error = Util.max_one(@errors)
 
+        def log = LogCapture.from_binary(@log)
+
         def result = Util.max_one(@results)
 
         def initialize(*)

data/lib/mutant/parallel/driver.rb

@@ -14,8 +14,6 @@ module Mutant
         :workers
       )
 
-      private(*anima.attribute_names)
-
       def initialize(**attributes)
         @alive = true
         super

data/lib/mutant/reporter/cli/printer/alive_results.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Reporter
+    class CLI
+      class Printer
+        # Shared logic for printing alive mutation results
+        module AliveResults
+          ALIVE_EXPLANATION = <<~'MESSAGE'
+            Uncovered mutations detected, exiting nonzero!
+            Alive mutations require one of two actions:
+            A) Keep the mutated code: Your tests specify the correct semantics,
+               and the original code is redundant. Accept the mutation.
+            B) Add a missing test: The original code is correct, but the tests
+               do not verify the behavior the mutation removed.
+          MESSAGE
+
+          def print_alive_results(failed_subject_results)
+            failed_subject_results.each do |subject_result|
+              SubjectResult.call(display_config:, output:, object: subject_result)
+            end
+          end
+        end # AliveResults
+      end # Printer
+    end # CLI
+  end # Reporter
+end # Mutant

data/lib/mutant/reporter/cli/printer/env_result.rb

@@ -8,22 +8,65 @@ module Mutant
         class EnvResult < self
           delegate(:failed_subject_results)
 
-          ALIVE_EXPLANATION = <<~'MESSAGE'
-            Alive mutations require one of two actions:
-            A) Keep the mutated code: Your tests specify the correct semantics,
-               and the original code is redundant. Accept the mutation.
-            B) Add a missing test: The original code is correct, but the tests
-               do not verify the behavior the mutation removed.
-          MESSAGE
+          SEPARATOR       = '-----------------------'
+          MORE_MESSAGE    = '(%d more alive mutation(s), use `mutant session subject %s` to see all details)'
+          STATS_FORMAT    = 'tests: %d, runtime: %.2fs, killtime: %.2fs'
+          NO_DIFF_MESSAGE = 'BUG: No diff generated, please report circumstances to https://github.com/mbj/mutant'
+
+          private_constant(*constants(false))
 
           # Run printer
           #
           # @return [undefined]
           def run
-            puts(ALIVE_EXPLANATION) if failed_subject_results.any?
-            visit_collection(SubjectResult, failed_subject_results)
+            unless failed_subject_results.empty?
+              puts(AliveResults::ALIVE_EXPLANATION)
+              failed_subject_results.each(&method(:print_subject_summary))
+            end
             visit(EnvProgress, object)
           end
+
+        private
+
+          def print_subject_summary(subject_result)
+            uncovered = subject_result.uncovered_results
+
+            if uncovered.any? { |coverage_result| critical?(coverage_result.mutation_result) }
+              SubjectResult.call(output:, object: subject_result)
+              return
+            end
+
+            print_subject_line(subject_result)
+            print_mutation_diff(uncovered.first.mutation_result)
+
+            remaining = uncovered.length - 1
+
+            return unless remaining.positive?
+
+            puts(MORE_MESSAGE % [remaining, subject_result.expression_syntax])
+          end
+
+          def print_subject_line(subject_result)
+            status(subject_result.identification)
+            puts(STATS_FORMAT % [subject_result.tests.length, subject_result.runtime, subject_result.killtime])
+          end
+
+          def critical?(mutation_result)
+            !mutation_result.mutation_type.eql?('evil')
+          end
+
+          def print_mutation_diff(mutation_result)
+            puts(mutation_result.mutation_identification)
+            puts(SEPARATOR)
+            diff = mutation_result.mutation_diff
+
+            if diff
+              output.write(color? ? colorize_diff(diff) : diff)
+            else
+              puts(NO_DIFF_MESSAGE)
+            end
+            puts(SEPARATOR)
+          end
         end # EnvResult
       end # Printer
     end # CLI

data/lib/mutant/reporter/cli/printer/isolation_result.rb

@@ -51,15 +51,12 @@ module Mutant
         private
 
           def print_log_messages
-            log = object.log
+            log = object.log.content
 
             return if log.empty?
 
-            puts('Log messages (combined stderr and stdout):')
-
-            log.each_line do |line|
-              puts('[killfork] %<line>s' % { line: })
-            end
+            puts('Killfork log (combined stderr and stdout):')
+            puts(log)
           end
 
           def print_process_status

data/lib/mutant/reporter/cli/printer/subject_result.rb

@@ -5,19 +5,117 @@ module Mutant
     class CLI
       class Printer
         # Subject result printer
+        #
+        # Renders subject identification, tests, and all uncovered mutations
+        # inline so that subject context (source, node) is available when
+        # printing mutation details.
         class SubjectResult < self
 
-          delegate :subject, :uncovered_results, :tests
+          delegate :uncovered_results, :tests
+
+          MAP = {
+            'evil'    => :evil_details,
+            'neutral' => :neutral_details,
+            'noop'    => :noop_details
+          }.freeze
+
+          NEUTRAL_MESSAGE = <<~'MESSAGE'
+            --- Neutral failure ---
+            Original code was inserted unmutated. And the test did NOT PASS.
+            Your tests do not pass initially or you found a bug in mutant / unparser.
+            Subject AST:
+            %s
+            Unparsed Source:
+            %s
+          MESSAGE
+
+          NO_DIFF_MESSAGE = <<~'MESSAGE'
+            --- Internal failure ---
+            BUG: A generated mutation did not result in exactly one diff hunk!
+            This is an invariant violation by the mutation generation engine.
+            Please report a reproduction to https://github.com/mbj/mutant
+            Original unparsed source:
+            %s
+            Original AST:
+            %s
+            Mutated unparsed source:
+            %s
+            Mutated AST:
+            %s
+          MESSAGE
+
+          NOOP_MESSAGE = <<~'MESSAGE'
+            ---- Noop failure -----
+            No code was inserted. And the test did NOT PASS.
+            This is typically a problem of your specs not passing unmutated.
+          MESSAGE
+
+          SEPARATOR    = '-----------------------'
+          STATS_FORMAT = 'tests: %d, runtime: %.2fs, killtime: %.2fs'
+
+          private_constant(*constants(false))
 
           # Run report printer
           #
           # @return [undefined]
           def run
-            status(subject.identification)
-            tests.each do |test|
-              puts("- #{test.identification}")
+            status(object.identification)
+            puts(STATS_FORMAT % [tests.length, object.runtime, object.killtime])
+            uncovered_results.each do |coverage_result|
+              print_mutation_result(coverage_result.mutation_result)
+            end
+            print_selected_tests
+          end
+
+        private
+
+          def print_selected_tests
+            if tests.empty?
+              puts('no selected tests')
+            else
+              puts("selected tests (#{tests.length}):")
+              tests.each do |test|
+                puts("- #{test.identification}")
+              end
+            end
+          end
+
+          def print_mutation_result(mutation_result)
+            puts(mutation_result.mutation_identification)
+            puts(SEPARATOR)
+            visit(IsolationResult, mutation_result.isolation_result) if show_isolation_logs?(mutation_result)
+            __send__(MAP.fetch(mutation_result.mutation_type), mutation_result)
+            puts(SEPARATOR)
+          end
+
+          def show_isolation_logs?(mutation_result)
+            display_config.isolation_logs || !mutation_result.mutation_type.eql?('evil')
+          end
+
+          # rubocop:disable Metrics/MethodLength
+          def evil_details(mutation_result)
+            diff = mutation_result.mutation_diff
+
+            if diff
+              output.write(color? ? colorize_diff(diff) : diff)
+            else
+              info(
+                NO_DIFF_MESSAGE,
+                object.source,
+                object.node.inspect,
+                mutation_result.mutation_source,
+                mutation_result.mutation_node.inspect
+              )
             end
-            visit_collection(CoverageResult, uncovered_results)
+          end
+          # rubocop:enable Metrics/MethodLength
+
+          def noop_details(_mutation_result)
+            info(NOOP_MESSAGE)
+          end
+
+          def neutral_details(mutation_result)
+            info(NEUTRAL_MESSAGE, object.node.inspect, mutation_result.mutation_source)
           end
 
         end # SubjectResult

data/lib/mutant/reporter/cli/printer/test.rb

@@ -110,7 +110,7 @@ module Mutant
             #
             # @return [undefined]
             def run
-              puts(object.output)
+              puts(object.output.content)
             end
 
           end # Result

data/lib/mutant/reporter/cli/printer.rb

@@ -5,13 +5,25 @@ module Mutant
     class CLI
       # CLI runner status printer base class
       class Printer
+        # Printer display options
+        class DisplayConfig
+          include Anima.new(:isolation_logs)
+
+          DEFAULT = new(isolation_logs: false)
+          VERBOSE = new(isolation_logs: true)
+        end
+
         include(
           AbstractType,
           Adamantium,
-          Anima.new(:output, :object),
+          Anima.new(:display_config, :output, :object),
           Procto
         )
 
+        def self.call(output:, object:, display_config: DisplayConfig::DEFAULT)
+          super
+        end
+
         private_class_method :new
 
         def call = run
@@ -82,6 +94,17 @@ module Mutant
         end
 
         alias_method :color?, :tty?
+
+        def colorize_diff(raw_diff)
+          raw_diff.lines.map do |line|
+            case line[0]
+            when '+' then Unparser::Color::GREEN.format(line)
+            when '-' then Unparser::Color::RED.format(line)
+            else
+              line
+            end
+          end.join
+        end
       end # Printer
     end # CLI
   end # Reporter

data/lib/mutant/repository/diff.rb

@@ -60,14 +60,13 @@ module Mutant
       end
 
       # rubocop:disable Metrics/MethodLength
-      # mutant:disable (3.2 specific mutation)
       def parse_line(root, line)
         match = FORMAT.match(line)
 
         if match
           Either::Right.new(
             Path.new(
-              path:  root.join(Util.one(match.captures)),
+              path:  root.join(Util.one(match)),
               to:,
               world:
             )