mutant 0.16.0 → 0.16.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d35acd82d2b4cf6222613f653da44131636400215c56a14a00f1ecd2ef212079
-  data.tar.gz: ae7ad7d71685be5108bb5fcc6be1b0cae5cd32f56e2848d25467c82d2f72771c
+  metadata.gz: 8f5176c82dd4c6a57785deebd566c3b29b14b4496d35c06e15c20ff3b98a0b37
+  data.tar.gz: 9f29a560a6c144480d8808cf24ec2ec2127b78bc7f9ef88e8e8a3e0f541e0974
 SHA512:
-  metadata.gz: 1481530eb5c56560e06a828086df6d8a5f12d47b3180bafc47f996ccd3a6db22b2cd0ddd213bb12c6934cf878341bad5f987f8cb91113ad0db58a0c68760d203
-  data.tar.gz: 657f62dc386d13f729dfb92fc78afed7c426cd4e64f53ca938c403c6cd4ad06ad856b379dde9d890d2a96ae692f64521975d9d3e0fd850095a4b03ab82d9b906
+  metadata.gz: a5e05c7b33041fb609ebcc89683461dba406c53592801d69603fa9003e0d8ee923f54d7b6f0bc9abcfd811ade64054ef3a8b9bf2bc30dbd44f37ca1f1ae2d4b6
+  data.tar.gz: 659e58f9ce856224a2a8f67d073c9006e340bcd838b0f6543cc57f8a12cbf6cc29c6dccad248744748a9f176750dae5240b719b797c7339a8552532e10d4ce22

data/VERSION

@@ -1 +1 @@
-0.16.0
+0.16.2

data/lib/mutant/ast/pattern/lexer.rb

@@ -3,20 +3,43 @@
 module Mutant
   class AST
     class Pattern
+      # rubocop:disable Metrics/ClassLength
       class Lexer
-        WHITESPACE     = [' ', "\t", "\n"].to_set.freeze
-        STRING_PATTERN = /\A[a-zA-Z][_a-zA-Z0-9]*\z/
+        WHITESPACE = [' ', "\t", "\n"].to_set.freeze
 
-        SINGLE_CHAR =
+        STRUCTURAL =
           {
             '(' => :group_start,
             ')' => :group_end,
             ',' => :delimiter,
-            '=' => :eq,
             '{' => :properties_start,
             '}' => :properties_end
           }.freeze
 
+        EQ_OPERATORS = %w[=== == =~].freeze
+
+        OPERATORS_BY_START =
+          {
+            '!' => %w[!= !~ !].freeze,
+            '<' => %w[<=> << <= <].freeze,
+            '>' => %w[>> >= >].freeze,
+            '+' => %w[+@ +].freeze,
+            '-' => %w[-@ -].freeze,
+            '*' => %w[** *].freeze,
+            '[' => ['[]=', '[]'].freeze,
+            '/' => ['/'].freeze,
+            '%' => ['%'].freeze,
+            '&' => ['&'].freeze,
+            '|' => ['|'].freeze,
+            '^' => ['^'].freeze,
+            '~' => ['~'].freeze
+          }.freeze
+
+        IDENTIFIER_START    = /[a-zA-Z]/
+        IDENTIFIER_CONTINUE = /[a-zA-Z0-9_]/
+
+        SETTER_TERMINATORS = (WHITESPACE + [',', ')', '}']).freeze
+
         def self.call(string)
           new(string).__send__(:run)
         end
@@ -31,7 +54,7 @@ module Mutant
                 #{token.display_location}
               MESSAGE
             end
-          end # Token
+          end # InvalidToken
         end # Error
 
         private_class_method :new
@@ -58,71 +81,123 @@ module Mutant
         end
 
         def consume
-          while next? && !instance_variable_defined?(:@error)
+          loop do
             skip_whitespace
+            break unless next? && !instance_variable_defined?(:@error)
 
-            consume_char || consume_string
-
-            skip_whitespace
+            consume_structural \
+              || consume_eq \
+              || consume_operator \
+              || consume_identifier \
+              || consume_invalid
           end
         end
 
-        def consume_char
+        def consume_structural
+          char = peek
+          type = STRUCTURAL.fetch(char) { return }
           start_position = @next_position
+          advance_position
+          @tokens << token(type:, start_position:)
+        end
 
-          char = peek
+        def consume_eq
+          return unless peek.eql?('=')
+
+          start_position = @next_position
 
-          type = SINGLE_CHAR.fetch(char) { return }
+          EQ_OPERATORS.each do |op|
+            next unless matches?(op)
+
+            advance_positions(op.length)
+            @tokens << token(type: :string, start_position:, value: op)
+            return true
+          end
 
           advance_position
+          @tokens << token(type: :eq, start_position:)
+        end
 
-          @tokens << token(type:, start_position:)
+        def consume_operator
+          operators = OPERATORS_BY_START[peek] or return
+          match     = operators.detect { |op| matches?(op) } or return
+
+          start_position = @next_position
+          advance_positions(match.length)
+          @tokens << token(type: :string, start_position:, value: match)
         end
 
-        def token(type:, start_position:, value: nil)
-          Token.new(
-            type:,
-            value:,
-            location: Source::Location.new(
-              source:     @source,
-              line_index: @line_index,
-              line_start: @line_start,
-              range:      range_from(start_position)
-            )
+        def consume_identifier
+          return unless IDENTIFIER_START.match?(peek)
+
+          start_position = @next_position
+          advance_position while IDENTIFIER_CONTINUE.match?(peek)
+          consume_identifier_suffix
+
+          @tokens << token(
+            type:           :string,
+            start_position:,
+            value:          @string[range_from(start_position)]
           )
         end
 
-        def consume_string
-          start_position = @next_position
+        def consume_identifier_suffix
+          advance_position if suffix_char?(peek)
+        end
 
-          token = build_string(start_position, read_string_body)
+        def suffix_char?(char)
+          char.eql?('!') || char.eql?('?') || (char.eql?('=') && setter_suffix_follows?)
+        end
 
-          if valid_string?(token.value)
-            @tokens << token
-          else
-            @error = Error::InvalidToken.new(token:)
-          end
+        def setter_suffix_follows?
+          next_char = @string[@next_position.succ]
+
+          next_char.nil? || SETTER_TERMINATORS.include?(next_char)
         end
 
-        def read_string_body
-          string = +''
+        def consume_invalid
+          start_position = @next_position
+          advance_invalid
+          @error = Error::InvalidToken.new(
+            token: token(
+              type:           :string,
+              start_position:,
+              value:          @string[range_from(start_position)]
+            )
+          )
+        end
 
-          while next?
-            char = peek
-            break if SINGLE_CHAR.key?(char) || whitespace?(char)
+        def advance_invalid
+          loop do
+            break unless next?
+            break if terminates_invalid?(peek)
 
-            string << char
             advance_position
           end
+        end
 
-          string
+        def terminates_invalid?(char)
+          STRUCTURAL.key?(char) || whitespace?(char)
         end
 
-        def build_string(start_position, string)
-          token(
-            type:           :string,
-            value:          string,
-            start_position:
+        def matches?(string)
+          @string[@next_position, string.length].eql?(string)
+        end
+
+        def advance_positions(count)
+          count.times { advance_position }
+        end
+
+        def token(type:, start_position:, value: nil)
+          Token.new(
+            type:,
+            value:,
+            location: Source::Location.new(
+              source:     @source,
+              line_index: @line_index,
+              line_start: @line_start,
+              range:      range_from(start_position)
+            )
           )
         end
 
@@ -130,10 +205,6 @@ module Mutant
           start_position...@next_position
         end
 
-        def valid_string?(string)
-          STRING_PATTERN.match?(string)
-        end
-
         def advance_position
           @next_position += 1
         end
@@ -165,6 +236,7 @@ module Mutant
           @next_position < @string.length
         end
       end # Lexer
+      # rubocop:enable Metrics/ClassLength
     end # Pattern
   end # AST
 end # Mutant

data/lib/mutant/cli/command/session.rb

@@ -21,7 +21,7 @@ module Mutant
 
         def load_session_file(path)
           world.parse_json(path.read)
-            .bind(&Result::Session::JSON.load_transform.public_method(:call))
+            .bind(&Result::Session::CODEC.load_transform.public_method(:call))
         end
 
         # Shared base for commands that operate on a session

data/lib/mutant/integration/null.rb

@@ -17,7 +17,7 @@ module Mutant
       def call(_tests)
         Result::Test.new(
           job_index: nil,
-          output:    '',
+          output:    LogCapture::String.new(content: ''),
           passed:    true,
           runtime:   0.0
         )

data/lib/mutant/isolation/fork.rb

@@ -89,7 +89,7 @@ module Mutant
         def result
           Result.new(
             exception:      @exception,
-            log:            @log_fragments.join,
+            log:            LogCapture.from_binary(@log_fragments.join),
             process_status: @process_status,
             timeout:        @timeout,
             value:          @value

data/lib/mutant/isolation/none.rb

@@ -23,7 +23,7 @@ module Mutant
 
         Result.new(
           exception:,
-          log:            '',
+          log:            LogCapture::String.new(content: ''),
           process_status: nil,
           timeout:        nil,
           value:

data/lib/mutant/isolation.rb

@@ -25,11 +25,11 @@ module Mutant
       dump = Transform::Success.new(
         block: lambda do |object|
           {
-            'exception'      => object.exception && Mutant::Result::Exception::JSON.dump(object.exception).from_right,
-            'log'            => object.log,
-            'process_status' => object.process_status && Mutant::Result::ProcessStatus::JSON.dump(object.process_status).from_right,
+            '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::JSON.dump(object.value).from_right
+            'value'          => object.value && Mutant::Result::Test::CODEC.dump(object.value).from_right
           }
         end
       )
@@ -38,11 +38,11 @@ module Mutant
         steps: [
           Transform::Hash.new(
             required: [
-              Transform::Hash::Key.new(value: 'exception',      transform: Transform::Nullable.new(transform: Mutant::Result::Exception::JSON.load_transform)),
-              Transform::Hash::Key.new(value: 'log',            transform: Transform::STRING),
-              Transform::Hash::Key.new(value: 'process_status', transform: Transform::Nullable.new(transform: Mutant::Result::ProcessStatus::JSON.load_transform)),
+              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::JSON.load_transform))
+              Transform::Hash::Key.new(value: 'value',          transform: Transform::Nullable.new(transform: Mutant::Result::Test::CODEC.load_transform))
             ],
             optional: []
           ),
@@ -51,7 +51,7 @@ module Mutant
         ]
       )
 
-      JSON = Transform::JSON.new(dump_transform: dump, load_transform: load)
+      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/parallel/connection.rb

@@ -18,10 +18,10 @@ module Mutant
 
         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/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/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/result/exception.rb

@@ -23,7 +23,7 @@ module Mutant
         )
       end
 
-      JSON = Transform::JSON.for_anima(self)
+      CODEC = Transform::Codec.for_anima(self)
     end # Exception
   end # Result
 end # Mutant

data/lib/mutant/result/json_writer.rb

@@ -24,7 +24,7 @@ module Mutant
     private
 
       def json
-        JSON.generate(Session::JSON.dump(session).from_right)
+        JSON.generate(Session::CODEC.dump(session).from_right)
       end
 
       def session

data/lib/mutant/result/process_status.rb

@@ -31,7 +31,7 @@ module Mutant
       def success?
         exitstatus.equal?(0)
       end
-      JSON = Transform::JSON.for_anima(self)
+      CODEC = Transform::Codec.for_anima(self)
     end # ProcessStatus
   end # Result
 end # Mutant

data/lib/mutant/result/session.rb

@@ -32,7 +32,7 @@ module Mutant
             '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 }
+            'subject_results' => object.subject_results.map { |subject_result| Subject::CODEC.dump(subject_result).from_right }
           }
         end
       )
@@ -47,7 +47,7 @@ module Mutant
               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))
+              Transform::Hash::Key.new(value: 'subject_results', transform: Transform::Array.new(transform: Subject::CODEC.load_transform))
             ],
             optional: []
           ),
@@ -56,7 +56,7 @@ module Mutant
         ]
       )
 
-      JSON = Transform::JSON.new(dump_transform: dump, load_transform: load)
+      CODEC = Transform::Codec.new(dump_transform: dump, load_transform: load)
 
     end # Session
   end # Result

data/lib/mutant/result/test.rb

@@ -17,14 +17,41 @@ module Mutant
         def initialize
           super(
             job_index: nil,
-            output:    '',
+            output:    LogCapture.from_binary(+''),
             passed:    false,
             runtime:   0.0
           )
         end
       end # VoidValue
 
-      JSON = Transform::JSON.for_anima(self)
+      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

@@ -150,7 +150,7 @@ module Mutant
         process_abort || test_result || timeout
       end
 
-      JSON = Transform::JSON.for_anima(self)
+      CODEC = Transform::Codec.for_anima(self)
     end
 
     class MutationIndex
@@ -226,7 +226,7 @@ module Mutant
       dump = Transform::Success.new(
         block: lambda do |object|
           {
-            'isolation_result'        => Isolation::Result::JSON.dump(object.isolation_result).from_right,
+            '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,
@@ -244,7 +244,7 @@ module Mutant
         steps: [
           Transform::Hash.new(
             required: [
-              Transform::Hash::Key.new(value: 'isolation_result', transform: Isolation::Result::JSON.load_transform),
+              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),
@@ -259,7 +259,7 @@ module Mutant
         ]
       )
 
-      JSON = Transform::JSON.new(dump_transform: dump, load_transform: load)
+      CODEC = Transform::Codec.new(dump_transform: dump, load_transform: load)
     end # Mutation
 
     # Coverage of a mutation against criteria
@@ -277,8 +277,8 @@ module Mutant
       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
+            'mutation_result' => Mutation::CODEC.dump(object.mutation_result).from_right,
+            'criteria_result' => CoverageCriteria::CODEC.dump(object.criteria_result).from_right
           }
         end
       )
@@ -287,8 +287,8 @@ module Mutant
         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)
+              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: []
           ),
@@ -297,7 +297,7 @@ module Mutant
         ]
       )
 
-      JSON = Transform::JSON.new(dump_transform: dump, load_transform: load)
+      CODEC = Transform::Codec.new(dump_transform: dump, load_transform: load)
     end # Coverage
 
     # Subject result
@@ -359,7 +359,7 @@ module Mutant
           {
             'amount_mutations'  => object.amount_mutations,
             'coverage_results'  => object.coverage_results
-              .map { |coverage_result| Coverage::JSON.dump(coverage_result).from_right },
+              .map { |coverage_result| Coverage::CODEC.dump(coverage_result).from_right },
             'expression_syntax' => object.expression_syntax,
             'identification'    => object.identification,
             'source'            => object.source,
@@ -387,7 +387,7 @@ module Mutant
           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: '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),
@@ -405,7 +405,7 @@ module Mutant
         ]
       )
 
-      JSON = Transform::JSON.new(dump_transform: dump, load_transform: load)
+      CODEC = Transform::Codec.new(dump_transform: dump, load_transform: load)
     end # Subject
   end # Result
 end # Mutant

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/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

data/lib/mutant.rb

@@ -69,7 +69,8 @@ module Mutant
   record.call(:require_mutant_lib) do
     require 'mutant/procto'
     require 'mutant/transform'
-    require 'mutant/transform/json'
+    require 'mutant/transform/codec'
+    require 'mutant/log_capture'
     require 'mutant/variable'
     require 'mutant/bootstrap'
     require 'mutant/version'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mutant
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.16.2
 platform: ruby
 authors:
 - Markus Schirp
@@ -252,6 +252,7 @@ files:
 - lib/mutant/isolation/fork.rb
 - lib/mutant/isolation/none.rb
 - lib/mutant/loader.rb
+- lib/mutant/log_capture.rb
 - lib/mutant/matcher.rb
 - lib/mutant/matcher/chain.rb
 - lib/mutant/matcher/config.rb
@@ -403,7 +404,7 @@ files:
 - lib/mutant/test/runner/sink.rb
 - lib/mutant/timer.rb
 - lib/mutant/transform.rb
-- lib/mutant/transform/json.rb
+- lib/mutant/transform/codec.rb
 - lib/mutant/usage.rb
 - lib/mutant/util.rb
 - lib/mutant/variable.rb
@@ -430,7 +431,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.6
 specification_version: 4
 summary: ''
 test_files: []

data/lib/mutant/transform/json.rb

@@ -1,68 +0,0 @@
-# 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