mutant 0.15.1 → 0.16.0

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
+
+      JSON = Transform::JSON.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::JSON.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::JSON.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)
+        ]
+      )
+
+      JSON = Transform::JSON.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::JSON.dump(object.mutation_result).from_right,
+            'criteria_result' => CoverageCriteria::JSON.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::JSON.load_transform),
+              Transform::Hash::Key.new(value: 'criteria_result', transform: CoverageCriteria::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 # 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::JSON.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::JSON.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)
+        ]
+      )
+
+      JSON = Transform::JSON.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/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/json.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Transform
+    # Bidirectional JSON transform
+    #
+    # Wraps a pair of dump/load transforms and optionally adds
+    # JSON string serialization via .build
+    class JSON
+      include Anima.new(:dump_transform, :load_transform)
+
+      # Build a JSON transform that wraps raw transforms with JSON.parse/generate
+      #
+      # @param [Transform] dump
+      # @param [Transform] load
+      #
+      # @return [JSON]
+      # rubocop:disable Metrics/MethodLength
+      def self.build(dump:, load:)
+        new(
+          dump_transform: Sequence.new(
+            steps: [
+              dump,
+              Success.new(block: ::JSON.public_method(:generate))
+            ]
+          ),
+          load_transform: Sequence.new(
+            steps: [
+              Exception.new(error_class: ::JSON::ParserError, block: ::JSON.public_method(:parse)),
+              load
+            ]
+          )
+        )
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # Build a JSON transform for simple Anima objects with JSON-primitive fields
+      #
+      # @param [Class] klass
+      #
+      # @return [JSON]
+      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 hash or JSON string
+      #
+      # @param [Object] object
+      #
+      # @return [Either<Error, Object>]
+      def dump(object)
+        dump_transform.call(object)
+      end
+
+      # Load object from hash or JSON string
+      #
+      # @param [Object] input
+      #
+      # @return [Either<Error, Object>]
+      def load(input)
+        load_transform.call(input)
+      end
+    end # JSON
+  end # Transform
+end # Mutant

data/lib/mutant/transform.rb

@@ -117,8 +117,6 @@ module Mutant
     class Index < self
       include Anima.new(:index, :transform)
 
-      private(*anima.attribute_names)
-
       # Create error at specified index
       #
       # @param [Error] cause
@@ -185,7 +183,7 @@ module Mutant
 
     # Transform guarding boolean primitives
     class Boolean < self
-      include Concord.new
+      include Equalizer.new
 
       MESSAGE = 'Expected: boolean but got: %<actual>s'
 
@@ -258,8 +256,8 @@ module Mutant
     class Hash < self
       include Anima.new(:optional, :required)
 
-      KEY_MESSAGE = 'Missing keys: %<missing>s, Unexpected keys: %<unexpected>s'
-      PRIMITIVE   = Primitive.new(primitive: ::Hash)
+      KEY_MESSAGE     = 'Missing keys: %<missing>s, Unexpected keys: %<unexpected>s'
+      PRIMITIVE       = Primitive.new(primitive: ::Hash)
 
       private_constant(*constants(false))
 
@@ -313,24 +311,16 @@ module Mutant
     private
 
       def transform(input)
-        transform_required(input).bind do |required|
-          transform_optional(input).fmap(&required.public_method(:merge))
+        coerce_keys(required, input).bind do |required|
+          coerce_keys(
+            optional.select { |key| input.key?(key.value) },
+            input
+          ).fmap(&required.public_method(:merge))
         end
       end
 
-      def transform_required(input)
-        transform_keys(required, input)
-      end
-
-      def transform_optional(input)
-        transform_keys(
-          optional.select { |key| input.key?(key.value) },
-          input
-        )
-      end
-
       # rubocop:disable Metrics/MethodLength
-      def transform_keys(keys, input)
+      def coerce_keys(keys, input)
         success(
           keys
             .to_h do |key|
@@ -375,6 +365,7 @@ module Mutant
 
       def required_keys = required.map(&:value)
       memoize :required_keys
+
     end # Hash
 
     # Sequence of transformations
@@ -411,7 +402,23 @@ module Mutant
       def call(input)
         success(block.call(input))
       end
-    end # Sequence
+    end # Success
+
+    # Nullable wrapper: passes nil through, delegates non-nil to inner transform
+    class Nullable < self
+      include Anima.new(:transform)
+
+      # Apply transformation to input
+      #
+      # @param [Object]
+      #
+      # @return [Either<Error, Object>]
+      def call(input)
+        input.nil? ? success(nil) : transform.call(input)
+      end
+
+      def slug = "nullable(#{transform.slug})"
+    end # Nullable
 
     # Generic exception transformer
     class Exception < self
@@ -429,10 +436,11 @@ module Mutant
       end
     end # Exception
 
-    BOOLEAN      = Transform::Boolean.new
-    FLOAT        = Transform::Primitive.new(primitive: Float)
-    INTEGER      = Transform::Primitive.new(primitive: Integer)
-    STRING       = Transform::Primitive.new(primitive: String)
-    STRING_ARRAY = Transform::Array.new(transform: STRING)
+    BOOLEAN         = Transform::Boolean.new
+    FLOAT           = Transform::Primitive.new(primitive: Float)
+    INTEGER         = Transform::Primitive.new(primitive: Integer)
+    STRING          = Transform::Primitive.new(primitive: String)
+    OPTIONAL_STRING = Nullable.new(transform: STRING)
+    STRING_ARRAY    = Transform::Array.new(transform: STRING)
   end # Transform
 end # Mutant

data/lib/mutant/world.rb

@@ -89,6 +89,12 @@ module Mutant
       recorder.record(name, &)
     end
 
+    def parse_json(string)
+      record(:json_parse) do
+        Either.wrap_error(json::ParserError) { json.parse(string) }
+      end
+    end
+
     def process_warmup
       process.warmup if process.respond_to?(:warmup)
     end

data/lib/mutant/zombifier.rb

@@ -13,8 +13,6 @@ module Mutant
       :root_require
     )
 
-    private(*anima.attribute_names)
-
     include AST::Sexp
 
     class LoadError < ::LoadError

data/lib/mutant.rb

@@ -52,7 +52,6 @@ module Mutant
   AbstractType = Unparser::AbstractType
   Adamantium   = Unparser::Adamantium
   Anima        = Unparser::Anima
-  Concord      = Unparser::Concord
   Either       = Unparser::Either
   Equalizer    = Unparser::Equalizer
 
@@ -70,6 +69,7 @@ module Mutant
   record.call(:require_mutant_lib) do
     require 'mutant/procto'
     require 'mutant/transform'
+    require 'mutant/transform/json'
     require 'mutant/variable'
     require 'mutant/bootstrap'
     require 'mutant/version'
@@ -96,6 +96,9 @@ module Mutant
     require 'mutant/ast/pattern/token'
     require 'mutant/ast/structure'
     require 'mutant/parser'
+    require 'mutant/result/test'
+    require 'mutant/result/process_status'
+    require 'mutant/result/exception'
     require 'mutant/isolation'
     require 'mutant/isolation/exception'
     require 'mutant/isolation/fork'
@@ -237,10 +240,11 @@ module Mutant
     require 'mutant/cli/command/environment/subject'
     require 'mutant/cli/command/environment/test'
     require 'mutant/cli/command/util'
-    require 'mutant/cli/command/root'
     require 'mutant/mutation/runner'
     require 'mutant/mutation/runner/sink'
     require 'mutant/result'
+    require 'mutant/result/session'
+    require 'mutant/result/json_writer'
     require 'mutant/reporter'
     require 'mutant/reporter/null'
     require 'mutant/reporter/sequence'
@@ -248,17 +252,18 @@ module Mutant
     require 'mutant/reporter/cli/progress_bar'
     require 'mutant/reporter/cli/printer'
     require 'mutant/reporter/cli/printer/config'
-    require 'mutant/reporter/cli/printer/coverage_result'
     require 'mutant/reporter/cli/printer/env'
     require 'mutant/reporter/cli/printer/env_progress'
+    require 'mutant/reporter/cli/printer/alive_results'
     require 'mutant/reporter/cli/printer/env_result'
     require 'mutant/reporter/cli/printer/isolation_result'
     require 'mutant/reporter/cli/printer/mutation'
-    require 'mutant/reporter/cli/printer/mutation_result'
     require 'mutant/reporter/cli/printer/status_progressive'
     require 'mutant/reporter/cli/printer/subject_result'
     require 'mutant/reporter/cli/printer/test'
     require 'mutant/reporter/cli/format'
+    require 'mutant/cli/command/session'
+    require 'mutant/cli/command/root'
     require 'mutant/repository'
     require 'mutant/repository/diff'
     require 'mutant/repository/diff/ranges'
@@ -343,6 +348,10 @@ module Mutant
     timer:
   )
 
+  # UUIDv7 identifying this mutant process invocation.
+  # Used as the JSON result filename and session identifier.
+  SESSION_ID = SecureRandom.uuid_v7
+
   # Reopen class to initialize constant to avoid dep circle
   class Config
     DEFAULT = new(