rugged 0.22.2 → 0.23.0b1

data/vendor/libgit2/src/repository.c

@@ -26,6 +26,7 @@
 #include "remote.h"
 #include "merge.h"
 #include "diff_driver.h"
+#include "annotated_commit.h"
 
 #ifdef GIT_WIN32
 # include "win32/w32_util.h"
@@ -37,8 +38,16 @@
 
 #define GIT_REPO_VERSION 0
 
-const char *git_repository__8dot3_default = "GIT~1";
-size_t git_repository__8dot3_default_len = 5;
+git_buf git_repository__reserved_names_win32[] = {
+	{ DOT_GIT, 0, CONST_STRLEN(DOT_GIT) },
+	{ GIT_DIR_SHORTNAME, 0, CONST_STRLEN(GIT_DIR_SHORTNAME) }
+};
+size_t git_repository__reserved_names_win32_len = 2;
+
+git_buf git_repository__reserved_names_posix[] = {
+	{ DOT_GIT, 0, CONST_STRLEN(DOT_GIT) },
+};
+size_t git_repository__reserved_names_posix_len = 1;
 
 static void set_odb(git_repository *repo, git_odb *odb)
 {
@@ -110,6 +119,8 @@ void git_repository__cleanup(git_repository *repo)
 
 void git_repository_free(git_repository *repo)
 {
+	size_t i;
+
 	if (repo == NULL)
 		return;
 
@@ -120,10 +131,14 @@ void git_repository_free(git_repository *repo)
 	git_diff_driver_registry_free(repo->diff_drivers);
 	repo->diff_drivers = NULL;
 
+	for (i = 0; i < repo->reserved_names.size; i++)
+		git_buf_free(git_array_get(repo->reserved_names, i));
+
 	git__free(repo->path_repository);
 	git__free(repo->workdir);
 	git__free(repo->namespace);
-	git__free(repo->name_8dot3);
+	git__free(repo->ident_name);
+	git__free(repo->ident_email);
 
 	git__memzero(repo, sizeof(*repo));
 	git__free(repo);
@@ -153,23 +168,37 @@ static bool valid_repository_path(git_buf *repository_path)
 static git_repository *repository_alloc(void)
 {
 	git_repository *repo = git__calloc(1, sizeof(git_repository));
-	if (!repo)
-		return NULL;
 
-	if (git_cache_init(&repo->objects) < 0) {
-		git__free(repo);
-		return NULL;
-	}
+	if (repo == NULL ||
+		git_cache_init(&repo->objects) < 0)
+		goto on_error;
+
+	git_array_init_to_size(repo->reserved_names, 4);
+	if (!repo->reserved_names.ptr)
+		goto on_error;
 
 	/* set all the entries in the cvar cache to `unset` */
 	git_repository__cvar_cache_clear(repo);
 
 	return repo;
+
+on_error:
+	if (repo)
+		git_cache_free(&repo->objects);
+
+	git__free(repo);
+	return NULL;
 }
 
 int git_repository_new(git_repository **out)
 {
-	*out = repository_alloc();
+	git_repository *repo;
+
+	*out = repo = repository_alloc();
+	GITERR_CHECK_ALLOC(repo);
+
+	repo->is_bare = 1;
+
 	return 0;
 }
 
@@ -189,7 +218,7 @@ static int load_config_data(git_repository *repo, const git_config *config)
 static int load_workdir(git_repository *repo, git_config *config, git_buf *parent_path)
 {
 	int         error;
-	const git_config_entry *ce;
+	git_config_entry *ce;
 	git_buf     worktree = GIT_BUF_INIT;
 
 	if (repo->is_bare)
@@ -202,7 +231,7 @@ static int load_workdir(git_repository *repo, git_config *config, git_buf *paren
 	if (ce && ce->value) {
 		if ((error = git_path_prettify_dir(
 				&worktree, ce->value, repo->path_repository)) < 0)
-			return error;
+			goto cleanup;
 
 		repo->workdir = git_buf_detach(&worktree);
 	}
@@ -210,14 +239,18 @@ static int load_workdir(git_repository *repo, git_config *config, git_buf *paren
 		repo->workdir = git_buf_detach(parent_path);
 	else {
 		if (git_path_dirname_r(&worktree, repo->path_repository) < 0 ||
-			git_path_to_dir(&worktree) < 0)
-			return -1;
+		    git_path_to_dir(&worktree) < 0) {
+			error = -1;
+			goto cleanup;
+		}
 
 		repo->workdir = git_buf_detach(&worktree);
 	}
 
 	GITERR_CHECK_ALLOC(repo->workdir);
-	return 0;
+cleanup:
+	git_config_entry_free(ce);
+	return error;
 }
 
 /*
@@ -314,6 +347,7 @@ static int read_gitfile(git_buf *path_out, const char *file_path)
 static int find_repo(
 	git_buf *repo_path,
 	git_buf *parent_path,
+	git_buf *link_path,
 	const char *start_path,
 	uint32_t flags,
 	const char *ceiling_dirs)
@@ -356,9 +390,14 @@ static int find_repo(
 				git_buf repo_link = GIT_BUF_INIT;
 
 				if (!(error = read_gitfile(&repo_link, path.ptr))) {
-					if (valid_repository_path(&repo_link))
+					if (valid_repository_path(&repo_link)) {
 						git_buf_swap(repo_path, &repo_link);
 
+						if (link_path)
+							error = git_buf_put(link_path, 
+								path.ptr, path.size);
+					}
+
 					git_buf_free(&repo_link);
 					break;
 				}
@@ -445,13 +484,16 @@ int git_repository_open_ext(
 	const char *ceiling_dirs)
 {
 	int error;
-	git_buf path = GIT_BUF_INIT, parent = GIT_BUF_INIT;
+	git_buf path = GIT_BUF_INIT, parent = GIT_BUF_INIT,
+		link_path = GIT_BUF_INIT;
 	git_repository *repo;
 
 	if (repo_ptr)
 		*repo_ptr = NULL;
 
-	error = find_repo(&path, &parent, start_path, flags, ceiling_dirs);
+	error = find_repo(
+		&path, &parent, &link_path, start_path, flags, ceiling_dirs);
+
 	if (error < 0 || !repo_ptr)
 		return error;
 
@@ -461,6 +503,11 @@ int git_repository_open_ext(
 	repo->path_repository = git_buf_detach(&path);
 	GITERR_CHECK_ALLOC(repo->path_repository);
 
+	if (link_path.size) {
+		repo->path_gitlink = git_buf_detach(&link_path);
+		GITERR_CHECK_ALLOC(repo->path_gitlink);
+	}
+
 	if ((flags & GIT_REPOSITORY_OPEN_BARE) != 0)
 		repo->is_bare = 1;
 	else {
@@ -512,7 +559,7 @@ int git_repository_discover(
 
 	git_buf_sanitize(out);
 
-	return find_repo(out, NULL, start_path, flags, ceiling_dirs);
+	return find_repo(out, NULL, NULL, start_path, flags, ceiling_dirs);
 }
 
 static int load_config(
@@ -776,7 +823,7 @@ int git_repository_index(git_index **out, git_repository *repo)
 
 void git_repository_set_index(git_repository *repo, git_index *index)
 {
-	assert(repo && index);
+	assert(repo);
 	set_index(repo, index);
 }
 
@@ -797,27 +844,88 @@ const char *git_repository_get_namespace(git_repository *repo)
 	return repo->namespace;
 }
 
-const char *git_repository__8dot3_name(git_repository *repo)
+#ifdef GIT_WIN32
+static int reserved_names_add8dot3(git_repository *repo, const char *path)
 {
-	if (!repo->has_8dot3) {
-		repo->has_8dot3 = 1;
+	char *name = git_win32_path_8dot3_name(path);
+	const char *def = GIT_DIR_SHORTNAME;
+	size_t name_len, def_len = CONST_STRLEN(GIT_DIR_SHORTNAME);
+	git_buf *buf;
 
-#ifdef GIT_WIN32
+	if (!name)
+		return 0;
+
+	name_len = strlen(name);
+
+	if (name_len == def_len && memcmp(name, def, def_len) == 0) {
+		git__free(name);
+		return 0;
+	}
+
+	if ((buf = git_array_alloc(repo->reserved_names)) == NULL)
+		return -1;
+
+	git_buf_attach(buf, name, name_len);
+	return true;
+}
+
+bool git_repository__reserved_names(
+	git_buf **out, size_t *outlen, git_repository *repo, bool include_ntfs)
+{
+	GIT_UNUSED(include_ntfs);
+
+	if (repo->reserved_names.size == 0) {
+		git_buf *buf;
+		size_t i;
+
+		/* Add the static defaults */
+		for (i = 0; i < git_repository__reserved_names_win32_len; i++) {
+			if ((buf = git_array_alloc(repo->reserved_names)) == NULL)
+				goto on_error;
+
+			buf->ptr = git_repository__reserved_names_win32[i].ptr;
+			buf->size = git_repository__reserved_names_win32[i].size;
+		}
+
+		/* Try to add any repo-specific reserved names */
 		if (!repo->is_bare) {
-			repo->name_8dot3 = git_win32_path_8dot3_name(repo->path_repository);
+			const char *reserved_path = repo->path_gitlink ?
+				repo->path_gitlink : repo->path_repository;
 
-			/* We anticipate the 8.3 name is "GIT~1", so use a static for
-			 * easy testing in the common case */
-			if (repo->name_8dot3 &&
-				strcasecmp(repo->name_8dot3, git_repository__8dot3_default) == 0)
-				repo->has_8dot3_default = 1;
+			if (reserved_names_add8dot3(repo, reserved_path) < 0)
+				goto on_error;
 		}
-#endif
 	}
 
-	return repo->has_8dot3_default ?
-		git_repository__8dot3_default : repo->name_8dot3;
+	*out = repo->reserved_names.ptr;
+	*outlen = repo->reserved_names.size;
+
+	return true;
+
+	/* Always give good defaults, even on OOM */
+on_error:
+	*out = git_repository__reserved_names_win32;
+	*outlen = git_repository__reserved_names_win32_len;
+
+	return false;
+}
+#else
+bool git_repository__reserved_names(
+	git_buf **out, size_t *outlen, git_repository *repo, bool include_ntfs)
+{
+	GIT_UNUSED(repo);
+
+	if (include_ntfs) {
+		*out = git_repository__reserved_names_win32;
+		*outlen = git_repository__reserved_names_win32_len;
+	} else {
+		*out = git_repository__reserved_names_posix;
+		*outlen = git_repository__reserved_names_posix_len;
+	}
+
+	return true;
 }
+#endif
 
 static int check_repositoryformatversion(git_config *config)
 {
@@ -1265,7 +1373,8 @@ static int repo_init_structure(
 		if (opts->template_path)
 			tdir = opts->template_path;
 		else if ((error = git_config_open_default(&cfg)) >= 0) {
-			error = git_config_get_string(&tdir, cfg, "init.templatedir");
+			if (!git_config_get_path(&template_buf, cfg, "init.templatedir"))
+				tdir = template_buf.ptr;
 			giterr_clear();
 		}
 
@@ -1837,7 +1946,7 @@ int git_repository_hashfile(
 	 */
 
 	error = git_path_join_unrooted(
-		&full_path, path, repo ? git_repository_workdir(repo) : NULL, NULL);
+		&full_path, path, git_repository_workdir(repo), NULL);
 	if (error < 0)
 		return error;
 
@@ -1848,7 +1957,7 @@ int git_repository_hashfile(
 	if (strlen(as_path) > 0) {
 		error = git_filter_list_load(
 			&fl, repo, NULL, as_path,
-			GIT_FILTER_TO_ODB, GIT_FILTER_OPT_DEFAULT);
+			GIT_FILTER_TO_ODB, GIT_FILTER_DEFAULT);
 		if (error < 0)
 			return error;
 	} else {
@@ -1886,98 +1995,149 @@ cleanup:
 	return error;
 }
 
-static bool looks_like_a_branch(const char *refname)
+static int checkout_message(git_buf *out, git_reference *old, const char *new)
 {
-	return git__prefixcmp(refname, GIT_REFS_HEADS_DIR) == 0;
+	git_buf_puts(out, "checkout: moving from ");
+
+	if (git_reference_type(old) == GIT_REF_SYMBOLIC)
+		git_buf_puts(out, git_reference__shorthand(git_reference_symbolic_target(old)));
+	else
+		git_buf_puts(out, git_oid_tostr_s(git_reference_target(old)));
+
+	git_buf_puts(out, " to ");
+
+	if (git_reference__is_branch(new))
+		git_buf_puts(out, git_reference__shorthand(new));
+	else
+		git_buf_puts(out, new);
+
+	if (git_buf_oom(out))
+		return -1;
+
+	return 0;
 }
 
 int git_repository_set_head(
 	git_repository* repo,
-	const char* refname,
-	const git_signature *signature,
-	const char *log_message)
+	const char* refname)
 {
-	git_reference *ref,
-		*new_head = NULL;
+	git_reference *ref = NULL, *current = NULL, *new_head = NULL;
+	git_buf log_message = GIT_BUF_INIT;
 	int error;
 
 	assert(repo && refname);
 
+	if ((error = git_reference_lookup(&current, repo, GIT_HEAD_FILE)) < 0)
+		return error;
+
+	if ((error = checkout_message(&log_message, current, refname)) < 0)
+		goto cleanup;
+
 	error = git_reference_lookup(&ref, repo, refname);
 	if (error < 0 && error != GIT_ENOTFOUND)
-		return error;
+		goto cleanup;
 
 	if (!error) {
 		if (git_reference_is_branch(ref)) {
 			error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE,
-					git_reference_name(ref), true, signature, log_message);
+					git_reference_name(ref), true, git_buf_cstr(&log_message));
 		} else {
-			error = git_repository_set_head_detached(repo, git_reference_target(ref),
-					signature, log_message);
+			error = git_repository_set_head_detached(repo, git_reference_target(ref));
 		}
-	} else if (looks_like_a_branch(refname)) {
+	} else if (git_reference__is_branch(refname)) {
 		error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE, refname,
-				true, signature, log_message);
+				true, git_buf_cstr(&log_message));
 	}
 
+cleanup:
+	git_buf_free(&log_message);
+	git_reference_free(current);
 	git_reference_free(ref);
 	git_reference_free(new_head);
 	return error;
 }
 
-int git_repository_set_head_detached(
-	git_repository* repo,
-	const git_oid* commitish,
-	const git_signature *signature,
-	const char *log_message)
+static int detach(git_repository *repo, const git_oid *id, const char *from)
 {
 	int error;
-	git_object *object,
-		*peeled = NULL;
-	git_reference *new_head = NULL;
+	git_buf log_message = GIT_BUF_INIT;
+	git_object *object = NULL, *peeled = NULL;
+	git_reference *new_head = NULL, *current = NULL;
 
-	assert(repo && commitish);
+	assert(repo && id);
 
-	if ((error = git_object_lookup(&object, repo, commitish, GIT_OBJ_ANY)) < 0)
+	if ((error = git_reference_lookup(&current, repo, GIT_HEAD_FILE)) < 0)
 		return error;
 
+	if ((error = git_object_lookup(&object, repo, id, GIT_OBJ_ANY)) < 0)
+		goto cleanup;
+
 	if ((error = git_object_peel(&peeled, object, GIT_OBJ_COMMIT)) < 0)
 		goto cleanup;
 
-	error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_object_id(peeled), true, signature, log_message);
+	if (from == NULL)
+		from = git_oid_tostr_s(git_object_id(peeled));
+
+	if ((error = checkout_message(&log_message, current, from)) < 0)
+		goto cleanup;
+
+	error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_object_id(peeled), true, git_buf_cstr(&log_message));
 
 cleanup:
+	git_buf_free(&log_message);
 	git_object_free(object);
 	git_object_free(peeled);
+	git_reference_free(current);
 	git_reference_free(new_head);
 	return error;
 }
 
-int git_repository_detach_head(
+int git_repository_set_head_detached(
 	git_repository* repo,
-	const git_signature *signature,
-	const char *reflog_message)
+	const git_oid* commitish)
+{
+	return detach(repo, commitish, NULL);
+}
+
+int git_repository_set_head_detached_from_annotated(
+	git_repository *repo,
+	const git_annotated_commit *commitish)
+{
+	assert(repo && commitish);
+
+	return detach(repo, git_annotated_commit_id(commitish), commitish->ref_name);
+}
+
+int git_repository_detach_head(git_repository* repo)
 {
-	git_reference *old_head = NULL,
-		*new_head = NULL;
+	git_reference *old_head = NULL,	*new_head = NULL, *current = NULL;
 	git_object *object = NULL;
+	git_buf log_message = GIT_BUF_INIT;
 	int error;
 
 	assert(repo);
 
-	if ((error = git_repository_head(&old_head, repo)) < 0)
+	if ((error = git_reference_lookup(&current, repo, GIT_HEAD_FILE)) < 0)
 		return error;
 
+	if ((error = git_repository_head(&old_head, repo)) < 0)
+		goto cleanup;
+
 	if ((error = git_object_lookup(&object, repo, git_reference_target(old_head), GIT_OBJ_COMMIT)) < 0)
 		goto cleanup;
 
+	if ((error = checkout_message(&log_message, current, git_oid_tostr_s(git_object_id(object)))) < 0)
+		goto cleanup;
+
 	error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_reference_target(old_head),
-			1, signature, reflog_message);
+			1, git_buf_cstr(&log_message));
 
 cleanup:
+	git_buf_free(&log_message);
 	git_object_free(object);
 	git_reference_free(old_head);
 	git_reference_free(new_head);
+	git_reference_free(current);
 	return error;
 }
 
@@ -2095,3 +2255,34 @@ int git_repository_init_init_options(
 		GIT_REPOSITORY_INIT_OPTIONS_INIT);
 	return 0;
 }
+
+int git_repository_ident(const char **name, const char **email, const git_repository *repo)
+{
+	*name = repo->ident_name;
+	*email = repo->ident_email;
+
+	return 0;
+}
+
+int git_repository_set_ident(git_repository *repo, const char *name, const char *email)
+{
+	char *tmp_name = NULL, *tmp_email = NULL;
+
+	if (name) {
+		tmp_name = git__strdup(name);
+		GITERR_CHECK_ALLOC(tmp_name);
+	}
+
+	if (email) {
+		tmp_email = git__strdup(email);
+		GITERR_CHECK_ALLOC(tmp_email);
+	}
+
+	tmp_name = git__swap(repo->ident_name, tmp_name);
+	tmp_email = git__swap(repo->ident_email, tmp_email);
+
+	git__free(tmp_name);
+	git__free(tmp_email);
+
+	return 0;
+}