mutant 0.5.24 → 0.5.25

data/lib/mutant/reporter/cli/report/subject.rb

@@ -5,10 +5,11 @@ module Mutant
 
         # Subject report printer
         class Subject < self
-          handle(Mutant::Runner::Subject)
 
           delegate :subject, :failed_mutations
 
+          handle(Mutant::Result::Subject)
+
           # Run report printer
           #
           # @return [self]
@@ -17,10 +18,10 @@ module Mutant
           #
           def run
             status(subject.identification)
-            object.tests.each do |test|
+            subject.tests.each do |test|
               puts("- #{test.identification}")
             end
-            object.failed_mutations.each(&method(:visit))
+            visit_collection(object.alive_mutation_results)
             self
           end
 

data/lib/mutant/reporter/cli/report/test.rb

@@ -0,0 +1,28 @@
+module Mutant
+  class Reporter
+    class CLI
+      class Report
+        # Test result reporter
+        class Test < self
+
+          handle(Mutant::Result::Test)
+
+          delegate :test, :runtime
+
+          # Run test result reporter
+          #
+          # @return [self]
+          #
+          # @api private
+          #
+          def run
+            status('- %s / runtime: %s', test.identification, object.runtime)
+            puts('Test Output:')
+            puts(object.output)
+          end
+
+        end
+      end # Report
+    end # CLI
+  end # Reporter
+end # Mutant

data/lib/mutant/reporter/null.rb

@@ -13,7 +13,7 @@ module Mutant
       #
       # @api private
       #
-      def report(_message)
+      def warn(_message)
         self
       end
 

data/lib/mutant/reporter/trace.rb

@@ -2,16 +2,29 @@ module Mutant
   class Reporter
     # Reporter to trace report calls, used as a spec adapter
     class Trace
-      include Concord::Public.new(:progress_calls, :report_calls)
+      include Adamantium::Mutable, Anima.new(:progress_calls, :report_calls, :warn_calls)
 
       # Return new trace reporter
       #
-      # @return [Tracer]
+      # @return [Trace]
       #
       # @api private
       #
       def self.new
-        super([], [])
+        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

data/lib/mutant/result.rb

@@ -0,0 +1,302 @@
+module Mutant
+  # Namespace and mixon module for results
+  module Result
+
+    # Coverage mixin
+    module Coverage
+
+      # Return coverage
+      #
+      # @return [Rational]
+      #
+      # @api private
+      #
+      def coverage
+        return Rational(0) if amount_mutations.zero?
+
+        Rational(amount_mutations_killed, amount_mutations)
+      end
+
+      # Hook called when module gets included
+      #
+      # @param [Class, Module] host
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def self.included(host)
+        super
+
+        host.memoize :coverage
+      end
+
+    end
+
+    # Test if operation is failing
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    #
+    def fail?
+      !success?
+    end
+
+    # Class level mixin
+    module ClassMethods
+
+      # Generate a sum messot from name and collection
+      #
+      # @param [Symbol] name
+      #   the attribute name on collection item and method name to use
+      #
+      # @param [Symbol] collection
+      #   the attribute name used to receive collection
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def sum(name, collection)
+        define_method(name) do
+          public_send(collection).map(&name).reduce(0, :+)
+        end
+        memoize name
+      end
+    end
+
+    # Return overhead
+    #
+    # @return [Float]
+    #
+    # @api private
+    #
+    def overhead
+      runtime - killtime
+    end
+
+    # Hook called when module gets included
+    #
+    # @param [Class, Module] hosto
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self.included(host)
+      host.class_eval do
+        include Adamantium::Flat, Anima::Update
+        extend ClassMethods
+      end
+    end
+
+    # Env result object
+    class Env
+      include Coverage, Result, Anima.new(:runtime, :env, :subject_results)
+
+      COVERAGE_PRECISION = 1
+
+      # Test if run was successful
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      #
+      def success?
+        (coverage * 100).to_f.round(COVERAGE_PRECISION).eql?(env.config.expected_coverage.round(COVERAGE_PRECISION))
+      end
+      memoize :success?
+
+      # Return failed subject results
+      #
+      # @return [Array<Result::Subject>]
+      #
+      # @api private
+      #
+      def failed_subject_results
+        subject_results.reject(&:success?)
+      end
+
+      sum :amount_mutations,        :subject_results
+      sum :amount_mutations_alive,  :subject_results
+      sum :amount_mutations_killed, :subject_results
+      sum :killtime,                :subject_results
+
+      # Return amount of subjects
+      #
+      # @return [Fixnum]
+      #
+      # @api private
+      #
+      def amount_subjects
+        env.subjects.length
+      end
+
+    end # Env
+
+    # Test result
+    class Test
+      include Result, Adamantium::Flat, Anima::Update, Anima.new(
+        :test,
+        :output,
+        :mutation,
+        :passed,
+        :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]
+      #
+      # @api private
+      #
+      alias_method :killtime, :runtime
+
+      # Test if mutation test result is successful
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      #
+      def success?
+        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
+    class Subject
+      include Coverage, Result, Anima.new(:subject, :mutation_results, :runtime)
+
+      sum :killtime, :mutation_results
+
+      # Test if subject was processed successful
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      #
+      def success?
+        alive_mutation_results.empty?
+      end
+
+      # Return killed mutations
+      #
+      # @return [Array<Result::Mutation>]
+      #
+      # @api private
+      #
+      def alive_mutation_results
+        mutation_results.reject(&:success?)
+      end
+      memoize :alive_mutation_results
+
+      # Return amount of mutations
+      #
+      # @return [Fixnum]
+      #
+      # @api private
+      #
+      def amount_mutations
+        subject.mutations.length
+      end
+
+      # Return number of killed mutations
+      #
+      # @return [Fixnum]
+      #
+      # @api private
+      #
+      def amount_mutations_killed
+        killed_mutation_results.length
+      end
+
+      # Return number of alive mutations
+      #
+      # @return [Fixnum]
+      #
+      # @api private
+      #
+      def amount_mutations_alive
+        amount_mutations - amount_mutations_killed
+      end
+
+      # Return alive mutations
+      #
+      # @return [Array<Result::Mutation>]
+      #
+      # @api private
+      #
+      def killed_mutation_results
+        mutation_results.select(&:success?)
+      end
+      memoize :killed_mutation_results
+
+    end # Subject
+
+    # Mutation result
+    class Mutation
+      include Result, Anima.new(:runtime, :mutation, :test_results)
+
+      # Test if mutation was handeled successfully
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      #
+      def success?
+        test_results.any?(&:success?)
+      end
+
+      # Return failed test results
+      #
+      # @return [Array]
+      #
+      # @api private
+      #
+      def failed_test_results
+        test_results.select(&:fail?)
+      end
+
+      sum :killtime, :test_results
+
+    end # Mutation
+
+  end # Result
+end # Mutant

data/lib/mutant/runner.rb

@@ -1,135 +1,108 @@
 module Mutant
   # Runner baseclass
   class Runner
-    include Adamantium::Flat, AbstractType
+    include Adamantium, Concord.new(:env), Procto.call(:result)
 
-    REGISTRY = {}
-
-    # Register handler
-    #
-    # @param [Class] klass
+    # Initialize object
     #
     # @return [undefined]
     #
     # @api private
     #
-    def self.register(klass)
-      REGISTRY[klass] = self
-    end
-    private_class_method :register
+    def initialize(env)
+      super
 
-    # Lookup runner
-    #
-    # @param [Class] klass
-    #
-    # @return [undefined]
-    #
-    # @api private
-    #
-    def self.lookup(klass)
-      current = klass
-      while current
-        return REGISTRY.fetch(current) if REGISTRY.key?(current)
-        current = current.superclass
-      end
+      @stop = false
 
-      raise ArgumentError, "No handler for: #{klass}"
-    end
-    private_class_method :lookup
+      config.integration.setup
 
-    # Run runner for object
-    #
-    # @param [Config] config
-    # @param [Object] object
-    #
-    # @return [Runner]
-    #
-    # @api private
-    #
-    def self.run(config, object, *arguments)
-      handler = lookup(object.class)
-      handler.new(config, object, *arguments)
-    end
+      progress(env)
 
-    # Test if runner is running
-    #
-    # Yeah this is evil. Should be refactored away
-    #
-    # @return [Boolean]
-    #
-    # @api private
-    #
-    def running?
-      @running
+      start = Time.now
+
+      @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
     end
 
-    # Return config
+    # Return result
     #
-    # @return [Mutant::Config]
+    # @return [Result::Env]
     #
     # @api private
     #
-    attr_reader :config
+    attr_reader :result
 
-    # Initialize object
-    #
-    # @param [Config] config
+  private
+
+    # Run subject
     #
-    # @return [undefined]
+    # @return [Report::Subject]
     #
     # @api private
     #
-    def initialize(config)
-      @config = config
-      @stop   = false
-      @start  = Time.now
-      @running = true
-      progress(self)
-      run
-      @running = false
-      progress(self)
-      @end = Time.now
+    def run_subject(subject)
+      Result::Subject.new(
+        subject:          subject,
+        mutation_results: visit_collection(subject.mutations, &method(:run_mutation)),
+        runtime:          nil
+      )
     end
 
-    # Test if runner should stop
+    # Run mutation
     #
-    # @return [Boolean]
+    # @return [Report::Mutation]
     #
     # @api private
     #
-    def stop?
-      @stop
+    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)
+      end
+
+      Result::Mutation.new(
+        mutation:     mutation,
+        runtime:      Time.now - start,
+        test_results: test_results
+      )
     end
 
-    # Return runtime
+    # Return config
     #
-    # @return [Float]
+    # @return [Config]
     #
     # @api private
     #
-    def runtime
-      (@end || Time.now) - @start
+    def config
+      env.config
     end
 
-    # Test if runner is successful
+    # Visit collection
     #
-    # @return [Boolean]
+    # @return [Array<Result>]
     #
     # @api private
     #
-    abstract_method :success?
+    def visit_collection(collection)
+      results = []
 
-  private
+      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
 
-    # Perform operation
-    #
-    # @return [undefined]
-    #
-    # @api private
-    #
-    abstract_method :run
+      results
+    end
 
-    # Run reporter on object
+    # Report progress
     #
     # @param [Object] object
     #
@@ -138,48 +111,29 @@ module Mutant
     # @api private
     #
     def progress(object)
-      reporter.progress(object)
-    end
-
-    # Return reporter
-    #
-    # @return [Reporter]
-    #
-    # @api private
-    #
-    def reporter
-      config.reporter
+      config.reporter.progress(object)
     end
 
-    # Perform dispatch on multiple inputs
-    #
-    # @param [Enumerable<Object>] input
-    #
-    # @return [Enumerable<Runner>]
-    #
-    # @api private
+    # Return test result
     #
-    def visit_collection(input, *arguments)
-      collection = []
-      input.each do |object|
-        runner = visit(object, *arguments)
-        collection << runner
-        @stop = runner.stop?
-        break if @stop
-      end
-      collection
-    end
-
-    # Visit object
-    #
-    # @param [Object] object
-    #
-    # @return [undefined]
+    # @return [Report::Test]
     #
     # @api private
     #
-    def visit(object, *arguments)
-      Runner.run(config, object, *arguments)
+    def run_mutation_test(mutation, test)
+      time = Time.now
+      config.isolation.call do
+        mutation.insert
+        test.run
+      end.update(test: test, mutation: mutation)
+    rescue Isolation::Error => exception
+      Result::Test.new(
+        test:     test,
+        mutation: mutation,
+        runtime:  Time.now - time,
+        output:   exception.message,
+        passed:   false
+      )
     end
 
   end # Runner