rugged 0.22.2 → 0.23.0b1

data/vendor/libgit2/src/refdb_fs.c

@@ -26,7 +26,7 @@
 #include <git2/sys/refs.h>
 #include <git2/sys/reflog.h>
 
-GIT__USE_STRMAP;
+GIT__USE_STRMAP
 
 #define DEFAULT_NESTING_LEVEL	5
 #define MAX_NESTING_LEVEL		10
@@ -1324,7 +1324,7 @@ static int refdb_fs_backend__rename(
 	/* Try to rename the refog; it's ok if the old doesn't exist */
 	error = refdb_reflog_fs__rename(_backend, old_name, new_name);
 	if (((error == 0) || (error == GIT_ENOTFOUND)) &&
-	    ((error = reflog_append(backend, new, NULL, NULL, who, message)) < 0)) {
+	    ((error = reflog_append(backend, new, git_reference_target(new), NULL, who, message)) < 0)) {
 		git_reference_free(new);
 		git_filebuf_cleanup(&file);
 		return error;

data/vendor/libgit2/src/refs.c

@@ -24,7 +24,7 @@
 #include <git2/signature.h>
 #include <git2/commit.h>
 
-GIT__USE_STRMAP;
+GIT__USE_STRMAP
 
 #define DEFAULT_NESTING_LEVEL	5
 #define MAX_NESTING_LEVEL		10
@@ -36,13 +36,13 @@ enum {
 
 static git_reference *alloc_ref(const char *name)
 {
-	git_reference *ref;
-	size_t namelen = strlen(name);
-
-	if ((ref = git__calloc(1, sizeof(git_reference) + namelen + 1)) == NULL)
-		return NULL;
+	git_reference *ref = NULL;
+	size_t namelen = strlen(name), reflen;
 
-	memcpy(ref->name, name, namelen + 1);
+	if (!GIT_ADD_SIZET_OVERFLOW(&reflen, sizeof(git_reference), namelen) &&
+		!GIT_ADD_SIZET_OVERFLOW(&reflen, reflen, 1) &&
+		(ref = git__calloc(1, reflen)) != NULL)
+		memcpy(ref->name, name, namelen + 1);
 
 	return ref;
 }
@@ -94,10 +94,14 @@ git_reference *git_reference__set_name(
 	git_reference *ref, const char *name)
 {
 	size_t namelen = strlen(name);
-	git_reference *rewrite =
-		git__realloc(ref, sizeof(git_reference) + namelen + 1);
-	if (rewrite != NULL)
+	size_t reflen;
+	git_reference *rewrite = NULL;
+
+	if (!GIT_ADD_SIZET_OVERFLOW(&reflen, sizeof(git_reference), namelen) &&
+		!GIT_ADD_SIZET_OVERFLOW(&reflen, reflen, 1) &&
+		(rewrite = git__realloc(ref, reflen)) != NULL)
 		memcpy(rewrite->name, name, namelen + 1);
+
 	return rewrite;
 }
 
@@ -412,12 +416,22 @@ static int reference__create(
 	return 0;
 }
 
+int configured_ident(git_signature **out, const git_repository *repo)
+{
+	if (repo->ident_name && repo->ident_email)
+		return git_signature_now(out, repo->ident_name, repo->ident_email);
+
+	/* if not configured let us fall-through to the next method  */
+	return -1;
+}
+
 int git_reference__log_signature(git_signature **out, git_repository *repo)
 {
 	int error;
 	git_signature *who;
 
-	if(((error = git_signature_default(&who, repo)) < 0) &&
+	if(((error = configured_ident(&who, repo)) < 0) &&
+	   ((error = git_signature_default(&who, repo)) < 0) &&
 	   ((error = git_signature_now(&who, "unknown", "unknown")) < 0))
 		return error;
 
@@ -432,7 +446,6 @@ int git_reference_create_matching(
 	const git_oid *id,
 	int force,
 	const git_oid *old_id,
-	const git_signature *signature,
 	const char *log_message)
 
 {
@@ -441,15 +454,11 @@ int git_reference_create_matching(
 	
 	assert(id);
 
-	if (!signature) {
-		if ((error = git_reference__log_signature(&who, repo)) < 0)
-			return error;
-		else
-			signature = who;
-	}
+	if ((error = git_reference__log_signature(&who, repo)) < 0)
+		return error;
 
 	error = reference__create(
-		ref_out, repo, name, id, NULL, force, signature, log_message, old_id, NULL);
+		ref_out, repo, name, id, NULL, force, who, log_message, old_id, NULL);
 
 	git_signature_free(who);
 	return error;
@@ -461,10 +470,9 @@ int git_reference_create(
 	const char *name,
 	const git_oid *id,
 	int force,
-	const git_signature *signature,
 	const char *log_message)
 {
-        return git_reference_create_matching(ref_out, repo, name, id, force, NULL, signature, log_message);
+        return git_reference_create_matching(ref_out, repo, name, id, force, NULL, log_message);
 }
 
 int git_reference_symbolic_create_matching(
@@ -474,7 +482,6 @@ int git_reference_symbolic_create_matching(
 	const char *target,
 	int force,
 	const char *old_target,
-	const git_signature *signature,
 	const char *log_message)
 {
 	int error;
@@ -482,15 +489,11 @@ int git_reference_symbolic_create_matching(
 
 	assert(target);
 
-	if (!signature) {
-		if ((error = git_reference__log_signature(&who, repo)) < 0)
-			return error;
-		else
-			signature = who;
-	}
+	if ((error = git_reference__log_signature(&who, repo)) < 0)
+		return error;
 
 	error = reference__create(
-		ref_out, repo, name, NULL, target, force, signature, log_message, NULL, old_target);
+		ref_out, repo, name, NULL, target, force, who, log_message, NULL, old_target);
 
 	git_signature_free(who);
 	return error;
@@ -502,10 +505,9 @@ int git_reference_symbolic_create(
 	const char *name,
 	const char *target,
 	int force,
-	const git_signature *signature,
 	const char *log_message)
 {
-	return git_reference_symbolic_create_matching(ref_out, repo, name, target, force, NULL, signature, log_message);
+	return git_reference_symbolic_create_matching(ref_out, repo, name, target, force, NULL, log_message);
 }
 
 static int ensure_is_an_updatable_direct_reference(git_reference *ref)
@@ -521,7 +523,6 @@ int git_reference_set_target(
 	git_reference **out,
 	git_reference *ref,
 	const git_oid *id,
-	const git_signature *signature,
 	const char *log_message)
 {
 	int error;
@@ -534,7 +535,7 @@ int git_reference_set_target(
 	if ((error = ensure_is_an_updatable_direct_reference(ref)) < 0)
 		return error;
 
-	return git_reference_create_matching(out, repo, ref->name, id, 1, &ref->target.oid, signature, log_message);
+	return git_reference_create_matching(out, repo, ref->name, id, 1, &ref->target.oid, log_message);
 }
 
 static int ensure_is_an_updatable_symbolic_reference(git_reference *ref)
@@ -550,7 +551,6 @@ int git_reference_symbolic_set_target(
 	git_reference **out,
 	git_reference *ref,
 	const char *target,
-	const git_signature *signature,
 	const char *log_message)
 {
 	int error;
@@ -561,7 +561,7 @@ int git_reference_symbolic_set_target(
 		return error;
 
 	return git_reference_symbolic_create_matching(
-		out, ref->db->repo, ref->name, target, 1, ref->target.symbolic, signature, log_message);
+		out, ref->db->repo, ref->name, target, 1, ref->target.symbolic, log_message);
 }
 
 static int reference__rename(git_reference **out, git_reference *ref, const char *new_name, int force,
@@ -589,7 +589,7 @@ static int reference__rename(git_reference **out, git_reference *ref, const char
 
 	/* Update HEAD it was pointing to the reference being renamed */
 	if (should_head_be_updated &&
-		(error = git_repository_set_head(ref->db->repo, normalized, signature, message)) < 0) {
+		(error = git_repository_set_head(ref->db->repo, normalized)) < 0) {
 		giterr_set(GITERR_REFERENCE, "Failed to update HEAD after renaming reference");
 		return error;
 	}
@@ -603,23 +603,16 @@ int git_reference_rename(
 	git_reference *ref,
 	const char *new_name,
 	int force,
-	const git_signature *signature,
 	const char *log_message)
 {
-	git_signature *who = (git_signature*)signature;
+	git_signature *who;
 	int error;
 
-	/* Should we return an error if there is no default? */
-	if (!who &&
-	    ((error = git_signature_default(&who, ref->db->repo)) < 0) &&
-	    ((error = git_signature_now(&who, "unknown", "unknown")) < 0)) {
+	if ((error = git_reference__log_signature(&who, ref->db->repo)) < 0)
 		return error;
-	}
 
 	error = reference__rename(out, ref, new_name, force, who, log_message);
-
-	if (!signature)
-		git_signature_free(who);
+	git_signature_free(who);
 
 	return error;
 }
@@ -1034,13 +1027,11 @@ int git_reference_cmp(
 	return git_oid__cmp(&ref1->target.oid, &ref2->target.oid);
 }
 
-static int reference__update_terminal(
-	git_repository *repo,
-	const char *ref_name,
-	const git_oid *oid,
-	int nesting,
-	const git_signature *signature,
-	const char *log_message)
+/**
+ * Get the end of a chain of references. If the final one is not
+ * found, we return the reference just before that.
+ */
+static int get_terminal(git_reference **out, git_repository *repo, const char *ref_name, int nesting)
 {
 	git_reference *ref;
 	int error = 0;
@@ -1050,27 +1041,23 @@ static int reference__update_terminal(
 		return GIT_ENOTFOUND;
 	}
 
-	error = git_reference_lookup(&ref, repo, ref_name);
-
-	/* If we haven't found the reference at all, create a new reference. */
-	if (error == GIT_ENOTFOUND) {
-		giterr_clear();
-		return git_reference_create(NULL, repo, ref_name, oid, 0, signature, log_message);
-	}
-
-	if (error < 0)
+	/* set to NULL to let the caller know that they're at the end of the chain */
+	if ((error = git_reference_lookup(&ref, repo, ref_name)) < 0) {
+		*out = NULL;
 		return error;
+	}
 
-	/* If the ref is a symbolic reference, follow its target. */
-	if (git_reference_type(ref) == GIT_REF_SYMBOLIC) {
-		error = reference__update_terminal(repo, git_reference_symbolic_target(ref), oid,
-			nesting+1, signature, log_message);
-		git_reference_free(ref);
+	if (git_reference_type(ref) == GIT_REF_OID) {
+		*out = ref;
+		error = 0;
 	} else {
-		/* If we're not moving the target, don't recreate the ref */
-		if (0 != git_oid_cmp(git_reference_target(ref), oid))
-			error = git_reference_create(NULL, repo, ref_name, oid, 1, signature, log_message);
-		git_reference_free(ref);
+		error = get_terminal(out, repo, git_reference_symbolic_target(ref), nesting + 1);
+		if (error == GIT_ENOTFOUND) {
+			if (!*out) /* set by the error case in lookup above */
+				*out = ref;
+		} else {
+			git_reference_free(ref);
+		}
 	}
 
 	return error;
@@ -1085,10 +1072,40 @@ int git_reference__update_terminal(
 	git_repository *repo,
 	const char *ref_name,
 	const git_oid *oid,
-	const git_signature *signature,
+	const git_signature *sig,
 	const char *log_message)
 {
-	return reference__update_terminal(repo, ref_name, oid, 0, signature, log_message);
+	git_reference *ref = NULL, *ref2 = NULL;
+	git_signature *who = NULL;
+	const git_signature *to_use;
+	int error = 0;
+
+	if (!sig && (error = git_reference__log_signature(&who, repo)) < 0)
+		return error;
+
+	to_use = sig ? sig : who;
+	error = get_terminal(&ref, repo, ref_name, 0);
+
+	/* found a dangling symref */
+	if (error == GIT_ENOTFOUND && ref) {
+		assert(git_reference_type(ref) == GIT_REF_SYMBOLIC);
+		giterr_clear();
+		error = reference__create(&ref2, repo, ref->target.symbolic, oid, NULL, 0, to_use,
+					  log_message, NULL, NULL);
+	} else if (error == GIT_ENOTFOUND) {
+		giterr_clear();
+		error = reference__create(&ref2, repo, ref_name, oid, NULL, 0, to_use,
+					  log_message, NULL, NULL);
+	}  else if (error == 0) {
+		assert(git_reference_type(ref) == GIT_REF_OID);
+		error = reference__create(&ref2, repo, ref->name, oid, NULL, 1, to_use,
+					  log_message, &ref->target.oid, NULL);
+	}
+
+	git_reference_free(ref2);
+	git_reference_free(ref);
+	git_signature_free(who);
+	return error;
 }
 
 int git_reference__update_for_commit(
@@ -1096,12 +1113,12 @@ int git_reference__update_for_commit(
 	git_reference *ref,
 	const char *ref_name,
 	const git_oid *id,
-	const git_signature *committer,
 	const char *operation)
 {
 	git_reference *ref_new = NULL;
 	git_commit *commit = NULL;
 	git_buf reflog_msg = GIT_BUF_INIT;
+	const git_signature *who;
 	int error;
 
 	if ((error = git_commit_lookup(&commit, repo, id)) < 0 ||
@@ -1111,12 +1128,18 @@ int git_reference__update_for_commit(
 			git_commit_summary(commit))) < 0)
 		goto done;
 
-	if (ref)
-		error = git_reference_set_target(
-			&ref_new, ref, id, committer, git_buf_cstr(&reflog_msg));
+	who = git_commit_committer(commit);
+
+	if (ref) {
+		if ((error = ensure_is_an_updatable_direct_reference(ref)) < 0)
+			return error;
+
+		error = reference__create(&ref_new, repo, ref->name, id, NULL, 1, who,
+					  git_buf_cstr(&reflog_msg), &ref->target.oid, NULL);
+	}
 	else
 		error = git_reference__update_terminal(
-			repo, ref_name, id, committer, git_buf_cstr(&reflog_msg));
+			repo, ref_name, id, who, git_buf_cstr(&reflog_msg));
 
 done:
 	git_reference_free(ref_new);
@@ -1263,10 +1286,8 @@ int git_reference_is_valid_name(const char *refname)
 	return git_reference__is_valid_name(refname, GIT_REF_FORMAT_ALLOW_ONELEVEL);
 }
 
-const char *git_reference_shorthand(const git_reference *ref)
+const char *git_reference__shorthand(const char *name)
 {
-	const char *name = ref->name;
-
 	if (!git__prefixcmp(name, GIT_REFS_HEADS_DIR))
 		return name + strlen(GIT_REFS_HEADS_DIR);
 	else if (!git__prefixcmp(name, GIT_REFS_TAGS_DIR))
@@ -1279,3 +1300,8 @@ const char *git_reference_shorthand(const git_reference *ref)
 	/* No shorthands are avaiable, so just return the name */
 	return name;
 }
+
+const char *git_reference_shorthand(const git_reference *ref)
+{
+	return git_reference__shorthand(ref->name);
+}

data/vendor/libgit2/src/refs.h

@@ -69,11 +69,12 @@ struct git_reference {
 git_reference *git_reference__set_name(git_reference *ref, const char *name);
 
 int git_reference__normalize_name(git_buf *buf, const char *name, unsigned int flags);
-int git_reference__update_terminal(git_repository *repo, const char *ref_name, const git_oid *oid, const git_signature *signature, const char *log_message);
+int git_reference__update_terminal(git_repository *repo, const char *ref_name, const git_oid *oid, const git_signature *sig, const char *log_message);
 int git_reference__is_valid_name(const char *refname, unsigned int flags);
 int git_reference__is_branch(const char *ref_name);
 int git_reference__is_remote(const char *ref_name);
 int git_reference__is_tag(const char *ref_name);
+const char *git_reference__shorthand(const char *name);
 
 /**
  * Lookup a reference by name and try to resolve to an OID.
@@ -106,7 +107,6 @@ int git_reference__update_for_commit(
 	git_reference *ref,
 	const char *ref_name,
 	const git_oid *id,
-	const git_signature *committer,
 	const char *operation);
 
 #endif

data/vendor/libgit2/src/refspec.c

@@ -133,6 +133,9 @@ int git_refspec__parse(git_refspec *refspec, const char *input, bool is_fetch)
 	return 0;
 
  invalid:
+        giterr_set(
+                GITERR_INVALID,
+                "'%s' is not a valid refspec.", input);
 	return -1;
 }
 

data/vendor/libgit2/src/remote.c

@@ -52,7 +52,7 @@ static int add_refspec(git_remote *remote, const char *string, bool is_fetch)
 
 static int download_tags_value(git_remote *remote, git_config *cfg)
 {
-	const git_config_entry *ce;
+	git_config_entry *ce;
 	git_buf buf = GIT_BUF_INIT;
 	int error;
 
@@ -70,6 +70,7 @@ static int download_tags_value(git_remote *remote, git_config *cfg)
 			remote->download_tags = GIT_REMOTE_DOWNLOAD_TAGS_ALL;
 	}
 
+	git_config_entry_free(ce);
 	return error;
 }
 
@@ -383,10 +384,9 @@ int git_remote_lookup(git_remote **out, git_repository *repo, const char *name)
 	if ((error = git_repository_config_snapshot(&config, repo)) < 0)
 		return error;
 
-	remote = git__malloc(sizeof(git_remote));
+	remote = git__calloc(1, sizeof(git_remote));
 	GITERR_CHECK_ALLOC(remote);
 
-	memset(remote, 0x0, sizeof(git_remote));
 	remote->update_fetchhead = 1;
 	remote->name = git__strdup(name);
 	GITERR_CHECK_ALLOC(remote->name);
@@ -549,7 +549,7 @@ int git_remote_save(const git_remote *remote)
 	git_config *cfg;
 	const char *tagopt = NULL;
 	git_buf buf = GIT_BUF_INIT;
-	const git_config_entry *existing;
+	git_config_entry *existing = NULL;
 
 	assert(remote);
 
@@ -619,6 +619,7 @@ int git_remote_save(const git_remote *remote)
 		cfg, git_buf_cstr(&buf), tagopt, true, false);
 
 cleanup:
+	git_config_entry_free(existing);
 	git_buf_free(&buf);
 	return error;
 }
@@ -754,7 +755,7 @@ int git_remote_ls(const git_remote_head ***out, size_t *size, git_remote *remote
 int git_remote__get_http_proxy(git_remote *remote, bool use_ssl, char **proxy_url)
 {
 	git_config *cfg;
-	const git_config_entry *ce;
+	git_config_entry *ce = NULL;
 	const char *val = NULL;
 	int error;
 
@@ -806,6 +807,7 @@ found:
 		*proxy_url = git__strdup(val);
 		GITERR_CHECK_ALLOC(*proxy_url);
 	}
+	git_config_entry_free(ce);
 
 	return 0;
 }
@@ -925,7 +927,6 @@ on_error:
 int git_remote_fetch(
 		git_remote *remote,
 		const git_strarray *refspecs,
-		const git_signature *signature,
 		const char *reflog_message)
 {
 	int error;
@@ -953,7 +954,7 @@ int git_remote_fetch(
 	}
 
 	/* Create "remote/foo" branches for all remote branches */
-	error = git_remote_update_tips(remote, signature, git_buf_cstr(&reflog_msg_buf));
+	error = git_remote_update_tips(remote, git_buf_cstr(&reflog_msg_buf));
 	git_buf_free(&reflog_msg_buf);
 	if (error < 0)
 		return error;
@@ -1258,7 +1259,6 @@ static int update_tips_for_spec(
 		git_remote *remote,
 		git_refspec *spec,
 		git_vector *refs,
-		const git_signature *signature,
 		const char *log_message)
 {
 	int error = 0, autotag;
@@ -1333,7 +1333,7 @@ static int update_tips_for_spec(
 
 		/* In autotag mode, don't overwrite any locally-existing tags */
 		error = git_reference_create(&ref, remote->repo, refname.ptr, &head->oid, !autotag, 
-				signature, log_message);
+				log_message);
 		if (error < 0 && error != GIT_EEXISTS)
 			goto on_error;
 
@@ -1419,7 +1419,7 @@ static int next_head(const git_remote *remote, git_vector *refs,
 	return GIT_ITEROVER;
 }
 
-static int opportunistic_updates(const git_remote *remote, git_vector *refs, const git_signature *sig, const char *msg)
+static int opportunistic_updates(const git_remote *remote, git_vector *refs, const char *msg)
 {
 	size_t i, j, k;
 	git_refspec *spec;
@@ -1442,7 +1442,7 @@ static int opportunistic_updates(const git_remote *remote, git_vector *refs, con
 		if ((error = git_refspec_transform(&refname, spec, head->name)) < 0)
 			return error;
 
-		error = git_reference_create(&ref, remote->repo, refname.ptr, &head->oid, true, sig, msg);
+		error = git_reference_create(&ref, remote->repo, refname.ptr, &head->oid, true, msg);
 		git_buf_free(&refname);
 		git_reference_free(ref);
 
@@ -1455,7 +1455,6 @@ static int opportunistic_updates(const git_remote *remote, git_vector *refs, con
 
 int git_remote_update_tips(
 		git_remote *remote,
-		const git_signature *signature,
 		const char *reflog_message)
 {
 	git_refspec *spec, tagspec;
@@ -1465,7 +1464,7 @@ int git_remote_update_tips(
 
 	/* push has its own logic hidden away in the push object */
 	if (remote->push) {
-		return git_push_update_tips(remote->push, signature, reflog_message);
+		return git_push_update_tips(remote->push);
 	}
 
 	if (git_refspec__parse(&tagspec, GIT_REFSPEC_TAGS, true) < 0)
@@ -1476,7 +1475,7 @@ int git_remote_update_tips(
 		goto out;
 
 	if (remote->download_tags == GIT_REMOTE_DOWNLOAD_TAGS_ALL) {
-		if ((error = update_tips_for_spec(remote, &tagspec, &refs, signature, reflog_message)) < 0)
+		if ((error = update_tips_for_spec(remote, &tagspec, &refs, reflog_message)) < 0)
 			goto out;
 	}
 
@@ -1484,13 +1483,13 @@ int git_remote_update_tips(
 		if (spec->push)
 			continue;
 
-		if ((error = update_tips_for_spec(remote, spec, &refs, signature, reflog_message)) < 0)
+		if ((error = update_tips_for_spec(remote, spec, &refs, reflog_message)) < 0)
 			goto out;
 	}
 
 	/* only try to do opportunisitic updates if the refpec lists differ */
 	if (remote->passed_refspecs)
-		error = opportunistic_updates(remote, &refs, signature, reflog_message);
+		error = opportunistic_updates(remote, &refs, reflog_message);
 
 out:
 	git_vector_free(&refs);
@@ -1756,7 +1755,7 @@ static int rename_one_remote_reference(
 		goto cleanup;
 
 	if ((error = git_reference_rename(&ref, reference_in, git_buf_cstr(&new_name), 1,
-					  NULL, git_buf_cstr(&log_message))) < 0)
+					  git_buf_cstr(&log_message))) < 0)
 		goto cleanup;
 
 	if (git_reference_type(ref) != GIT_REF_SYMBOLIC)
@@ -1776,7 +1775,7 @@ static int rename_one_remote_reference(
 		goto cleanup;
 
 	error = git_reference_symbolic_set_target(&dummy, ref, git_buf_cstr(&new_name),
-						  NULL, git_buf_cstr(&log_message));
+						  git_buf_cstr(&log_message));
 
 	git_reference_free(dummy);
 
@@ -2378,8 +2377,7 @@ cleanup:
 	return error;
 }
 
-int git_remote_push(git_remote *remote, const git_strarray *refspecs, const git_push_options *opts,
-		    const git_signature *signature, const char *reflog_message)
+int git_remote_push(git_remote *remote, const git_strarray *refspecs, const git_push_options *opts)
 {
 	int error;
 
@@ -2391,7 +2389,7 @@ int git_remote_push(git_remote *remote, const git_strarray *refspecs, const git_
 	if ((error = git_remote_upload(remote, refspecs, opts)) < 0)
 		return error;
 
-	error = git_remote_update_tips(remote, signature, reflog_message);
+	error = git_remote_update_tips(remote, NULL);
 
 	git_remote_disconnect(remote);
 	return error;