mutant 0.10.16 → 0.10.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 376273ed7dd5673bc6acc7d2393b3b9d05c5779a33b36fffce4a2fd93742e313
-  data.tar.gz: 186a12fae490b557d0f48f879017a2faf61b2edfef09cd44d8e11549c34a8526
+  metadata.gz: ace60aadd53eaa9d10a47ad5bfd16cc0bd825be0588356fdfacc8e00ee767c20
+  data.tar.gz: 89f5a6460423c7ae12a735f55df13aa8e0077e76243a6fb0bf09d31babafc774
 SHA512:
-  metadata.gz: 8f2a51ac2f6e515d9e4b96f3ede03773ae20c9038e9b4f31f639e733598cff0d86ed6d7020b727b167b5e518425ae90b97c1b53a5c3c26abbc6c417bf18eacd0
-  data.tar.gz: bd2084f932c8267845e0371ff267d0acd2c8085684fdb7acb718253777adcd1b8098c5288c6978c4542ca9327bba0f62d8206ec90c8baad73be3fad46e471808
+  metadata.gz: 3dd24a1870b332e38dd4e40041d6ce60f1fe23bdf26490ace7bb8f5a285f927880a1898cf6e85d04055723aca9043fa382b19bc86ad29565bafd7a51258b1727
+  data.tar.gz: a855387e41f516caf8759eba4e0c0fe10f144dd4d5e9241bf3f41a768d3fde8bcee0ae70ff3b1ddaeeaf97aa8cd38301832c6b963d0c5eff8d245dc721638594

data/lib/mutant.rb

@@ -43,6 +43,7 @@ end # Mutant
 require 'mutant/bootstrap'
 require 'mutant/version'
 require 'mutant/env'
+require 'mutant/pipe'
 require 'mutant/util'
 require 'mutant/registry'
 require 'mutant/ast'
@@ -171,6 +172,7 @@ require 'mutant/cli/command/subscription'
 require 'mutant/cli/command/environment'
 require 'mutant/cli/command/environment/run'
 require 'mutant/cli/command/environment/show'
+require 'mutant/cli/command/environment/subject'
 require 'mutant/cli/command/root'
 require 'mutant/runner'
 require 'mutant/runner/sink'

data/lib/mutant/ast/meta/send.rb

@@ -13,7 +13,6 @@ module Mutant
 
         public :receiver, :selector
 
-        INDEX_ASSIGNMENT_SELECTOR            = :[]=
         ATTRIBUTE_ASSIGNMENT_SELECTOR_SUFFIX = '='
 
         # Arguments of mutated node

data/lib/mutant/ast/types.rb

@@ -6,11 +6,6 @@ module Mutant
     module Types
       ASSIGNABLE_VARIABLES = Set.new(%i[ivasgn lvasgn cvasgn gvasgn]).freeze
 
-      INDEX_ASSIGN_OPERATOR = :[]=
-
-      # Set of nodes that cannot be on the LHS of an assignment
-      NOT_ASSIGNABLE         = Set.new(%i[int float str dstr class module self nil]).freeze
-
       # Set of op-assign types
       OP_ASSIGN              = Set.new(%i[or_asgn and_asgn op_asgn]).freeze
       # Set of node types that are not valid when emitted standalone
@@ -53,10 +48,6 @@ module Mutant
         METHOD_OPERATORS - (INDEX_OPERATORS + UNARY_METHOD_OPERATORS)
       )
 
-      OPERATOR_METHODS = Set.new(
-        METHOD_OPERATORS + INDEX_OPERATORS + UNARY_METHOD_OPERATORS
-      ).freeze
-
       # Nodes that are NOT handled by mutant.
       #
       # not - 1.8 only, mutant does not support 1.8

data/lib/mutant/bootstrap.rb

@@ -30,7 +30,7 @@ module Mutant
     # @return [Either<String, Env>]
     #
     # rubocop:disable Metrics/MethodLength
-    def self.apply(world, config)
+    def self.call(world, config)
       env = Env
         .empty(world, config)
         .tap(&method(:infect))
@@ -109,7 +109,7 @@ module Mutant
         return
       end
 
-      expression_parser.apply(name).from_right {}
+      expression_parser.call(name).from_right {}
     end
     private_class_method :expression
     # rubocop:enable Metrics/MethodLength

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

@@ -25,7 +25,7 @@ module Mutant
         def bootstrap
           Config.load_config_file(world)
             .fmap(&method(:expand))
-            .bind { Bootstrap.apply(world, @config) }
+            .bind { Bootstrap.call(world, @config) }
         end
 
         def expand(file_config)
@@ -33,7 +33,7 @@ module Mutant
         end
 
         def parse_remaining_arguments(arguments)
-          Mutant.traverse(@config.expression_parser.public_method(:apply), arguments)
+          Mutant.traverse(@config.expression_parser, arguments)
             .fmap do |match_expressions|
               matcher(match_expressions: match_expressions)
               self
@@ -82,10 +82,10 @@ module Mutant
           parser.separator('Matcher:')
 
           parser.on('--ignore-subject EXPRESSION', 'Ignore subjects that match EXPRESSION as prefix') do |pattern|
-            add_matcher(:ignore_expressions, @config.expression_parser.apply(pattern).from_right)
+            add_matcher(:ignore_expressions, @config.expression_parser.call(pattern).from_right)
           end
           parser.on('--start-subject EXPRESSION', 'Start mutation testing at a specific subject') do |pattern|
-            add_matcher(:start_expressions, @config.expression_parser.apply(pattern).from_right)
+            add_matcher(:start_expressions, @config.expression_parser.call(pattern).from_right)
           end
           parser.on('--since REVISION', 'Only select subjects touched since REVISION') do |revision|
             add_matcher(

data/lib/mutant/cli/command/environment/run.rb

@@ -26,9 +26,9 @@ module Mutant
         private
 
           def action
-            soft_fail(License.apply(world))
+            soft_fail(License.call(world))
               .bind { bootstrap }
-              .bind(&Runner.public_method(:apply))
+              .bind(&Runner.public_method(:call))
               .bind(&method(:from_result))
           end
 

data/lib/mutant/cli/command/environment/show.rb

@@ -12,8 +12,7 @@ module Mutant
         private
 
           def action
-            bootstrap
-              .fmap(&method(:report_env))
+            bootstrap.fmap(&method(:report_env))
           end
 
           def report_env(env)

data/lib/mutant/cli/command/environment/subject.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Mutant
+  module CLI
+    class Command
+      class Environment
+        class Subject < self
+          NAME              = 'subject'
+          SHORT_DESCRIPTION = 'Subject subcommands'
+
+          class List < self
+            NAME              = 'list'
+            SHORT_DESCRIPTION = 'List subjects'
+            SUBCOMMANDS       = EMPTY_ARRAY
+
+          private
+
+            def action
+              bootstrap.fmap(&method(:list_subjects))
+            end
+
+            def list_subjects(env)
+              print('Subjects in environment: %d' % env.subjects.length)
+              env.subjects.each do |subject|
+                print(subject.expression.syntax)
+              end
+            end
+
+            def print(message)
+              world.stdout.puts(message)
+            end
+          end
+
+          SUBCOMMANDS = [List].freeze
+        end # Subject
+      end # Environment
+    end # Command
+  end # CLI
+end # Mutant

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

@@ -4,7 +4,7 @@ module Mutant
   module CLI
     class Command
       class Environment < self
-        SUBCOMMANDS = [Environment::Show].freeze
+        SUBCOMMANDS = [Environment::Subject, Environment::Show].freeze
       end # Environment
 
       class Root < self

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

@@ -10,7 +10,7 @@ module Mutant
       private
 
         def license
-          License.apply(world)
+          License.call(world)
         end
 
         class Test < self

data/lib/mutant/env.rb

@@ -43,19 +43,21 @@ module Mutant
     end
     # rubocop:enable Metrics/MethodLength
 
-    # Kill mutation
+    # Cover mutation with specific index
     #
-    # @param [Mutation] mutation
+    # @param [Integer] mutation_index
     #
-    # @return [Result::Mutation]
-    def kill(mutation)
+    # @return [Result::MutationIndex]
+    def cover_index(mutation_index)
+      mutation = mutations.fetch(mutation_index)
+
       start = timer.now
 
       tests = selections.fetch(mutation.subject)
 
-      Result::Mutation.new(
+      Result::MutationIndex.new(
         isolation_result: run_mutation_tests(mutation, tests),
-        mutation:         mutation,
+        mutation_index:   mutation_index,
         runtime:          timer.now - start
       )
     end

data/lib/mutant/expression.rb

@@ -4,7 +4,7 @@ module Mutant
 
   # Abstract base class for match expression
   class Expression
-    include AbstractType, Adamantium::Flat
+    include AbstractType
 
     fragment             = /[A-Za-z][A-Za-z\d_]*/.freeze
     SCOPE_NAME_PATTERN   = /(?<scope_name>#{fragment}(?:#{SCOPE_OPERATOR}#{fragment})*)/.freeze
@@ -12,6 +12,10 @@ module Mutant
 
     private_constant(*constants(false))
 
+    def self.new(*)
+      super.freeze
+    end
+
     # Syntax of expression
     #
     # @return [Matcher]
@@ -55,9 +59,14 @@ module Mutant
     #   otherwise
     def self.try_parse(input)
       match = self::REGEXP.match(input)
-      return unless match
+      from_match(match) if match
+    end
+
+    def self.from_match(match)
       names = anima.attribute_names
-      new(Hash[names.zip(names.map(&match.method(:[])))])
+      new(Hash[names.zip(names.map(&match.public_method(:[])))])
     end
+    private_class_method :from_match
+
   end # Expression
 end # Mutant

data/lib/mutant/expression/method.rb

@@ -5,6 +5,8 @@ module Mutant
 
     # Explicit method expression
     class Method < self
+      extend AST::Sexp
+
       include Anima.new(
         :method_name,
         :scope_name,
@@ -18,22 +20,21 @@ module Mutant
         '#' => [Matcher::Methods::Instance]
       )
 
-      METHOD_NAME_PATTERN = Regexp.union(
-        /(?<method_name>[A-Za-z_][A-Za-z\d_]*[!?=]?)/,
-        *AST::Types::OPERATOR_METHODS.map(&:to_s)
-      ).freeze
+      METHOD_NAME_PATTERN = /(?<method_name>.+)/.freeze
 
       private_constant(*constants(false))
 
       REGEXP = /\A#{SCOPE_NAME_PATTERN}#{SCOPE_SYMBOL_PATTERN}#{METHOD_NAME_PATTERN}\z/.freeze
 
+      def initialize(*)
+        super
+        @syntax = [scope_name, scope_symbol, method_name].join.freeze
+      end
+
       # Syntax of expression
       #
       # @return [String]
-      def syntax
-        [scope_name, scope_symbol, method_name].join
-      end
-      memoize :syntax
+      attr_reader :syntax
 
       # Matcher for expression
       #
@@ -47,6 +48,30 @@ module Mutant
         Matcher::Filter.new(methods_matcher, ->(subject) { subject.expression.eql?(self) })
       end
 
+      def self.try_parse(input)
+        match = REGEXP.match(input) or return
+
+        from_match(match) if valid_method_name?(match[:method_name])
+      end
+
+      # Test if string is a valid Ruby method name
+      #
+      # Note that this crazyness is indeed the "correct" solution.
+      #
+      # See: https://github.com/whitequark/parser/issues/213
+      #
+      # @param [String]
+      #
+      # @return [Boolean]
+      def self.valid_method_name?(name)
+        buffer = ::Parser::Source::Buffer.new(nil, source: "def #{name}; end")
+
+        ::Parser::CurrentRuby
+          .new
+          .parse(buffer).eql?(s(:def, name.to_sym, s(:args), nil))
+      end
+      private_class_method :valid_method_name?
+
     private
 
       def scope

data/lib/mutant/expression/methods.rb

@@ -20,13 +20,15 @@ module Mutant
 
       REGEXP = /\A#{SCOPE_NAME_PATTERN}#{SCOPE_SYMBOL_PATTERN}\z/.freeze
 
+      def initialize(*)
+        super
+        @syntax = [scope_name, scope_symbol].join.freeze
+      end
+
       # Syntax of expression
       #
       # @return [String]
-      def syntax
-        [scope_name, scope_symbol].join
-      end
-      memoize :syntax
+      attr_reader :syntax
 
       # Matcher on expression
       #

data/lib/mutant/expression/namespace.rb

@@ -16,6 +16,9 @@ module Mutant
         # @return [undefined]
         def initialize(*)
           super
+
+          @syntax = "#{scope_name}*"
+
           @recursion_pattern = Regexp.union(
             /\A#{scope_name}\z/,
             /\A#{scope_name}::/,
@@ -26,10 +29,7 @@ module Mutant
         # Syntax for expression
         #
         # @return [String]
-        def syntax
-          "#{scope_name}*"
-        end
-        memoize :syntax
+        attr_reader :syntax
 
         # Matcher for expression
         #
@@ -52,7 +52,6 @@ module Mutant
             0
           end
         end
-
       end # Recursive
 
       # Exact namespace expression
@@ -67,7 +66,13 @@ module Mutant
         #
         # @return [Matcher]
         def matcher
-          Matcher::Scope.new(Object.const_get(scope_name))
+          scope = find_scope
+
+          if scope
+            Matcher::Scope.new(scope)
+          else
+            Matcher::Null.new
+          end
         end
 
         # Syntax for expression
@@ -76,6 +81,12 @@ module Mutant
         alias_method :syntax, :scope_name
         public :syntax
 
+      private
+
+        def find_scope
+          Object.const_get(scope_name)
+        rescue NameError # rubocop:disable Lint/SuppressedException
+        end
       end # Exact
     end # Namespace
   end # Expression

data/lib/mutant/expression/parser.rb

@@ -5,7 +5,7 @@ module Mutant
     class Parser
       include Concord.new(:types)
 
-      # Apply expression parsing
+      # Parse expression
       #
       # @param [String] input
       #
@@ -14,7 +14,7 @@ module Mutant
       #
       # @return [nil]
       #   otherwise
-      def apply(input)
+      def call(input)
         expressions = expressions(input)
         case expressions.length
         when 0

data/lib/mutant/integration/null.rb

@@ -16,11 +16,10 @@ module Mutant
       # @param [Enumerable<Mutant::Test>] tests
       #
       # @return [Result::Test]
-      def call(tests)
+      def call(_tests)
         Result::Test.new(
           passed:  true,
-          runtime: 0.0,
-          tests:   tests
+          runtime: 0.0
         )
       end
 

data/lib/mutant/isolation/fork.rb

@@ -64,6 +64,7 @@ module Mutant
         end
       end # Pipe
 
+      # rubocop:disable Metrics/ClassLength
       class Parent
         include(
           Anima.new(*ATTRIBUTES),
@@ -149,17 +150,26 @@ module Mutant
 
             break unless ready
 
-            ready.each do |fd|
-              if fd.eof?
-                targets.delete(fd)
+            ready.each do |target|
+              if target.eof?
+                targets.delete(target)
               else
-                targets.fetch(fd) << fd.read_nonblock(READ_SIZE)
+                read_fragment(target, targets.fetch(target))
               end
             end
           end
         end
         # rubocop:enable Metrics/MethodLength
 
+        def read_fragment(target, fragments)
+          loop do
+            result = target.read_nonblock(READ_SIZE, exception: false)
+            break unless result.instance_of?(String)
+            fragments << result
+            break if result.bytesize < READ_SIZE
+          end
+        end
+
         # rubocop:disable Metrics/MethodLength
         def terminate_graceful
           status = nil
@@ -199,6 +209,7 @@ module Mutant
           @result = defined?(@result) ? @result.add_error(result) : result
         end
       end # Parent
+      # rubocop:enable Metrics/ClassLength
 
       class Child
         include(
@@ -219,7 +230,7 @@ module Mutant
 
       end # Child
 
-      private_constant(*(constants(false) - %i[ChildError ForkError]))
+      private_constant(*constants(false))
 
       # Call block in isolation
       #

data/lib/mutant/license.rb

@@ -12,7 +12,7 @@ module Mutant
     # @return [Either<String,Subscription>]
     #
     # @api private
-    def self.apply(world)
+    def self.call(world)
       load_mutant_license(world)
         .fmap { license_path(world) }
         .bind { |path| Subscription.load(world, world.json.load(path)) }

data/lib/mutant/license/subscription.rb

@@ -30,7 +30,7 @@ module Mutant
           'oss' => Opensource
         }.fetch(value.fetch('type'))
           .from_json(value.fetch('contents'))
-          .apply(world)
+          .call(world)
       end
 
       # Subscription self description

data/lib/mutant/license/subscription/commercial.rb

@@ -15,7 +15,7 @@ module Mutant
           new(value.fetch('authors').map(&Author.public_method(:new)).to_set)
         end
 
-        def apply(world)
+        def call(world)
           candidates = candidates(world)
 
           if (licensed & candidates).any?

data/lib/mutant/license/subscription/opensource.rb

@@ -50,7 +50,7 @@ module Mutant
           )
         end
 
-        def apply(world)
+        def call(world)
           world
             .capture_stdout(%w[git remote --verbose])
             .fmap(&method(:parse_remotes))

data/lib/mutant/mutator/node/arguments.rb

@@ -8,8 +8,6 @@ module Mutant
 
         handle(:args)
 
-        PROCARG = %i[restarg mlhs].freeze
-
       private
 
         def dispatch

data/lib/mutant/mutator/node/defined.rb

@@ -13,10 +13,19 @@ module Mutant
       private
 
         def dispatch
-          emit_singletons
-          emit(N_TRUE)
+          emit(N_NIL)
+          emit_instance_variable_mutation
+        end
+
+        def emit_instance_variable_mutation
+          return unless n_ivar?(expression)
+
+          instance_variable_name = Mutant::Util.one(expression.children)
 
-          emit_expression_mutations { |node| !n_self?(node) }
+          emit(
+            s(:send, nil, :instance_variable_defined?,
+              s(:sym, instance_variable_name))
+          )
         end
 
       end # Defined

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

@@ -11,8 +11,6 @@ module Mutant
 
           children :value
 
-          PREFIX = '__mutant__'
-
         private
 
           def dispatch

data/lib/mutant/mutator/node/procarg_zero.rb

@@ -4,12 +4,6 @@ module Mutant
   class Mutator
     class Node
       class ProcargZero < self
-        MAP = {
-          ::Parser::AST::Node => :emit_argument_node_mutations,
-          Symbol              => :emit_argument_symbol_mutations
-        }.freeze
-
-        private_constant(*constants(false))
 
         handle :procarg0
 

data/lib/mutant/mutator/node/send.rb

@@ -14,30 +14,32 @@ module Mutant
         children :receiver, :selector
 
         SELECTOR_REPLACEMENTS = IceNine.deep_freeze(
-          reverse_map:   %i[map each],
-          kind_of?:      %i[instance_of?],
+          :< =>          %i[== eql? equal?],
+          :<= =>         %i[< == eql? equal?],
+          :== =>         %i[eql? equal?],
+          :> =>          %i[== eql? equal?],
+          :>= =>         %i[> == eql? equal?],
+          __send__:      %i[public_send],
+          all?:          %i[any?],
+          any?:          %i[all?],
+          at:            %i[fetch key?],
+          eql?:          %i[equal?],
+          fetch:         %i[key?],
+          flat_map:      %i[map],
+          gsub:          %i[sub],
           is_a?:         %i[instance_of?],
+          kind_of?:      %i[instance_of?],
+          map:           %i[each],
+          method:        %i[public_method],
           reverse_each:  %i[each],
+          reverse_map:   %i[map each],
           reverse_merge: %i[merge],
-          map:           %i[each],
-          flat_map:      %i[map],
           send:          %i[public_send __send__],
-          __send__:      %i[public_send],
-          method:        %i[public_method],
-          gsub:          %i[sub],
-          eql?:          %i[equal?],
-          to_s:          %i[to_str],
-          to_i:          %i[to_int],
           to_a:          %i[to_ary],
           to_h:          %i[to_hash],
-          at:            %i[fetch key?],
-          fetch:         %i[key?],
-          values_at:     %i[fetch_values],
-          :== =>         %i[eql? equal?],
-          :>= =>         %i[> == eql? equal?],
-          :<= =>         %i[< == eql? equal?],
-          :> =>          %i[== eql? equal?],
-          :< =>          %i[== eql? equal?]
+          to_i:          %i[to_int],
+          to_s:          %i[to_str],
+          values_at:     %i[fetch_values]
         )
 
         RECEIVER_SELECTOR_REPLACEMENTS = IceNine.deep_freeze(

data/lib/mutant/parallel.rb

@@ -6,45 +6,61 @@ module Mutant
 
     # Run async computation returning driver
     #
+    # @param [World] world
     # @param [Config] config
     #
     # @return [Driver]
-    def self.async(config)
-      shared = {
-        var_active_jobs: shared(Variable::IVar, config, value: Set.new),
-        var_final:       shared(Variable::IVar, config),
-        var_sink:        shared(Variable::IVar, config, value: config.sink)
-      }
+    def self.async(world, config)
+      shared  = shared_state(world, config)
+      workers = workers(world, config, shared)
 
       Driver.new(
-        threads: threads(config, worker(config, **shared)),
+        workers: workers,
+        threads: threads(world, config, workers),
         **shared
       )
     end
 
-    # The worker
-    #
-    # @param [Config] config
-    #
-    # @return [Worker]
-    def self.worker(config, **shared)
-      Worker.new(
-        processor:   config.processor,
-        var_running: shared(Variable::MVar, config, value: config.jobs),
-        var_source:  shared(Variable::IVar, config, value: config.source),
-        **shared
-      )
+    def self.workers(world, config, shared)
+      Array.new(config.jobs) do |index|
+        Worker.start(
+          block:        config.block,
+          index:        index,
+          process_name: "#{config.process_name}-#{index}",
+          world:        world,
+          **shared
+        )
+      end
     end
+    private_class_method :workers
+
+    def self.shared_state(world, config)
+      {
+        var_active_jobs: shared(Variable::IVar, world, value: Set.new),
+        var_final:       shared(Variable::IVar, world),
+        var_running:     shared(Variable::MVar, world, value: config.jobs),
+        var_sink:        shared(Variable::IVar, world, value: config.sink),
+        var_source:      shared(Variable::IVar, world, value: config.source)
+      }
+    end
+    private_class_method :shared_state
+
+    def self.threads(world, config, workers)
+      thread = world.thread
 
-    def self.threads(config, worker)
-      Array.new(config.jobs) { config.thread.new(&worker.method(:call)) }
+      workers.map do |worker|
+        thread.new do
+          thread.current.name = "#{config.thread_name}-#{worker.index}"
+          worker.call
+        end
+      end
     end
     private_class_method :threads
 
-    def self.shared(klass, config, **attributes)
+    def self.shared(klass, world, **attributes)
       klass.new(
-        condition_variable: config.condition_variable,
-        mutex:              config.mutex,
+        condition_variable: world.condition_variable,
+        mutex:              world.mutex,
         **attributes
       )
     end
@@ -75,13 +91,12 @@ module Mutant
     # Parallel run configuration
     class Config
       include Adamantium::Flat, Anima.new(
-        :condition_variable,
+        :block,
         :jobs,
-        :mutex,
-        :processor,
+        :process_name,
         :sink,
         :source,
-        :thread
+        :thread_name
       )
     end # Config
 

data/lib/mutant/parallel/driver.rb

@@ -8,7 +8,10 @@ module Mutant
         :threads,
         :var_active_jobs,
         :var_final,
-        :var_sink
+        :var_running,
+        :var_sink,
+        :var_source,
+        :workers
       )
 
       private(*anima.attribute_names)
@@ -29,7 +32,10 @@ module Mutant
 
       def finalize(status)
         status.tap do
-          threads.each(&:join) if status.done?
+          if status.done?
+            workers.each(&:join)
+            threads.each(&:join)
+          end
         end
       end
 
@@ -38,7 +44,7 @@ module Mutant
           var_sink.with do |sink|
             Status.new(
               active_jobs: active_jobs.dup.freeze,
-              done:        threads.all? { |thread| !thread.alive? },
+              done:        threads.all? { |worker| !worker.alive? },
               payload:     sink.status
             )
           end

data/lib/mutant/parallel/worker.rb

@@ -4,7 +4,10 @@ module Mutant
   module Parallel
     class Worker
       include Adamantium::Flat, Anima.new(
-        :processor,
+        :connection,
+        :index,
+        :pid,
+        :process,
         :var_active_jobs,
         :var_final,
         :var_running,
@@ -14,6 +17,45 @@ module Mutant
 
       private(*anima.attribute_names)
 
+      public :index
+
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/ParameterLists
+      def self.start(world:, block:, process_name:, **attributes)
+        io      = world.io
+        process = world.process
+
+        request  = Pipe.from_io(io)
+        response = Pipe.from_io(io)
+
+        pid = process.fork do
+          world.thread.current.name = process_name
+          world.process.setproctitle(process_name)
+
+          Child.new(
+            block:      block,
+            connection: Pipe::Connection.from_pipes(
+              marshal: world.marshal,
+              reader:  request,
+              writer:  response
+            )
+          ).call
+        end
+
+        new(
+          pid:        pid,
+          process:    process,
+          connection: Pipe::Connection.from_pipes(
+            marshal: world.marshal,
+            reader:  response,
+            writer:  request
+          ),
+          **attributes
+        )
+      end
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/ParameterLists
+
       # Run worker payload
       #
       # @return [self]
@@ -23,7 +65,7 @@ module Mutant
 
           job_start(job)
 
-          result = processor.call(job.payload)
+          result = connection.call(job.payload)
 
           job_done(job)
 
@@ -35,6 +77,12 @@ module Mutant
         self
       end
 
+      def join
+        process.kill('TERM', pid)
+        process.wait(pid)
+        self
+      end
+
     private
 
       def next_job
@@ -66,6 +114,16 @@ module Mutant
         var_final.put(nil) if var_running.modify(&:pred).zero?
       end
 
+      class Child
+        include Anima.new(:block, :connection)
+
+        def call
+          loop do
+            connection.send_value(block.call(connection.receive_value))
+          end
+        end
+      end
+      private_constant :Child
     end # Worker
   end # Parallel
 end # Mutant

data/lib/mutant/pipe.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Mutant
+  # Pipe abstraction
+  class Pipe
+    include Adamantium::Flat, Anima.new(:reader, :writer)
+
+    # Run block with pipe in binmode
+    #
+    # @return [undefined]
+    def self.with(io)
+      io.pipe(binmode: true) do |(reader, writer)|
+        yield new(reader: reader, writer: writer)
+      end
+    end
+
+    def self.from_io(io)
+      reader, writer = io.pipe(binmode: true)
+      new(reader: reader, writer: writer)
+    end
+
+    # Writer end of the pipe
+    #
+    # @return [IO]
+    def to_writer
+      reader.close
+      writer
+    end
+
+    # Parent reader end of the pipe
+    #
+    # @return [IO]
+    def to_reader
+      writer.close
+      reader
+    end
+
+    class Connection
+      include Anima.new(:marshal, :reader, :writer)
+
+      Error = Class.new(RuntimeError)
+
+      class Frame
+        include Concord.new(:io)
+
+        HEADER_FORMAT = 'N'
+        MAX_BYTES     = (2**32).pred
+        HEADER_SIZE   = 4
+
+        def receive_value
+          header = read(HEADER_SIZE)
+          read(Util.one(header.unpack(HEADER_FORMAT)))
+        end
+
+        def send_value(body)
+          bytesize = body.bytesize
+
+          fail Error, 'message to big' if bytesize > MAX_BYTES
+
+          io.write([bytesize].pack(HEADER_FORMAT))
+          io.write(body)
+        end
+
+      private
+
+        def read(bytes)
+          io.read(bytes) or fail Error, 'Unexpected EOF'
+        end
+      end
+
+      def call(payload)
+        send_value(payload)
+        receive_value
+      end
+
+      def receive_value
+        marshal.load(reader.receive_value)
+      end
+
+      def send_value(value)
+        writer.send_value(marshal.dump(value))
+        self
+      end
+
+      def self.from_pipes(marshal:, reader:, writer:)
+        new(
+          marshal: marshal,
+          reader:  Frame.new(reader.to_reader),
+          writer:  Frame.new(writer.to_writer)
+        )
+      end
+    end
+  end # Pipe
+end # Mutant

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

@@ -12,11 +12,6 @@ module Mutant
             %s
           MESSAGE
 
-          LOG_MESSAGES = <<~'MESSAGE'
-            Log messages (combined stderr and stdout):
-            %s
-          MESSAGE
-
           EXCEPTION_ERROR_MESSAGE = <<~'MESSAGE'
             Killing the mutation resulted in an integration error.
             This is the case when the tests selected for the current mutation
@@ -36,7 +31,7 @@ module Mutant
             ```
           MESSAGE
 
-          TIMEOUT_ERROR_MESSAGE =<<~'MESSAGE'
+          TIMEOUT_ERROR_MESSAGE = <<~'MESSAGE'
             Mutation analysis ran into the configured timeout of %0.9<timeout>g seconds.
           MESSAGE
 

data/lib/mutant/result.rb

@@ -121,11 +121,7 @@ module Mutant
 
     # Test result
     class Test
-      include Result, Anima.new(
-        :passed,
-        :runtime,
-        :tests
-      )
+      include Anima.new(:passed, :runtime)
 
       class VoidValue < self
         include Singleton
@@ -137,7 +133,6 @@ module Mutant
           super(
             passed:  false,
             runtime: 0.0,
-            tests:   []
           )
         end
       end # VoidValue
@@ -237,6 +232,14 @@ module Mutant
       end
     end
 
+    class MutationIndex
+      include Anima.new(
+        :isolation_result,
+        :mutation_index,
+        :runtime
+      )
+    end # MutationIndex
+
     # Mutation result
     class Mutation
       include Result, Anima.new(

data/lib/mutant/runner.rb

@@ -6,7 +6,7 @@ module Mutant
     # Run against env
     #
     # @return [Either<String, Result>]
-    def self.apply(env)
+    def self.call(env)
       reporter(env).start(env)
 
       Either::Right.new(run_mutation_analysis(env))
@@ -17,7 +17,7 @@ module Mutant
 
       run_driver(
         reporter,
-        Parallel.async(mutation_test_config(env))
+        Parallel.async(env.world, mutation_test_config(env))
       ).tap do |result|
         reporter.report(result)
       end
@@ -34,16 +34,13 @@ module Mutant
     private_class_method :run_driver
 
     def self.mutation_test_config(env)
-      world = env.world
-
       Parallel::Config.new(
-        condition_variable: world.condition_variable,
-        jobs:               env.config.jobs,
-        mutex:              world.mutex,
-        processor:          env.method(:kill),
-        sink:               Sink.new(env),
-        source:             Parallel::Source::Array.new(env.mutations),
-        thread:             world.thread
+        block:        env.method(:cover_index),
+        jobs:         env.config.jobs,
+        process_name: 'mutant-worker-process',
+        sink:         Sink.new(env),
+        source:       Parallel::Source::Array.new(env.mutations.each_index.to_a),
+        thread_name:  'mutant-worker-thread'
       )
     end
     private_class_method :mutation_test_config

data/lib/mutant/runner/sink.rb

@@ -34,10 +34,12 @@ module Mutant
 
       # Handle mutation finish
       #
-      # @param [Result::Mutation] mutation_result
+      # @param [Result::MutationIndex] mutation_index_result
       #
       # @return [self]
-      def result(mutation_result)
+      def result(mutation_index_result)
+        mutation_result = mutation_result(mutation_index_result)
+
         subject = mutation_result.mutation.subject
 
         @subject_results[subject] = Result::Subject.new(
@@ -58,6 +60,14 @@ module Mutant
         )
       end
 
+      def mutation_result(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
+        )
+      end
+
       def previous_coverage_results(subject)
         subject_result = @subject_results.fetch(subject) { return EMPTY_ARRAY }
         subject_result.coverage_results

data/lib/mutant/test.rb

@@ -3,7 +3,7 @@
 module Mutant
   # Abstract base class for test that might kill a mutation
   class Test
-    include Adamantium::Flat, Anima.new(
+    include Anima.new(
       :expressions,
       :id
     )

data/lib/mutant/timer.rb

@@ -54,8 +54,6 @@ module Mutant
       class None < self
         include Concord.new
 
-        STATUS = Status.new(nil)
-
         # The time left
         #
         # @return [Float, nil]

data/lib/mutant/transform.rb

@@ -383,8 +383,6 @@ module Mutant
       #
       # @param [Object]
       #
-      # ignore :reek:NestedIterators
-      #
       # @return [Either<Error, Object>]
       def call(input)
         current = input

data/lib/mutant/version.rb

@@ -2,5 +2,5 @@
 
 module Mutant
   # Current mutant version
-  VERSION = '0.10.16'
+  VERSION = '0.10.21'
 end # Mutant

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mutant
 version: !ruby/object:Gem::Version
-  version: 0.10.16
+  version: 0.10.21
 platform: ruby
 authors:
 - Markus Schirp
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-08 00:00:00.000000000 Z
+date: 2020-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: abstract_type
@@ -307,6 +307,7 @@ files:
 - lib/mutant/cli/command/environment.rb
 - lib/mutant/cli/command/environment/run.rb
 - lib/mutant/cli/command/environment/show.rb
+- lib/mutant/cli/command/environment/subject.rb
 - lib/mutant/cli/command/root.rb
 - lib/mutant/cli/command/subscription.rb
 - lib/mutant/config.rb
@@ -411,6 +412,7 @@ files:
 - lib/mutant/parallel/source.rb
 - lib/mutant/parallel/worker.rb
 - lib/mutant/parser.rb
+- lib/mutant/pipe.rb
 - lib/mutant/range.rb
 - lib/mutant/registry.rb
 - lib/mutant/reporter.rb