git 5.6.0 → 6.0.0

data/lib/git/factories.rb

@@ -18,6 +18,33 @@ module Git
   # @api private
   #
   module Factories # rubocop:disable Metrics/ModuleLength
+    # Option keys {Git.open} accepts
+    #
+    # @return [Array<Symbol>]
+    #
+    # @api private
+    #
+    OPEN_ALLOWED_OPTS = %i[repository index log git_ssh binary_path].freeze
+    private_constant :OPEN_ALLOWED_OPTS
+
+    # Option keys {Git.bare} accepts
+    #
+    # @return [Array<Symbol>]
+    #
+    # @api private
+    #
+    BARE_ALLOWED_OPTS = %i[index log git_ssh binary_path].freeze
+    private_constant :BARE_ALLOWED_OPTS
+
+    # Option keys {Git.init} accepts
+    #
+    # @return [Array<Symbol>]
+    #
+    # @api private
+    #
+    INIT_ALLOWED_OPTS = %i[bare initial_branch repository separate_git_dir index log git_ssh binary_path].freeze
+    private_constant :INIT_ALLOWED_OPTS
+
     # Clone a repository into a new directory
     #
     # @example Clone into the default directory
@@ -36,6 +63,11 @@ module Git
     # @param directory [String, Pathname, nil] the local directory name to clone into;
     #   git derives the name from the URL when `nil`
     #
+    #   Expanded before git runs, so `~` is the home directory and a relative
+    #   path is relative to `:chdir` when given and to the process working
+    #   directory otherwise. git creates the expanded directory, and the
+    #   returned repository is bound to it.
+    #
     # @param options [Hash] options that control cloning
     #
     #   Some options configure the returned {Git::Repository} instance after
@@ -79,7 +111,14 @@ module Git
     #
     # @option options [Boolean, nil] :dissociate stop borrowing from references
     #
-    # @option options [String, nil] :separate_git_dir alternate git directory path
+    # @option options [String, nil] :repository alternate git directory path
+    #
+    #   Writes a gitfile in the working tree. Alias: `:separate_git_dir`.
+    #   Expanded before git runs, like `directory`: `~` is the home directory
+    #   and a relative path is relative to `:chdir` when given and to the
+    #   process working directory otherwise.
+    #
+    # @option options [String, nil] :separate_git_dir alias for `:repository`
     #
     # @option options [String, Array<String>, nil] :server_option
     #   protocol-v2 server options
@@ -153,32 +192,47 @@ module Git
     #
     # @option options [String, nil] :index a non-standard path to the index file
     #
+    #   Expanded before git runs, like `directory`: a relative path is expanded
+    #   against `:chdir` when given, and against the process working directory
+    #   otherwise.
+    #
     # @option options [String, Pathname, nil] :chdir run `git clone` from within
     #   this directory
     #
-    # @option options [String, Pathname, nil] :path deprecated; use `:chdir` instead
-    #
-    # @option options [Boolean, nil] :recursive deprecated; use
-    #   `:recurse_submodules` instead
-    #
-    # @option options [String, nil] :remote deprecated; use `:origin` instead
+    #   Expanded before git runs, so `~` is the home directory and a relative
+    #   path is relative to the process working directory. `directory`,
+    #   `:repository`, and `:index` are expanded against the expanded value.
     #
     # @return [Git::Repository] a repository bound to the cloned working copy or
     #   bare repository
     #
-    # @raise [ArgumentError] if unsupported options are provided
+    # @raise [ArgumentError] if unsupported options are provided, or if
+    #   `directory`, `:repository`, `:index`, or `:chdir` begins with `~user`
+    #   for a user that does not exist
     #
     # @raise [Git::FailedError] if git exits with a non-zero exit status
     #
+    # @raise [Git::Error] if a filesystem call made while resolving the paths
+    #   fails
+    #
     # @raise [Git::UnexpectedResultError] if the cloned directory cannot be
     #   determined from git's output
     #
+    # @note If git fails before the transfer completes, git removes `directory`
+    #   and the separate git directory it created, or empties `directory` when
+    #   it existed before the call. A `:repository` path that already exists is
+    #   refused before the transfer starts. If the transfer completes but the
+    #   checkout fails, or the `:timeout` or the global timeout kills git, what
+    #   git wrote is left in place. If {Git::UnexpectedResultError} is raised,
+    #   the completed clone is left in place.
+    #
     # @api public
     #
     def clone(repository_url, directory = nil, options = {})
       opts, context_opts = prepare_clone_options(options)
+      directory = expand_directory(directory, bare: context_opts[:bare], base: opts[:chdir]) if directory
       clone_result = run_clone_command(repository_url, directory, opts, context_opts)
-      paths = resolve_paths_from_clone_result(clone_result, opts, context_opts)
+      paths = resolve_paths_from_clone_result(clone_result, directory, opts, context_opts)
 
       from_paths(clone_repository_options(context_opts), paths)
     end
@@ -196,6 +250,10 @@ module Git
     #
     # @param directory [String] the directory to initialize; defaults to `'.'`
     #
+    #   Expanded before git runs, so `~` is the home directory and a relative
+    #   path is relative to the process working directory. git creates the
+    #   expanded directory, and the returned repository is bound to it.
+    #
     # @param options [Hash] options that control initialization
     #
     #   Some options configure the returned {Git::Repository} instance after
@@ -208,6 +266,8 @@ module Git
     # @option options [String, nil] :repository path for the `.git` directory
     #
     #   Writes a gitfile in the working tree. Alias: `:separate_git_dir`.
+    #   Expanded before git runs, like `directory`: `~` is the home directory
+    #   and a relative path is relative to the process working directory.
     #
     # @option options [String, nil] :separate_git_dir alias for `:repository`
     #
@@ -228,19 +288,33 @@ module Git
     # @option options [String, nil] :index custom index path for the returned
     #   repository
     #
-    #   Ignored when `:bare` is `true`.
+    #   Expanded before git runs, like `directory`: `~` is the home directory
+    #   and a relative path is relative to the process working directory.
     #
     # @return [Git::Repository] a repository bound to the newly initialized repository
     #
+    # @raise [ArgumentError] if `options` contains an unknown key
+    #
+    # @raise [ArgumentError] if `directory`, `:repository`, or `:index` begins
+    #   with `~user` for a user that does not exist
+    #
     # @raise [Git::FailedError] if git exits with a non-zero exit status
     #
+    # @raise [Git::Error] if a filesystem call made while resolving the paths
+    #   fails
+    #
+    # @note If git exits non-zero after it starts writing, whatever it wrote is
+    #   left in place: `directory` when git created it, and a git directory
+    #   (`.git`, or the `:repository` path and the gitfile pointing at it) that
+    #   git may not recognize as a repository. If git succeeds but the
+    #   repository cannot be opened, the initialized repository is left in place.
+    #
     # @api public
     #
     def init(directory = '.', options = {})
-      options = options.dup
-      if options.key?(:separate_git_dir) && options[:repository].nil?
-        options[:repository] = options.delete(:separate_git_dir)
-      end
+      reject_unknown_option_keys!(options.keys, INIT_ALLOWED_OPTS)
+      options = normalize_init_options(options)
+      directory = expand_directory(directory, bare: options[:bare])
 
       run_init_command(directory, options)
       open_after_init(directory, options)
@@ -254,6 +328,8 @@ module Git
     # @param working_dir [String] the path to the root of the working copy
     #
     #   May be any path inside the working tree when `:repository` is not given.
+    #   Expanded before use: `~` is the home directory and a relative path is
+    #   relative to the process working directory.
     #
     # @param options [Hash] options that control how the repository is located
     #
@@ -261,10 +337,13 @@ module Git
     #   `.git` directory
     #
     #   When given, `working_dir` is used as-is (the working tree root is not
-    #   auto-detected).
+    #   auto-detected). A relative path is expanded against the process working
+    #   directory, not against `working_dir`.
     #
     # @option options [String, nil] :index a non-standard path to the index file
     #
+    #   A relative path is expanded against the process working directory.
+    #
     # @option options [Logger, nil] :log logger used for git operations
     #
     # @option options [String, nil, :use_global_config] :git_ssh
@@ -281,8 +360,15 @@ module Git
     #
     # @return [Git::Repository] a repository bound to the resolved paths
     #
+    # @raise [ArgumentError] if `options` contains an unknown key
+    #
     # @raise [ArgumentError] if `working_dir` is not a directory or is not inside
-    #   a git working tree
+    #   a git working tree, or if it begins with `~user` for a user that does not
+    #   exist
+    #
+    # @raise [Git::Error] if the `.git` path is a gitdir pointer file that cannot
+    #   be read, if the git binary cannot be found or fails to launch, or if a
+    #   filesystem call made while resolving the paths fails
     #
     # @note This method opens working copies only. To open a bare repository, use
     #   `Git.bare`.
@@ -290,14 +376,14 @@ module Git
     # @api public
     #
     def open(working_dir, options = {})
-      raise ArgumentError, "'#{working_dir}' is not a directory" unless Dir.exist?(working_dir)
+      reject_unknown_option_keys!(options.keys, OPEN_ALLOWED_OPTS)
+      expanded_dir = PathResolver.expand_path(working_dir, PathResolver::WORKING_DIRECTORY_MESSAGE)
+      raise ArgumentError, "'#{working_dir}' is not a directory" unless Dir.exist?(expanded_dir)
 
-      working_dir = resolve_open_working_dir(working_dir, options) unless options[:repository]
+      working_dir = options[:repository] ? expanded_dir : resolve_open_working_dir(expanded_dir, options)
 
-      paths = PathResolver.resolve_paths(
-        working_directory: working_dir,
-        repository: options[:repository],
-        index: options[:index]
+      paths = resolve_repository_paths(
+        working_dir, bare: false, repository: options[:repository], index: options[:index]
       )
 
       from_paths(options, paths)
@@ -308,10 +394,19 @@ module Git
     # @example Open a bare repository
     #   repository = Git.bare('/path/to/repo.git')
     #
+    # @example Bind a bare repository to a scratch index
+    #   repository = Git.bare('/srv/repo.git', index: '/tmp/scratch.index')
+    #   repository.read_tree('HEAD')
+    #   tree_sha = repository.write_tree
+    #
     # @param git_dir [String] the path to the bare repository directory
     #
     # @param options [Hash] options used to configure the repository instance
     #
+    # @option options [String, nil] :index a non-standard path to the index file
+    #
+    #   A relative path is expanded against the process working directory.
+    #
     # @option options [Logger, nil] :log logger used for git operations
     #
     # @option options [String, nil, :use_global_config] :git_ssh
@@ -328,10 +423,15 @@ module Git
     #
     # @return [Git::Repository] a repository bound to the bare repository directory
     #
+    # @raise [ArgumentError] if `options` contains an unknown key
+    #
+    # @raise [Git::Error] if `git_dir` is a gitdir pointer file that cannot be read
+    #
     # @api public
     #
     def bare(git_dir, options = {})
-      paths = PathResolver.resolve_paths(repository: git_dir, bare: true)
+      reject_unknown_option_keys!(options.keys, BARE_ALLOWED_OPTS)
+      paths = resolve_repository_paths(git_dir, bare: true, index: options[:index])
 
       from_paths(options, paths)
     end
@@ -380,8 +480,15 @@ module Git
 
     # Resolve repository paths from a completed clone result
     #
+    # When the caller gave a directory, it was expanded before git ran and is
+    # used as is. Only when git derived the name from the URL is the directory
+    # read from git's output, where it is a relative name under `:chdir`.
+    #
     # @param clone_result [Git::CommandLine::Result] the completed clone result
     #
+    # @param directory [String, nil] the expanded directory given to {.clone},
+    #   or `nil` when git derived the name from the URL
+    #
     # @param opts [Hash] command-ready clone options
     #
     # @param context_opts [Hash] context options produced while preparing clone
@@ -390,26 +497,75 @@ module Git
     # @option opts [String, Pathname, nil] :chdir run `git clone` from within
     #   this directory
     #
-    # @option opts [Boolean, nil] :bare clone as a bare repository
-    #
-    # @option opts [Boolean, nil] :mirror set up a mirror of the source
+    # @option context_opts [Boolean] :bare whether `:bare` or `:mirror` was
+    #   requested
     #
-    # @option context_opts [String, nil] :index custom index path for the
-    #   returned repository
+    # @option context_opts [String, nil] :index the already expanded custom
+    #   index path for the returned repository
     #
     # @return [Hash{Symbol => (String, nil)}] resolved path hash
     #
-    # @raise [Git::UnexpectedResultError] if the clone directory cannot be parsed
+    # @raise [Git::UnexpectedResultError] if no directory was given and the clone
+    #   directory cannot be parsed from git's output
+    #
+    # @api private
+    #
+    def resolve_paths_from_clone_result(clone_result, directory, opts, context_opts)
+      clone_dir = directory || prefix_with_chdir(parse_clone_directory(clone_result.stderr), opts[:chdir])
+
+      bare = context_opts[:bare] || bare_clone?(clone_result.stderr)
+      resolve_repository_paths(clone_dir, bare: bare, index: context_opts[:index])
+    end
+
+    # Expand the directory given to {.init} or {.clone} before git sees it
+    #
+    # git does not expand `~` in a path on its command line, so the expansion
+    # happens here. The directory git creates is then the one the returned
+    # repository is bound to.
+    #
+    # @param directory [String, Pathname] the directory to initialize or clone
+    #   into
+    #
+    # @param bare [Boolean, nil] whether the directory is the bare repository
+    #   itself rather than a working directory; selects the error message
+    #
+    # @param base [String, Pathname, nil] the directory a relative path is
+    #   expanded against, or `nil` for the process working directory
+    #
+    # @return [String] the absolute path
+    #
+    # @raise [ArgumentError] if the path begins with `~user` for a user that
+    #   does not exist
+    #
+    # @raise [Git::Error] if the path cannot be expanded, which happens when the
+    #   process working directory has been removed
+    #
+    # @api private
+    #
+    def expand_directory(directory, bare:, base: nil)
+      message = bare ? PathResolver::REPOSITORY_MESSAGE : PathResolver::WORKING_DIRECTORY_MESSAGE
+      PathResolver.expand_path(directory, message, base: base)
+    end
+
+    # Join the clone directory git reported onto the `:chdir` it ran in
+    #
+    # Used only when no directory was given to {.clone}: git derives a relative
+    # name from the URL and creates it under `chdir`. An absolute path, should
+    # git ever report one, passes through unchanged.
+    #
+    # @param path [String] the clone directory reported by `git clone`
+    #
+    # @param chdir [String, Pathname, nil] the directory git ran in, or `nil`
+    #
+    # @return [String] `path` prefixed with `chdir` when `chdir` is given and
+    #   `path` is relative; otherwise `path` unchanged
     #
     # @api private
     #
-    def resolve_paths_from_clone_result(clone_result, opts, context_opts)
-      clone_dir, cloned_bare = parse_clone_stderr(clone_result.stderr)
-      chdir = opts[:chdir]
-      clone_dir = File.join(chdir, clone_dir) if chdir && !Pathname.new(clone_dir).absolute?
+    def prefix_with_chdir(path, chdir)
+      return path if chdir.nil? || Pathname.new(path).absolute?
 
-      bare = opts[:bare] || opts[:mirror] || cloned_bare
-      resolve_clone_paths(clone_dir, bare, context_opts[:index])
+      File.join(chdir, path)
     end
 
     # Build repository construction options from clone context options
@@ -473,12 +629,32 @@ module Git
     #
     # @raise [ArgumentError] if `working_dir` is not inside a git working tree
     #
+    # @raise [Git::Error] if the git binary cannot be found or fails to launch, or
+    #   if `working_dir` cannot be expanded to an absolute path
+    #
     # @api private
     #
     def resolve_open_working_dir(working_dir, options)
       PathResolver.root_of_worktree(working_dir, **context_defaults(options))
     end
 
+    # Raise if `keys` contains a key outside `allowed`
+    #
+    # @param keys [Array<Symbol>] the keys of the caller-supplied options
+    #
+    # @param allowed [Array<Symbol>] the keys the factory accepts
+    #
+    # @return [void]
+    #
+    # @raise [ArgumentError] if `keys` contains an unknown key
+    #
+    # @api private
+    #
+    def reject_unknown_option_keys!(keys, allowed)
+      unknown = keys - allowed
+      raise ArgumentError, "Unknown options: #{unknown.join(', ')}" unless unknown.empty?
+    end
+
     # Build a repository from caller options and resolved paths
     #
     # @param options [Hash] the caller-supplied options (`:git_ssh`,
@@ -523,15 +699,45 @@ module Git
     #
     def prepare_clone_options(options)
       opts = options.dup
-      deprecate_clone_path_option!(opts)
-      deprecate_clone_recursive_option!(opts)
-      deprecate_clone_remote_option!(opts)
       context_opts = extract_clone_context_options!(opts)
+      expand_path_option!(opts, :chdir, PathResolver::CHDIR_MESSAGE)
       normalize_clone_repository_option!(opts)
+      expand_path_option!(context_opts, :index, PathResolver::INDEX_MESSAGE, base: opts[:chdir])
 
       [opts, context_opts]
     end
 
+    # Expand a path option in place when it is present
+    #
+    # git does no tilde expansion and ruby-git starts it without a shell, so
+    # every path option is expanded here before git sees it. A path that cannot
+    # be expanded is rejected before git runs.
+    #
+    # @param hash [Hash] the options hash (mutated in place)
+    #
+    # @param key [Symbol] the option to expand; left alone when `nil` or absent
+    #
+    # @param message [String] the {Git::Error} message when expansion fails
+    #
+    # @param base [String, Pathname, nil] the directory a relative path is
+    #   expanded against, or `nil` for the process working directory
+    #
+    # @return [void] mutates `hash` in place
+    #
+    # @raise [ArgumentError] if the path begins with `~user` for a user that
+    #   does not exist
+    #
+    # @raise [Git::Error] if the path cannot be expanded, which happens when the
+    #   process working directory has been removed
+    #
+    # @api private
+    #
+    def expand_path_option!(hash, key, message, base: nil)
+      return unless hash[key]
+
+      hash[key] = PathResolver.expand_path(hash[key], message, base: base)
+    end
+
     # Extract clone context options from command-ready options
     #
     # @param opts [Hash] clone options (mutated in place)
@@ -547,7 +753,14 @@ module Git
     # @option opts [String, nil] :index custom index path for the returned
     #   repository
     #
-    # @return [Hash{Symbol => Object}] context options for clone setup
+    # @option opts [Boolean, nil] :bare clone as a bare repository; left in
+    #   `opts` for git
+    #
+    # @option opts [Boolean, nil] :mirror set up a mirror of the source; left in
+    #   `opts` for git
+    #
+    # @return [Hash{Symbol => Object}] context options for clone setup, with
+    #   `:bare` true when either `:bare` or `:mirror` was requested
     #
     # @api private
     #
@@ -556,47 +769,127 @@ module Git
         logger: opts.delete(:log),
         git_ssh: opts.key?(:git_ssh) ? opts.delete(:git_ssh) : :use_global_config,
         binary_path: opts.key?(:binary_path) ? opts.delete(:binary_path) : :use_global_config,
-        index: opts.delete(:index)
+        index: opts.delete(:index),
+        bare: opts[:bare] || opts[:mirror] || false
       }
     end
 
     # Normalize the clone repository option for `git clone`
     #
+    # Resolves the `:separate_git_dir` alias to `:repository`, then renames
+    # `:repository` to `:separate_git_dir` and expands it before git runs,
+    # against `:chdir` when given, like the clone directory. git does no tilde
+    # expansion, so a `~`-prefixed path handed to git would create a directory
+    # literally named `~`.
+    #
     # @param opts [Hash] clone options (mutated in place)
     #
     # @option opts [String, nil] :repository alternate git directory path
     #
+    # @option opts [String, nil] :separate_git_dir alias for `:repository`
+    #
+    # @option opts [String, Pathname, nil] :chdir the directory git runs in
+    #
     # @return [void] mutates `opts` in place
     #
+    # @raise [ArgumentError] if `:repository` begins with `~user` for a user
+    #   that does not exist
+    #
+    # @raise [Git::Error] if the path cannot be expanded, which happens when the
+    #   process working directory has been removed
+    #
     # @api private
     #
     def normalize_clone_repository_option!(opts)
-      return unless opts.key?(:repository)
-
+      resolve_repository_alias!(opts)
       repository_val = opts.delete(:repository)
-      opts[:separate_git_dir] = repository_val if repository_val
+      return unless repository_val
+
+      opts[:separate_git_dir] =
+        PathResolver.expand_path(repository_val, PathResolver::REPOSITORY_MESSAGE, base: opts[:chdir])
     end
 
-    # Resolve paths for the cloned repository
+    # Resolve the repository, working directory, and index paths for a repository
     #
-    # @param clone_dir [String] the directory reported by `git clone`
+    # @param dir [String] the bare git directory, or the working directory of a
+    #   non-bare repository
     #
-    # @param bare [Boolean] whether the clone is bare
+    # @param bare [Boolean] whether the repository is bare
     #
     # @param index [String, nil] optional custom index path
     #
+    # @param repository [String, nil] optional custom `.git` directory path;
+    #   ignored when `bare` is `true`
+    #
     # @return [Hash{Symbol => (String, nil)}] resolved path hash
     #
     # @api private
     #
-    def resolve_clone_paths(clone_dir, bare, index)
-      args = bare ? { repository: clone_dir, bare: true } : { working_directory: clone_dir }
+    def resolve_repository_paths(dir, bare:, index:, repository: nil)
+      args = bare ? { repository: dir, bare: true } : { working_directory: dir, repository: repository }
       PathResolver.resolve_paths(**args, index: index)
     end
 
+    # Normalize the options given to {.init}
+    #
+    # Resolves the `:separate_git_dir` alias to `:repository` and expands
+    # `:repository` and `:index` before git runs, so the git directory git
+    # creates is the one the returned repository is bound to and a path that
+    # cannot be expanded is rejected before a repository is left on disk.
+    #
+    # @param options [Hash] the caller-supplied options hash
+    #
+    # @option options [String, nil] :repository path for the `.git` directory
+    #
+    # @option options [String, nil] :separate_git_dir alias for `:repository`
+    #
+    # @option options [String, nil] :index custom index path for the returned
+    #   repository
+    #
+    # @return [Hash] a new options hash with `:repository` set and expanded when
+    #   either spelling was given, and `:index` expanded when given
+    #
+    # @raise [ArgumentError] if `:repository` or `:index` begins with `~user`
+    #   for a user that does not exist
+    #
+    # @raise [Git::Error] if a path cannot be expanded, which happens when the
+    #   process working directory has been removed
+    #
+    # @api private
+    #
+    def normalize_init_options(options)
+      options = options.dup
+      resolve_repository_alias!(options)
+      expand_path_option!(options, :repository, PathResolver::REPOSITORY_MESSAGE)
+      expand_path_option!(options, :index, PathResolver::INDEX_MESSAGE)
+      options
+    end
+
+    # Resolve the `:separate_git_dir` alias onto `:repository`
+    #
+    # `:separate_git_dir` is removed. Its value becomes `:repository` unless
+    # `:repository` was given a non-nil value, which wins.
+    #
+    # @param options [Hash] factory options (mutated in place)
+    #
+    # @option options [String, nil] :repository path for the git directory
+    #
+    # @option options [String, nil] :separate_git_dir alias for `:repository`
+    #
+    # @return [void] mutates `options` in place
+    #
+    # @api private
+    #
+    def resolve_repository_alias!(options)
+      return unless options.key?(:separate_git_dir)
+
+      separate_git_dir = options.delete(:separate_git_dir)
+      options[:repository] = separate_git_dir if options[:repository].nil?
+    end
+
     # Run the `git init` command using a global execution context
     #
-    # @param directory [String] the directory to initialize
+    # @param directory [String] the absolute path of the directory to initialize
     #
     # @param options [Hash] the normalized options hash (after alias resolution)
     #
@@ -674,6 +967,9 @@ module Git
     #
     # @option options [Logger, nil] :log logger used for git operations
     #
+    # @option options [String, nil] :index custom index path for the returned
+    #   repository
+    #
     # @return [Hash{Symbol => Object}] options accepted by {.open} and {.bare}
     #
     # @api private
@@ -684,6 +980,7 @@ module Git
         binary_path: options.fetch(:binary_path, :use_global_config)
       }.tap do |open_opts|
         open_opts[:log] = options[:log] if options[:log]
+        open_opts[:index] = options[:index] if options[:index]
       end
     end
 
@@ -710,104 +1007,43 @@ module Git
     #
     def worktree_open_options_after_init(options)
       base_open_options_after_init(options).tap do |open_opts|
-        open_opts[:index] = options[:index] if options[:index]
         open_opts[:repository] = options[:repository] if options[:repository]
       end
     end
 
-    # Parse the clone directory and bare status from `git clone` stderr output
+    # Parse the directory git derived from the URL out of `git clone` stderr
+    #
+    # Only called when no directory was given to {.clone}. The name git derives
+    # is a single path component, so it never spans a line.
     #
     # @param stderr [String] stderr output from `git clone`
     #
-    # @return [Array] a two-element tuple `[clone_dir, bare]`
+    # @return [String] the clone directory git reported
     #
     # @raise [Git::UnexpectedResultError] if the stderr output cannot be parsed
     #
     # @api private
     #
-    def parse_clone_stderr(stderr)
-      match = stderr.match(/Cloning into (?:(bare repository) )?'(.+)'\.\.\./)
+    def parse_clone_directory(stderr)
+      match = stderr.match(/^Cloning into (?:bare repository )?'(.+)'\.\.\.$/)
       raise Git::UnexpectedResultError, "Unable to determine clone directory from: #{stderr}" unless match
 
-      [match[2], !match[1].nil?]
+      match[1]
     end
 
-    # Handle the deprecated `:path` option for {clone}
-    #
-    # @param opts [Hash] clone options (mutated in place)
-    #
-    # @option opts [String, Pathname, nil] :path deprecated; use `:chdir`
-    #   instead
+    # Whether `git clone` reported that it created a bare repository
     #
-    # @option opts [String, Pathname, nil] :chdir run `git clone` from within
-    #   this directory
-    #
-    # @return [void] mutates `opts` in place
-    #
-    # @api private
-    #
-    def deprecate_clone_path_option!(opts)
-      return unless opts.key?(:path)
-
-      if defined?(Git::Deprecation)
-        Git::Deprecation.warn(
-          'The :path option for Git.clone is deprecated and will be removed in v6.0.0. ' \
-          'Use :chdir instead.'
-        )
-      end
-      path = opts.delete(:path)
-      opts[:chdir] ||= path
-    end
-
-    # Handle the deprecated `:recursive` option for {clone}
+    # Matches only the fixed prefix of git's progress line, so a destination
+    # that spans several lines does not affect the result.
     #
-    # @param opts [Hash] clone options (mutated in place)
-    #
-    # @option opts [Boolean, nil] :recursive deprecated; use
-    #   `:recurse_submodules` instead
-    #
-    # @option opts [Boolean, String, Array<String>, nil] :recurse_submodules
-    #   initialize submodules after cloning
-    #
-    # @return [void] mutates `opts` in place
-    #
-    # @api private
-    #
-    def deprecate_clone_recursive_option!(opts)
-      return unless opts.key?(:recursive)
-
-      if defined?(Git::Deprecation)
-        Git::Deprecation.warn(
-          'The :recursive option for Git.clone is deprecated and will be removed in v6.0.0. ' \
-          'Use :recurse_submodules instead.'
-        )
-      end
-      opts[:recurse_submodules] = opts.delete(:recursive)
-    end
-
-    # Handle the deprecated `:remote` option for {clone}
-    #
-    # @param opts [Hash] clone options (mutated in place)
-    #
-    # @option opts [String, nil] :remote deprecated; use `:origin` instead
-    #
-    # @option opts [String, nil] :origin remote name to use instead of
-    #   `origin`
+    # @param stderr [String] stderr output from `git clone`
     #
-    # @return [void] mutates `opts` in place
+    # @return [Boolean] true when git reported a bare repository
     #
     # @api private
     #
-    def deprecate_clone_remote_option!(opts)
-      return unless opts.key?(:remote)
-
-      if defined?(Git::Deprecation)
-        Git::Deprecation.warn(
-          'The :remote option for Git.clone is deprecated and will be removed in v6.0.0. ' \
-          'Use :origin instead.'
-        )
-      end
-      opts[:origin] = opts.delete(:remote)
+    def bare_clone?(stderr)
+      stderr.match?(/^Cloning into bare repository '/)
     end
   end
 end