mutant 0.15.0 → 0.16.0

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,13 +8,65 @@ module Mutant
         class EnvResult < self
           delegate(:failed_subject_results)
 
+          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
-            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/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.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:
             )

data/lib/mutant/result/exception.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Mutant
+  module Result
+    # Serializable exception data
+    class Exception
+      include Anima.new(
+        :backtrace,
+        :message,
+        :original_class
+      )
+
+      # Build from a Ruby exception
+      #
+      # @param [::Exception] exception
+      #
+      # @return [Exception]
+      def self.from_exception(exception)
+        new(
+          backtrace:      exception.backtrace,
+          message:        exception.message,
+          original_class: exception.class.name
+        )
+      end
+
+      JSON = Transform::JSON.for_anima(self)
+    end # Exception
+  end # Result
+end # Mutant

data/lib/mutant/result/json_writer.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Mutant
+  module Result
+    # Write result JSON to .mutant/results/
+    class JSONWriter
+      include Anima.new(:env, :result)
+
+      RESULTS_DIR = '.mutant/results'
+
+      # Write result JSON file
+      #
+      # @return [Pathname]
+      def call
+        dir = env.world.pathname.new(RESULTS_DIR)
+        dir.mkpath
+
+        path = dir.join("#{SESSION_ID}.json")
+        path.write(json)
+
+        path
+      end
+
+    private
+
+      def json
+        JSON.generate(Session::JSON.dump(session).from_right)
+      end
+
+      def session
+        Session.new(
+          killtime:        result.killtime,
+          mutant_version:  VERSION,
+          pid:             env.world.process.pid,
+          ruby_version:    RUBY_VERSION,
+          runtime:         result.runtime,
+          session_id:      SESSION_ID,
+          subject_results: result.subject_results
+        )
+      end
+    end # JSONWriter
+  end # Result
+end # Mutant

data/lib/mutant/result/process_status.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Mutant
+  module Result
+    # Serializable process status
+    #
+    # Replaces Process::Status in the result tree with a
+    # round-trippable value object.
+    class ProcessStatus
+      include Anima.new(:exitstatus)
+
+      # Build from a Process::Status object
+      #
+      # @param [Process::Status] process_status
+      #
+      # @return [ProcessStatus]
+      def self.from_process_status(process_status)
+        new(exitstatus: process_status.exitstatus)
+      end
+
+      # Stable inspect without memory address for use in user-facing output
+      #
+      # @return [String]
+      def inspect
+        "#<#{self.class.name} exitstatus=#{exitstatus}>"
+      end
+
+      # Test for successful exit
+      #
+      # @return [Boolean]
+      def success?
+        exitstatus.equal?(0)
+      end
+      JSON = Transform::JSON.for_anima(self)
+    end # ProcessStatus
+  end # Result
+end # Mutant

data/lib/mutant/result/session.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Mutant
+  module Result
+    # Top-level result object containing session metadata and subject results
+    class Session
+      # Extract timestamp from UUIDv7 session_id
+      module Timestamp
+        # @return [Time]
+        def timestamp
+          ms = session_id.delete('-')[0, 12].to_i(16)
+          Time.at(ms / 1000.0).utc
+        end
+      end
+
+      include Timestamp, Anima.new(
+        :killtime,
+        :mutant_version,
+        :pid,
+        :ruby_version,
+        :runtime,
+        :session_id,
+        :subject_results
+      )
+
+      dump = Transform::Success.new(
+        block: lambda do |object|
+          {
+            'killtime'        => object.killtime,
+            'mutant_version'  => object.mutant_version,
+            'pid'             => object.pid,
+            'ruby_version'    => object.ruby_version,
+            'runtime'         => object.runtime,
+            'session_id'      => object.session_id,
+            'subject_results' => object.subject_results.map { |subject_result| Subject::JSON.dump(subject_result).from_right }
+          }
+        end
+      )
+
+      load = Transform::Sequence.new(
+        steps: [
+          Transform::Hash.new(
+            required: [
+              Transform::Hash::Key.new(value: 'killtime',        transform: Transform::FLOAT),
+              Transform::Hash::Key.new(value: 'mutant_version',  transform: Transform::STRING),
+              Transform::Hash::Key.new(value: 'pid',             transform: Transform::INTEGER),
+              Transform::Hash::Key.new(value: 'ruby_version',    transform: Transform::STRING),
+              Transform::Hash::Key.new(value: 'runtime',         transform: Transform::FLOAT),
+              Transform::Hash::Key.new(value: 'session_id',      transform: Transform::STRING),
+              Transform::Hash::Key.new(value: 'subject_results', transform: Transform::Array.new(transform: Subject::JSON.load_transform))
+            ],
+            optional: []
+          ),
+          Transform::Hash::Symbolize.new,
+          Transform::Success.new(block: method(:new).to_proc)
+        ]
+      )
+
+      JSON = Transform::JSON.new(dump_transform: dump, load_transform: load)
+
+    end # Session
+  end # Result
+end # Mutant

data/lib/mutant/result/test.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Mutant
+  module Result
+    # Test result
+    class Test
+      include Anima.new(:job_index, :passed, :runtime, :output)
+
+      alias_method :success?, :passed
+
+      class VoidValue < self
+        include Singleton
+
+        # Initialize object
+        #
+        # @return [undefined]
+        def initialize
+          super(
+            job_index: nil,
+            output:    '',
+            passed:    false,
+            runtime:   0.0
+          )
+        end
+      end # VoidValue
+
+      JSON = Transform::JSON.for_anima(self)
+    end # Test
+  end # Result
+end # Mutant