bundler 2.1.4 → 2.4.1

data/lib/bundler/shared_helpers.rb

@@ -13,13 +13,13 @@ module Bundler
     def root
       gemfile = find_gemfile
       raise GemfileNotFound, "Could not locate Gemfile" unless gemfile
-      Pathname.new(gemfile).tap{|x| x.untaint if RUBY_VERSION < "2.7" }.expand_path.parent
+      Pathname.new(gemfile).tap {|x| x.untaint if RUBY_VERSION < "2.7" }.expand_path.parent
     end
 
     def default_gemfile
       gemfile = find_gemfile
       raise GemfileNotFound, "Could not locate Gemfile" unless gemfile
-      Pathname.new(gemfile).tap{|x| x.untaint if RUBY_VERSION < "2.7" }.expand_path
+      Pathname.new(gemfile).tap {|x| x.untaint if RUBY_VERSION < "2.7" }.expand_path
     end
 
     def default_lockfile
@@ -28,7 +28,7 @@ module Bundler
       case gemfile.basename.to_s
       when "gems.rb" then Pathname.new(gemfile.sub(/.rb$/, ".locked"))
       else Pathname.new("#{gemfile}.lock")
-      end.tap{|x| x.untaint if RUBY_VERSION < "2.7" }
+      end.tap {|x| x.untaint if RUBY_VERSION < "2.7" }
     end
 
     def default_bundle_dir
@@ -100,7 +100,7 @@ module Bundler
     #
     # @see {Bundler::PermissionError}
     def filesystem_access(path, action = :write, &block)
-      yield(path.dup.tap{|x| x.untaint if RUBY_VERSION < "2.7" })
+      yield(path.dup.tap {|x| x.untaint if RUBY_VERSION < "2.7" })
     rescue Errno::EACCES
       raise PermissionError.new(path, action)
     rescue Errno::EAGAIN
@@ -109,7 +109,7 @@ module Bundler
       raise VirtualProtocolError.new
     rescue Errno::ENOSPC
       raise NoSpaceOnDeviceError.new(path, action)
-    rescue *[const_get_safely(:ENOTSUP, Errno)].compact
+    rescue Errno::ENOTSUP
       raise OperationNotSupportedError.new(path, action)
     rescue Errno::EEXIST, Errno::ENOENT
       raise
@@ -117,13 +117,6 @@ module Bundler
       raise GenericSystemCallError.new(e, "There was an error accessing `#{path}`.")
     end
 
-    def const_get_safely(constant_name, namespace)
-      const_in_namespace = namespace.constants.include?(constant_name.to_s) ||
-        namespace.constants.include?(constant_name.to_sym)
-      return nil unless const_in_namespace
-      namespace.const_get(constant_name)
-    end
-
     def major_deprecation(major_version, message, print_caller_location: false)
       if print_caller_location
         caller_location = caller_locations(2, 2).first
@@ -148,17 +141,10 @@ module Bundler
       end
       return unless multiple_gemfiles
       message = "Multiple gemfiles (gems.rb and Gemfile) detected. " \
-                "Make sure you remove Gemfile and Gemfile.lock since bundler is ignoring them in favor of gems.rb and gems.rb.locked."
+                "Make sure you remove Gemfile and Gemfile.lock since bundler is ignoring them in favor of gems.rb and gems.locked."
       Bundler.ui.warn message
     end
 
-    def trap(signal, override = false, &block)
-      prior = Signal.trap(signal) do
-        block.call
-        prior.call unless override
-      end
-    end
-
     def ensure_same_dependencies(spec, old_deps, new_deps)
       new_deps = new_deps.reject {|d| d.type == :development }
       old_deps = old_deps.reject {|d| d.type == :development }
@@ -177,7 +163,7 @@ module Bundler
         "\nEither installing with `--full-index` or running `bundle update #{spec.name}` should fix the problem."
     end
 
-    def pretty_dependency(dep, print_source = false)
+    def pretty_dependency(dep)
       msg = String.new(dep.name)
       msg << " (#{dep.requirement})" unless dep.requirement == Gem::Requirement.default
 
@@ -186,7 +172,6 @@ module Bundler
         msg << " " << platform_string if !platform_string.empty? && platform_string != Gem::Platform::RUBY
       end
 
-      msg << " from the `#{dep.source}` source" if print_source && dep.source
       msg
     end
 
@@ -194,11 +179,11 @@ module Bundler
       return @md5_available if defined?(@md5_available)
       @md5_available = begin
         require "openssl"
-        OpenSSL::Digest::MD5.digest("")
+        ::OpenSSL::Digest.digest("MD5", "")
         true
       rescue LoadError
         true
-      rescue OpenSSL::Digest::DigestError
+      rescue ::OpenSSL::Digest::DigestError
         false
       end
     end
@@ -212,7 +197,7 @@ module Bundler
       filesystem_access(gemfile_path) {|g| File.open(g, "w") {|file| file.puts contents } }
     end
 
-  private
+    private
 
     def validate_bundle_path
       path_separator = Bundler.rubygems.path_separator
@@ -250,10 +235,10 @@ module Bundler
 
     def search_up(*names)
       previous = nil
-      current  = File.expand_path(SharedHelpers.pwd).tap{|x| x.untaint if RUBY_VERSION < "2.7" }
+      current  = File.expand_path(SharedHelpers.pwd).tap {|x| x.untaint if RUBY_VERSION < "2.7" }
 
       until !File.directory?(current) || current == previous
-        if ENV["BUNDLE_SPEC_RUN"]
+        if ENV["BUNDLER_SPEC_RUN"]
           # avoid stepping above the tmp directory when testing
           gemspec = if ENV["GEM_COMMAND"]
             # for Ruby Core
@@ -288,10 +273,10 @@ module Bundler
 
     def set_bundle_variables
       # bundler exe & lib folders have same root folder, typical gem installation
-      exe_file = File.expand_path("../../../exe/bundle", __FILE__)
+      exe_file = File.expand_path("../../exe/bundle", __dir__)
 
       # for Ruby core repository testing
-      exe_file = File.expand_path("../../../libexec/bundle", __FILE__) unless File.exist?(exe_file)
+      exe_file = File.expand_path("../../libexec/bundle", __dir__) unless File.exist?(exe_file)
 
       # bundler is a default gem, exe path is separate
       exe_file = Bundler.rubygems.bin_path("bundler", "bundle", VERSION) unless File.exist?(exe_file)
@@ -299,6 +284,7 @@ module Bundler
       Bundler::SharedHelpers.set_env "BUNDLE_BIN_PATH", exe_file
       Bundler::SharedHelpers.set_env "BUNDLE_GEMFILE", find_gemfile.to_s
       Bundler::SharedHelpers.set_env "BUNDLER_VERSION", Bundler::VERSION
+      Bundler::SharedHelpers.set_env "BUNDLER_SETUP", File.expand_path("setup", __dir__)
     end
 
     def set_path
@@ -323,16 +309,15 @@ module Bundler
     end
 
     def bundler_ruby_lib
-      resolve_path File.expand_path("../..", __FILE__)
+      File.expand_path("..", __dir__)
     end
 
     def clean_load_path
-      bundler_lib = bundler_ruby_lib
-
       loaded_gem_paths = Bundler.rubygems.loaded_gem_paths
 
       $LOAD_PATH.reject! do |p|
-        next if resolve_path(p).start_with?(bundler_lib)
+        resolved_path = resolve_path(p)
+        next if $LOADED_FEATURES.any? {|lf| lf.start_with?(resolved_path) }
         loaded_gem_paths.delete(p)
       end
       $LOAD_PATH.uniq!
@@ -340,7 +325,7 @@ module Bundler
 
     def resolve_path(path)
       expanded = File.expand_path(path)
-      return expanded unless File.respond_to?(:realpath) && File.exist?(expanded)
+      return expanded unless File.exist?(expanded)
 
       File.realpath(expanded)
     end

data/lib/bundler/similarity_detector.rb

@@ -26,7 +26,7 @@ module Bundler
       end
     end
 
-  protected
+    protected
 
     # https://www.informit.com/articles/article.aspx?p=683059&seqNum=36
     def levenshtein_distance(this, that, ins = 2, del = 2, sub = 1)

data/lib/bundler/source/git/git_proxy.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "shellwords"
-
 module Bundler
   class Source
     class Git
@@ -17,8 +15,8 @@ module Bundler
       class GitNotAllowedError < GitError
         def initialize(command)
           msg = String.new
-          msg << "Bundler is trying to run a `git #{command}` at runtime. You probably need to run `bundle install`. However, "
-          msg << "this error message could probably be more useful. Please submit a ticket at https://github.com/bundler/bundler/issues "
+          msg << "Bundler is trying to run `#{command}` at runtime. You probably need to run `bundle install`. However, "
+          msg << "this error message could probably be more useful. Please submit a ticket at https://github.com/rubygems/rubygems/issues/new?labels=Bundler&template=bundler-related-issue.md "
           msg << "with steps to reproduce as well as the following\n\nCALLER: #{caller.join("\n")}"
           super msg
         end
@@ -27,21 +25,20 @@ module Bundler
       class GitCommandError < GitError
         attr_reader :command
 
-        def initialize(command, path = nil, extra_info = nil)
+        def initialize(command, path, extra_info = nil)
           @command = command
 
           msg = String.new
-          msg << "Git error: command `git #{command}` in directory #{SharedHelpers.pwd} has failed."
+          msg << "Git error: command `#{command}` in directory #{path} has failed."
           msg << "\n#{extra_info}" if extra_info
-          msg << "\nIf this error persists you could try removing the cache directory '#{path}'" if path && path.exist?
           super msg
         end
       end
 
       class MissingGitRevisionError < GitCommandError
-        def initialize(command, path, ref, repo)
+        def initialize(command, destination_path, ref, repo)
           msg = "Revision #{ref} does not exist in the repository #{repo}. Maybe you misspelled it?"
-          super command, path, msg
+          super command, destination_path, msg
         end
       end
 
@@ -49,72 +46,59 @@ module Bundler
       # All actions required by the Git source is encapsulated in this
       # object.
       class GitProxy
-        attr_accessor :path, :uri, :ref
+        attr_accessor :path, :uri, :branch, :tag, :ref, :explicit_ref
         attr_writer :revision
 
-        def initialize(path, uri, ref, revision = nil, git = nil)
+        def initialize(path, uri, options = {}, revision = nil, git = nil)
           @path     = path
           @uri      = uri
-          @ref      = ref
+          @branch   = options["branch"]
+          @tag      = options["tag"]
+          @ref      = options["ref"]
+          @explicit_ref = branch || tag || ref
           @revision = revision
           @git      = git
-          raise GitNotInstalledError.new if allow? && !Bundler.git_present?
+          @commit_ref = nil
         end
 
         def revision
-          return @revision if @revision
-
-          begin
-            @revision ||= find_local_revision
-          rescue GitCommandError => e
-            raise MissingGitRevisionError.new(e.command, path, ref, URICredentialsFilter.credential_filtered_uri(uri))
-          end
-
-          @revision
+          @revision ||= allowed_with_path { find_local_revision }
         end
 
-        def branch
-          @branch ||= allowed_in_path do
-            git("rev-parse --abbrev-ref HEAD").strip
+        def current_branch
+          @current_branch ||= allowed_with_path do
+            git("rev-parse", "--abbrev-ref", "HEAD", :dir => path).strip
           end
         end
 
         def contains?(commit)
-          allowed_in_path do
-            result, status = git_null("branch --contains #{commit}")
+          allowed_with_path do
+            result, status = git_null("branch", "--contains", commit, :dir => path)
             status.success? && result =~ /^\* (.*)$/
           end
         end
 
         def version
-          git("--version").match(/(git version\s*)?((\.?\d+)+).*/)[2]
+          @version ||= full_version.match(/((\.?\d+)+).*/)[1]
         end
 
         def full_version
-          git("--version").sub("git version", "").strip
+          @full_version ||= git("--version").sub(/git version\s*/, "").strip
         end
 
         def checkout
-          return if path.exist? && has_revision_cached?
-          extra_ref = "#{Shellwords.shellescape(ref)}:#{Shellwords.shellescape(ref)}" if ref && ref.start_with?("refs/")
+          return if has_revision_cached?
 
-          Bundler.ui.info "Fetching #{URICredentialsFilter.credential_filtered_uri(uri)}"
+          Bundler.ui.info "Fetching #{credential_filtered_uri}"
 
-          unless path.exist?
-            SharedHelpers.filesystem_access(path.dirname) do |p|
-              FileUtils.mkdir_p(p)
-            end
-            git_retry %(clone #{uri_escaped_with_configured_credentials} "#{path}" --bare --no-hardlinks --quiet)
-            return unless extra_ref
-          end
+          extra_fetch_needed = clone_needs_extra_fetch?
+          unshallow_needed = clone_needs_unshallow?
+          return unless extra_fetch_needed || unshallow_needed
 
-          in_path do
-            git_retry %(fetch --force --quiet --tags #{uri_escaped_with_configured_credentials} "refs/heads/*:refs/heads/*" #{extra_ref})
-          end
+          git_remote_fetch(unshallow_needed ? ["--unshallow"] : depth_args)
         end
 
         def copy_to(destination, submodules = false)
-          # method 1
           unless File.exist?(destination.join(".git"))
             begin
               SharedHelpers.filesystem_access(destination.dirname) do |p|
@@ -123,135 +107,281 @@ module Bundler
               SharedHelpers.filesystem_access(destination) do |p|
                 FileUtils.rm_rf(p)
               end
-              git_retry %(clone --no-checkout --quiet "#{path}" "#{destination}")
+              git "clone", "--no-checkout", "--quiet", path.to_s, destination.to_s
               File.chmod(((File.stat(destination).mode | 0o777) & ~File.umask), destination)
             rescue Errno::EEXIST => e
-              file_path = e.message[%r{.*?(/.*)}, 1]
+              file_path = e.message[%r{.*?((?:[a-zA-Z]:)?/.*)}, 1]
               raise GitError, "Bundler could not install a gem because it needs to " \
                 "create a directory, but a file exists - #{file_path}. Please delete " \
                 "this file and try again."
             end
           end
-          # method 2
-          SharedHelpers.chdir(destination) do
-            git_retry %(fetch --force --quiet --tags "#{path}")
 
-            begin
-              git "reset --hard #{@revision}"
-            rescue GitCommandError => e
-              raise MissingGitRevisionError.new(e.command, path, @revision, URICredentialsFilter.credential_filtered_uri(uri))
-            end
+          git "fetch", "--force", "--quiet", *extra_fetch_args, :dir => destination if @commit_ref
+
+          git "reset", "--hard", @revision, :dir => destination
+
+          if submodules
+            git_retry "submodule", "update", "--init", "--recursive", :dir => destination
+          elsif Gem::Version.create(version) >= Gem::Version.create("2.9.0")
+            inner_command = "git -C $toplevel submodule deinit --force $sm_path"
+            git_retry "submodule", "foreach", "--quiet", inner_command, :dir => destination
+          end
+        end
+
+        private
 
-            if submodules
-              git_retry "submodule update --init --recursive"
-            elsif Gem::Version.create(version) >= Gem::Version.create("2.9.0")
-              git_retry "submodule deinit --all --force"
+        def git_remote_fetch(args)
+          command = ["fetch", "--force", "--quiet", "--no-tags", *args, "--", configured_uri, refspec].compact
+          command_with_no_credentials = check_allowed(command)
+
+          Bundler::Retry.new("`#{command_with_no_credentials}` at #{path}", [MissingGitRevisionError]).attempts do
+            out, err, status = capture(command, path)
+            return out if status.success?
+
+            if err.include?("couldn't find remote ref")
+              raise MissingGitRevisionError.new(command_with_no_credentials, path, explicit_ref, credential_filtered_uri)
+            else
+              raise GitCommandError.new(command_with_no_credentials, path, err)
             end
           end
         end
 
-      private
+        def clone_needs_extra_fetch?
+          return true if path.exist?
 
-        def git_null(command)
-          command_with_no_credentials = URICredentialsFilter.credential_filtered_string(command, uri)
-          raise GitNotAllowedError.new(command_with_no_credentials) unless allow?
+          SharedHelpers.filesystem_access(path.dirname) do |p|
+            FileUtils.mkdir_p(p)
+          end
+          git_retry "clone", "--bare", "--no-hardlinks", "--quiet", *extra_clone_args, "--", configured_uri, path.to_s
+
+          extra_ref
+        end
 
-          out, status = SharedHelpers.with_clean_git_env do
-            capture_and_ignore_stderr("git #{command}")
+        def clone_needs_unshallow?
+          return false unless path.join("shallow").exist?
+          return true if full_clone?
+
+          @revision && @revision != head_revision
+        end
+
+        def extra_ref
+          return false if not_pinned?
+          return true unless full_clone?
+
+          ref.start_with?("refs/")
+        end
+
+        def depth
+          return @depth if defined?(@depth)
+
+          @depth = if !supports_fetching_unreachable_refs?
+            nil
+          elsif not_pinned? || pinned_to_full_sha?
+            1
+          elsif ref.include?("~")
+            parsed_depth = ref.split("~").last
+            parsed_depth.to_i + 1
           end
+        end
 
-          [URICredentialsFilter.credential_filtered_string(out, uri), status]
+        def refspec
+          commit = pinned_to_full_sha? ? ref : @revision
+
+          if commit
+            @commit_ref = "refs/#{commit}-sha"
+            return "#{commit}:#{@commit_ref}"
+          end
+
+          reference = fully_qualified_ref
+
+          reference ||= if ref.include?("~")
+            ref.split("~").first
+          elsif ref.start_with?("refs/")
+            ref
+          else
+            "refs/*"
+          end
+
+          "#{reference}:#{reference}"
         end
 
-        def git_retry(command)
-          Bundler::Retry.new("`git #{URICredentialsFilter.credential_filtered_string(command, uri)}`", GitNotAllowedError).attempts do
-            git(command)
+        def fully_qualified_ref
+          if branch
+            "refs/heads/#{branch}"
+          elsif tag
+            "refs/tags/#{tag}"
+          elsif ref.nil?
+            "refs/heads/#{current_branch}"
           end
         end
 
-        def git(command, check_errors = true, error_msg = nil)
-          command_with_no_credentials = URICredentialsFilter.credential_filtered_string(command, uri)
-          raise GitNotAllowedError.new(command_with_no_credentials) unless allow?
+        def not_pinned?
+          branch || tag || ref.nil?
+        end
+
+        def pinned_to_full_sha?
+          ref =~ /\A\h{40}\z/
+        end
+
+        def git_null(*command, dir: nil)
+          check_allowed(command)
+
+          capture(command, dir, :ignore_err => true)
+        end
+
+        def git_retry(*command, dir: nil)
+          command_with_no_credentials = check_allowed(command)
 
-          out, status = SharedHelpers.with_clean_git_env do
-            capture_and_filter_stderr(uri, "git #{command}")
+          Bundler::Retry.new("`#{command_with_no_credentials}` at #{dir || SharedHelpers.pwd}").attempts do
+            git(*command, :dir => dir)
           end
+        end
+
+        def git(*command, dir: nil)
+          command_with_no_credentials = check_allowed(command)
+
+          out, err, status = capture(command, dir)
 
-          stdout_with_no_credentials = URICredentialsFilter.credential_filtered_string(out, uri)
-          raise GitCommandError.new(command_with_no_credentials, path, error_msg) if check_errors && !status.success?
-          stdout_with_no_credentials
+          raise GitCommandError.new(command_with_no_credentials, dir || SharedHelpers.pwd, err) unless status.success?
+
+          Bundler.ui.warn err unless err.empty?
+
+          out
         end
 
         def has_revision_cached?
-          return unless @revision
-          in_path { git("cat-file -e #{@revision}") }
+          return unless @revision && path.exist?
+          git("cat-file", "-e", @revision, :dir => path)
           true
         rescue GitError
           false
         end
 
-        def remove_cache
-          FileUtils.rm_rf(path)
+        def find_local_revision
+          return head_revision if explicit_ref.nil?
+
+          find_revision_for(explicit_ref)
         end
 
-        def find_local_revision
-          allowed_in_path do
-            git("rev-parse --verify #{Shellwords.shellescape(ref)}", true).strip
-          end
+        def head_revision
+          verify("HEAD")
         end
 
-        # Escape the URI for git commands
-        def uri_escaped_with_configured_credentials
-          remote = configured_uri_for(uri)
-          if Bundler::WINDOWS
-            # Windows quoting requires double quotes only, with double quotes
-            # inside the string escaped by being doubled.
-            '"' + remote.gsub('"') { '""' } + '"'
-          else
-            # Bash requires single quoted strings, with the single quotes escaped
-            # by ending the string, escaping the quote, and restarting the string.
-            "'" + remote.gsub("'") { "'\\''" } + "'"
-          end
+        def find_revision_for(reference)
+          verify(reference)
+        rescue GitCommandError => e
+          raise MissingGitRevisionError.new(e.command, path, reference, credential_filtered_uri)
         end
 
-        # Adds credentials to the URI as Fetcher#configured_uri_for does
-        def configured_uri_for(uri)
-          if /https?:/ =~ uri
+        def verify(reference)
+          git("rev-parse", "--verify", reference, :dir => path).strip
+        end
+
+        # Adds credentials to the URI
+        def configured_uri
+          if /https?:/.match?(uri)
             remote = Bundler::URI(uri)
             config_auth = Bundler.settings[remote.to_s] || Bundler.settings[remote.host]
             remote.userinfo ||= config_auth
             remote.to_s
+          elsif File.exist?(uri)
+            "file://#{uri}"
           else
-            uri
+            uri.to_s
           end
         end
 
+        # Removes credentials from the URI
+        def credential_filtered_uri
+          URICredentialsFilter.credential_filtered_uri(uri)
+        end
+
         def allow?
-          @git ? @git.allow_git_ops? : true
+          allowed = @git ? @git.allow_git_ops? : true
+
+          raise GitNotInstalledError.new if allowed && !Bundler.git_present?
+
+          allowed
         end
 
-        def in_path(&blk)
+        def with_path(&blk)
           checkout unless path.exist?
-          _ = URICredentialsFilter # load it before we chdir
-          SharedHelpers.chdir(path, &blk)
+          blk.call
         end
 
-        def allowed_in_path
-          return in_path { yield } if allow?
+        def allowed_with_path
+          return with_path { yield } if allow?
           raise GitError, "The git source #{uri} is not yet checked out. Please run `bundle install` before trying to start your application"
         end
 
-        def capture_and_filter_stderr(uri, cmd)
-          require "open3"
-          return_value, captured_err, status = Open3.capture3(cmd)
-          Bundler.ui.warn URICredentialsFilter.credential_filtered_string(captured_err, uri) if uri && !captured_err.empty?
-          [return_value, status]
+        def check_allowed(command)
+          require "shellwords"
+          command_with_no_credentials = URICredentialsFilter.credential_filtered_string("git #{command.shelljoin}", uri)
+          raise GitNotAllowedError.new(command_with_no_credentials) unless allow?
+          command_with_no_credentials
+        end
+
+        def capture(cmd, dir, ignore_err: false)
+          SharedHelpers.with_clean_git_env do
+            require "open3"
+            out, err, status = Open3.capture3(*capture3_args_for(cmd, dir))
+
+            filtered_out = URICredentialsFilter.credential_filtered_string(out, uri)
+            return [filtered_out, status] if ignore_err
+
+            filtered_err = URICredentialsFilter.credential_filtered_string(err, uri)
+            [filtered_out, filtered_err, status]
+          end
+        end
+
+        def capture3_args_for(cmd, dir)
+          return ["git", *cmd] unless dir
+
+          if Bundler.feature_flag.bundler_3_mode? || supports_minus_c?
+            ["git", "-C", dir.to_s, *cmd]
+          else
+            ["git", *cmd, { :chdir => dir.to_s }]
+          end
+        end
+
+        def extra_clone_args
+          args = depth_args
+          return [] if args.empty?
+
+          args += ["--single-branch"]
+          args.unshift("--no-tags") if supports_cloning_with_no_tags?
+
+          args += ["--branch", branch || tag] if branch || tag
+          args
+        end
+
+        def depth_args
+          return [] if full_clone?
+
+          ["--depth", depth.to_s]
+        end
+
+        def extra_fetch_args
+          extra_args = [path.to_s, *depth_args]
+          extra_args.push(@commit_ref)
+          extra_args
+        end
+
+        def full_clone?
+          depth.nil?
+        end
+
+        def supports_minus_c?
+          @supports_minus_c ||= Gem::Version.new(version) >= Gem::Version.new("1.8.5")
+        end
+
+        def supports_fetching_unreachable_refs?
+          @supports_fetching_unreachable_refs ||= Gem::Version.new(version) >= Gem::Version.new("2.5.0")
         end
 
-        def capture_and_ignore_stderr(cmd)
-          require "open3"
-          return_value, _, status = Open3.capture3(cmd)
-          [return_value, status]
+        def supports_cloning_with_no_tags?
+          @supports_cloning_with_no_tags ||= Gem::Version.new(version) >= Gem::Version.new("2.14.0-rc0")
         end
       end
     end