mutant 0.5.26 → 0.6.0

data/lib/mutant/reporter/cli/tput.rb

@@ -0,0 +1,27 @@
+module Mutant
+  class Reporter
+    class CLI
+      # Interface to the optionally present tput binary
+      class Tput
+        include Adamantium, Concord::Public.new(:available, :prepare, :restore)
+
+        private_class_method :new
+
+        capture = lambda do |command|
+          stdout, _stderr, exitstatus = Open3.capture3(command)
+          stdout if exitstatus.success?
+        end
+
+        reset   = capture.('tput reset')
+        save    = capture.('tput sc') if reset
+        restore = capture.('tput rc') if save
+        clean   = capture.('tput ed') if restore
+
+        UNAVAILABLE = new(false, nil, nil)
+
+        INSTANCE = clean ? new(true, reset + save, restore + clean) : UNAVAILABLE
+
+      end # TPUT
+    end # CLI
+  end # Reporter
+end # Mutant

data/lib/mutant/reporter/null.rb

@@ -5,40 +5,10 @@ module Mutant
     class Null < self
       include Equalizer.new
 
-      # Write warning message
-      #
-      # @param [String] _message
-      #
-      # @return [self]
-      #
-      # @api private
-      #
-      def warn(_message)
-        self
-      end
-
-      # Report object
-      #
-      # @param [Object] _object
-      #
-      # @return [self]
-      #
-      # @api private
-      #
-      def report(_object)
-        self
-      end
-
-      # Report progress on object
-      #
-      # @param [Object] _object
-      #
-      # @return [self]
-      #
-      # @api private
-      #
-      def progress(_object)
-        self
+      %w[warn report start progress].each do |name|
+        define_method name do |_object|
+          self
+        end
       end
 
     end # Null

data/lib/mutant/reporter/trace.rb

@@ -2,7 +2,7 @@ module Mutant
   class Reporter
     # Reporter to trace report calls, used as a spec adapter
     class Trace
-      include Adamantium::Mutable, Anima.new(:progress_calls, :report_calls, :warn_calls)
+      include Adamantium::Mutable, Anima.new(:start_calls, :progress_calls, :report_calls, :warn_calls)
 
       # Return new trace reporter
       #
@@ -14,43 +14,11 @@ module Mutant
         super(Hash[anima.attribute_names.map { |name| [name, []] }])
       end
 
-      # Warn with message
-      #
-      # @param [String] message
-      #
-      # @return [self]
-      #
-      # @api private
-      #
-      def warn(message)
-        warn_calls << message
-        self
-      end
-
-      # Report object
-      #
-      # @param [Object] object
-      #
-      # @return [self]
-      #
-      # @api private
-      #
-      def report(object)
-        report_calls << object
-        self
-      end
-
-      # Report new progress on object
-      #
-      # @param [Object] object
-      #
-      # @return [self]
-      #
-      # @api private
-      #
-      def progress(object)
-        progress_calls << object
-        self
+      %w[start progress report warn].each do |name|
+        define_method(name) do |object|
+          public_send(:"#{name}_calls") << object
+          self
+        end
       end
 
     end # Tracker

data/lib/mutant/result.rb

@@ -12,9 +12,9 @@ module Mutant
       # @api private
       #
       def coverage
-        return Rational(0) if amount_mutations.zero?
+        return Rational(0) if amount_mutation_results.zero?
 
-        Rational(amount_mutations_killed, amount_mutations)
+        Rational(amount_mutations_killed, amount_mutation_results)
       end
 
       # Hook called when module gets included
@@ -31,22 +31,12 @@ module Mutant
         host.memoize :coverage
       end
 
-    end
-
-    # Test if operation is failing
-    #
-    # @return [Boolean]
-    #
-    # @api private
-    #
-    def fail?
-      !success?
-    end
+    end # Coverage
 
     # Class level mixin
     module ClassMethods
 
-      # Generate a sum messot from name and collection
+      # Generate a sum method from name and collection
       #
       # @param [Symbol] name
       #   the attribute name on collection item and method name to use
@@ -64,6 +54,28 @@ 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
@@ -78,7 +90,7 @@ module Mutant
 
     # Hook called when module gets included
     #
-    # @param [Class, Module] hosto
+    # @param [Class, Module] host
     #
     # @return [undefined]
     #
@@ -93,11 +105,11 @@ module Mutant
 
     # Env result object
     class Env
-      include Coverage, Result, Anima.new(:runtime, :env, :subject_results)
+      include Coverage, Result, Anima.new(:runtime, :env, :subject_results, :done)
 
       COVERAGE_PRECISION = 1
 
-      # Test if run was successful
+      # Test if run is successful
       #
       # @return [Boolean]
       #
@@ -119,6 +131,7 @@ module Mutant
       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
@@ -137,7 +150,7 @@ module Mutant
 
     # Test result
     class Test
-      include Result, Adamantium::Flat, Anima::Update, Anima.new(
+      include Result, Anima.new(
         :test,
         :output,
         :mutation,
@@ -145,16 +158,6 @@ module Mutant
         :runtime
       )
 
-      # NOTE:
-      #
-      #  The test is intentionally NOT part of the mashalled data.
-      #  In rspec the example group cannot deterministically being marshalled, because
-      #  they reference a crazy mix of IO objects, global objects etc.
-      #
-      MARSHALLED_IVARS = (anima.attribute_names - [:test]).map do |name|
-        :"@#{name}"
-      end
-
       # Return killtime
       #
       # @return [Float]
@@ -173,31 +176,6 @@ module Mutant
         mutation.killed_by?(self)
       end
 
-      # Return marshallable data
-      #
-      #
-      # @return [Array]
-      #
-      # @api private
-      #
-      def marshal_dump
-        MARSHALLED_IVARS.map(&method(:instance_variable_get))
-      end
-
-      # Load marshalled data
-      #
-      # @param [Array] array
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
-      def marshal_load(array)
-        MARSHALLED_IVARS.zip(array) do |instance_variable_name, value|
-          instance_variable_set(instance_variable_name, value)
-        end
-      end
-
     end # Test
 
     # Subject result
@@ -227,6 +205,16 @@ module Mutant
       end
       memoize :alive_mutation_results
 
+      # Return amount of mutations
+      #
+      # @return [Fixnum]
+      #
+      # @api private
+      #
+      def amount_mutation_results
+        mutation_results.length
+      end
+
       # Return amount of mutations
       #
       # @return [Fixnum]
@@ -254,7 +242,7 @@ module Mutant
       # @api private
       #
       def amount_mutations_alive
-        amount_mutations - amount_mutations_killed
+        alive_mutation_results.length
       end
 
       # Return alive mutations
@@ -272,9 +260,9 @@ module Mutant
 
     # Mutation result
     class Mutation
-      include Result, Anima.new(:runtime, :mutation, :test_results)
+      include Result, Anima.new(:runtime, :mutation, :test_results, :index)
 
-      # Test if mutation was handeled successfully
+      # Test if mutation was handled successfully
       #
       # @return [Boolean]
       #

data/lib/mutant/runner.rb

@@ -1,7 +1,7 @@
 module Mutant
   # Runner baseclass
   class Runner
-    include Adamantium, Concord.new(:env), Procto.call(:result)
+    include Adamantium::Flat, Concord.new(:env), Procto.call(:result)
 
     # Initialize object
     #
@@ -12,21 +12,19 @@ module Mutant
     def initialize(env)
       super
 
-      @stop = false
+      @collector   = Collector.new(env)
+      @mutex       = Mutex.new
+      @mutations   = env.mutations.dup
 
       config.integration.setup
 
-      progress(env)
+      config.reporter.start(env)
 
-      start = Time.now
+      run
 
-      @result = Result::Env.new(
-        env: env,
-        subject_results: visit_collection(env.subjects, &method(:run_subject)),
-        runtime: Time.now - start
-      ).tap do |report|
-        config.reporter.report(report)
-      end
+      @result = @collector.result.update(done: true)
+
+      config.reporter.report(result)
     end
 
     # Return result
@@ -39,79 +37,128 @@ module Mutant
 
   private
 
-    # Run subject
+    # Run mutation analysis
     #
     # @return [Report::Subject]
     #
     # @api private
     #
-    def run_subject(subject)
-      Result::Subject.new(
-        subject:          subject,
-        mutation_results: visit_collection(subject.mutations, &method(:run_mutation)),
-        runtime:          nil
+    def run
+      Parallel.map(
+        @mutations,
+        in_processes: config.processes,
+        finish:       method(:finish),
+        start:        method(:start),
+        &method(:run_mutation)
       )
     end
 
-    # Run mutation
+    # Handle started mutation
     #
-    # @return [Report::Mutation]
+    # @param [Mutation] mutation
+    # @param [Fixnum] _index
+    #
+    # @return [undefined]
     #
     # @api private
     #
-    def run_mutation(mutation)
-      start = Time.now
-      test_results = mutation.subject.tests.each_with_object([]) do |test, results|
-        results << result = run_mutation_test(mutation, test).tap(&method(:progress))
-        break results if mutation.killed_by?(result)
+    def start(mutation, _index)
+      @mutex.synchronize do
+        @collector.start(mutation)
       end
+    end
 
-      Result::Mutation.new(
-        mutation:     mutation,
-        runtime:      Time.now - start,
-        test_results: test_results
-      )
+    # Handle finished mutation
+    #
+    # @param [Mutation] mutation
+    # @param [Fixnum] index
+    # @param [Object] result
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def finish(mutation, index, result)
+      return unless result.kind_of?(Mutant::Result::Mutation)
+
+      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
+
+      @mutex.synchronize do
+        process_result(result.update(index: index, mutation: mutation, test_results: test_results))
+      end
     end
 
-    # Return config
+    # Process result
     #
-    # @return [Config]
+    # @param [Result::Mutation] result
+    #
+    # @return [undefined]
     #
     # @api private
     #
-    def config
-      env.config
+    def process_result(result)
+      @collector.finish(result)
+      config.reporter.progress(@collector)
+      handle_exit(result)
     end
 
-    # Visit collection
+    # Handle exit if needed
+    #
+    # @param [Result::Mutation] mutation
     #
-    # @return [Array<Result>]
+    # @return [undefined]
     #
     # @api private
     #
-    def visit_collection(collection)
-      results = []
+    def handle_exit(result)
+      return if !config.fail_fast || result.success?
 
-      collection.each do |item|
-        progress(item)
-        start = Time.now
-        results << result = yield(item).update(runtime: Time.now - start).tap(&method(:progress))
-        break if @stop ||= config.fail_fast? && result.fail?
-      end
+      @mutations.clear
+    end
 
-      results
+    # 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
 
-    # Report progress
+    # Kill mutation
     #
-    # @param [Object] object
+    # @param [Mutation] mutation
     #
-    # @return [undefined]
+    # @return [Array<Result::Test>]
     #
     # @api private
     #
-    def progress(object)
-      config.reporter.progress(object)
+    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
+    end
+
+    # Return config
+    #
+    # @return [Config]
+    #
+    # @api private
+    #
+    def config
+      env.config
     end
 
     # Return test result
@@ -125,11 +172,11 @@ module Mutant
       config.isolation.call do
         mutation.insert
         test.run
-      end.update(test: test, mutation: mutation)
+      end
     rescue Isolation::Error => exception
       Result::Test.new(
-        test:     test,
-        mutation: mutation,
+        test:     nil,
+        mutation: nil,
         runtime:  Time.now - time,
         output:   exception.message,
         passed:   false