mutant 0.5.24 → 0.5.25

data/lib/mutant/reporter/cli/progress/env.rb

@@ -0,0 +1,30 @@
+module Mutant
+  class Reporter
+    class CLI
+      class Progress
+        # Progress printer for configuration
+        class Env < self
+
+          handle Mutant::Env
+
+          delegate :config
+
+          # Report configuration
+          #
+          # @param [Mutant::Config] config
+          #
+          # @return [self]
+          #
+          # @api private
+          #
+          def run
+            visit(config)
+            info 'Available Subjects: %d', object.matchable_scopes.length
+            info 'Subjects:           %d', object.subjects.length
+          end
+
+        end # Progress
+      end # Printer
+    end # CLI
+  end # Reporter
+end # Mutant

data/lib/mutant/reporter/cli/progress/noop.rb

@@ -5,7 +5,10 @@ module Mutant
         # Noop CLI progress reporter
         class Noop < self
 
-          handle(Mutant::Runner::Killer)
+          handle(Mutant::Test)
+          handle(Mutant::Mutation)
+          handle(Mutant::Result::Env)
+          handle(Mutant::Result::Test)
 
           # Noop progress report
           #

data/lib/mutant/reporter/cli/progress/result.rb

@@ -0,0 +1,12 @@
+module Mutant
+  class Reporter
+    class CLI
+      class Progress
+        # Abstract namespace class for result progress printers
+        class Result < self
+          include AbstractType
+        end # Result
+      end # Progress
+    end # CLI
+  end # Reporter
+end # Mutant

data/lib/mutant/reporter/cli/progress/result/mutation.rb

@@ -0,0 +1,45 @@
+module Mutant
+  class Reporter
+    class CLI
+      class Progress
+        class Result
+          # Mutation test result progress reporter
+          class Mutation < self
+
+            handle(Mutant::Result::Mutation)
+
+            SUCCESS = '.'.freeze
+            FAILURE = 'F'.freeze
+
+            # Run printer
+            #
+            # @return [self]
+            #
+            # @api private
+            #
+            def run
+              char(success? ? SUCCESS : FAILURE)
+              self
+            end
+
+          private
+
+            # Write colorized char
+            #
+            # @param [String] char
+            #
+            # @return [undefined]
+            #
+            # @api private
+            #
+            def char(char)
+              output.write(colorize(status_color, char))
+              output.flush
+            end
+
+          end # Mutation
+        end # Result
+      end # Progress
+    end # CLI
+  end # Reporter
+end # Mutant

data/lib/mutant/reporter/cli/progress/result/subject.rb

@@ -0,0 +1,54 @@
+module Mutant
+  class Reporter
+    class CLI
+      class Progress
+        class Result
+          # Reporter for subject runners
+          class Subject < self
+
+            FORMAT = '(%02d/%02d) %3d%% - killtime: %0.02fs runtime: %0.02fs overhead: %0.02fs'.freeze
+
+            handle(Mutant::Result::Subject)
+
+            # Run printer
+            #
+            # @return [self]
+            #
+            # @api private
+            #
+            def run
+              print_progress_bar_finish
+              print_stats
+              self
+            end
+
+            delegate :coverage, :runtime, :amount_mutations_killed, :amount_mutations, :killtime, :overhead
+
+          private
+
+            # Print stats
+            #
+            # @return [undefined]
+            #
+            # @api private
+            #
+            def print_stats
+              status(FORMAT, amount_mutations_killed, amount_mutations, coverage * 100, killtime, runtime, overhead)
+            end
+
+            # Print progress bar finish
+            #
+            # @return [undefined]
+            #
+            # @api private
+            #
+            def print_progress_bar_finish
+              puts unless amount_mutations.zero?
+            end
+
+          end # Subject
+        end # Result
+      end # Progress
+    end  # CLI
+  end # Reporter
+end # Mutant

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

@@ -2,14 +2,10 @@ module Mutant
   class Reporter
     class CLI
       class Progress
-        # Reporter for subject runners
+        # CLI progress reporter for subjects
         class Subject < self
 
-          FORMAT = '(%02d/%02d) %3d%% - %0.02fs'.freeze
-
-          handle(Mutant::Runner::Subject)
-
-          delegate :running?, :tests, :subject
+          handle Mutant::Subject
 
           # Run printer
           #
@@ -18,93 +14,14 @@ module Mutant
           # @api private
           #
           def run
-            if running?
-              puts(subject.identification)
-              tests.each do |test|
-                puts "- #{test.identification}"
-              end
-            else
-              print_progress_bar_finish
-              print_stats
+            puts("#{object.identification} mutations: #{object.mutations.length}")
+            object.tests.each do |test|
+              puts "- #{test.identification}"
             end
-            self
-          end
-
-        private
-
-          # Return mutation time on subject
-          #
-          # @return [Float]
-          #
-          # @api private
-          #
-          def time
-            mutations.map(&:runtime).inject(0, :+)
-          end
-
-          # Print stats
-          #
-          # @return [undefined]
-          #
-          # @api private
-          #
-          def print_stats
-            status(FORMAT, amount_kills, amount_mutations, coverage, time)
-          end
-
-          # Print progress bar finish
-          #
-          # @return [undefined]
-          #
-          # @api private
-          #
-          def print_progress_bar_finish
-            puts unless amount_mutations.zero?
-          end
-
-          # Return kills
-          #
-          # @return [Fixnum]
-          #
-          # @api private
-          #
-          def amount_kills
-            amount_mutations - object.failed_mutations.length
-          end
-
-          # Return amount of mutations
-          #
-          # @return [Array<Mutation>]
-          #
-          # @api private
-          #
-          def amount_mutations
-            mutations.length
-          end
-
-          # Return mutations
-          #
-          # @return [Array<Mutation>]
-          #
-          # @api private
-          #
-          def mutations
-            object.mutations
-          end
-
-          # Return subject coverage
-          #
-          # @return [Float]
-          #
-          # @api private
-          #
-          def coverage
-            return 0 if amount_mutations.zero?
-            Rational(amount_kills, amount_mutations) * 100
           end
 
-        end # Runner
+        end # Subject
       end # Progress
-    end  # CLI
+    end # CLI
   end # Reporter
 end # Mutant

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

@@ -61,6 +61,8 @@ module Mutant
         # @api private
         #
         def included(host)
+          super
+
           object = self
           host.class_eval do
             define_singleton_method(:lookup, &object.method(:lookup))

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

@@ -0,0 +1,92 @@
+module Mutant
+  class Reporter
+    class CLI
+      class Report
+
+        # Env result reporter
+        class Env < self
+
+          handle(Result::Env)
+
+          delegate(
+            :coverage, :failed_subject_results, :amount_subjects, :amount_mutations,
+            :amount_mutations_alive, :amount_mutations_killed, :runtime, :killtime, :overhead, :env
+          )
+
+          # Run printer
+          #
+          # @return [self]
+          #
+          # @api private
+          #
+          def run
+            visit_collection(failed_subject_results)
+            info 'Subjects:  %s',        amount_subjects
+            info 'Mutations: %s',        amount_mutations
+            info 'Kills:     %s',        amount_mutations_killed
+            info 'Alive:     %s',        amount_mutations_alive
+            info 'Runtime:   %0.2fs',    runtime
+            info 'Killtime:  %0.2fs',    killtime
+            info 'Overhead:  %0.2f%%',   overhead_percent
+            status 'Coverage:  %0.2f%%', coverage_percent
+            status 'Expected:  %0.2f%%', env.config.expected_coverage
+            print_generic_stats
+            self
+          end
+
+        private
+
+          # Print generic stats
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def print_generic_stats
+            stats = generic_stats.to_a.sort_by(&:last)
+            return if stats.empty?
+            info('Nodes handled by generic mutator (type:occurrences):')
+            stats.reverse_each do |type, amount|
+              info('%-10s: %d', type, amount)
+            end
+          end
+
+          # Return coverage percent
+          #
+          # @return [Float]
+          #
+          # @api private
+          #
+          def coverage_percent
+            coverage * 100
+          end
+
+          # Return overhead percent
+          #
+          # @return [Float]
+          #
+          # @api private
+          #
+          def overhead_percent
+            (overhead / killtime) * 100
+          end
+
+          # Return stats for nodes handled by generic mutator
+          #
+          # @return [Hash<Symbo, Fixnum>]
+          #
+          # @api private
+          #
+          def generic_stats
+            object.subject_results.each_with_object(Hash.new(0)) do |result, stats|
+              Walker.run(result.subject.node) do |node|
+                stats[node.type] += 1 if Mutator::Registry.lookup(node).equal?(Mutator::Node::Generic)
+              end
+            end
+          end
+
+        end # Env
+      end # Report
+    end # CLI
+  end # Reporter
+end # Mutant

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

@@ -6,72 +6,35 @@ module Mutant
         # 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
+          handle Mutant::Result::Mutation
 
-          end # Noop
+          delegate :mutation, :failed_test_results
 
-          # Reporter for mutations producing a diff
-          class Diff < self
-            handle(Mutant::Mutation::Evil)
-            handle(Mutant::Mutation::Neutral)
+          DIFF_ERROR_MESSAGE = 'BUG: Mutation NOT resulted in exactly one diff. Please report a reproduction!'.freeze
 
-            DIFF_ERROR_MESSAGE = 'BUG: Mutation NOT resulted in exactly one diff. Please report a reproduction'.freeze
+          MAP = {
+            Mutant::Mutation::Evil    => :evil_details,
+            Mutant::Mutation::Neutral => :neutral_details,
+            Mutant::Mutation::Noop    => :noop_details
+          }.freeze
 
-          private
+          NEUTRAL_MESSAGE =
+            "--- Neutral failure ---\n" \
+            "Original code was inserted unmutated. And the test did NOT PASS.\n" \
+            "Your tests do not pass initially or you found a bug in mutant / unparser.\n" \
+            "Subject AST:\n" \
+            "%s\n" \
+            "Unparsed Source:\n" \
+            "%s\n" \
+            "Test Reports: %d\n"
 
-            # Run report printer
-            #
-            # @return [String]
-            #
-            # @api private
-            #
-            def details
-              original, current = object.original_source, object.source
-              diff = Mutant::Diff.build(original, current)
-              diff = color? ? diff.colorized_diff : diff.diff
-              diff || DIFF_ERROR_MESSAGE
-            end
-          end # Diff
-        end # Mutation
+          NOOP_MESSAGE    =
+            "---- Noop failure -----\n" \
+            "No code was inserted. And the test did NOT PASS.\n" \
+            "This is typically a problem of your specs not passing unmutated.\n" \
+            "Test Reports: %d\n"
 
-        # Subject report printer
-        class MutationRunner < self
-          handle(Mutant::Runner::Mutation)
+          FOOTER = '-----------------------'.freeze
 
           # Run report printer
           #
@@ -80,39 +43,57 @@ module Mutant
           # @api private
           #
           def run
-            visit(object.mutation)
-            if object.mutation.kind_of?(Mutant::Mutation::Neutral::Noop)
-              report_noop
-            end
+            puts(mutation.identification)
+            print_details
+            puts(FOOTER)
             self
           end
 
-          delegate :killers
-
         private
 
-          # Report noop output
+          # Return details
           #
           # @return [undefined]
           #
           # @api private
           #
-          def report_noop
-            info('NOOP MUTATION TESTS FAILED!')
-            noop_reports.each do |report|
-              puts(report.test.identification)
-              puts(report.output)
-            end
+          def print_details
+            send(MAP.fetch(mutation.class))
+          end
+
+          # Return evil details
+          #
+          # @return [String]
+          #
+          # @api private
+          #
+          def evil_details
+            original, current = mutation.original_source, mutation.source
+            diff = Mutant::Diff.build(original, current)
+            diff = color? ? diff.colorized_diff : diff.diff
+            info(diff || DIFF_ERROR_MESSAGE)
+          end
+
+          # Noop details
+          #
+          # @return [String]
+          #
+          # @api private
+          #
+          def noop_details
+            info(NOOP_MESSAGE, failed_test_results.length)
+            visit_collection(failed_test_results)
           end
 
-          # Return test noop reports
+          # Neutral details
           #
-          # @return [Enumerable<Test::Report>]
+          # @return [String]
           #
           # @api private
           #
-          def noop_reports
-            killers.reject(&:success?).map(&:report).map(&:test_report)
+          def neutral_details
+            info(NEUTRAL_MESSAGE, mutation.subject.node.inspect, mutation.source, failed_test_results.length)
+            visit_collection(failed_test_results)
           end
 
         end # Mutation