mutant 0.15.1 → 0.16.2

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
+
+      CODEC = Transform::Codec.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::CODEC.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
+      CODEC = Transform::Codec.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::CODEC.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::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 # Session
+  end # Result
+end # Mutant

data/lib/mutant/result/test.rb

@@ -0,0 +1,57 @@
+# 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:    LogCapture.from_binary(+''),
+            passed:    false,
+            runtime:   0.0
+          )
+        end
+      end # VoidValue
+
+      dump = Transform::Success.new(
+        block: lambda do |object|
+          {
+            'job_index' => object.job_index,
+            'output'    => LogCapture::CODEC.dump(object.output).from_right,
+            'passed'    => object.passed,
+            'runtime'   => object.runtime
+          }
+        end
+      )
+
+      load = Transform::Sequence.new(
+        steps: [
+          Transform::Hash.new(
+            required: [
+              Transform::Hash::Key.new(value: 'job_index', transform: Transform::Nullable.new(transform: Transform::INTEGER)),
+              Transform::Hash::Key.new(value: 'output',    transform: LogCapture::CODEC.load_transform),
+              Transform::Hash::Key.new(value: 'passed',    transform: Transform::BOOLEAN),
+              Transform::Hash::Key.new(value: 'runtime',   transform: Transform::FLOAT)
+            ],
+            optional: []
+          ),
+          Transform::Hash::Symbolize.new,
+          Transform::Success.new(block: method(:new).to_proc)
+        ]
+      )
+
+      CODEC = Transform::Codec.new(dump_transform: dump, load_transform: load)
+    end # Test
+  end # Result
+end # Mutant

data/lib/mutant/result.rb

@@ -48,7 +48,7 @@ module Mutant
       end
     end # ClassMethods
 
-    private_constant(*constants(false))
+    private_constant(:CoverageMetric, :ClassMethods)
 
     # Hook called when module gets included
     #
@@ -140,98 +140,6 @@ module Mutant
       def amount_tests_success = test_results.count(&:passed)
     end # TestEnv
 
-    # 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
-    end # Test
-
-    # Subject result
-    class Subject
-      include CoverageMetric, Result, Anima.new(
-        :coverage_results,
-        :subject,
-        :tests
-      )
-
-      sum :killtime, :coverage_results
-      sum :runtime,  :coverage_results
-
-      # Test if subject was processed successful
-      #
-      # @return [Boolean]
-      def success?
-        uncovered_results.empty?
-      end
-
-      # Alive mutations
-      #
-      # @return [Array<Result::Coverage>]
-      def uncovered_results = coverage_results.reject(&:success?)
-      memoize :uncovered_results
-
-      # Amount of mutations
-      #
-      # @return [Integer]
-      def amount_mutation_results = coverage_results.length
-
-      # Amount of mutations
-      #
-      # @return [Integer]
-      def amount_timeouts = coverage_results.count(&:timeout?)
-
-      # Amount of mutations
-      #
-      # @return [Integer]
-      def amount_mutations = subject.mutations.length
-
-      # Number of killed mutations
-      #
-      # @return [Integer]
-      def amount_mutations_killed = covered_results.length
-
-      # Number of alive mutations
-      #
-      # @return [Integer]
-      def amount_mutations_alive = uncovered_results.length
-
-    private
-
-      def covered_results = coverage_results.select(&:success?)
-      memoize :covered_results
-
-    end # Subject
-
-    # Coverage of a mutation against criteria
-    class Coverage
-      include Result, Anima.new(
-        :mutation_result,
-        :criteria_result
-      )
-
-      delegate :killtime, :mutation_result
-      delegate :runtime,  :mutation_result
-      delegate :success?, :criteria_result
-      delegate :timeout?, :mutation_result
-    end # Coverage
-
     class CoverageCriteria
       include Result, Anima.new(*Config::CoverageCriteria.anima.attribute_names)
 
@@ -241,6 +149,8 @@ module Mutant
       def success?
         process_abort || test_result || timeout
       end
+
+      CODEC = Transform::Codec.for_anima(self)
     end
 
     class MutationIndex
@@ -255,13 +165,25 @@ module Mutant
     class Mutation
       include Result, Anima.new(
         :isolation_result,
-        :mutation,
+        :mutation_diff,
+        :mutation_identification,
+        :mutation_node,
+        :mutation_source,
+        :mutation_type,
         :runtime
       )
 
+      TEST_PASS_SUCCESS = {
+        'evil'    => false,
+        'neutral' => true,
+        'noop'    => true
+      }.freeze
+
+      private_constant(:TEST_PASS_SUCCESS)
+
       # Create mutation criteria results
       #
-      # @praam [Result::CoverageCriteria]
+      # @param [Result::CoverageCriteria]
       def criteria_result(coverage_criteria)
         CoverageCriteria.new(
           process_abort: coverage_criteria.process_abort && process_abort?,
@@ -297,10 +219,193 @@ module Mutant
       #
       # @return [Boolean]
       def test_result_success?
-        isolation_result.valid_value? && mutation.class.success?(isolation_result.value)
+        isolation_result.valid_value? && TEST_PASS_SUCCESS.fetch(mutation_type).equal?(isolation_result.value.passed)
       end
       memoize :test_result_success?
 
+      dump = Transform::Success.new(
+        block: lambda do |object|
+          {
+            'isolation_result'        => Isolation::Result::CODEC.dump(object.isolation_result).from_right,
+            'mutation_diff'           => object.mutation_diff,
+            'mutation_identification' => object.mutation_identification,
+            'mutation_source'         => object.mutation_source,
+            'mutation_type'           => object.mutation_type,
+            'runtime'                 => object.runtime
+          }
+        end
+      )
+
+      derive_mutation_node = Transform::Success.new(
+        block: ->(hash) { hash.merge('mutation_node' => Unparser.parse(hash.fetch('mutation_source'))) }
+      )
+
+      load = Transform::Sequence.new(
+        steps: [
+          Transform::Hash.new(
+            required: [
+              Transform::Hash::Key.new(value: 'isolation_result', transform: Isolation::Result::CODEC.load_transform),
+              Transform::Hash::Key.new(value: 'mutation_diff',    transform: Transform::OPTIONAL_STRING),
+              Transform::Hash::Key.new(value: 'mutation_identification', transform: Transform::STRING),
+              Transform::Hash::Key.new(value: 'mutation_source',  transform: Transform::STRING),
+              Transform::Hash::Key.new(value: 'mutation_type',    transform: Transform::STRING),
+              Transform::Hash::Key.new(value: 'runtime',          transform: Transform::FLOAT)
+            ],
+            optional: []
+          ),
+          derive_mutation_node,
+          Transform::Hash::Symbolize.new,
+          Transform::Success.new(block: method(:new).to_proc)
+        ]
+      )
+
+      CODEC = Transform::Codec.new(dump_transform: dump, load_transform: load)
     end # Mutation
+
+    # Coverage of a mutation against criteria
+    class Coverage
+      include Result, Anima.new(
+        :mutation_result,
+        :criteria_result
+      )
+
+      delegate :killtime, :mutation_result
+      delegate :runtime,  :mutation_result
+      delegate :success?, :criteria_result
+      delegate :timeout?, :mutation_result
+
+      dump = Transform::Success.new(
+        block: lambda do |object|
+          {
+            'mutation_result' => Mutation::CODEC.dump(object.mutation_result).from_right,
+            'criteria_result' => CoverageCriteria::CODEC.dump(object.criteria_result).from_right
+          }
+        end
+      )
+
+      load = Transform::Sequence.new(
+        steps: [
+          Transform::Hash.new(
+            required: [
+              Transform::Hash::Key.new(value: 'mutation_result', transform: Mutation::CODEC.load_transform),
+              Transform::Hash::Key.new(value: 'criteria_result', transform: CoverageCriteria::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 # Coverage
+
+    # Subject result
+    class Subject
+      include CoverageMetric, Result, Anima.new(
+        :amount_mutations,
+        :coverage_results,
+        :expression_syntax,
+        :identification,
+        :node,
+        :source,
+        :source_path,
+        :tests
+      )
+
+      sum :killtime, :coverage_results
+      sum :runtime,  :coverage_results
+
+      # Test if subject was processed successful
+      #
+      # @return [Boolean]
+      def success?
+        uncovered_results.empty?
+      end
+
+      # Alive mutations
+      #
+      # @return [Array<Result::Coverage>]
+      def uncovered_results = coverage_results.reject(&:success?)
+      memoize :uncovered_results
+
+      # Amount of mutations
+      #
+      # @return [Integer]
+      def amount_mutation_results = coverage_results.length
+
+      # Amount of mutations
+      #
+      # @return [Integer]
+      def amount_timeouts = coverage_results.count(&:timeout?)
+
+      # Number of killed mutations
+      #
+      # @return [Integer]
+      def amount_mutations_killed = covered_results.length
+
+      # Number of alive mutations
+      #
+      # @return [Integer]
+      def amount_mutations_alive = uncovered_results.length
+
+    private
+
+      def covered_results = coverage_results.select(&:success?)
+      memoize :covered_results
+
+      dump = Transform::Success.new(
+        block: lambda do |object|
+          {
+            'amount_mutations'  => object.amount_mutations,
+            'coverage_results'  => object.coverage_results
+              .map { |coverage_result| Coverage::CODEC.dump(coverage_result).from_right },
+            'expression_syntax' => object.expression_syntax,
+            'identification'    => object.identification,
+            'source'            => object.source,
+            'source_path'       => object.source_path,
+            'tests'             => object.tests.map(&:identification)
+          }
+        end
+      )
+
+      Transform::Block.capture(:parse_node) do |source|
+        Either.wrap_error(::Parser::SyntaxError) { Unparser.parse(source) }
+          .lmap(&:message)
+      end
+
+      load_test = Transform::Success.new(
+        block: ->(id) { Mutant::Test.new(expressions: EMPTY_ARRAY, id:) }
+      )
+
+      derive_node = Transform::Success.new(
+        block: ->(hash) { hash.merge('node' => Unparser.parse(hash.fetch('source'))) }
+      )
+
+      load = Transform::Sequence.new(
+        steps: [
+          Transform::Hash.new(
+            required: [
+              Transform::Hash::Key.new(value: 'amount_mutations',  transform: Transform::INTEGER),
+              Transform::Hash::Key.new(value: 'coverage_results',  transform: Transform::Array.new(transform: Coverage::CODEC.load_transform)),
+              Transform::Hash::Key.new(value: 'expression_syntax', transform: Transform::STRING),
+              Transform::Hash::Key.new(value: 'identification',    transform: Transform::STRING),
+              Transform::Hash::Key.new(value: 'source',            transform: Transform::STRING),
+              Transform::Hash::Key.new(value: 'source_path',       transform: Transform::STRING),
+              Transform::Hash::Key.new(
+                value:     'tests',
+                transform: Transform::Array.new(transform: load_test)
+              )
+            ],
+            optional: []
+          ),
+          derive_node,
+          Transform::Hash::Symbolize.new,
+          Transform::Success.new(block: method(:new).to_proc)
+        ]
+      )
+
+      CODEC = Transform::Codec.new(dump_transform: dump, load_transform: load)
+    end # Subject
   end # Result
 end # Mutant

data/lib/mutant/segment/recorder.rb

@@ -12,8 +12,6 @@ module Mutant
         :timer
       )
 
-      private(*anima.attribute_names)
-
       # rubocop:disable Metrics/MethodLength
       def record(name)
         start     = timer.now

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

@@ -38,7 +38,7 @@ module Mutant
         # @return [self]
         def response(response)
           if response.error
-            env.world.stderr.puts(response.log)
+            env.world.stderr.puts(response.log.content)
             fail response.error
           end
 

data/lib/mutant/timer.rb

@@ -57,7 +57,9 @@ module Mutant
 
       # Deadline that never expires
       class None < self
-        include Concord.new
+        include Equalizer.new
+
+        def initialize; end # rubocop:disable Lint/MissingSuper
 
         # The time left
         #

data/lib/mutant/transform/codec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Transform
+    # Bidirectional codec over Ruby objects.
+    #
+    # Wraps a pair of dump/load transforms that convert between domain
+    # objects and a JSON-compatible Ruby structure (hashes, arrays,
+    # primitives). The outer layer that converts the structure to/from
+    # a JSON string is handled by callers as needed.
+    class Codec
+      include Anima.new(:dump_transform, :load_transform)
+
+      # Build a codec for simple Anima objects with primitive fields
+      #
+      # @param [Class] klass
+      #
+      # @return [Codec]
+      def self.for_anima(klass)
+        new(
+          dump_transform: Success.new(block: ->(object) { object.to_h.transform_keys(&:to_s) }),
+          load_transform: Success.new(block: ->(hash) { klass.new(**hash.transform_keys(&:to_sym)) })
+        )
+      end
+
+      # Dump object to Ruby structure
+      #
+      # @param [Object] object
+      #
+      # @return [Either<Error, Object>]
+      def dump(object)
+        dump_transform.call(object)
+      end
+
+      # Load object from Ruby structure
+      #
+      # @param [Object] input
+      #
+      # @return [Either<Error, Object>]
+      def load(input)
+        load_transform.call(input)
+      end
+    end # Codec
+  end # Transform
+end # Mutant