mutant 0.7.3 → 0.7.4

data/lib/mutant/env.rb

@@ -71,6 +71,22 @@ module Mutant
     #
     attr_reader :matchable_scopes
 
+    # Kill mutation
+    #
+    # @param [Mutation] mutation
+    #
+    # @return [Result::Mutation]
+    #
+    # @api private
+    #
+    def kill_mutation(mutation)
+      test_result = mutation.kill(config.isolation, config.integration)
+      Result::Mutation.new(
+        mutation:    mutation,
+        test_result: test_result
+      )
+    end
+
   private
 
     # Return scope name
@@ -109,7 +125,7 @@ module Mutant
     def expression(scope)
       name = scope_name(scope) or return
 
-      unless name.is_a?(String)
+      unless name.instance_of?(String)
         warn("#{scope.class}#name from: #{scope.inspect} returned #{name.inspect}. #{SEMANTICS_MESSAGE}")
         return
       end

data/lib/mutant/isolation.rb

@@ -17,7 +17,7 @@ module Mutant
       def self.call(&block)
         block.call
       rescue => exception
-        fail Error, exception
+        raise Error, exception
       end
     end
 
@@ -37,6 +37,8 @@ module Mutant
       #
       # @api private
       #
+      # rubocop:disable MethodLength
+      #
       def self.call(&block)
         reader, writer = IO.pipe.map(&:binmode)
 
@@ -52,7 +54,7 @@ module Mutant
         writer.close
         Marshal.load(reader.read)
       rescue => exception
-        fail Error, exception
+        raise Error, exception
       ensure
         Process.waitpid(pid) if pid
       end

data/lib/mutant/loader.rb

@@ -12,6 +12,10 @@ module Mutant
       #
       # @api private
       #
+      # One off the very few valid uses of eval
+      #
+      # rubocop:disable Lint/Eval
+      #
       def call
         eval(
           source,

data/lib/mutant/matcher/compiler.rb

@@ -42,6 +42,8 @@ module Mutant
       #
       # @api private
       #
+      # rubocop:disable MethodLength
+      #
       def predicate
         if subject_selector && subject_rejector
           Morpher::Evaluator::Predicate::Boolean::And.new([

data/lib/mutant/mutation.rb

@@ -16,6 +16,8 @@ module Mutant
     #
     # @api private
     #
+    # rubocop:disable MethodLength
+    #
     def kill(isolation, integration)
       start = Time.now
       tests = subject.tests

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

@@ -19,7 +19,7 @@ module Mutant
           emit_singletons unless parent_node && n_const?(parent_node)
           emit_type(nil, *children.drop(1))
           children.each_with_index do |child, index|
-            mutate_child(index) if child.is_a?(Parser::AST::Node)
+            mutate_child(index) if child.instance_of?(Parser::AST::Node)
           end
         end
 

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

@@ -26,7 +26,7 @@ module Mutant
         #
         def dispatch
           children.each_with_index do |child, index|
-            mutate_child(index) if child.is_a?(Parser::AST::Node)
+            mutate_child(index) if child.instance_of?(Parser::AST::Node)
           end
         end
 

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

@@ -47,6 +47,7 @@ module Mutant
         def mutate_if_branch
           emit_type(condition, else_branch, nil) if else_branch
           return unless if_branch
+          emit(if_branch)
           emit_if_branch_mutations
           emit_type(condition, if_branch, nil)
         end
@@ -59,6 +60,7 @@ module Mutant
         #
         def mutate_else_branch
           return unless else_branch
+          emit(else_branch)
           emit_else_branch_mutations
           emit_type(condition, nil, else_branch)
         end

data/lib/mutant/parallel.rb

@@ -0,0 +1,93 @@
+module Mutant
+  # Parallel excecution engine of arbitrary payloads
+  module Parallel
+
+    # Driver for parallelized execution
+    class Driver
+      include Concord.new(:binding)
+
+      # Return scheduler status
+      #
+      # @return [Object]
+      #
+      # @api private
+      #
+      def status
+        binding.call(__method__)
+      end
+
+      # Stop master gracefully
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def stop
+        binding.call(__method__)
+        self
+      end
+    end # Driver
+
+    # Run async computation returing driver
+    #
+    # @return [Driver]
+    #
+    # @api private
+    #
+    def self.async(config)
+      Driver.new(config.env.new_mailbox.bind(Master.call(config)))
+    end
+
+    # Job result sink
+    class Sink
+      include AbstractType
+
+      # Process job result
+      #
+      # @param [Object]
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      abstract_method :result
+
+      # Return status
+      #
+      # @return [Object]
+      #
+      # @api private
+      #
+      abstract_method :status
+
+      # Test if processing should stop
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      #
+      abstract_method :stop?
+    end # Sink
+
+    # Job to push to workers
+    class Job
+      include Adamantium::Flat, Anima.new(:index, :payload)
+    end # Job
+
+    # Job result object received from workers
+    class JobResult
+      include Adamantium::Flat, Anima.new(:job, :payload)
+    end # JobResult
+
+    # Parallel run configuration
+    class Config
+      include Anima::Update, Adamantium::Flat, Anima.new(:env, :processor, :source, :sink, :jobs)
+    end # Config
+
+    # Parallel execution status
+    class Status
+      include Adamantium::Flat, Anima::Update, Anima.new(:payload, :done, :active_jobs)
+    end
+
+  end # Parallel
+end # Mutant

data/lib/mutant/{runner → parallel}/master.rb

@@ -1,8 +1,8 @@
 module Mutant
-  class Runner
-    # Master actor to control workers
+  module Parallel
+    # Master parallel worker
     class Master
-      include Concord.new(:env, :actor)
+      include Concord.new(:config, :actor)
 
       private_class_method :new
 
@@ -14,14 +14,12 @@ module Mutant
       #
       # @api private
       #
-      def self.call(env)
-        env.config.actor_env.spawn do |actor|
-          new(env, actor).__send__(:run)
+      def self.call(config)
+        config.env.spawn do |actor|
+          new(config, actor).__send__(:run)
         end
       end
 
-    private
-
       # Initialize object
       #
       # @return [undefined]
@@ -31,30 +29,44 @@ module Mutant
       def initialize(*)
         super
 
-        @scheduler = Scheduler.new(env)
-        @workers   = env.config.jobs
-        @stop      = false
-        @stopping  = false
+        @stop        = false
+        @workers     = 0
+        @active_jobs = Set.new
+        @index       = 0
       end
 
+    private
+
       # Run work loop
       #
       # @return [self]
       #
       # @api private
       #
+      # rubocop:disable MethodLength
+      #
       def run
-        @workers.times do |id|
-          Worker.run(
-            id:     id,
-            config: env.config,
-            parent: actor.sender
-          )
+        config.jobs.times do
+          @workers += 1
+          config.env.spawn do |worker_actor|
+            Worker.run(
+              actor:     worker_actor,
+              processor: config.processor,
+              parent:    actor.sender
+            )
+          end
         end
 
         receive_loop
       end
 
+      MAP = IceNine.deep_freeze(
+        ready:  :handle_ready,
+        status: :handle_status,
+        result: :handle_result,
+        stop:   :handle_stop
+      )
+
       # Handle messages
       #
       # @param [Actor::Message] message
@@ -65,18 +77,10 @@ module Mutant
       #
       def handle(message)
         type, payload = message.type, message.payload
-        case type
-        when :ready
-          ready_worker(payload)
-        when :status
-          handle_status(payload)
-        when :result
-          handle_result(payload)
-        when :stop
-          handle_stop(payload)
-        else
+        method = MAP.fetch(type) do
           fail Actor::ProtocolError, "Unexpected message: #{type.inspect}"
         end
+        __send__(method, payload)
       end
 
       # Run receive loop
@@ -86,10 +90,7 @@ module Mutant
       # @api private
       #
       def receive_loop
-        loop do
-          break if @workers.zero? && @stop
-          handle(actor.receiver.call)
-        end
+        handle(actor.receiver.call) until @workers.zero? && @stop
       end
 
       # Handle status
@@ -101,7 +102,12 @@ module Mutant
       # @api private
       #
       def handle_status(sender)
-        sender.call(Actor::Message.new(:status, @scheduler.status))
+        status = Status.new(
+          payload:     sink.status,
+          done:        sink.stop? || @workers.zero?,
+          active_jobs: @active_jobs.dup.freeze
+        )
+        sender.call(Actor::Message.new(:status, status))
       end
 
       # Handle result
@@ -113,9 +119,8 @@ module Mutant
       # @api private
       #
       def handle_result(job_result)
-        return if @stopping
-        @scheduler.job_result(job_result)
-        @stopping = env.config.fail_fast && @scheduler.status.done
+        @active_jobs.delete(job_result.job)
+        sink.result(job_result.payload)
       end
 
       # Handle stop
@@ -127,7 +132,6 @@ module Mutant
       # @api private
       #
       def handle_stop(sender)
-        @stopping = true
         @stop = true
         receive_loop
         sender.call(Actor::Message.new(:stop))
@@ -141,18 +145,29 @@ module Mutant
       #
       # @api private
       #
-      def ready_worker(sender)
-        if @stopping
+      def handle_ready(sender)
+        if stop_work?
           stop_worker(sender)
           return
         end
 
-        job = @scheduler.next_job
+        sender.call(Actor::Message.new(:job, next_job))
+      end
 
-        if job
-          sender.call(Actor::Message.new(:job, job))
-        else
-          stop_worker(sender)
+      # Return next job if any
+      #
+      # @return [Job]
+      #   if next job is available
+      #
+      # @return [nil]
+      #
+      def next_job
+        Job.new(
+          index:   @index,
+          payload: source.next
+        ).tap do |job|
+          @index += 1
+          @active_jobs << job
         end
       end
 
@@ -169,6 +184,36 @@ module Mutant
         sender.call(Actor::Message.new(:stop))
       end
 
+      # Test if scheduling stopped
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      #
+      def stop_work?
+        @stop || !source.next? || sink.stop?
+      end
+
+      # Return source
+      #
+      # @return [Source]
+      #
+      # @api private
+      #
+      def source
+        config.source
+      end
+
+      # Return source
+      #
+      # @return [Sink]
+      #
+      # @api private
+      #
+      def sink
+        config.sink
+      end
+
     end # Master
-  end # Runner
+  end # Parallel
 end # Mutant

data/lib/mutant/parallel/source.rb

@@ -0,0 +1,73 @@
+module Mutant
+  module Parallel
+    # Job source for parallel execution
+    class Source
+      include AbstractType
+
+      NoJobError = Class.new(RuntimeError)
+
+      # Return next job
+      #
+      # @return [Object]
+      #
+      # @raise [NoJobError]
+      #   when no next job is available
+      #
+      # @api private
+      #
+      abstract_method :next
+
+      # Test if next job is available
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      #
+      abstract_method :next?
+
+      # Job source backed by a finite array
+      class Array
+        include Concord.new(:jobs)
+
+        # Initialize objecto
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def initialize(*)
+          super
+
+          @next_index = 0
+        end
+
+        # Test if next job is available
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        #
+        def next?
+          @next_index < jobs.length
+        end
+
+        # Return next job
+        #
+        # @return [Object]
+        #
+        # @raise [NoJobError]
+        #   when no next job is available
+        #
+        # @api private
+        #
+        def next
+          fail NoJobError unless next?
+          jobs.fetch(@next_index).tap do
+            @next_index += 1
+          end
+        end
+
+      end # Array
+    end # Source
+  end # Parallel
+end # Mutant