mutant 0.5.12 → 0.5.13

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

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+module Mutant
+  class Reporter
+    class CLI
+      # Abstract base class for process printers
+      class Progress < Printer
+        include AbstractType, Registry.new
+      end # Progress
+    end # CLI
+  end # Reporter
+end # Mutant

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

@@ -0,0 +1,32 @@
+module Mutant
+  class Reporter
+    class CLI
+      class Progress
+        # Progress printer for configuration
+        class Config < self
+
+          handle(Mutant::Config)
+
+          delegate :matcher, :strategy, :expected_coverage
+
+          # Report configuration
+          #
+          # @param [Mutant::Config] config
+          #
+          # @return [self]
+          #
+          # @api private
+          #
+          def run
+            info 'Mutant configuration:'
+            info 'Matcher:         %s',     matcher.inspect
+            info 'Strategy:        %s',     strategy.inspect
+            info 'Expect Coverage: %02f%%', expected_coverage.inspect
+            self
+          end
+
+        end # Progress
+      end # Printer
+    end # CLI
+  end # Reporter
+end # Mutant

data/lib/mutant/reporter/cli/{printer/killer.rb → progress/mutation.rb}

@@ -1,14 +1,12 @@
-# encoding: utf-8
-
 module Mutant
   class Reporter
     class CLI
-      class Printer
+      class Progress
 
-        # Printer for killer results
-        class Killer < self
+        # Mutation progress reporter
+        class Mutation < self
 
-          handle(Mutant::Killer)
+          handle(Runner::Mutation)
 
           SUCCESS = '.'.freeze
           FAILURE = 'F'.freeze
@@ -20,11 +18,7 @@ module Mutant
           # @api private
           #
           def run
-            if success?
-              char(SUCCESS, Color::GREEN)
-            else
-              char(FAILURE, Color::RED)
-            end
+            char(success? ? SUCCESS : FAILURE)
           end
 
         private
@@ -32,19 +26,18 @@ module Mutant
           # Write colorized char
           #
           # @param [String] char
-          # @param [Color]
           #
           # @return [undefined]
           #
           # @api private
           #
-          def char(char, color)
-            output.write(colorize(color, char))
+          def char(char)
+            output.write(colorize(status_color, char))
             output.flush
           end
 
-        end # Killer
-      end # Printer
+        end # Mutation
+      end # Progress
     end # CLI
   end # Reporter
 end # Mutant

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

@@ -0,0 +1,22 @@
+module Mutant
+  class Reporter
+    class CLI
+      class Progress
+        # Noop CLI progress reporter
+        class Noop < self
+
+          handle(Mutant::Mutation)
+
+          # Noop progress report
+          #
+          # @return [self]
+          #
+          def run
+            self
+          end
+
+        end # Noop
+      end # Progress
+    end # CLI
+  end # Reporter
+end # Mutant

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

@@ -0,0 +1,118 @@
+module Mutant
+  class Reporter
+    class CLI
+      class Progress
+        # Subject results printer
+        class Subject < self
+
+          handle(Mutant::Subject)
+
+          # Run subject results printer
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def run
+            puts(object.identification)
+          end
+
+        end # Subject
+
+        # Reporter for subject runners
+        class SubjectRunner < self
+
+          FORMAT = '(%02d/%02d) %3d%% - %0.02fs'.freeze
+
+          handle(Mutant::Runner::Subject)
+
+          # Run printer
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def run
+            print_progress_bar_finish
+            print_stats
+            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 # Progress
+    end  # CLI
+  end # Reporter
+end # Mutant

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

@@ -0,0 +1,77 @@
+module Mutant
+  class Reporter
+    class CLI
+      # Mixin to generate registry semantics
+      class Registry < Module
+        include Concord.new(:registry)
+
+        # Return new registry
+        #
+        # @return [Registry]
+        #
+        # @api private
+        #
+        def self.new
+          super({})
+        end
+
+        # Register handler for class
+        #
+        # @param [Class] klass
+        #
+        # @return [self]
+        #
+        # @api private
+        #
+        def handle(subject, handler)
+          raise "Duplicate registration of #{subject}" if registry.key?(subject)
+          registry[subject] = handler
+          self
+        end
+
+        # Lookup handler
+        #
+        # @param [Class] subject
+        #
+        # @return [Object]
+        #   if found
+        #
+        # @raise [RuntimeError]
+        #   otherwise
+        #
+        # @api private
+        #
+        def lookup(subject)
+          current = subject
+          until current == Object
+            if registry.key?(current)
+              return registry.fetch(current)
+            end
+            current = current.superclass
+          end
+          raise "No printer for: #{subject}"
+        end
+
+        # Hook called when module is included
+        #
+        # @param [Class,Module] host
+        #
+        # @return [undefined]
+        #
+        def included(host)
+          object = self
+          host.class_eval do
+            define_singleton_method(:lookup, &object.method(:lookup))
+            private_class_method :lookup
+
+            define_singleton_method(:handle) do |subject|
+              object.handle(subject, self)
+            end
+            private_class_method :handle
+          end
+        end
+
+      end # Registry
+    end # CLI
+  end # Reporter
+end # Mutant

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

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+module Mutant
+  class Reporter
+    class CLI
+      # Abstract base class for process printers
+      class Report < Printer
+        include AbstractType, Registry.new
+      end # Report
+    end # CLI
+  end # Reporter
+end # Mutant

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

@@ -0,0 +1,118 @@
+# encoding: utf-8
+
+module Mutant
+  class Reporter
+    class CLI
+      class Report
+
+        # Printer for configuration
+        class Config < self
+
+          handle(Mutant::Runner::Config)
+
+          delegate(
+            :amount_kills, :amount_mutations, :amount_kils,
+            :coverage, :subjects, :failed_subjects, :runtime, :mutations
+          )
+
+          # Run printer
+          #
+          # @return [self]
+          #
+          # @api private
+          #
+          def run
+            failed_subjects.each(&method(:visit))
+            info   'Subjects:  %s',      amount_subjects
+            info   'Mutations: %s',      amount_mutations
+            info   'Kills:     %s',      amount_kills
+            info   'Alive:     %s',      amount_alive
+            info   'Runtime:   %0.2fs',  runtime
+            info   'Killtime:  %0.2fs',  killtime
+            info   'Overhead:  %0.2f%%', overhead
+            status 'Coverage:  %0.2f%%', coverage
+            status 'Expected:  %0.2f%%', object.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 stats for nodes handled by generic mutator
+          #
+          # @return [Hash<Symbo, Fixnum>]
+          #
+          # @api private
+          #
+          def generic_stats
+            subjects.each_with_object(Hash.new(0)) do |runner, stats|
+              Walker.run(runner.subject.node) do |node|
+                if Mutator::Registry.lookup(node) == Mutator::Node::Generic
+                  stats[node.type] += 1
+                end
+              end
+            end
+          end
+
+          # Return amount of subjects
+          #
+          # @return [Fixnum]
+          #
+          # @api private
+          #
+          def amount_subjects
+            subjects.length
+          end
+
+          # Return amount of time in killers
+          #
+          # @return [Float]
+          #
+          # @api private
+          #
+          def killtime
+            mutations.map(&:runtime).inject(0, :+)
+          end
+          memoize :killtime
+
+          # Return mutant overhead
+          #
+          # @return [Float]
+          #
+          # @api private
+          #
+          def overhead
+            return 0 if runtime.zero?
+            Rational(runtime - killtime, runtime) * 100
+          end
+
+          # Return amount of alive mutations
+          #
+          # @return [Fixnum]
+          #
+          # @api private
+          #
+          def amount_alive
+            object.amount_mutations - amount_kills
+          end
+
+        end # Config
+      end # Report
+    end # CLI
+  end # Reporter
+end # Mutant