mutant 0.5.12 → 0.5.13

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

@@ -0,0 +1,112 @@
+# encoding: utf-8
+
+module Mutant
+  class Reporter
+    class CLI
+      class Report
+
+        # Reporter for mutations
+        class Mutation < self
+
+          # Run report printer
+          #
+          # @return [self]
+          #
+          # @api private
+          #
+          def run
+            puts(object.identification)
+            puts(details)
+            self
+          end
+
+          # Reporter for noop mutations
+          class Noop < self
+            handle(Mutant::Mutation::Neutral::Noop)
+
+            MESSAGE = [
+              'Parsed subject AST:',
+              '%s',
+              'Unparsed source:',
+              '%s'
+            ].join("\n").freeze
+
+            delegate :killers
+
+          private
+
+            # Return details
+            #
+            # @return [self]
+            #
+            # @api private
+            #
+            def details
+              info(MESSAGE, object.subject.node.inspect, object.original_source)
+            end
+
+          end # Noop
+
+          # Reporter for mutations producing a diff
+          class Diff < self
+            handle(Mutant::Mutation::Evil)
+            handle(Mutant::Mutation::Neutral)
+
+          private
+
+            # Run report printer
+            #
+            # @return [self]
+            #
+            # @api private
+            #
+            def details
+              original, current = object.original_source, object.source
+              diff = Mutant::Diff.build(original, current)
+              color? ? diff.colorized_diff : diff.diff
+            end
+
+          end # Diff
+        end # Mutation
+
+        # Subject report printer
+        class MutationRunner < self
+          handle(Mutant::Runner::Mutation)
+
+          # Run report printer
+          #
+          # @return [self]
+          #
+          # @api private
+          #
+          def run
+            visit(object.mutation)
+            if object.mutation.kind_of?(Mutant::Mutation::Neutral::Noop)
+              report_noop
+            end
+            self
+          end
+
+          delegate :killers
+
+        private
+
+          # Report noop output
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def report_noop
+            info('NOOP MUTATION TESTS FAILED!')
+            killers.reject(&:success?).map(&:report).map(&:test_report).each do |report|
+              puts(report.test.identification)
+              puts(report.output)
+            end
+          end
+
+        end # Mutation
+      end # Report
+    end # CLI
+  end # Reporter
+end # Mutant

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

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+module Mutant
+  class Reporter
+    class CLI
+      class Report
+
+        # Subject report printer
+        class Subject < self
+          handle(Mutant::Runner::Subject)
+
+          delegate :subject, :failed_mutations
+
+          # Run report printer
+          #
+          # @return [self]
+          #
+          # @api private
+          #
+          def run
+            status(subject.identification)
+            object.tests.each do |test|
+              puts("- #{test.identification}")
+            end
+            object.failed_mutations.each(&method(:visit))
+            self
+          end
+
+        end # Subject
+      end # Report
+    end # CLI
+  end # Reporter
+end # Mutant

data/lib/mutant/reporter/null.rb

@@ -5,6 +5,7 @@ module Mutant
 
     # Null reporter
     class Null < self
+      include Equalizer.new
 
       # Report object
       #
@@ -18,6 +19,18 @@ module Mutant
         self
       end
 
+      # Report progress on object
+      #
+      # @param [Object] _object
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def progress(_object)
+        self
+      end
+
     end # Null
   end # Reporter
 end # Mutant

data/lib/mutant/reporter/trace.rb

@@ -0,0 +1,41 @@
+module Mutant
+  class Reporter
+    # Reporter to trace report calls, used as a spec adapter
+    class Trace
+      include Concord::Public.new(:progress_calls, :report_calls)
+
+      # Return new trace reporter
+      #
+      # @return [Tracer]
+      #
+      # @api private
+      #
+      def self.new
+        super([], [])
+      end
+
+      # Report object
+      #
+      # @param [Object] object
+      #
+      # @return [self]
+      #
+      def report(object)
+        report_calls << object
+        self
+      end
+
+      # Report new progress on object
+      #
+      # @param [Object] object
+      #
+      # @return [self]
+      #
+      def progress(object)
+        progress_calls << object
+        self
+      end
+
+    end # Tracker
+  end # reporter
+end # Mutant

data/lib/mutant/runner.rb

@@ -48,9 +48,9 @@ module Mutant
     #
     # @api private
     #
-    def self.run(config, object)
+    def self.run(config, object, *arguments)
       handler = lookup(object.class)
-      handler.new(config, object)
+      handler.new(config, object, *arguments)
     end
 
     # Return config
@@ -101,16 +101,6 @@ module Mutant
       (@end || Time.now) - @start
     end
 
-    # Return reporter
-    #
-    # @return [Reporter]
-    #
-    # @api private
-    #
-    def reporter
-      config.reporter
-    end
-
     # Test if runner is successful
     #
     # @return [true]
@@ -133,7 +123,7 @@ module Mutant
     #
     abstract_method :run
 
-    # Return reporter
+    # Run reporter on object
     #
     # @param [Object] object
     #
@@ -141,20 +131,32 @@ module Mutant
     #
     # @api private
     #
-    def report(object)
-      reporter.report(object)
+    def progress(object)
+      reporter.progress(object)
     end
 
-    # Perform dispatch
+    # Return reporter
+    #
+    # @return [Reporter]
+    #
+    # @api private
+    #
+    def reporter
+      config.reporter
+    end
+
+    # Perform dispatch on multiple inputs
+    #
+    # @param [Enumerable<Object>] input
     #
     # @return [Enumerable<Runner>]
     #
     # @api private
     #
-    def dispatch(input)
+    def visit_collection(input, *arguments)
       collection = []
       input.each do |object|
-        runner = visit(object)
+        runner = visit(object, *arguments)
         collection << runner
         @stop = runner.stop?
         break if @stop
@@ -170,8 +172,8 @@ module Mutant
     #
     # @api private
     #
-    def visit(object)
-      Runner.run(config, object)
+    def visit(object, *arguments)
+      Runner.run(config, object, *arguments)
     end
 
   end # Runner

data/lib/mutant/runner/config.rb

@@ -5,6 +5,9 @@ module Mutant
     # Runner for object config
     class Config < self
 
+      # The expected coverage precision
+      COVERAGE_PRECISION = 1
+
       register Mutant::Config
 
       # Run runner for object
@@ -40,8 +43,6 @@ module Mutant
       end
       memoize :failed_subjects
 
-      COVERAGE_PRECISION = 1
-
       # Test if run was successful
       #
       # @return [true]
@@ -122,7 +123,7 @@ module Mutant
       def run_subjects
         strategy = self.strategy
         strategy.setup
-        @subjects = dispatch(config.subjects)
+        @subjects = visit_collection(config.subjects)
         strategy.teardown
       end
 
@@ -133,10 +134,10 @@ module Mutant
       # @api private
       #
       def run
-        report(config)
+        progress(config)
         run_subjects
         @end = Time.now
-        report(self)
+        reporter.report(self)
       end
 
     end # Config

data/lib/mutant/runner/killer.rb

@@ -0,0 +1,59 @@
+module Mutant
+  class Runner
+    # Killer runner
+    class Killer < self
+      include Equalizer.new(:config, :killer)
+
+      register Mutant::Killer
+
+      # Return killer
+      #
+      # @return [Killer]
+      #
+      # @api private
+      #
+      attr_reader :killer
+      protected :killer
+
+      # Return kill report
+      #
+      # @return [Killer::Report]
+      #
+      # @api private
+      #
+      attr_reader :report
+
+      # Test if killer ran successfully
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def success?
+        @report.success?
+      end
+
+      # Initialize object
+      #
+      # @param [Config] config
+      # @param [Mutation] mutation
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def initialize(config, killer)
+        @killer = killer
+        super(config)
+      end
+
+      # Run killer
+      #
+      # @api private
+      #
+      def run
+        @report = killer.run
+      end
+
+    end # Killer
+  end # Runner
+end # Mutant

data/lib/mutant/runner/mutation.rb

@@ -4,7 +4,7 @@ module Mutant
   class Runner
     # Mutation runner
     class Mutation < self
-      include Equalizer.new(:config, :mutation)
+      include Equalizer.new(:config, :mutation, :tests)
 
       register Mutant::Mutation
 
@@ -16,26 +16,28 @@ module Mutant
       #
       attr_reader :mutation
 
-      # Return killer instance
+      # Return killers
       #
-      # @return [Killer]
+      # @return [Enumerable<Runner::Killer>]
       #
       # @api private
       #
-      attr_reader :killer
+      attr_reader :killers
 
       # Initialize object
       #
       # @param [Config] config
       # @param [Mutation] mutation
+      # @param [Enumerable<Test>] tests
       #
       # @return [undefined]
       #
       # @api private
       #
-      def initialize(config, mutation)
-        @mutation = mutation
+      def initialize(config, mutation, tests)
+        @mutation, @tests = mutation, tests
         super(config)
+        @stop = config.fail_fast && !success?
       end
 
       # Test if mutation was handeled successfully
@@ -49,7 +51,7 @@ module Mutant
       # @api private
       #
       def success?
-        mutation.success?(killer)
+        killers.any?(&:success?)
       end
 
     private
@@ -61,9 +63,14 @@ module Mutant
       # @api private
       #
       def run
-        @killer = config.strategy.kill(mutation)
-        report(killer)
-        @stop = config.fail_fast && !killer.success?
+        progress(mutation)
+        @killers = @tests.map do |test|
+          Mutant::Killer.new(
+            mutation: mutation,
+            test:     test
+          )
+        end.map(&method(:visit))
+        progress(self)
       end
 
     end # Mutation