rugged 1.7.2 → 1.9.0

data/vendor/libgit2/src/libgit2/checkout.c

@@ -30,8 +30,8 @@
 #include "fs_path.h"
 #include "attr.h"
 #include "pool.h"
-#include "strmap.h"
 #include "path.h"
+#include "hashmap_str.h"
 
 /* See docs/checkout-internals.md for more information */
 
@@ -72,7 +72,7 @@ typedef struct {
 	size_t total_steps;
 	size_t completed_steps;
 	git_checkout_perfdata perfdata;
-	git_strmap *mkdir_map;
+	git_hashset_str mkdir_pathcache;
 	git_attr_session attr_session;
 } checkout_data;
 
@@ -294,6 +294,9 @@ static int checkout_action_no_wd(
 
 	*action = CHECKOUT_ACTION__NONE;
 
+	if ((data->strategy & GIT_CHECKOUT_NONE))
+		return 0;
+
 	switch (delta->status) {
 	case GIT_DELTA_UNMODIFIED: /* case 12 */
 		error = checkout_notify(data, GIT_CHECKOUT_NOTIFY_DIRTY, delta, NULL);
@@ -302,17 +305,17 @@ static int checkout_action_no_wd(
 		*action = CHECKOUT_ACTION_IF(RECREATE_MISSING, UPDATE_BLOB, NONE);
 		break;
 	case GIT_DELTA_ADDED:    /* case 2 or 28 (and 5 but not really) */
-		*action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
+		*action = CHECKOUT_ACTION__UPDATE_BLOB;
 		break;
 	case GIT_DELTA_MODIFIED: /* case 13 (and 35 but not really) */
 		*action = CHECKOUT_ACTION_IF(RECREATE_MISSING, UPDATE_BLOB, CONFLICT);
 		break;
 	case GIT_DELTA_TYPECHANGE: /* case 21 (B->T) and 28 (T->B)*/
 		if (delta->new_file.mode == GIT_FILEMODE_TREE)
-			*action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
+			*action = CHECKOUT_ACTION__UPDATE_BLOB;
 		break;
 	case GIT_DELTA_DELETED: /* case 8 or 25 */
-		*action = CHECKOUT_ACTION_IF(SAFE, REMOVE, NONE);
+		*action = CHECKOUT_ACTION__REMOVE;
 		break;
 	default: /* impossible */
 		break;
@@ -494,6 +497,9 @@ static int checkout_action_with_wd(
 {
 	*action = CHECKOUT_ACTION__NONE;
 
+	if ((data->strategy & GIT_CHECKOUT_NONE))
+		return 0;
+
 	switch (delta->status) {
 	case GIT_DELTA_UNMODIFIED: /* case 14/15 or 33 */
 		if (checkout_is_workdir_modified(data, &delta->old_file, &delta->new_file, wd)) {
@@ -512,14 +518,14 @@ static int checkout_action_with_wd(
 		if (checkout_is_workdir_modified(data, &delta->old_file, &delta->new_file, wd))
 			*action = CHECKOUT_ACTION_IF(FORCE, REMOVE, CONFLICT);
 		else
-			*action = CHECKOUT_ACTION_IF(SAFE, REMOVE, NONE);
+			*action = CHECKOUT_ACTION__REMOVE;
 		break;
 	case GIT_DELTA_MODIFIED: /* case 16, 17, 18 (or 36 but not really) */
 		if (wd->mode != GIT_FILEMODE_COMMIT &&
 			checkout_is_workdir_modified(data, &delta->old_file, &delta->new_file, wd))
 			*action = CHECKOUT_ACTION_IF(FORCE, UPDATE_BLOB, CONFLICT);
 		else
-			*action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
+			*action = CHECKOUT_ACTION__UPDATE_BLOB;
 		break;
 	case GIT_DELTA_TYPECHANGE: /* case 22, 23, 29, 30 */
 		if (delta->old_file.mode == GIT_FILEMODE_TREE) {
@@ -527,13 +533,13 @@ static int checkout_action_with_wd(
 				/* either deleting items in old tree will delete the wd dir,
 				 * or we'll get a conflict when we attempt blob update...
 				 */
-				*action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
+				*action = CHECKOUT_ACTION__UPDATE_BLOB;
 			else if (wd->mode == GIT_FILEMODE_COMMIT) {
 				/* workdir is possibly a "phantom" submodule - treat as a
 				 * tree if the only submodule info came from the config
 				 */
 				if (submodule_is_config_only(data, wd->path))
-					*action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
+					*action = CHECKOUT_ACTION__UPDATE_BLOB;
 				else
 					*action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);
 			} else
@@ -542,7 +548,7 @@ static int checkout_action_with_wd(
 		else if (checkout_is_workdir_modified(data, &delta->old_file, &delta->new_file, wd))
 			*action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);
 		else
-			*action = CHECKOUT_ACTION_IF(SAFE, REMOVE_AND_UPDATE, NONE);
+			*action = CHECKOUT_ACTION__REMOVE_AND_UPDATE;
 
 		/* don't update if the typechange is to a tree */
 		if (delta->new_file.mode == GIT_FILEMODE_TREE)
@@ -563,6 +569,9 @@ static int checkout_action_with_wd_blocker(
 {
 	*action = CHECKOUT_ACTION__NONE;
 
+	if ((data->strategy & GIT_CHECKOUT_NONE))
+		return 0;
+
 	switch (delta->status) {
 	case GIT_DELTA_UNMODIFIED:
 		/* should show delta as dirty / deleted */
@@ -597,6 +606,9 @@ static int checkout_action_with_wd_dir(
 {
 	*action = CHECKOUT_ACTION__NONE;
 
+	if ((data->strategy & GIT_CHECKOUT_NONE))
+		return 0;
+
 	switch (delta->status) {
 	case GIT_DELTA_UNMODIFIED: /* case 19 or 24 (or 34 but not really) */
 		GIT_ERROR_CHECK_ERROR(
@@ -627,7 +639,7 @@ static int checkout_action_with_wd_dir(
 			 * directory if is it left empty, so we can defer removing the
 			 * dir and it will succeed if no children are left.
 			 */
-			*action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
+			*action = CHECKOUT_ACTION__UPDATE_BLOB;
 		}
 		else if (delta->new_file.mode != GIT_FILEMODE_TREE)
 			/* For typechange to dir, dir is already created so no action */
@@ -1419,8 +1431,10 @@ static int checkout_mkdir(
 	struct git_futils_mkdir_options mkdir_opts = {0};
 	int error;
 
-	mkdir_opts.dir_map = data->mkdir_map;
-	mkdir_opts.pool = &data->pool;
+	if (git_pool_is_initialized(&data->pool)) {
+		mkdir_opts.cache_pool = &data->pool;
+		mkdir_opts.cache_pathset = &data->mkdir_pathcache;
+	}
 
 	error = git_futils_mkdir_relative(
 		path, base, mode, flags, &mkdir_opts);
@@ -2316,11 +2330,11 @@ static void checkout_data_clear(checkout_data *data)
 		data->opts.baseline = NULL;
 	}
 
-	git_vector_free(&data->removes);
+	git_vector_dispose(&data->removes);
 	git_pool_clear(&data->pool);
 
-	git_vector_free_deep(&data->remove_conflicts);
-	git_vector_free_deep(&data->update_conflicts);
+	git_vector_dispose_deep(&data->remove_conflicts);
+	git_vector_dispose_deep(&data->update_conflicts);
 
 	git__free(data->pfx);
 	data->pfx = NULL;
@@ -2331,8 +2345,7 @@ static void checkout_data_clear(checkout_data *data)
 	git_index_free(data->index);
 	data->index = NULL;
 
-	git_strmap_free(data->mkdir_map);
-	data->mkdir_map = NULL;
+	git_hashset_str_dispose(&data->mkdir_pathcache);
 
 	git_attr_session__free(&data->attr_session);
 }
@@ -2432,14 +2445,12 @@ static int checkout_data_init(
 
 	/* if you are forcing, allow all safe updates, plus recreate missing */
 	if ((data->opts.checkout_strategy & GIT_CHECKOUT_FORCE) != 0)
-		data->opts.checkout_strategy |= GIT_CHECKOUT_SAFE |
-			GIT_CHECKOUT_RECREATE_MISSING;
+		data->opts.checkout_strategy |= GIT_CHECKOUT_RECREATE_MISSING;
 
 	/* if the repository does not actually have an index file, then this
 	 * is an initial checkout (perhaps from clone), so we allow safe updates
 	 */
-	if (!data->index->on_disk &&
-		(data->opts.checkout_strategy & GIT_CHECKOUT_SAFE) != 0)
+	if (!data->index->on_disk)
 		data->opts.checkout_strategy |= GIT_CHECKOUT_RECREATE_MISSING;
 
 	data->strategy = data->opts.checkout_strategy;
@@ -2513,8 +2524,7 @@ static int checkout_data_init(
 	    (error = git_vector_init(&data->remove_conflicts, 0, NULL)) < 0 ||
 	    (error = git_vector_init(&data->update_conflicts, 0, NULL)) < 0 ||
 	    (error = git_str_puts(&data->target_path, data->opts.target_directory)) < 0 ||
-	    (error = git_fs_path_to_dir(&data->target_path)) < 0 ||
-	    (error = git_strmap_new(&data->mkdir_map)) < 0)
+	    (error = git_fs_path_to_dir(&data->target_path)) < 0)
 		goto cleanup;
 
 	data->target_len = git_str_len(&data->target_path);

data/vendor/libgit2/src/libgit2/checkout.h

@@ -12,8 +12,6 @@
 #include "git2/checkout.h"
 #include "iterator.h"
 
-#define GIT_CHECKOUT__NOTIFY_CONFLICT_TREE (1u << 12)
-
 /**
  * Update the working directory to match the target iterator.  The
  * expected baseline value can be passed in via the checkout options

data/vendor/libgit2/src/libgit2/cherrypick.c

@@ -73,8 +73,7 @@ static int cherrypick_normalize_opts(
 	const char *their_label)
 {
 	int error = 0;
-	unsigned int default_checkout_strategy = GIT_CHECKOUT_SAFE |
-		GIT_CHECKOUT_ALLOW_CONFLICTS;
+	unsigned int default_checkout_strategy = GIT_CHECKOUT_ALLOW_CONFLICTS;
 
 	GIT_UNUSED(repo);
 

data/vendor/libgit2/src/libgit2/clone.c

@@ -16,14 +16,14 @@
 #include "git2/commit.h"
 #include "git2/tree.h"
 
+#include "checkout.h"
 #include "remote.h"
 #include "futils.h"
 #include "refs.h"
 #include "fs_path.h"
 #include "repository.h"
 #include "odb.h"
-
-static int clone_local_into(git_repository *repo, git_remote *remote, const git_fetch_options *fetch_opts, const git_checkout_options *co_opts, const char *branch, int link);
+#include "net.h"
 
 static int create_branch(
 	git_reference **branch,
@@ -336,8 +336,9 @@ static int create_and_configure_origin(
 	git_remote_create_cb remote_create = options->remote_cb;
 	void *payload = options->remote_cb_payload;
 
-	/* If the path exists and is a dir, the url should be the absolute path */
-	if (git_fs_path_root(url) < 0 && git_fs_path_exists(url) && git_fs_path_isdir(url)) {
+	/* If the path is local and exists it should be the absolute path. */
+	if (!git_net_str_is_url(url) && git_fs_path_root(url) < 0 &&
+	    git_fs_path_exists(url)) {
 		if (p_realpath(url, buf) == NULL)
 			return -1;
 
@@ -360,35 +361,50 @@ on_error:
 	return error;
 }
 
-static bool should_checkout(
+static int should_checkout(
+	bool *out,
 	git_repository *repo,
 	bool is_bare,
-	const git_checkout_options *opts)
+	const git_clone_options *opts)
 {
-	if (is_bare)
-		return false;
+	int error;
 
-	if (!opts)
-		return false;
+	if (!opts || is_bare ||
+	    opts->checkout_opts.checkout_strategy == GIT_CHECKOUT_NONE) {
+		*out = false;
+		return 0;
+	}
 
-	if (opts->checkout_strategy == GIT_CHECKOUT_NONE)
-		return false;
+	if ((error = git_repository_head_unborn(repo)) < 0)
+		return error;
 
-	return !git_repository_head_unborn(repo);
+	*out = !error;
+	return 0;
 }
 
-static int checkout_branch(git_repository *repo, git_remote *remote, const git_checkout_options *co_opts, const char *branch, const char *reflog_message)
+static int checkout_branch(
+	git_repository *repo,
+	git_remote *remote,
+	const git_clone_options *opts,
+	const char *reflog_message)
 {
+	bool checkout;
 	int error;
 
-	if (branch)
-		error = update_head_to_branch(repo, remote, branch, reflog_message);
+	if (opts->checkout_branch)
+		error = update_head_to_branch(repo, remote, opts->checkout_branch, reflog_message);
 	/* Point HEAD to the same ref as the remote's head */
 	else
 		error = update_head_to_remote(repo, remote, reflog_message);
 
-	if (!error && should_checkout(repo, git_repository_is_bare(repo), co_opts))
-		error = git_checkout_head(repo, co_opts);
+	if (error < 0)
+		return error;
+
+	if ((error = should_checkout(&checkout, repo, git_repository_is_bare(repo), opts)) < 0)
+		return error;
+
+	if (checkout)
+		error = git_checkout_head(repo, &opts->checkout_opts);
 
 	return error;
 }
@@ -396,16 +412,13 @@ static int checkout_branch(git_repository *repo, git_remote *remote, const git_c
 static int clone_into(
 	git_repository *repo,
 	git_remote *_remote,
-	const git_fetch_options *opts,
-	const git_checkout_options *co_opts,
-	const char *branch)
+	const git_clone_options *opts)
 {
-	int error;
 	git_str reflog_message = GIT_STR_INIT;
 	git_remote_connect_options connect_opts = GIT_REMOTE_CONNECT_OPTIONS_INIT;
-	git_fetch_options fetch_opts;
 	git_remote *remote;
 	git_oid_t oid_type;
+	int error;
 
 	GIT_ASSERT_ARG(repo);
 	GIT_ASSERT_ARG(_remote);
@@ -418,13 +431,7 @@ static int clone_into(
 	if ((error = git_remote_dup(&remote, _remote)) < 0)
 		return error;
 
-	memcpy(&fetch_opts, opts, sizeof(git_fetch_options));
-	fetch_opts.update_fetchhead = 0;
-
-	if (!opts->depth)
-		fetch_opts.download_tags = GIT_REMOTE_DOWNLOAD_TAGS_ALL;
-
-	if ((error = git_remote_connect_options__from_fetch_opts(&connect_opts, remote, &fetch_opts)) < 0)
+	if ((error = git_remote_connect_options__from_fetch_opts(&connect_opts, remote, &opts->fetch_opts)) < 0)
 		goto cleanup;
 
 	git_str_printf(&reflog_message, "clone: from %s", git_remote_url(remote));
@@ -442,10 +449,10 @@ static int clone_into(
 	    (error = git_repository__set_objectformat(repo, oid_type)) < 0)
 		goto cleanup;
 
-	if ((error = git_remote_fetch(remote, NULL, &fetch_opts, git_str_cstr(&reflog_message))) != 0)
+	if ((error = git_remote_fetch(remote, NULL, &opts->fetch_opts, git_str_cstr(&reflog_message))) != 0)
 		goto cleanup;
 
-	error = checkout_branch(repo, remote, co_opts, branch, git_str_cstr(&reflog_message));
+	error = checkout_branch(repo, remote, opts, git_str_cstr(&reflog_message));
 
 cleanup:
 	git_remote_free(remote);
@@ -455,37 +462,142 @@ cleanup:
 	return error;
 }
 
-int git_clone__should_clone_local(const char *url_or_path, git_clone_local_t local)
+static bool can_link(const char *src, const char *dst, int link)
+{
+#ifdef GIT_WIN32
+	GIT_UNUSED(src);
+	GIT_UNUSED(dst);
+	GIT_UNUSED(link);
+	return false;
+#else
+
+	struct stat st_src, st_dst;
+
+	if (!link)
+		return false;
+
+	if (p_stat(src, &st_src) < 0)
+		return false;
+
+	if (p_stat(dst, &st_dst) < 0)
+		return false;
+
+	return st_src.st_dev == st_dst.st_dev;
+#endif
+}
+
+static int clone_local_into(
+	git_repository *repo,
+	git_remote *remote,
+	const git_clone_options *opts)
+{
+	int error, flags;
+	git_repository *src;
+	git_str src_odb = GIT_STR_INIT, dst_odb = GIT_STR_INIT, src_path = GIT_STR_INIT;
+	git_str reflog_message = GIT_STR_INIT;
+	bool link = (opts && opts->local != GIT_CLONE_LOCAL_NO_LINKS);
+
+	GIT_ASSERT_ARG(repo);
+	GIT_ASSERT_ARG(remote);
+
+	if (!git_repository_is_empty(repo)) {
+		git_error_set(GIT_ERROR_INVALID, "the repository is not empty");
+		return -1;
+	}
+
+	/*
+	 * Let's figure out what path we should use for the source
+	 * repo, if it's not rooted, the path should be relative to
+	 * the repository's worktree/gitdir.
+	 */
+	if ((error = git_fs_path_from_url_or_path(&src_path, git_remote_url(remote))) < 0)
+		return error;
+
+	/* Copy .git/objects/ from the source to the target */
+	if ((error = git_repository_open(&src, git_str_cstr(&src_path))) < 0) {
+		git_str_dispose(&src_path);
+		return error;
+	}
+
+	if (git_repository__item_path(&src_odb, src, GIT_REPOSITORY_ITEM_OBJECTS) < 0 ||
+	    git_repository__item_path(&dst_odb, repo, GIT_REPOSITORY_ITEM_OBJECTS) < 0) {
+		error = -1;
+		goto cleanup;
+	}
+
+	flags = 0;
+	if (can_link(git_repository_path(src), git_repository_path(repo), link))
+		flags |= GIT_CPDIR_LINK_FILES;
+
+	error = git_futils_cp_r(git_str_cstr(&src_odb), git_str_cstr(&dst_odb),
+				flags, GIT_OBJECT_DIR_MODE);
+
+	/*
+	 * can_link() doesn't catch all variations, so if we hit an
+	 * error and did want to link, let's try again without trying
+	 * to link.
+	 */
+	if (error < 0 && link) {
+		flags &= ~GIT_CPDIR_LINK_FILES;
+		error = git_futils_cp_r(git_str_cstr(&src_odb), git_str_cstr(&dst_odb),
+					flags, GIT_OBJECT_DIR_MODE);
+	}
+
+	if (error < 0)
+		goto cleanup;
+
+	git_str_printf(&reflog_message, "clone: from %s", git_remote_url(remote));
+
+	if ((error = git_remote_fetch(remote, NULL, &opts->fetch_opts, git_str_cstr(&reflog_message))) != 0)
+		goto cleanup;
+
+	error = checkout_branch(repo, remote, opts, git_str_cstr(&reflog_message));
+
+cleanup:
+	git_str_dispose(&reflog_message);
+	git_str_dispose(&src_path);
+	git_str_dispose(&src_odb);
+	git_str_dispose(&dst_odb);
+	git_repository_free(src);
+	return error;
+}
+
+int git_clone__should_clone_local(
+	bool *out,
+	const char *url_or_path,
+	git_clone_local_t local)
 {
 	git_str fromurl = GIT_STR_INIT;
-	const char *path = url_or_path;
-	bool is_url, is_local;
+
+	*out = false;
 
 	if (local == GIT_CLONE_NO_LOCAL)
 		return 0;
 
-	if ((is_url = git_fs_path_is_local_file_url(url_or_path)) != 0) {
-		if (git_fs_path_fromurl(&fromurl, url_or_path) < 0) {
-			is_local = -1;
-			goto done;
-		}
+	if (git_net_str_is_url(url_or_path)) {
+		/* If GIT_CLONE_LOCAL_AUTO is specified, any url should
+		 * be treated as remote */
+		if (local == GIT_CLONE_LOCAL_AUTO ||
+		    !git_fs_path_is_local_file_url(url_or_path))
+			return 0;
 
-		path = fromurl.ptr;
-	}
+		if (git_fs_path_fromurl(&fromurl, url_or_path) < 0)
+			return -1;
 
-	is_local = (!is_url || local != GIT_CLONE_LOCAL_AUTO) &&
-		git_fs_path_isdir(path);
+		*out = git_fs_path_isdir(git_str_cstr(&fromurl));
+		git_str_dispose(&fromurl);
+	} else {
+		*out = git_fs_path_isdir(url_or_path);
+	}
 
-done:
-	git_str_dispose(&fromurl);
-	return is_local;
+	return 0;
 }
 
-static int git__clone(
+static int clone_repo(
 	git_repository **out,
 	const char *url,
 	const char *local_path,
-	const git_clone_options *_options,
+	const git_clone_options *given_opts,
 	int use_existing)
 {
 	int error = 0;
@@ -499,11 +611,17 @@ static int git__clone(
 	GIT_ASSERT_ARG(url);
 	GIT_ASSERT_ARG(local_path);
 
-	if (_options)
-		memcpy(&options, _options, sizeof(git_clone_options));
+	if (given_opts)
+		memcpy(&options, given_opts, sizeof(git_clone_options));
 
 	GIT_ERROR_CHECK_VERSION(&options, GIT_CLONE_OPTIONS_VERSION, "git_clone_options");
 
+	/* enforce some behavior on fetch */
+	options.fetch_opts.update_fetchhead = 0;
+
+	if (!options.fetch_opts.depth)
+		options.fetch_opts.download_tags = GIT_REMOTE_DOWNLOAD_TAGS_ALL;
+
 	/* Only clone to a new directory or an empty directory */
 	if (git_fs_path_exists(local_path) && !use_existing && !git_fs_path_is_empty_dir(local_path)) {
 		git_error_set(GIT_ERROR_INVALID,
@@ -524,33 +642,31 @@ static int git__clone(
 		return error;
 
 	if (!(error = create_and_configure_origin(&origin, repo, url, &options))) {
-		int clone_local = git_clone__should_clone_local(url, options.local);
-		int link = options.local != GIT_CLONE_LOCAL_NO_LINKS;
-
-		if (clone_local == 1)
-			error = clone_local_into(
-				repo, origin, &options.fetch_opts, &options.checkout_opts,
-				options.checkout_branch, link);
-		else if (clone_local == 0)
-			error = clone_into(
-				repo, origin, &options.fetch_opts, &options.checkout_opts,
-				options.checkout_branch);
+		bool clone_local;
+
+		if ((error = git_clone__should_clone_local(&clone_local, url, options.local)) < 0) {
+			git_remote_free(origin);
+			return error;
+		}
+
+		if (clone_local)
+			error = clone_local_into(repo, origin, &options);
 		else
-			error = -1;
+			error = clone_into(repo, origin, &options);
 
 		git_remote_free(origin);
 	}
 
 	if (error != 0) {
-		git_error_state last_error = {0};
-		git_error_state_capture(&last_error, error);
+		git_error *last_error;
+		git_error_save(&last_error);
 
 		git_repository_free(repo);
 		repo = NULL;
 
 		(void)git_futils_rmdir_r(local_path, NULL, rmdir_flags);
 
-		git_error_state_restore(&last_error);
+		git_error_restore(last_error);
 	}
 
 	*out = repo;
@@ -561,18 +677,18 @@ int git_clone(
 	git_repository **out,
 	const char *url,
 	const char *local_path,
-	const git_clone_options *_options)
+	const git_clone_options *options)
 {
-	return git__clone(out, url, local_path, _options, 0);
+	return clone_repo(out, url, local_path, options, 0);
 }
 
 int git_clone__submodule(
 	git_repository **out,
 	const char *url,
 	const char *local_path,
-	const git_clone_options *_options)
+	const git_clone_options *options)
 {
-	return git__clone(out, url, local_path, _options, 1);
+	return clone_repo(out, url, local_path, options, 1);
 }
 
 int git_clone_options_init(git_clone_options *opts, unsigned int version)
@@ -588,99 +704,3 @@ int git_clone_init_options(git_clone_options *opts, unsigned int version)
 	return git_clone_options_init(opts, version);
 }
 #endif
-
-static bool can_link(const char *src, const char *dst, int link)
-{
-#ifdef GIT_WIN32
-	GIT_UNUSED(src);
-	GIT_UNUSED(dst);
-	GIT_UNUSED(link);
-	return false;
-#else
-
-	struct stat st_src, st_dst;
-
-	if (!link)
-		return false;
-
-	if (p_stat(src, &st_src) < 0)
-		return false;
-
-	if (p_stat(dst, &st_dst) < 0)
-		return false;
-
-	return st_src.st_dev == st_dst.st_dev;
-#endif
-}
-
-static int clone_local_into(git_repository *repo, git_remote *remote, const git_fetch_options *fetch_opts, const git_checkout_options *co_opts, const char *branch, int link)
-{
-	int error, flags;
-	git_repository *src;
-	git_str src_odb = GIT_STR_INIT, dst_odb = GIT_STR_INIT, src_path = GIT_STR_INIT;
-	git_str reflog_message = GIT_STR_INIT;
-
-	GIT_ASSERT_ARG(repo);
-	GIT_ASSERT_ARG(remote);
-
-	if (!git_repository_is_empty(repo)) {
-		git_error_set(GIT_ERROR_INVALID, "the repository is not empty");
-		return -1;
-	}
-
-	/*
-	 * Let's figure out what path we should use for the source
-	 * repo, if it's not rooted, the path should be relative to
-	 * the repository's worktree/gitdir.
-	 */
-	if ((error = git_fs_path_from_url_or_path(&src_path, git_remote_url(remote))) < 0)
-		return error;
-
-	/* Copy .git/objects/ from the source to the target */
-	if ((error = git_repository_open(&src, git_str_cstr(&src_path))) < 0) {
-		git_str_dispose(&src_path);
-		return error;
-	}
-
-	if (git_repository__item_path(&src_odb, src, GIT_REPOSITORY_ITEM_OBJECTS) < 0 ||
-	    git_repository__item_path(&dst_odb, repo, GIT_REPOSITORY_ITEM_OBJECTS) < 0) {
-		error = -1;
-		goto cleanup;
-	}
-
-	flags = 0;
-	if (can_link(git_repository_path(src), git_repository_path(repo), link))
-		flags |= GIT_CPDIR_LINK_FILES;
-
-	error = git_futils_cp_r(git_str_cstr(&src_odb), git_str_cstr(&dst_odb),
-				flags, GIT_OBJECT_DIR_MODE);
-
-	/*
-	 * can_link() doesn't catch all variations, so if we hit an
-	 * error and did want to link, let's try again without trying
-	 * to link.
-	 */
-	if (error < 0 && link) {
-		flags &= ~GIT_CPDIR_LINK_FILES;
-		error = git_futils_cp_r(git_str_cstr(&src_odb), git_str_cstr(&dst_odb),
-					flags, GIT_OBJECT_DIR_MODE);
-	}
-
-	if (error < 0)
-		goto cleanup;
-
-	git_str_printf(&reflog_message, "clone: from %s", git_remote_url(remote));
-
-	if ((error = git_remote_fetch(remote, NULL, fetch_opts, git_str_cstr(&reflog_message))) != 0)
-		goto cleanup;
-
-	error = checkout_branch(repo, remote, co_opts, branch, git_str_cstr(&reflog_message));
-
-cleanup:
-	git_str_dispose(&reflog_message);
-	git_str_dispose(&src_path);
-	git_str_dispose(&src_odb);
-	git_str_dispose(&dst_odb);
-	git_repository_free(src);
-	return error;
-}