mutest 0.0.1 → 0.0.2

data/lib/mutest/reporter/cli/printer.rb

@@ -0,0 +1,124 @@
+module Mutest
+  class Reporter
+    class CLI
+      # CLI runner status printer base class
+      class Printer
+        include AbstractType,
+                Adamantium::Flat,
+                Concord.new(:output, :object),
+                Procto.call(:run)
+
+        private_class_method :new
+
+        # Create delegators to object
+        #
+        # @return [undefined]
+        def self.delegate(*names)
+          names.each(&method(:define_delegator))
+        end
+        private_class_method :delegate
+
+        # Create delegator to object
+        #
+        # @param [Symbol] name
+        #
+        # @return [undefined]
+        def self.define_delegator(name)
+          define_method(name) do
+            object.public_send(name)
+          end
+          private(name)
+        end
+        private_class_method :define_delegator
+
+        delegate :success?
+
+        NL = "\n".freeze
+
+        # Run printer
+        #
+        # @return [self]
+        abstract_method :run
+
+        private
+
+        # Status color
+        #
+        # @return [Color]
+        def status_color
+          success? ? Color::GREEN : Color::RED
+        end
+
+        # Visit a collection of objects
+        #
+        # @return [Class::Printer] printer
+        # @return [Enumerable<Object>] collection
+        #
+        # @return [undefined]
+        def visit_collection(printer, collection)
+          collection.each do |object|
+            visit(printer, object)
+          end
+        end
+
+        # Visit object
+        #
+        # @param [Class::Printer] printer
+        # @param [Object] object
+        #
+        # @return [undefined]
+        def visit(printer, object)
+          printer.call(output, object)
+        end
+
+        # Print an info line to output
+        #
+        # @return [undefined]
+        def info(string, *arguments)
+          puts(string % arguments)
+        end
+
+        # Print a status line to output
+        #
+        # @return [undefined]
+        def status(string, *arguments)
+          puts(colorize(status_color, string % arguments))
+        end
+
+        # Print a line to output
+        #
+        # @return [undefined]
+        def puts(string)
+          output.puts(string)
+        end
+
+        # Colorize message
+        #
+        # @param [Color] color
+        # @param [String] message
+        #
+        # @return [String]
+        #   if color is enabled
+        #   unmodified message otherwise
+        def colorize(color, message)
+          color = Color::NONE unless tty?
+          color.format(message)
+        end
+
+        # Test if output is a tty
+        #
+        # @return [Boolean]
+        def tty?
+          output.tty?
+        end
+
+        # Test if output can be colored
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        alias_method :color?, :tty?
+      end # Printer
+    end # CLI
+  end # Reporter
+end # Mutest

data/lib/mutest/reporter/cli/printer/config.rb

@@ -0,0 +1,24 @@
+module Mutest
+  class Reporter
+    class CLI
+      class Printer
+        # Printer for mutation config
+        class Config < self
+          # Report configuration
+          #
+          # @param [Mutest::Config] config
+          #
+          # @return [undefined]
+          def run
+            info 'Mutest configuration:'
+            info 'Matcher:         %s',      object.matcher.inspect
+            info 'Integration:     %s',      object.integration
+            info 'Jobs:            %d',      object.jobs
+            info 'Includes:        %s',      object.includes
+            info 'Requires:        %s',      object.requires
+          end
+        end # Config
+      end # Printer
+    end # CLI
+  end # Reporter
+end # Mutest

data/lib/mutest/reporter/cli/printer/env_progress.rb

@@ -0,0 +1,76 @@
+module Mutest
+  class Reporter
+    class CLI
+      class Printer
+        # Env progress printer
+        class EnvProgress < self
+          delegate(
+            :coverage,
+            :amount_subjects,
+            :amount_mutations,
+            :amount_mutations_alive,
+            :amount_mutations_killed,
+            :amount_mutation_results,
+            :runtime,
+            :killtime,
+            :overhead,
+            :env
+          )
+
+          # rubocop:disable SpaceInsideBrackets
+          FORMATS = IceNine.deep_freeze([
+            [:info,   'Subjects:        %s',      :amount_subjects          ],
+            [:info,   'Mutations:       %s',      :amount_mutations         ],
+            [:info,   'Results:         %s',      :amount_mutation_results  ],
+            [: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         ],
+            [:info,   'Mutations/s:     %0.2f',   :mutations_per_second     ],
+            [:status, 'Coverage:        %0.2f%%', :coverage_percent         ]
+          ])
+
+          # Run printer
+          #
+          # @return [undefined]
+          def run
+            visit(Config, env.config)
+            FORMATS.each do |report, format, value|
+              __send__(report, format, __send__(value))
+            end
+          end
+
+          private
+
+          # Mutations processed per second
+          #
+          # @return [Float]
+          #
+          # @api private
+          def mutations_per_second
+            amount_mutation_results / runtime
+          end
+
+          # Coverage in percent
+          #
+          # @return [Float]
+          #
+          # @api private
+          def coverage_percent
+            coverage * 100
+          end
+
+          # Overhead in percent
+          #
+          # @return [Float]
+          #
+          # @api private
+          def overhead_percent
+            (overhead / killtime) * 100
+          end
+        end # EnvProgress
+      end # Printer
+    end # CLI
+  end # Reporter
+end # Mutest

data/lib/mutest/reporter/cli/printer/env_result.rb

@@ -0,0 +1,20 @@
+module Mutest
+  class Reporter
+    class CLI
+      class Printer
+        # Full env result reporter
+        class EnvResult < self
+          delegate(:failed_subject_results)
+
+          # Run printer
+          #
+          # @return [undefined]
+          def run
+            visit_collection(SubjectResult, failed_subject_results)
+            visit(EnvProgress, object)
+          end
+        end # EnvResult
+      end # Printer
+    end # CLI
+  end # Reporter
+end # Mutest

data/lib/mutest/reporter/cli/printer/mutation_progress_result.rb

@@ -0,0 +1,31 @@
+module Mutest
+  class Reporter
+    class CLI
+      class Printer
+        # Printer for mutation progress results
+        class MutationProgressResult < self
+          SUCCESS = '.'.freeze
+          FAILURE = 'F'.freeze
+
+          # Run printer
+          #
+          # @return [undefined]
+          def run
+            char(success? ? SUCCESS : FAILURE)
+          end
+
+          private
+
+          # Write colorized char
+          #
+          # @param [String] char
+          #
+          # @return [undefined]
+          def char(char)
+            output.write(colorize(status_color, char))
+          end
+        end # MutationProgressResult
+      end # Printer
+    end # CLI
+  end # Reporter
+end # Mutest

data/lib/mutest/reporter/cli/printer/mutation_result.rb

@@ -0,0 +1,127 @@
+module Mutest
+  class Reporter
+    class CLI
+      class Printer
+        # Reporter for mutation results
+        #
+        # :reek:TooManyConstants
+        class MutationResult < self
+          delegate :mutation, :test_result
+
+          DIFF_ERROR_MESSAGE =
+            'BUG: Mutation NOT resulted in exactly one diff hunk. Please report a reproduction!'.freeze
+
+          MAP = {
+            Mutest::Mutation::Evil    => :evil_details,
+            Mutest::Mutation::Neutral => :neutral_details,
+            Mutest::Mutation::Noop    => :noop_details
+          }.freeze
+
+          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 mutest / unparser.\n" \
+            "Subject AST:\n" \
+            "%s\n" \
+            "Unparsed Source:\n" \
+            "%s\n" \
+            "Test Result:\n".freeze
+
+          NO_DIFF_MESSAGE =
+            "--- Internal failure ---\n" \
+            "BUG: Mutation NOT resulted in exactly one diff hunk. Please report a reproduction!\n" \
+            "Original unparsed source:\n" \
+            "%s\n" \
+            "Original AST:\n" \
+            "%s\n" \
+            "Mutated unparsed source:\n" \
+            "%s\n" \
+            "Mutated AST:\n" \
+            "%s\n".freeze
+
+          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 Result:\n".freeze
+
+          FOOTER = '-----------------------'.freeze
+
+          # Run report printer
+          #
+          # @return [undefined]
+          def run
+            puts(mutation.identification)
+            print_details
+            puts(FOOTER)
+          end
+
+          private
+
+          # Print mutation details
+          #
+          # @return [undefined]
+          def print_details
+            __send__(MAP.fetch(mutation.class))
+          end
+
+          # Evil mutation details
+          #
+          # @return [String]
+          def evil_details
+            diff = Diff.build(mutation.original_source, mutation.source)
+            diff = color? ? diff.colorized_diff : diff.diff
+            if diff
+              output.write(diff)
+            else
+              print_no_diff_message
+            end
+          end
+
+          # Print no diff message
+          #
+          # @return [undefined]
+          def print_no_diff_message
+            info(
+              NO_DIFF_MESSAGE,
+              mutation.original_source,
+              original_node.inspect,
+              mutation.source,
+              mutation.node.inspect
+            )
+          end
+
+          # Noop details
+          #
+          # @return [String]
+          def noop_details
+            info(NOOP_MESSAGE)
+            visit_test_result
+          end
+
+          # Neutral details
+          #
+          # @return [String]
+          def neutral_details
+            info(NEUTRAL_MESSAGE, original_node.inspect, mutation.source)
+            visit_test_result
+          end
+
+          # Visit failed test results
+          #
+          # @return [undefined]
+          def visit_test_result
+            visit(TestResult, test_result)
+          end
+
+          # Original node
+          #
+          # @return [Parser::AST::Node]
+          def original_node
+            mutation.subject.node
+          end
+        end # MutationResult
+      end # Printer
+    end # CLI
+  end # Reporter
+end # Mutest

data/lib/mutest/reporter/cli/printer/status.rb

@@ -0,0 +1,49 @@
+module Mutest
+  class Reporter
+    class CLI
+      class Printer
+        # Printer for runner status
+        class Status < self
+          delegate(:active_jobs, :payload)
+
+          ACTIVE_JOB_HEADER = 'Active Jobs:'.freeze
+          ACTIVE_JOB_FORMAT = '%d: %s'.freeze
+
+          # Print progress for collector
+          #
+          # @return [undefined]
+          def run
+            visit(EnvProgress, payload)
+            job_status
+            info('Active subjects: %d', active_subject_results.length)
+            visit_collection(SubjectProgress, active_subject_results)
+          end
+
+          private
+
+          # Print worker status
+          #
+          # @return [undefined]
+          def job_status
+            return if active_jobs.empty?
+            info(ACTIVE_JOB_HEADER)
+            active_jobs.sort_by(&:index).each do |job|
+              info(ACTIVE_JOB_FORMAT, job.index, job.payload.identification)
+            end
+          end
+
+          # Active subject results
+          #
+          # @return [Array<Result::Subject>]
+          def active_subject_results
+            active_subjects = active_jobs.map(&:payload).flat_map(&:subject)
+
+            payload.subject_results.select do |subject_result|
+              active_subjects.include?(subject_result.subject)
+            end
+          end
+        end # Status
+      end # Printer
+    end # CLI
+  end # Reporter
+end # Mutest