git-fastclone 1.2.7 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22f5537cbc1297198ea1aa106a305ef5ad9526dc24fc9a39048c6889e6d441b4
-  data.tar.gz: 0f1f38ba2756185c3c02b7a5ec3cf40c01e4498e743388f41991ca1d817793de
+  metadata.gz: d83fead53c699b625667b994e06ab9cfe0c25ed62c01239c054ec1523109f986
+  data.tar.gz: 9e4513fe51d1e1deb357a1781fadd1df723997df527402c12beb436103ce7b2a
 SHA512:
-  metadata.gz: 22634dabfc0c4d91682dc7db8d9e18e6cdc4a6d6db079a66c5e498ccc6ed70c8bcb7ccd24657b91e5142d0fe8be0f34169223d1d70cb1262ed3c6d88e3ec0e83
-  data.tar.gz: 8dd73fac0eb7eec9b8e8ead616a48549860722982b756b950ad020cd295da4dffeaf4b89b7dad3c88f2dc4b82119a40172a499441924bbcf2885e280313850eb
+  metadata.gz: ecc286e3180698eab52e06e61d3bf62c27af6524a3ab398d86cf1bbbe336dd9c547609ec6744264be506ea9f41920cf68210b08d6fad752f5d8fc589b069e2be
+  data.tar.gz: 653a21b17f4a033ee23bd77f1953a72df9176006ebb320a33ed179e4f7f2a957133a4569f1d91722c65d2d638ee727eae15d41b6b73f5b133d138823365e6937

data/README.md

@@ -44,8 +44,10 @@ Usage
     git fastclone [options] <git-repo-url>
 
     -b, --branch <branch>   Clone a specific branch
-    -v, --verbose           Shows more info
-    -c, --color             Pretty colors!
+    -v, --verbose           Verbose mode
+    -c, --color             Display colored output
+        --config CONFIG     Git config applied to the cloned repo
+        --lock-timeout N    Timeout in seconds to acquire a lock on any reference repo.
 
 Change the default `REFERENCE_REPO_DIR` environment variable if necessary.
 

data/bin/git-fastclone

@@ -15,7 +15,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '/../lib'))
+$LOAD_PATH.unshift(File.expand_path("#{File.dirname(__FILE__)}/../lib"))
 
 require 'git-fastclone'
 

data/lib/git-fastclone/version.rb

@@ -2,5 +2,5 @@
 
 # Version string for git-fastclone
 module GitFastCloneVersion
-  VERSION = '1.2.7'.freeze
+  VERSION = '1.3.1'
 end

data/lib/git-fastclone.rb

@@ -41,7 +41,7 @@ module GitFastClone
 
     def reference_repo_dir(url, reference_dir, using_local_repo)
       if using_local_repo
-        File.join(reference_dir, 'local' + reference_repo_name(url))
+        File.join(reference_dir, "local#{reference_repo_name(url)}")
       else
         File.join(reference_dir, reference_repo_name(url))
       end
@@ -69,9 +69,9 @@ module GitFastClone
 
     include GitFastClone::UrlHelper
 
-    DEFAULT_REFERENCE_REPO_DIR = '/var/tmp/git-fastclone/reference'.freeze
+    DEFAULT_REFERENCE_REPO_DIR = '/var/tmp/git-fastclone/reference'
 
-    DEFAULT_GIT_ALLOW_PROTOCOL = 'file:git:http:https:ssh'.freeze
+    DEFAULT_GIT_ALLOW_PROTOCOL = 'file:git:http:https:ssh'
 
     attr_accessor :reference_dir, :prefetch_submodules, :reference_updated, :reference_mutex,
                   :options, :logger, :abs_clone_path, :using_local_repo, :verbose, :color,
@@ -121,7 +121,7 @@ module GitFastClone
       puts "Cloning #{path_from_git_url(url)} to #{File.join(abs_clone_path, path)}"
       Terrapin::CommandLine.environment['GIT_ALLOW_PROTOCOL'] =
         ENV['GIT_ALLOW_PROTOCOL'] || DEFAULT_GIT_ALLOW_PROTOCOL
-      clone(url, options[:branch], path)
+      clone(url, options[:branch], path, options[:config])
     end
 
     def parse_options
@@ -137,7 +137,7 @@ module GitFastClone
 
         opts.on('-v', '--verbose', 'Verbose mode') do
           self.verbose = true
-          self.logger = Logger.new(STDOUT)
+          self.logger = Logger.new($stdout)
           logger.formatter = proc do |_severity, _datetime, _progname, msg|
             "#{msg}\n"
           end
@@ -148,6 +148,10 @@ module GitFastClone
           self.color = true
         end
 
+        opts.on('--config CONFIG', 'Git config applied to the cloned repo') do |config|
+          options[:config] = config
+        end
+
         opts.on('--lock-timeout N', 'Timeout in seconds to acquire a lock on any reference repo.
                 Default is 0 which waits indefinitely.') do |timeout_secs|
           self.flock_timeout_secs = timeout_secs
@@ -159,7 +163,7 @@ module GitFastClone
       parse_options
 
       unless ARGV[0]
-        STDERR.puts usage
+        warn usage
         exit(129)
       end
 
@@ -185,16 +189,41 @@ module GitFastClone
       [url, path, options]
     end
 
+    def clear_clone_dest_if_needed(attempt_number, clone_dest)
+      return unless attempt_number.positive?
+
+      dest_with_dotfiles = Dir.glob("#{clone_dest}/*", File::FNM_DOTMATCH)
+      dest_files = dest_with_dotfiles.reject { |f| %w[. ..].include?(File.basename(f)) }
+      return if dest_files.empty?
+
+      clear_clone_dest(dest_files)
+    end
+
+    def clear_clone_dest(dest_files)
+      puts 'Non-empty clone directory found, clearing its content now.'
+      FileUtils.rm_rf(dest_files)
+    end
+
     # Checkout to SOURCE_DIR. Update all submodules recursively. Use reference
     # repos everywhere for speed.
-    def clone(url, rev, src_dir)
+    def clone(url, rev, src_dir, config)
+      clone_dest = File.join(abs_clone_path, src_dir).to_s
       initial_time = Time.now
 
-      with_git_mirror(url) do |mirror|
-        Terrapin::CommandLine.new('git clone', '--quiet --reference :mirror :url :path')
+      if Dir.exist?(clone_dest) && !Dir.empty?(clone_dest)
+        raise "Can't clone into an existing non-empty path: #{clone_dest}"
+      end
+
+      with_git_mirror(url) do |mirror, attempt_number|
+        clear_clone_dest_if_needed(attempt_number, clone_dest)
+
+        clone_command = '--quiet --reference :mirror :url :path'
+        clone_command += ' --config :config' unless config.nil?
+        Terrapin::CommandLine.new('git clone', clone_command)
                              .run(mirror: mirror.to_s,
                                   url: url.to_s,
-                                  path: File.join(abs_clone_path, src_dir).to_s)
+                                  path: clone_dest,
+                                  config: config.to_s)
       end
 
       # Only checkout if we're changing branches to a non-default branch
@@ -238,7 +267,7 @@ module GitFastClone
 
     def thread_update_submodule(submodule_url, submodule_path, threads, pwd)
       threads << Thread.new do
-        with_git_mirror(submodule_url) do |mirror|
+        with_git_mirror(submodule_url) do |mirror, _|
           Terrapin::CommandLine.new('cd', ':dir; git submodule update --quiet --reference :mirror :path')
                                .run(dir: File.join(abs_clone_path, pwd).to_s,
                                     mirror: mirror.to_s,
@@ -263,14 +292,12 @@ module GitFastClone
       lockfile.close
     end
 
-    def with_reference_repo_thread_lock(url)
+    def with_reference_repo_thread_lock(url, &block)
       # We also need thread level locking because pre-fetch means multiple threads can
       # attempt to update the same repository from a single git-fastclone process
       # file locks in posix are tracked per process, not per userland thread.
       # This gives us the equivalent of pthread_mutex around these accesses.
-      reference_mutex[reference_repo_name(url)].synchronize do
-        yield
-      end
+      reference_mutex[reference_repo_name(url)].synchronize(&block)
     end
 
     def update_submodule_reference(url, submodule_url_list)
@@ -331,6 +358,31 @@ module GitFastClone
       raise e if fail_hard
     end
 
+    def retriable_error?(error)
+      error_strings = [
+        'fatal: missing blob object',
+        'fatal: remote did not send all necessary objects',
+        /fatal: packed object [a-z0-9]+ \(stored in .*?\) is corrupt/,
+        /fatal: pack has \d+ unresolved delta/,
+        'error: unable to read sha1 file of ',
+        'fatal: did not receive expected object',
+        /^fatal: unable to read tree [a-z0-9]+\n^warning: Clone succeeded, but checkout failed/
+      ]
+      error.to_s =~ /^STDERR:\n.*^#{Regexp.union(error_strings)}/m
+    end
+
+    def print_formatted_error(error)
+      indented_error = error.to_s.split("\n").map { |s| ">  #{s}\n" }.join
+      puts "Encountered a retriable error:\n#{indented_error}\n\nRemoving the fastclone cache."
+    end
+
+    # To avoid corruption of the cache, if we failed to update or check out we remove
+    # the cache directory entirely. This may cause the current clone to fail, but if the
+    # underlying error from git is transient it will not affect future clones.
+    def clear_cache(dir)
+      FileUtils.remove_entry_secure(dir, force: true)
+    end
+
     # This command will create and bring the mirror up-to-date on-demand,
     # blocking any code passed in while the mirror is brought up-to-date
     #
@@ -347,27 +399,18 @@ module GitFastClone
       # This makes sure we have control and unlock when the block returns:
       with_reference_repo_lock(url) do
         dir = reference_repo_dir(url, reference_dir, using_local_repo)
-        retries_left = 1
+        retries_allowed = 1
+        attempt_number = 0
 
         begin
-          yield dir
+          yield dir, attempt_number
         rescue Terrapin::ExitStatusError => e
-          error_strings = [
-            'fatal: missing blob object',
-            'fatal: remote did not send all necessary objects',
-            /fatal: packed object [a-z0-9]+ \(stored in .*?\) is corrupt/,
-            /fatal: pack has \d+ unresolved delta/,
-            'error: unable to read sha1 file of ',
-            'fatal: did not receive expected object',
-            /^fatal: unable to read tree [a-z0-9]+\n^warning: Clone succeeded, but checkout failed/
-          ]
-          if e.to_s =~ /^STDERR:\n.+^#{Regexp.union(error_strings)}/m
-            # To avoid corruption of the cache, if we failed to update or check out we remove
-            # the cache directory entirely. This may cause the current clone to fail, but if the
-            # underlying error from git is transient it will not affect future clones.
-            FileUtils.remove_entry_secure(dir, force: true)
-            if retries_left > 0
-              retries_left -= 1
+          if retriable_error?(e)
+            print_formatted_error(e)
+            clear_cache(dir)
+
+            if attempt_number < retries_allowed
+              attempt_number += 1
               retry
             end
           end

data/spec/git_fastclone_runner_spec.rb

@@ -56,11 +56,22 @@ describe GitFastClone::Runner do
     let(:options) { { branch: placeholder_arg } }
 
     it 'should run with the correct args' do
-      allow(subject).to receive(:parse_inputs) { [placeholder_arg, placeholder_arg, options] }
-      expect(subject).to receive(:clone).with(placeholder_arg, placeholder_arg, placeholder_arg)
+      allow(subject).to receive(:parse_inputs) { [placeholder_arg, placeholder_arg, options, nil] }
+      expect(subject).to receive(:clone).with(placeholder_arg, placeholder_arg, placeholder_arg, nil)
 
       subject.run
     end
+
+    describe 'with custom configs' do
+      let(:options) { { branch: placeholder_arg, config: 'conf' } }
+
+      it 'should clone correctly' do
+        allow(subject).to receive(:parse_inputs) { [placeholder_arg, placeholder_arg, options, 'conf'] }
+        expect(subject).to receive(:clone).with(placeholder_arg, placeholder_arg, placeholder_arg, 'conf')
+
+        subject.run
+      end
+    end
   end
 
   describe '.parse_inputs' do
@@ -74,17 +85,69 @@ describe GitFastClone::Runner do
   end
 
   describe '.clone' do
-    it 'should clone correctly' do
-      terrapin_commandline_double = double('new_terrapin_commandline')
-      allow(subject).to receive(:with_git_mirror) {}
+    let(:terrapin_commandline_double) { double('new_terrapin_commandline') }
+    before(:each) do
       allow(terrapin_commandline_double).to receive(:run) {}
-      allow(Terrapin::CommandLine).to receive(:new) { terrapin_commandline_double }
-
       expect(Time).to receive(:now).twice { 0 }
-      expect(Terrapin::CommandLine).to receive(:new)
-      expect(terrapin_commandline_double).to receive(:run)
+      allow(Dir).to receive(:pwd) { '/pwd' }
+      allow(Dir).to receive(:chdir).and_yield
+      allow(subject).to receive(:with_git_mirror).and_yield('/cache', 0)
+      expect(subject).to receive(:clear_clone_dest_if_needed).once {}
+    end
+
+    it 'should clone correctly' do
+      expect(Terrapin::CommandLine).to receive(:new).with(
+        'git clone',
+        '--quiet --reference :mirror :url :path'
+      ) { terrapin_commandline_double }
+      expect(Terrapin::CommandLine).to receive(:new).with(
+        'git checkout',
+        '--quiet :rev'
+      ) { terrapin_commandline_double }
+      expect(terrapin_commandline_double).to receive(:run).with(
+        mirror: '/cache',
+        url: placeholder_arg,
+        path: '/pwd/.',
+        config: ''
+      )
+      expect(terrapin_commandline_double).to receive(:run).with(rev: placeholder_arg)
+
+      subject.clone(placeholder_arg, placeholder_arg, '.', nil)
+    end
+
+    it 'should clone correctly with custom configs' do
+      expect(Terrapin::CommandLine).to receive(:new).with(
+        'git clone',
+        '--quiet --reference :mirror :url :path --config :config'
+      ) { terrapin_commandline_double }
+      expect(terrapin_commandline_double).to receive(:run).with(
+        mirror: '/cache',
+        url: placeholder_arg,
+        path: '/pwd/.',
+        config: 'config'
+      )
+
+      subject.clone(placeholder_arg, nil, '.', 'config')
+    end
+  end
+
+  describe '.clear_clone_dest_if_needed' do
+    it 'does not clear on first attempt' do
+      expect(Dir).not_to receive(:glob)
+      expect(subject).not_to receive(:clear_clone_dest)
+      subject.clear_clone_dest_if_needed(0, '/some/path')
+    end
+
+    it 'does not clear if the directory is only FNM_DOTMATCH self and parent refs' do
+      expect(Dir).to receive(:glob).and_return(%w[. ..])
+      expect(subject).not_to receive(:clear_clone_dest)
+      subject.clear_clone_dest_if_needed(1, '/some/path')
+    end
 
-      subject.clone(placeholder_arg, placeholder_arg, '.')
+    it 'does clear if the directory is not empty' do
+      expect(Dir).to receive(:glob).and_return(%w[. .. /some/path/file.txt])
+      expect(subject).to receive(:clear_clone_dest) {}
+      subject.clear_clone_dest_if_needed(1, '/some/path')
     end
   end
 
@@ -268,209 +331,154 @@ describe GitFastClone::Runner do
   end
 
   describe '.with_git_mirror' do
-    it 'should yield properly' do
+    before(:each) do
       allow(subject).to receive(:update_reference_repo) {}
-      expect(subject).to receive(:reference_repo_dir)
+      allow(subject).to receive(:print_formatted_error) {}
+      expect(subject).to receive(:reference_repo_dir).and_return(test_reference_repo_dir)
       expect(subject).to receive(:reference_repo_lock_file).and_return(lockfile)
+    end
 
-      subject.with_git_mirror(test_url_valid) do
-        yielded << test_url_valid
-      end
+    def retriable_error
+      %(
+        STDOUT:
 
-      expect(yielded).to eq([test_url_valid])
+        STDERR:
+
+        fatal: bad object ee35b1e14e7c3a53dcc14d82606e5b872f6a05a7
+        fatal: remote did not send all necessary objects
+      ).strip.split("\n").map(&:strip).join("\n")
     end
 
-    it 'should retry when the cache looks corrupted' do
-      allow(subject).to receive(:update_reference_repo) {}
-      expect(subject).to receive(:reference_repo_dir)
-      expect(subject).to receive(:reference_repo_lock_file).and_return(lockfile)
+    def try_with_git_mirror(responses, results)
+      lambdas = responses.map do |response|
+        if response == true
+          # Simulate successful response
+          ->(url) { url }
+        else
+          # Simulate failed error response
+          ->(_url) { raise Terrapin::ExitStatusError, response }
+        end
+      end
 
-      responses = [
-        lambda { |_url|
-          raise Terrapin::ExitStatusError, <<-ERROR.gsub(/^ {12}/, '')
-            STDOUT:
-
-            STDERR:
-
-            fatal: bad object ee35b1e14e7c3a53dcc14d82606e5b872f6a05a7
-            fatal: remote did not send all necessary objects
-          ERROR
-        },
-        ->(url) { url }
-      ]
-      subject.with_git_mirror(test_url_valid) do
-        yielded << responses.shift.call(test_url_valid)
+      subject.with_git_mirror(test_url_valid) do |url, attempt|
+        raise 'Not enough responses were provided!' if lambdas.empty?
+
+        yielded << [lambdas.shift.call(url), attempt]
       end
 
-      expect(responses).to be_empty
-      expect(yielded).to eq([test_url_valid])
+      expect(lambdas).to be_empty
+      expect(yielded).to eq(results)
     end
 
-    it 'should retry when the clone succeeds but checkout fails with corrupt packed object' do
-      allow(subject).to receive(:update_reference_repo) {}
-      expect(subject).to receive(:reference_repo_dir)
-      expect(subject).to receive(:reference_repo_lock_file).and_return(lockfile)
-
-      responses = [
-        lambda { |_url|
-          raise Terrapin::ExitStatusError, <<-ERROR.gsub(/^ {12}/, '')
-            STDOUT:
-
-            STDERR:
-
-            fatal: packed object 7c4d79704f8adf701f38a7bfb3e33ec5342542f1 (stored in /private/var/tmp/git-fastclone/reference/some-repo.git/objects/pack/pack-d37d7ed3e88d6e5f0ac141a7b0a2b32baf6e21a0.pack) is corrupt
-            warning: Clone succeeded, but checkout failed.
-            You can inspect what was checked out with 'git status' and retry with 'git restore --source=HEAD :/'
-          ERROR
-        },
-        ->(url) { url }
-      ]
-      subject.with_git_mirror(test_url_valid) do
-        yielded << responses.shift.call(test_url_valid)
-      end
+    it 'should yield properly' do
+      expect(subject).not_to receive(:clear_cache)
+      try_with_git_mirror([true], [[test_reference_repo_dir, 0]])
+    end
 
-      expect(responses).to be_empty
-      expect(yielded).to eq([test_url_valid])
+    it 'should retry once for retriable errors' do
+      expect(subject).to receive(:clear_cache).once {}
+      try_with_git_mirror([retriable_error, true], [[test_reference_repo_dir, 1]])
     end
 
-    it 'should retry when the clone succeeds but checkout fails with unable to read tree' do
-      allow(subject).to receive(:update_reference_repo) {}
-      expect(subject).to receive(:reference_repo_dir)
-      expect(subject).to receive(:reference_repo_lock_file).and_return(lockfile)
+    it 'should only retry twice at most' do
+      expect(subject).to receive(:clear_cache).twice {}
+      expect do
+        try_with_git_mirror([retriable_error, retriable_error], [])
+      end.to raise_error(Terrapin::ExitStatusError)
+    end
 
-      responses = [
-        lambda { |_url|
-          raise Terrapin::ExitStatusError, <<-ERROR.gsub(/^ {12}/, '')
-            STDOUT:
-
-            STDERR:
-
-            error: Could not read 92cf57b8f07df010ab5f607b109c325e30e46235
-            fatal: unable to read tree 0c32c0521d3b0bfb4e74e4a39b97a84d1a3bb9a1
-            warning: Clone succeeded, but checkout failed.
-            You can inspect what was checked out with 'git status'
-            and retry with 'git restore --source=HEAD :/'
-          ERROR
-        },
-        ->(url) { url }
-      ]
-      subject.with_git_mirror(test_url_valid) do
-        yielded << responses.shift.call(test_url_valid)
-      end
+    it 'should not retry for non-retriable errors' do
+      expect(subject).not_to receive(:clear_cache)
+      expect do
+        try_with_git_mirror(['Some unexpected error message'], [])
+      end.to raise_error(Terrapin::ExitStatusError)
+    end
+  end
 
-      expect(responses).to be_empty
-      expect(yielded).to eq([test_url_valid])
+  describe '.retriable_error?' do
+    def format_error(error)
+      error_wrapper = "STDOUT:\n\nSTDERR:\n#{error}"
+      error_wrapper.strip.lines.map(&:strip).join("\n")
     end
 
-    it 'should retry when one delta is missing' do
-      allow(subject).to receive(:update_reference_repo) {}
-      expect(subject).to receive(:reference_repo_dir)
-      expect(subject).to receive(:reference_repo_lock_file).and_return(lockfile)
+    it 'not for a random error message' do
+      error = format_error 'random error message'
 
-      responses = [
-        lambda { |_url|
-          raise Terrapin::ExitStatusError, <<-ERROR.gsub(/^ {12}/, '')
-            STDOUT:
-
-            STDERR:
-
-            error: Could not read f7fad86d06fee0678f9af7203b6031feabb40c3e
-            fatal: pack has 1 unresolved delta
-            fatal: index-pack failed
-          ERROR
-        },
-        ->(url) { url }
-      ]
-      subject.with_git_mirror(test_url_valid) do
-        yielded << responses.shift.call(test_url_valid)
-      end
+      expect(subject.retriable_error?(error)).to be_falsey
+    end
 
-      expect(responses).to be_empty
-      expect(yielded).to eq([test_url_valid])
+    it 'when the cache looks corrupted' do
+      error = format_error <<-ERROR
+        fatal: bad object ee35b1e14e7c3a53dcc14d82606e5b872f6a05a7
+        fatal: remote did not send all necessary objects
+      ERROR
+
+      expect(subject.retriable_error?(error)).to be_truthy
     end
 
-    it 'should retry when deltas are missing' do
-      allow(subject).to receive(:update_reference_repo) {}
-      expect(subject).to receive(:reference_repo_dir)
-      expect(subject).to receive(:reference_repo_lock_file).and_return(lockfile)
+    it 'when the clone succeeds but checkout fails with corrupt packed object' do
+      error = format_error <<-ERROR
+        fatal: packed object 7c4d79704f8adf701f38a7bfb3e33ec5342542f1 (stored in /private/var/tmp/git-fastclone/reference/some-repo.git/objects/pack/pack-d37d7ed3e88d6e5f0ac141a7b0a2b32baf6e21a0.pack) is corrupt
+        warning: Clone succeeded, but checkout failed.
+        You can inspect what was checked out with 'git status' and retry with 'git restore --source=HEAD :/'
+      ERROR
 
-      responses = [
-        lambda { |_url|
-          raise Terrapin::ExitStatusError, <<-ERROR.gsub(/^ {12}/, '')
-            STDOUT:
-
-            STDERR:
-
-            error: Could not read f7fad86d06fee0678f9af7203b6031feabb40c3e
-            fatal: pack has 138063 unresolved deltas
-            fatal: index-pack failed
-          ERROR
-        },
-        ->(url) { url }
-      ]
-      subject.with_git_mirror(test_url_valid) do
-        yielded << responses.shift.call(test_url_valid)
-      end
+      expect(subject.retriable_error?(error)).to be_truthy
+    end
 
-      expect(responses).to be_empty
-      expect(yielded).to eq([test_url_valid])
+    it 'when the clone succeeds but checkout fails with unable to read tree' do
+      error = format_error <<-ERROR
+        error: Could not read 92cf57b8f07df010ab5f607b109c325e30e46235
+        fatal: unable to read tree 0c32c0521d3b0bfb4e74e4a39b97a84d1a3bb9a1
+        warning: Clone succeeded, but checkout failed.
+        You can inspect what was checked out with 'git status'
+        and retry with 'git restore --source=HEAD :/'
+      ERROR
+
+      expect(subject.retriable_error?(error)).to be_truthy
     end
-  end
 
-  it 'should retry when the cache errors with unable to read sha1 file' do
-    allow(subject).to receive(:update_reference_repo) {}
-    expect(subject).to receive(:reference_repo_dir)
-    expect(subject).to receive(:reference_repo_lock_file).and_return(lockfile)
-
-    responses = [
-      lambda { |_url|
-        raise Terrapin::ExitStatusError, <<-ERROR.gsub(/^ {12}/, '')
-            STDOUT:
-
-            STDERR:
-
-            error: unable to read sha1 file of sqiosbuild/lib/action/action.rb (6113b739af82d8b07731de8a58d6e233301f80ab)
-            fatal: unable to checkout working tree
-            warning: Clone succeeded, but checkout failed.
-            You can inspect what was checked out with 'git status'
-            and retry with 'git restore --source=HEAD :/'
-        ERROR
-      },
-      ->(url) { url }
-    ]
-    subject.with_git_mirror(test_url_valid) do
-      yielded << responses.shift.call(test_url_valid)
-    end
-
-    expect(responses).to be_empty
-    expect(yielded).to eq([test_url_valid])
-  end
+    it 'when one delta is missing' do
+      error = format_error <<-ERROR
+        error: Could not read f7fad86d06fee0678f9af7203b6031feabb40c3e
+        fatal: pack has 1 unresolved delta
+        fatal: index-pack failed
+      ERROR
+
+      expect(subject.retriable_error?(error)).to be_truthy
+    end
 
-  it 'should retry when the cache errors with did not receive expected object' do
-    allow(subject).to receive(:update_reference_repo) {}
-    expect(subject).to receive(:reference_repo_dir)
-    expect(subject).to receive(:reference_repo_lock_file).and_return(lockfile)
+    it 'when deltas are missing' do
+      error = format_error <<-ERROR
+        error: Could not read f7fad86d06fee0678f9af7203b6031feabb40c3e
+        fatal: pack has 138063 unresolved deltas
+        fatal: index-pack failed
+      ERROR
 
-    responses = [
-      lambda { |_url|
-        raise Terrapin::ExitStatusError, <<-ERROR.gsub(/^ {12}/, '')
-            STDOUT:
+      expect(subject.retriable_error?(error)).to be_truthy
+    end
 
-            STDERR:
+    it 'when the cache errors with unable to read sha1 file' do
+      error = format_error <<-ERROR
+        error: unable to read sha1 file of sqiosbuild/lib/action/action.rb (6113b739af82d8b07731de8a58d6e233301f80ab)
+        fatal: unable to checkout working tree
+        warning: Clone succeeded, but checkout failed.
+        You can inspect what was checked out with 'git status'
+        and retry with 'git restore --source=HEAD :/'
+      ERROR
 
-            error: Could not read 6682dfe81f66656436e60883dd795e7ec6735153
-            error: Could not read 0cd3703c23fa44c0043d97fbc26356a23939f31b
-            fatal: did not receive expected object 3c64c9dd49c79bd09aa13d4b05ac18263ca29ccd
-            fatal: index-pack failed
-        ERROR
-      },
-      ->(url) { url }
-    ]
-    subject.with_git_mirror(test_url_valid) do
-      yielded << responses.shift.call(test_url_valid)
+      expect(subject.retriable_error?(error)).to be_truthy
     end
 
-    expect(responses).to be_empty
-    expect(yielded).to eq([test_url_valid])
+    it 'when the cache errors with did not receive expected object' do
+      error = format_error <<-ERROR
+      error: Could not read 6682dfe81f66656436e60883dd795e7ec6735153
+      error: Could not read 0cd3703c23fa44c0043d97fbc26356a23939f31b
+      fatal: did not receive expected object 3c64c9dd49c79bd09aa13d4b05ac18263ca29ccd
+      fatal: index-pack failed
+      ERROR
+
+      expect(subject.retriable_error?(error)).to be_truthy
+    end
   end
 end

data/spec/git_fastclone_url_helper_spec.rb

@@ -62,7 +62,7 @@ describe GitFastClone::UrlHelper do
       allow(subject).to receive(:reference_repo_name) { test_reference_dir }
 
       expect(subject.reference_repo_dir(test_url_valid, test_reference_dir, false))
-        .to eq(test_reference_dir + '/' + test_reference_dir)
+        .to eq("#{test_reference_dir}/#{test_reference_dir}")
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: git-fastclone
 version: !ruby/object:Gem::Version
-  version: 1.2.7
+  version: 1.3.1
 platform: ruby
 authors:
 - Michael Tauraso
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-26 00:00:00.000000000 Z
+date: 2022-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -61,7 +61,8 @@ files:
 homepage: http://square.github.io/git-fastclone/
 licenses:
 - Apache
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -70,18 +71,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: git-clone --recursive on steroids!
-test_files:
-- spec/git_fastclone_runner_spec.rb
-- spec/git_fastclone_url_helper_spec.rb
-- spec/spec_helper.rb
+test_files: []