mutant 0.6.7 → 0.7.1

data/lib/mutant/result.rb

@@ -54,30 +54,8 @@ module Mutant
         end
         memoize name
       end
-
-      # Compute result tracking runtime
-      #
-      # @return [Result]
-      #
-      # @api private
-      #
-      def compute
-        start = Time.now
-        new(yield.merge(runtime: Time.now - start))
-      end
-
     end # ClassMethods
 
-    # Test if operation is failing
-    #
-    # @return [Boolean]
-    #
-    # @api private
-    #
-    def fail?
-      !success?
-    end
-
     # Return overhead
     #
     # @return [Float]
@@ -98,7 +76,7 @@ module Mutant
     #
     def self.included(host)
       host.class_eval do
-        include Adamantium::Flat, Anima::Update
+        include Adamantium, Anima::Update
         extend ClassMethods
       end
     end
@@ -120,6 +98,16 @@ module Mutant
       end
       memoize :success?
 
+      # Test if runner should continue on env
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      #
+      def continue?
+        !env.config.fail_fast || subject_results.all?(&:success?)
+      end
+
       # Return failed subject results
       #
       # @return [Array<Result::Subject>]
@@ -130,12 +118,21 @@ module Mutant
         subject_results.reject(&:success?)
       end
 
-      sum :amount_mutations,        :subject_results
       sum :amount_mutation_results, :subject_results
       sum :amount_mutations_alive,  :subject_results
       sum :amount_mutations_killed, :subject_results
       sum :killtime,                :subject_results
 
+      # Return amount of mutations
+      #
+      # @return [Fixnum]
+      #
+      # @api private
+      #
+      def amount_mutations
+        env.mutations.length
+      end
+
       # Return amount of subjects
       #
       # @return [Fixnum]
@@ -151,38 +148,19 @@ module Mutant
     # Test result
     class Test
       include Result, Anima.new(
-        :test,
+        :tests,
         :output,
-        :mutation,
         :passed,
         :runtime
       )
-
-      # Return killtime
-      #
-      # @return [Float]
-      #
-      # @api private
-      #
-      alias_method :killtime, :runtime
-
-      # Test if mutation test result is successful
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      #
-      def success?
-        mutation.killed_by?(self)
-      end
-
     end # Test
 
     # Subject result
     class Subject
-      include Coverage, Result, Anima.new(:subject, :mutation_results, :runtime)
+      include Coverage, Result, Anima.new(:subject, :mutation_results)
 
       sum :killtime, :mutation_results
+      sum :runtime,  :mutation_results
 
       # Test if subject was processed successful
       #
@@ -194,6 +172,16 @@ module Mutant
         alive_mutation_results.empty?
       end
 
+      # Test if runner should continue on subject
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      #
+      def continue?
+        mutation_results.all?(&:success?)
+      end
+
       # Return killed mutations
       #
       # @return [Array<Result::Mutation>]
@@ -260,31 +248,30 @@ module Mutant
 
     # Mutation result
     class Mutation
-      include Result, Anima.new(:runtime, :mutation, :test_results, :index)
+      include Result, Anima.new(:mutation, :test_result, :index)
 
-      # Test if mutation was handled successfully
+      # Return runtime
       #
-      # @return [Boolean]
+      # @return [Float]
       #
       # @api private
       #
-      def success?
-        test_results.any?(&:success?)
+      def runtime
+        test_result.runtime
       end
 
-      # Return failed test results
+      alias_method :killtime, :runtime
+
+      # Test if mutation was handled successfully
       #
-      # @return [Array]
+      # @return [Boolean]
       #
       # @api private
       #
-      def failed_test_results
-        test_results.select(&:fail?)
+      def success?
+        mutation.class.success?(test_result)
       end
 
-      sum :killtime, :test_results
-
     end # Mutation
-
   end # Result
 end # Mutant

data/lib/mutant/runner.rb

@@ -3,163 +3,78 @@ module Mutant
   class Runner
     include Adamantium::Flat, Concord.new(:env), Procto.call(:result)
 
+    # Status of the runner execution
+    class Status
+      include Adamantium, Anima::Update, Anima.new(
+        :env_result,
+        :active_jobs,
+        :done
+      )
+    end # Status
+
+    # Job to push to workers
+    class Job
+      include Adamantium::Flat, Anima.new(:index, :mutation)
+    end # Job
+
+    # Job result object received from workers
+    class JobResult
+      include Adamantium::Flat, Anima.new(:job, :result)
+    end
+
+    REPORT_FREQUENCY = 20.0
+    REPORT_DELAY     = 1 / REPORT_FREQUENCY
+
     # Initialize object
     #
     # @return [undefined]
     #
     # @api private
     #
-    def initialize(env)
+    def initialize(*)
       super
 
-      @collector = Collector.new(env)
-      @mutex     = Mutex.new
-      @mutations = env.mutations.dup
-      @index     = 0
-      @continue  = true
-
-      config.integration.setup
-
       reporter.start(env)
+      config.integration.setup
 
-      run
-
-      @result = @collector.result
-
-      reporter.report(result)
-    end
-
-    # Return result
-    #
-    # @return [Result::Env]
-    #
-    # @api private
-    #
-    attr_reader :result
-
-  private
+      @master = config.actor_env.current.bind(Master.call(env))
 
-    # Run mutation analysis
-    #
-    # @return [Report::Subject]
-    #
-    # @api private
-    #
-    def run
-      Parallel.map(
-        method(:next),
-        in_threads: config.jobs,
-        finish:     method(:finish),
-        start:      method(:start),
-        &method(:run_mutation)
-      )
-    end
+      status = nil
 
-    # Return next mutation or stop
-    #
-    # @return [Mutation]
-    #   in case there is a next mutation
-    #
-    # @return [Parallel::Stop]
-    #   in case there is no next mutation or runner should stop early
-    #
-    #
-    # @api private
-    def next
-      @mutex.synchronize do
-        mutation = @mutations.at(@index)
-        if @continue && mutation
-          @index += 1
-          mutation
-        else
-          Parallel::Stop
-        end
+      loop do
+        status = current_status
+        break if status.done
+        reporter.progress(status)
+        Kernel.sleep(REPORT_DELAY)
       end
-    end
 
-    # Handle started mutation
-    #
-    # @param [Mutation] mutation
-    # @param [Fixnum] _index
-    #
-    # @return [undefined]
-    #
-    # @api private
-    #
-    def start(mutation, _index)
-      @mutex.synchronize do
-        @collector.start(mutation)
-      end
-    end
+      reporter.progress(status)
 
-    # Handle finished mutation
-    #
-    # @param [Mutation] mutation
-    # @param [Fixnum] index
-    # @param [Object] result
-    #
-    # @return [undefined]
-    #
-    # @api private
-    #
-    def finish(mutation, index, result)
-      return unless result.is_a?(Mutant::Result::Mutation)
+      @master.call(:stop)
 
-      test_results = result.test_results.zip(mutation.subject.tests).map do |test_result, test|
-        test_result.update(test: test, mutation: mutation) if test_result
-      end.compact
+      @result = status.env_result
 
-      @mutex.synchronize do
-        process_result(result.update(index: index, mutation: mutation, test_results: test_results))
-      end
+      reporter.report(@result)
     end
 
-    # Process result
-    #
-    # @param [Result::Mutation] result
+    # Return result
     #
-    # @return [undefined]
+    # @return [Result::Env]
     #
     # @api private
     #
-    def process_result(result)
-      @collector.finish(result)
-      reporter.progress(@collector)
-      return unless config.fail_fast && !result.success?
-      @continue = false
-    end
+    attr_reader :result
 
-    # Run mutation
-    #
-    # @param [Mutation] mutation
-    #
-    # @return [Report::Mutation]
-    #
-    # @api private
-    #
-    def run_mutation(mutation)
-      Result::Mutation.compute do
-        {
-          index:        nil,
-          mutation:     nil,
-          test_results: kill_mutation(mutation)
-        }
-      end
-    end
+  private
 
-    # Kill mutation
-    #
-    # @param [Mutation] mutation
+    # Return reporter
     #
-    # @return [Array<Result::Test>]
+    # @return [Reporter]
     #
     # @api private
     #
-    def kill_mutation(mutation)
-      mutation.subject.tests.each_with_object([]) do |test, results|
-        results << result = run_mutation_test(mutation, test)
-        return results if mutation.killed_by?(result)
-      end
+    def reporter
+      env.config.reporter
     end
 
     # Return config
@@ -172,36 +87,14 @@ module Mutant
       env.config
     end
 
-    # Return test result
-    #
-    # @return [Report::Test]
-    #
-    # @api private
-    #
-    def run_mutation_test(mutation, test)
-      time = Time.now
-      config.isolation.call do
-        mutation.insert
-        test.run
-      end
-    rescue Isolation::Error => exception
-      Result::Test.new(
-        test:     test,
-        mutation: mutation,
-        runtime:  Time.now - time,
-        output:   exception.message,
-        passed:   false
-      )
-    end
-
-    # Return reporter
+    # Return current status
     #
-    # @return [Reporter]
+    # @return [Status]
     #
     # @api private
     #
-    def reporter
-      config.reporter
+    def current_status
+      @master.call(:status)
     end
 
   end # Runner

data/lib/mutant/runner/master.rb

@@ -0,0 +1,174 @@
+module Mutant
+  class Runner
+    # Master actor to control workers
+    class Master
+      include Concord.new(:env, :actor)
+
+      private_class_method :new
+
+      # Run master runner component
+      #
+      # @param [Env] env
+      #
+      # @return [Actor::Sender]
+      #
+      # @api private
+      #
+      def self.call(env)
+        env.config.actor_env.spawn do |actor|
+          new(env, actor).__send__(:run)
+        end
+      end
+
+    private
+
+      # Initialize object
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def initialize(*)
+        super
+
+        @scheduler = Scheduler.new(env)
+        @workers   = env.config.jobs
+        @stop      = false
+        @stopping  = false
+      end
+
+      # Run work loop
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def run
+        @workers.times do |id|
+          Worker.run(
+            id:     id,
+            config: env.config,
+            parent: actor.sender
+          )
+        end
+
+        receive_loop
+      end
+
+      # Handle messages
+      #
+      # @param [Actor::Message] message
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      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
+          fail Actor::ProtocolError, "Unexpected message: #{type.inspect}"
+        end
+      end
+
+      # Run receive loop
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def receive_loop
+        loop do
+          break if @workers.zero? && @stop
+          handle(actor.receiver.call)
+        end
+      end
+
+      # Handle status
+      #
+      # @param [Actor::Sender] sender
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def handle_status(sender)
+        sender.call(Actor::Message.new(:status, @scheduler.status))
+      end
+
+      # Handle result
+      #
+      # @param [JobResult] job_result
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def handle_result(job_result)
+        return if @stopping
+        @scheduler.job_result(job_result)
+        @stopping = env.config.fail_fast && @scheduler.status.done
+      end
+
+      # Handle stop
+      #
+      # @param [Actor::Sender] sender
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def handle_stop(sender)
+        @stopping = true
+        @stop = true
+        receive_loop
+        sender.call(Actor::Message.new(:stop))
+      end
+
+      # Handle ready worker
+      #
+      # @param [Actor::Sender] sender
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def ready_worker(sender)
+        if @stopping
+          stop_worker(sender)
+          return
+        end
+
+        job = @scheduler.next_job
+
+        if job
+          sender.call(Actor::Message.new(:job, job))
+        else
+          stop_worker(sender)
+        end
+      end
+
+      # Stop worker
+      #
+      # @param [Actor::Sender] sender
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def stop_worker(sender)
+        @workers -= 1
+        sender.call(Actor::Message.new(:stop))
+      end
+
+    end # Master
+  end # Runner
+end # Mutant