mutant 0.8.24 → 0.9.0

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

@@ -5,11 +5,15 @@ module Mutant
     class CLI
       class Printer
         # Reporter for mutation results
-        #
-        # :reek:TooManyConstants
         class IsolationResult < self
           CHILD_ERROR_MESSAGE = <<~'MESSAGE'
-            Killfork exited nonzero. Its result (if any) was ignored:
+            Killfork exited nonzero. Its result (if any) was ignored.
+            Process status:
+            %s
+          MESSAGE
+
+          LOG_MESSAGES = <<~'MESSAGE'
+            Log messages (combined stderr and stdout):
             %s
           MESSAGE
 
@@ -57,6 +61,7 @@ module Mutant
           # @return [undefined]
           def run
             __send__(MAP.fetch(object.class))
+            print_log_messages
           end
 
         private
@@ -68,6 +73,15 @@ module Mutant
             visit(TestResult, object.value)
           end
 
+          # Print log messages
+          #
+          # @return [undefined]
+          def print_log_messages
+            log = object.log
+
+            puts(LOG_MESSAGES % log) unless log.empty?
+          end
+
           # Visit child error isolation result
           #
           # @return [undefined]

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

@@ -5,8 +5,6 @@ module Mutant
     class CLI
       class Printer
         # Reporter for mutation results
-        #
-        # :reek:TooManyConstants
         class MutationResult < self
 
           delegate :mutation, :isolation_result
@@ -67,7 +65,8 @@ module Mutant
           def print_details
             __send__(MAP.fetch(mutation.class))
 
-            visit_isolation_result unless isolation_result.success?
+            puts(FOOTER)
+            visit_isolation_result
           end
 
           # Evil mutation details

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

@@ -6,16 +6,16 @@ module Mutant
       class Printer
         # Reporter for progressive output format on scheduler Status objects
         class StatusProgressive < self
-          FORMAT = '(%02d/%02d) %3d%% - killtime: %0.02fs runtime: %0.02fs overhead: %0.02fs'
+          FORMAT = 'progress: %02d/%02d alive: %d runtime: %0.02fs killtime: %0.02fs mutations/s: %0.02f'
 
           delegate(
-            :coverage,
-            :runtime,
-            :amount_mutations_killed,
-            :amount_mutations,
             :amount_mutation_results,
+            :amount_mutations,
+            :amount_mutations_alive,
+            :amount_mutations_killed,
             :killtime,
-            :overhead
+            :overhead,
+            :runtime
           )
 
           # Run printer
@@ -24,12 +24,12 @@ module Mutant
           def run
             status(
               FORMAT,
-              amount_mutations_killed,
+              amount_mutation_results,
               amount_mutations,
-              coverage * 100,
-              killtime,
+              amount_mutations_alive,
               runtime,
-              overhead
+              killtime,
+              mutations_per_second
             )
           end
 
@@ -41,6 +41,15 @@ module Mutant
           def object
             super().payload
           end
+
+          # Mutations processed per second
+          #
+          # @return [Float]
+          #
+          # @api private
+          def mutations_per_second
+            amount_mutation_results / runtime
+          end
         end # StatusProgressive
       end # Printer
     end # CLI

data/lib/mutant/repository.rb

@@ -2,9 +2,6 @@
 
 module Mutant
   module Repository
-    # Error raised on repository interaction problems
-    RepositoryError = Class.new(RuntimeError)
-
     # Subject filter based on repository diff
     class SubjectFilter
       include Adamantium, Concord.new(:diff)
@@ -19,67 +16,5 @@ module Mutant
       end
 
     end # SubjectFilter
-
-    # Diff between two objects in repository
-    class Diff
-      include Adamantium, Anima.new(:config, :from, :to)
-
-      HEAD = 'HEAD'
-
-      # Test if diff changes file at line range
-      #
-      # @param [Pathname] path
-      # @param [Range<Integer>] line_range
-      #
-      # @return [Boolean]
-      #
-      # @raise [RepositoryError]
-      #   when git command failed
-      def touches?(path, line_range)
-        return false unless within_working_directory?(path) && tracks?(path)
-
-        command = %W[
-          git log
-          #{from}...#{to}
-          --ignore-all-space
-          -L #{line_range.begin},#{line_range.end}:#{path}
-        ]
-
-        stdout, status = config.open3.capture2(*command, binmode: true)
-
-        fail RepositoryError, "Command #{command} failed!" unless status.success?
-
-        !stdout.empty?
-      end
-
-    private
-
-      # Test if path is tracked in repository
-      #
-      # FIXME: Cache results, to avoid spending time on producing redundant results.
-      #
-      # @param [Pathname] path
-      #
-      # @return [Boolean]
-      def tracks?(path)
-        command = %W[git ls-files --error-unmatch -- #{path}]
-        config.kernel.system(
-          *command,
-          out: File::NULL,
-          err: File::NULL
-        )
-      end
-
-      # Test if the path is within the current working directory
-      #
-      # @param [Pathname] path
-      #
-      # @return [TrueClass, nil]
-      def within_working_directory?(path)
-        working_directory = config.pathname.pwd
-        path.ascend { |parent| return true if working_directory.eql?(parent) }
-      end
-
-    end # Diff
   end # Repository
 end # Mutant

data/lib/mutant/repository/diff.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Mutant
+  module Repository
+    # Diff index between HEAD and a tree reference
+    class Diff
+      include Adamantium, Anima.new(:world, :to)
+
+      FORMAT = /\A:\d{6} \d{6} [a-f\d]{40} [a-f\d]{40} [ACDMRTUX]\t(.*)\n\z/.freeze
+
+      private_constant(*constants(false))
+
+      class Error < RuntimeError; end
+
+      # Test if diff changes file at line range
+      #
+      # @param [Pathname] path
+      # @param [Range<Integer>] line_range
+      #
+      # @return [Boolean]
+      #
+      # @raise [RepositoryError]
+      #   when git command failed
+      def touches?(path, line_range)
+        touched_paths
+          .fetch(path) { return false }
+          .touches?(line_range)
+      end
+
+    private
+
+      # Touched paths
+      #
+      # @return [Hash{Pathname => Path}]
+      #
+      # rubocop:disable Metrics/MethodLength
+      def touched_paths
+        pathname = world.pathname
+        work_dir = pathname.pwd
+
+        world
+          .capture_stdout(%W[git diff-index #{to}])
+          .from_right
+          .lines
+          .map do |line|
+            path = parse_line(work_dir, line)
+            [path.path, path]
+          end
+          .to_h
+      end
+      memoize :touched_paths
+
+      # Parse path
+      #
+      # @param [Pathname] work_dir
+      # @param [String] line
+      #
+      # @return [Path]
+      def parse_line(work_dir, line)
+        match = FORMAT.match(line) or fail Error, "Invalid git diff-index line: #{line}"
+
+        Path.new(
+          path:  work_dir.join(match.captures.first),
+          to:    to,
+          world: world
+        )
+      end
+
+      # Path touched by a diff
+      class Path
+        include Adamantium, Anima.new(:world, :to, :path)
+
+        DECIMAL = /(?:0|[1-9]\d*)/.freeze
+        REGEXP  = /\A@@ -(#{DECIMAL})(?:,(#{DECIMAL}))? \+(#{DECIMAL})(?:,(#{DECIMAL}))? @@/.freeze
+
+        private_constant(*constants(false))
+
+        # Test if diff path touches a line range
+        #
+        # @param [Range<Integer>] range
+        #
+        # @return [Boolean]
+        def touches?(line_range)
+          diff_ranges.any? do |range|
+            Range.overlap?(range, line_range)
+          end
+        end
+
+      private
+
+        # Ranges of hunks in the diff
+        #
+        # @return [Array<Range<Integer>>]
+        def diff_ranges
+          world
+            .capture_stdout(%W[git diff --unified=0 #{to} -- #{path}])
+            .fmap(&Ranges.method(:parse))
+            .from_right
+        end
+        memoize :diff_ranges
+      end # Path
+    end # Diff
+  end # Repository
+end # Mutant

data/lib/mutant/repository/diff/ranges.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Mutant
+  module Repository
+    class Diff
+      module Ranges
+        DECIMAL = /(?:0|[1-9]\d*)/.freeze
+        REGEXP  = /\A@@ -(#{DECIMAL})(?:,(#{DECIMAL}))? \+(#{DECIMAL})(?:,(#{DECIMAL}))? @@/.freeze
+
+        private_constant(*constants(false))
+
+        # Parse a unified diff into ranges
+        #
+        # @param [String]
+        #
+        # @return [Set<Range<Integer>>]
+        def self.parse(diff)
+          diff.lines.flat_map(&method(:parse_ranges)).to_set
+        end
+
+        # Parse ranges from line
+        #
+        # @param [String] line
+        #
+        # @return [Array<Range<Integer>>]
+        def self.parse_ranges(line)
+          match = REGEXP.match(line) or return EMPTY_ARRAY
+
+          match
+            .captures
+            .each_slice(2)
+            .map { |start, offset| mk_range(start, offset) }
+            .reject { |range| range.end < range.begin }
+        end
+        private_class_method :parse_ranges
+
+        # Construct a range from start point and offset
+        #
+        # @param [String] start
+        # @param [String, nil] offset
+        #
+        # @return [Range<Integer>]
+        def self.mk_range(start, offset)
+          start = Integer(start)
+
+          ::Range.new(start, start + (offset ? Integer(offset).pred : 0))
+        end
+        private_class_method :mk_range
+      end # Ranges
+    end # Diff
+  end # Repository
+end # Ranges

data/lib/mutant/result.rb

@@ -101,13 +101,6 @@ module Mutant
         env.mutations.length
       end
 
-      # Amount of subjects
-      #
-      # @return [Integer]
-      def amount_subjects
-        env.subjects.length
-      end
-
       # Test if processing needs to stop
       #
       # @return [Boolean]
@@ -126,6 +119,22 @@ module Mutant
         :runtime,
         :tests
       )
+
+      class VoidValue < self
+        include Singleton
+
+        # Initialize object
+        #
+        # @return [undefined]
+        def initialize
+          super(
+            output:  '',
+            passed:  false,
+            runtime: 0.0,
+            tests:   []
+          )
+        end
+      end # VoidValue
     end # Test
 
     # Subject result

data/lib/mutant/runner.rb

@@ -1,84 +1,75 @@
 # frozen_string_literal: true
 
 module Mutant
-  # Runner baseclass
-  class Runner
-    include Adamantium::Flat, Concord.new(:env), Procto.call(:result)
-
-    # Initialize object
+  # Runner
+  module Runner
+    # Run against env
     #
-    # @return [undefined]
-    def initialize(*)
-      super
+    # @return [Either<String, Result>]
+    def self.apply(env)
+      reporter(env).start(env)
 
-      reporter.start(env)
-
-      run_mutation_analysis
+      Either::Right.new(run_mutation_analysis(env))
     end
 
-    # Final result
-    #
-    # @return [Result::Env]
-    attr_reader :result
-
-  private
-
     # Run mutation analysis
     #
     # @return [undefined]
-    def run_mutation_analysis
-      @result = run_driver(Parallel.async(mutation_test_config))
-      reporter.report(result)
+    def self.run_mutation_analysis(env)
+      reporter = reporter(env)
+
+      run_driver(
+        reporter,
+        Parallel.async(mutation_test_config(env))
+      ).tap do |result|
+        reporter.report(result)
+      end
     end
+    private_class_method :run_mutation_analysis
 
     # Run driver
     #
+    # @param [Reporter] reporter
     # @param [Driver] driver
     #
     # @return [Object]
     #   the last returned status payload
-    def run_driver(driver)
-      status = nil
-      sleep  = env.config.kernel.method(:sleep)
-
+    def self.run_driver(reporter, driver)
       loop do
-        status = driver.status
+        status = driver.wait_timeout(reporter.delay)
+        break status.payload if status.done?
         reporter.progress(status)
-        break if status.done
-        sleep.call(reporter.delay)
       end
-
-      driver.stop
-
-      status.payload
     end
+    private_class_method :run_driver
 
     # Configuration for parallel execution engine
     #
-    # @return [Parallel::Config]
-    def mutation_test_config
+    # @return [Parallell::Config]
+    def self.mutation_test_config(env)
+      world = env.world
+
       Parallel::Config.new(
-        env:       env.actor_env,
-        jobs:      config.jobs,
-        processor: env.method(:kill),
-        sink:      Sink.new(env),
-        source:    Parallel::Source::Array.new(env.mutations)
+        condition_variable: world.condition_variable,
+        jobs:               env.config.jobs,
+        mutex:              world.mutex,
+        processor:          env.method(:kill),
+        sink:               Sink.new(env),
+        source:             Parallel::Source::Array.new(env.mutations),
+        thread:             world.thread
       )
     end
+    private_class_method :mutation_test_config
 
     # Reporter to use
     #
+    # @param [Env] env
+    #
     # @return [Reporter]
-    def reporter
+    def self.reporter(env)
       env.config.reporter
     end
-
-    # Config for this mutant execution
-    #
-    # @return [Config]
-    def config
-      env.config
-    end
+    private_class_method :reporter
 
   end # Runner
 end # Mutant