Change incremental detection to support worktree

* This allows incremental to be triggered also from dirty worktrees.
* In addition its more efficient as we do not shell out to git as often
  anymore. While still leaving open room for improvement.

[Fix #461]

Author: mbj

lib/mutant/cli.rb

@@ -2,8 +2,6 @@
 
 module Mutant
   # Commandline parser / runner
-  #
-  # rubocop:disable Metrics/ClassLength
   class CLI
     include Concord.new(:world, :config)
 
@@ -149,11 +147,7 @@ def add_filter_options(opts)
         add_matcher(
           :subject_filters,
           Repository::SubjectFilter.new(
-            Repository::Diff.new(
-              from:  Repository::Diff::HEAD,
-              to:    revision,
-              world: world
-            )
+            Repository::Diff.new(to: revision, world: world)
           )
         )
       end
@@ -213,5 +207,4 @@ def add_matcher(attribute, value)
       with(matcher: config.matcher.add(attribute, value))
     end
   end # CLI
-  # rubocop:enable Metrics/ClassLength
 end # Mutant

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)

lib/mutant/repository/diff.rb

@@ -2,11 +2,15 @@
 
 module Mutant
   module Repository
-    # Diff between two objects in repository
+    # Diff index between HEAD and a tree reference
     class Diff
-      include Adamantium, Anima.new(:world, :from, :to)
+      include Adamantium, Anima.new(:world, :to)
 
-      HEAD = 'HEAD'
+      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
       #
@@ -18,50 +22,83 @@ class Diff
       # @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 = world.open3.capture2(*command, binmode: true)
-
-        fail RepositoryError, "Command #{command} failed!" unless status.success?
-
-        !stdout.empty?
+        touched_paths
+          .fetch(path) { return false }
+          .touches?(line_range)
       end
 
     private
 
-      # Test if path is tracked in repository
-      #
-      # FIXME: Cache results, to avoid spending time on producing redundant results.
+      # Touched paths
       #
-      # @param [Pathname] path
+      # @return [Hash{Pathname => Path}]
       #
-      # @return [Boolean]
-      def tracks?(path)
-        command = %W[git ls-files --error-unmatch -- #{path}]
-        world.kernel.system(
-          *command,
-          out: File::NULL,
-          err: File::NULL
-        )
+      # 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
 
-      # Test if the path is within the current working directory
+      # Parse path
       #
-      # @param [Pathname] path
+      # @param [Pathname] work_dir
+      # @param [String] line
       #
-      # @return [TrueClass, nil]
-      def within_working_directory?(path)
-        working_directory = world.pathname.pwd
-        path.ascend { |parent| return true if working_directory.eql?(parent) }
+      # @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

spec/unit/mutant/cli_spec.rb

@@ -250,7 +250,6 @@ def apply
           subject_filters: [
             Mutant::Repository::SubjectFilter.new(
               Mutant::Repository::Diff.new(
-                from:  'HEAD',
                 to:    'master',
                 world: world
               )

spec/unit/mutant/repository/diff_spec.rb

@@ -2,106 +2,119 @@
 
 describe Mutant::Repository::Diff do
   describe '#touches?' do
-    let(:object) do
-      described_class.new(
-        world: world,
-        from:  'from_rev',
-        to:    'to_rev'
-      )
+    def apply
+      subject.touches?(path, line_range)
     end
 
+    subject { described_class.new(world: world, to: 'to_rev') }
+
+    let(:pathname)   { class_double(Pathname, pwd: pwd) }
+    let(:open3)      { class_double(Open3)              }
+    let(:kernel)     { class_double(Kernel)             }
+    let(:pwd)        { Pathname.new('/foo')             }
+    let(:path)       { Pathname.new('/foo/bar.rb')      }
+    let(:line_range) { 4..5                             }
+
     let(:world) do
       instance_double(
         Mutant::World,
         kernel:   kernel,
-        open3:    open3,
         pathname: pathname
       )
     end
 
-    let(:pathname)   { class_double(Pathname, pwd: pwd) }
-    let(:open3)      { class_double(Open3)              }
-    let(:kernel)     { class_double(Kernel)             }
-    let(:pwd)        { Pathname.new('/foo')             }
-    let(:path)       { Pathname.new('/foo/bar.rb')      }
-    let(:line_range) { 1..2                             }
-
-    subject { object.touches?(path, line_range) }
-
-    shared_context 'test if git tracks the file' do
-      before do
-        # rubocop:disable Lint/UnneededSplatExpansion
-        expect(world.kernel).to receive(:system)
-          .ordered
-          .with(
-            *%W[git ls-files --error-unmatch -- #{path}],
-            out: File::NULL,
-            err: File::NULL
-          ).and_return(git_ls_success?)
-      end
+    let(:allowed_paths) do
+      %w[bar.rb baz.rb].map do |path|
+        [path, Pathname.new(path)]
+      end.to_h
     end
 
-    context 'when file is in a different subdirectory' do
-      let(:path) { Pathname.new('/baz/bar.rb') }
-
-      before do
-        expect(world.kernel).to_not receive(:system)
-      end
-
-      it { should be(false) }
+    let(:file_diff_expectations) { [] }
+
+    let(:raw_expectations) do
+      [
+        {
+          receiver:  world,
+          selector:  :capture_stdout,
+          arguments: [%w[git diff-index to_rev]],
+          reaction:  { return: Mutant::Either::Right.new(index_stdout) }
+        },
+        *file_diff_expectations
+      ]
     end
 
-    context 'when file is NOT tracked in repository' do
-      let(:git_ls_success?) { false }
+    before do
+      allow(pathname).to receive(:new, &allowed_paths.method(:fetch))
+    end
 
-      include_context 'test if git tracks the file'
+    context 'when file is not touched in the diff' do
+      let(:index_stdout) { '' }
 
-      it { should be(false) }
+      it 'returns false' do
+        verify_events { expect(apply).to be(false) }
+      end
     end
 
-    context 'when file is tracked in repository' do
-      let(:git_ls_success?) { true                                                 }
-      let(:status)          { instance_double(Process::Status, success?: success?) }
-      let(:stdout)          { instance_double(String, empty?: stdout_empty?)       }
-      let(:stdout_empty?)   { false                                                }
+    context 'when a diff-index line is invalid' do
+      let(:index_stdout) { 'invalid-line' }
 
-      include_context 'test if git tracks the file'
+      it 'raises error' do
+        expect { verify_events { apply } }
+          .to raise_error(
+            described_class::Error,
+            'Invalid git diff-index line: invalid-line'
+          )
+      end
+    end
 
-      before do
-        expect(world.open3).to receive(:capture2)
-          .ordered
-          .with(*expected_git_log_command, binmode: true)
-          .and_return([stdout, status])
+    context 'when file is touched in the diff' do
+      let(:index_stdout) do
+        <<~STR
+          :000000 000000 0000000000000000000000000000000000000000 0000000000000000000000000000000000000000 M\tbar.rb
+          :000000 000000 0000000000000000000000000000000000000000 0000000000000000000000000000000000000000 M\tbaz.rb
+        STR
       end
 
-      let(:expected_git_log_command) do
-        %W[git log from_rev...to_rev --ignore-all-space -L 1,2:#{path}]
+      let(:file_diff_expectations) do
+        [
+          {
+            receiver:  world,
+            selector:  :capture_stdout,
+            arguments: [%w[git diff --unified=0 to_rev -- /foo/bar.rb]],
+            reaction:  { return: Mutant::Either::Right.new(diff_stdout) }
+          }
+        ]
       end
 
-      context 'on failure of git log command' do
-        let(:success?) { false }
+      context 'and diff touches the line range' do
+        let(:diff_stdout) do
+          <<~'DIFF'
+            --- bar.rb
+            +++ bar.rb
+            @@ -4 +4 @@ header
+            -a
+            +b
+          DIFF
+        end
 
-        it 'raises error' do
-          expect { subject }.to raise_error(
-            Mutant::Repository::RepositoryError,
-            "Command #{expected_git_log_command} failed!"
-          )
+        it 'returns true' do
+          verify_events { expect(apply).to be(true) }
         end
       end
 
-      context 'on suuccess of git command' do
-        let(:success?) { true }
-
-        context 'on empty stdout' do
-          let(:stdout_empty?) { true }
-
-          it { should be(false) }
+      context 'and diff does not touch the line range' do
+        let(:diff_stdout) do
+          <<~'DIFF'
+            --- bar.rb
+            +++ bar.rb
+            @@ -3 +3 @@ header
+            -a
+            +b
+          DIFF
         end
 
-        context 'on non empty stdout' do
-          let(:stdout_empty?) { false }
-
-          it { should be(true) }
+        it 'returns false' do
+          verify_events { expect(apply).to be(false) }
         end
       end
     end