mutant 0.10.1 → 0.10.8

data/lib/mutant/mutator/node/send.rb

@@ -99,7 +99,7 @@ module Mutant
 
           dynamic_selector, *actual_arguments = *arguments
 
-          return unless n_sym?(dynamic_selector)
+          return unless dynamic_selector && n_sym?(dynamic_selector)
 
           method_name = AST::Meta::Symbol.new(dynamic_selector).name
 

data/lib/mutant/parallel.rb

@@ -41,7 +41,6 @@ module Mutant
     end
     private_class_method :threads
 
-    # ignore :reek:LongParameterList
     def self.shared(klass, config, **attributes)
       klass.new(
         condition_variable: config.condition_variable,

data/lib/mutant/parallel/worker.rb

@@ -17,8 +17,6 @@ module Mutant
       # Run worker payload
       #
       # @return [self]
-      #
-      # ignore :reek:TooManyStatements
       def call
         loop do
           job = next_job or break

data/lib/mutant/reporter/cli.rb

@@ -11,8 +11,6 @@ module Mutant
       # @param [IO] output
       #
       # @return [Reporter::CLI]
-      #
-      # :reek:ManualDispatch
       def self.build(output)
         new(
           output,

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

@@ -12,13 +12,17 @@ module Mutant
           # @param [Mutant::Config] config
           #
           # @return [undefined]
+          #
+          # rubocop:disable Metrics/AbcSize
           def run
-            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
+            info 'Matcher:         %s',    object.matcher.inspect
+            info 'Integration:     %s',    object.integration || 'null'
+            info 'Jobs:            %s',    object.jobs || 'auto'
+            info 'Includes:        %s',    object.includes
+            info 'Requires:        %s',    object.requires
+            info 'MutationTimeout: %0.9g', object.mutation_timeout if object.mutation_timeout
           end
+          # rubocop:enable Metrics/AbcSize
 
         end # Config
       end # Printer

data/lib/mutant/reporter/cli/printer/coverage_result.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Reporter
+    class CLI
+      class Printer
+        # Reporter for mutation coverage results
+        class CoverageResult < self
+          # Run report printer
+          #
+          # @return [undefined]
+          def run
+            visit(MutationResult, object.mutation_result)
+          end
+        end # Printer
+      end # Coverage
+    end # CLI
+  end # Reporter
+end # Mutant

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

@@ -10,6 +10,7 @@ module Mutant
             :amount_mutation_results,
             :amount_mutations_alive,
             :amount_mutations_killed,
+            :amount_timeouts,
             :coverage,
             :env,
             :killtime,
@@ -21,6 +22,7 @@ module Mutant
             [:info,   'Results:         %s',      :amount_mutation_results],
             [:info,   'Kills:           %s',      :amount_mutations_killed],
             [:info,   'Alive:           %s',      :amount_mutations_alive ],
+            [:info,   'Timeouts:        %s',      :amount_timeouts        ],
             [:info,   'Runtime:         %0.2fs',  :runtime                ],
             [:info,   'Killtime:        %0.2fs',  :killtime               ],
             [:info,   'Overhead:        %0.2f%%', :overhead_percent       ],

data/lib/mutant/reporter/cli/printer/isolation_result.rb

@@ -6,7 +6,7 @@ module Mutant
       class Printer
         # Reporter for mutation results
         class IsolationResult < self
-          CHILD_ERROR_MESSAGE = <<~'MESSAGE'
+          PROCESS_ERROR_MESSAGE = <<~'MESSAGE'
             Killfork exited nonzero. Its result (if any) was ignored.
             Process status:
             %s
@@ -36,40 +36,24 @@ module Mutant
             ```
           MESSAGE
 
-          FORK_ERROR_MESSAGE = <<~'MESSAGE'
-            Forking the child process to isolate the mutation in failed.
-            This meant that either the RubyVM or your OS was under too much
-            pressure to add another child process.
-
-            Possible solutions are:
-            * Reduce concurrency
-            * Reduce locks
+          TIMEOUT_ERROR_MESSAGE =<<~'MESSAGE'
+            Mutation analysis ran into the configured timeout of %0.9<timeout>g seconds.
           MESSAGE
 
-          MAP = {
-            Isolation::Fork::ChildError   => :visit_child_error,
-            Isolation::Fork::ForkError    => :visit_fork_error,
-            Isolation::Result::ErrorChain => :visit_chain,
-            Isolation::Result::Exception  => :visit_exception,
-            Isolation::Result::Success    => :visit_success
-          }.freeze
-
           private_constant(*constants(false))
 
           # Run report printer
           #
           # @return [undefined]
           def run
+            print_timeout
+            print_process_status
             print_log_messages
-            __send__(MAP.fetch(object.class))
+            print_exception
           end
 
         private
 
-          def visit_success
-            visit(TestResult, object.value)
-          end
-
           def print_log_messages
             log = object.log
 
@@ -82,16 +66,23 @@ module Mutant
             end
           end
 
-          def visit_child_error
-            puts(CHILD_ERROR_MESSAGE % object.value.inspect)
+          def print_process_status
+            process_status = object.process_status or return
+
+            if process_status.success?
+              puts("Killfork: #{process_status.inspect}")
+            else
+              puts(PROCESS_ERROR_MESSAGE % process_status.inspect)
+            end
           end
 
-          def visit_fork_error
-            puts(FORK_ERROR_MESSAGE)
+          def print_timeout
+            timeout = object.timeout or return
+            puts(TIMEOUT_ERROR_MESSAGE % { timeout: timeout })
           end
 
-          def visit_exception
-            exception = object.value
+          def print_exception
+            exception = object.exception or return
 
             puts(
               EXCEPTION_ERROR_MESSAGE % [
@@ -100,13 +91,6 @@ module Mutant
               ]
             )
           end
-
-          def visit_chain
-            printer = self.class
-
-            visit(printer, object.value)
-            visit(printer, object.next)
-          end
         end # IsolationResult
       end # Printer
     end # CLI

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

@@ -46,24 +46,23 @@ module Mutant
             This is typically a problem of your specs not passing unmutated.
           MESSAGE
 
-          FOOTER = '-----------------------'
+          SEPARATOR = '-----------------------'
 
           # Run report printer
           #
           # @return [undefined]
           def run
             puts(mutation.identification)
+            puts(SEPARATOR)
             print_details
-            puts(FOOTER)
+            puts(SEPARATOR)
           end
 
         private
 
           def print_details
+            visit(IsolationResult, isolation_result)
             __send__(MAP.fetch(mutation.class))
-
-            puts(FOOTER)
-            visit_isolation_result
           end
 
           def evil_details
@@ -94,10 +93,6 @@ module Mutant
             info(NEUTRAL_MESSAGE, original_node.inspect, mutation.source)
           end
 
-          def visit_isolation_result
-            visit(IsolationResult, isolation_result)
-          end
-
           def original_node
             mutation.subject.node
           end

data/lib/mutant/reporter/cli/printer/subject_result.rb

@@ -7,7 +7,7 @@ module Mutant
         # Subject result printer
         class SubjectResult < self
 
-          delegate :subject, :alive_mutation_results, :tests
+          delegate :subject, :uncovered_results, :tests
 
           # Run report printer
           #
@@ -17,7 +17,7 @@ module Mutant
             tests.each do |test|
               puts("- #{test.identification}")
             end
-            visit_collection(MutationResult, alive_mutation_results)
+            visit_collection(CoverageResult, uncovered_results)
           end
 
         end # SubjectResult

data/lib/mutant/result.rb

@@ -4,8 +4,8 @@ module Mutant
   # Namespace and mixin module for results
   module Result
 
-    # Coverage mixin
-    module Coverage
+    # CoverageMetric mixin
+    module CoverageMetric
       FULL_COVERAGE = Rational(1).freeze
       private_constant(*constants(false))
 
@@ -19,7 +19,7 @@ module Mutant
           Rational(amount_mutations_killed, amount_mutation_results)
         end
       end
-    end # Coverage
+    end # CoverageMetric
 
     # Class level mixin
     module ClassMethods
@@ -39,6 +39,13 @@ module Mutant
         end
         memoize(name)
       end
+
+      # Delegate a method to child
+      def delegate(name, target)
+        define_method(name) do
+          public_send(target).public_send(name)
+        end
+      end
     end # ClassMethods
 
     private_constant(*constants(false))
@@ -68,7 +75,7 @@ module Mutant
 
     # Env result object
     class Env
-      include Coverage, Result, Anima.new(
+      include CoverageMetric, Result, Anima.new(
         :env,
         :runtime,
         :subject_results
@@ -92,6 +99,7 @@ module Mutant
       sum :amount_mutation_results, :subject_results
       sum :amount_mutations_alive,  :subject_results
       sum :amount_mutations_killed, :subject_results
+      sum :amount_timeouts,         :subject_results
       sum :killtime,                :subject_results
 
       # Amount of mutations
@@ -114,7 +122,6 @@ module Mutant
     # Test result
     class Test
       include Result, Anima.new(
-        :output,
         :passed,
         :runtime,
         :tests
@@ -128,7 +135,6 @@ module Mutant
         # @return [undefined]
         def initialize
           super(
-            output:  '',
             passed:  false,
             runtime: 0.0,
             tests:   []
@@ -139,35 +145,42 @@ module Mutant
 
     # Subject result
     class Subject
-      include Coverage, Result, Anima.new(
-        :mutation_results,
+      include CoverageMetric, Result, Anima.new(
+        :coverage_results,
         :subject,
         :tests
       )
 
-      sum :killtime, :mutation_results
-      sum :runtime,  :mutation_results
+      sum :killtime, :coverage_results
+      sum :runtime,  :coverage_results
 
       # Test if subject was processed successful
       #
       # @return [Boolean]
       def success?
-        alive_mutation_results.empty?
+        uncovered_results.empty?
       end
 
       # Alive mutations
       #
-      # @return [Array<Result::Mutation>]
-      def alive_mutation_results
-        mutation_results.reject(&:success?)
+      # @return [Array<Result::Coverage>]
+      def uncovered_results
+        coverage_results.reject(&:success?)
       end
-      memoize :alive_mutation_results
+      memoize :uncovered_results
 
       # Amount of mutations
       #
       # @return [Integer]
       def amount_mutation_results
-        mutation_results.length
+        coverage_results.length
+      end
+
+      # Amount of mutations
+      #
+      # @return [Integer]
+      def amount_timeouts
+        coverage_results.count(&:timeout?)
       end
 
       # Amount of mutations
@@ -181,25 +194,49 @@ module Mutant
       #
       # @return [Integer]
       def amount_mutations_killed
-        killed_mutation_results.length
+        covered_results.length
       end
 
       # Number of alive mutations
       #
       # @return [Integer]
       def amount_mutations_alive
-        alive_mutation_results.length
+        uncovered_results.length
       end
 
     private
 
-      def killed_mutation_results
-        mutation_results.select(&:success?)
+      def covered_results
+        coverage_results.select(&:success?)
       end
-      memoize :killed_mutation_results
+      memoize :covered_results
 
     end # Subject
 
+    # Coverage of a mutation against criteria
+    class Coverage
+      include Result, Anima.new(
+        :mutation_result,
+        :criteria_result
+      )
+
+      delegate :killtime, :mutation_result
+      delegate :runtime,  :mutation_result
+      delegate :success?, :criteria_result
+      delegate :timeout?, :mutation_result
+    end # Coverage
+
+    class CoverageCriteria
+      include Result, Anima.new(*Config::CoverageCriteria.anima.attribute_names)
+
+      # Test if one coverage criteria indicates success
+      #
+      # @return [Boolean]
+      def success?
+        process_abort || test_result || timeout
+      end
+    end
+
     # Mutation result
     class Mutation
       include Result, Anima.new(
@@ -208,25 +245,49 @@ module Mutant
         :runtime
       )
 
+      # Create mutation criteria results
+      #
+      # @praam [Result::CoverageCriteria]
+      def criteria_result(coverage_criteria)
+        CoverageCriteria.new(
+          process_abort: coverage_criteria.process_abort && process_abort?,
+          test_result:   coverage_criteria.test_result   && test_result_success?,
+          timeout:       coverage_criteria.timeout       && timeout?
+        )
+      end
+
       # Time the tests had been running
       #
       # @return [Float]
       def killtime
-        if isolation_result.success?
-          isolation_result.value.runtime
-        else
-          0.0
-        end
+        isolation_result.value&.runtime || 0.0
+      end
+
+      # Test for timeout
+      #
+      # @return [Boolean]
+      def timeout?
+        !isolation_result.timeout.nil?
+      end
+
+      # Test for unexpected process abort
+      #
+      # @return [Boolean]
+      def process_abort?
+        process_status = isolation_result.process_status or return false
+
+        !timeout? && !process_status.exited?
       end
 
+    private
+
       # Test if mutation was handled successfully
       #
       # @return [Boolean]
-      def success?
-        isolation_result.success? &&
-          mutation.class.success?(isolation_result.value)
+      def test_result_success?
+        isolation_result.valid_value? && mutation.class.success?(isolation_result.value)
       end
-      memoize :success?
+      memoize :test_result_success?
 
     end # Mutation
   end # Result