rugged 1.7.2 → 1.9.4

data/vendor/libgit2/src/libgit2/push.c

@@ -56,14 +56,22 @@ int git_push_new(git_push **out, git_remote *remote, const git_push_options *opt
 	}
 
 	if (git_vector_init(&p->status, 0, push_status_ref_cmp) < 0) {
-		git_vector_free(&p->specs);
+		git_vector_dispose(&p->specs);
 		git__free(p);
 		return -1;
 	}
 
 	if (git_vector_init(&p->updates, 0, NULL) < 0) {
-		git_vector_free(&p->status);
-		git_vector_free(&p->specs);
+		git_vector_dispose(&p->status);
+		git_vector_dispose(&p->specs);
+		git__free(p);
+		return -1;
+	}
+
+	if (git_vector_init(&p->remote_push_options, 0, git__strcmp_cb) < 0) {
+		git_vector_dispose(&p->status);
+		git_vector_dispose(&p->specs);
+		git_vector_dispose(&p->updates);
 		git__free(p);
 		return -1;
 	}
@@ -213,12 +221,25 @@ int git_push_update_tips(git_push *push, const git_remote_callbacks *callbacks)
 			fire_callback = 0;
 		}
 
-		if (fire_callback && callbacks && callbacks->update_tips) {
-			error = callbacks->update_tips(git_str_cstr(&remote_ref_name),
-						&push_spec->roid, &push_spec->loid, callbacks->payload);
+		if (!fire_callback || !callbacks)
+			continue;
 
-			if (error < 0)
-				goto on_error;
+		if (callbacks->update_refs)
+			error = callbacks->update_refs(
+				git_str_cstr(&remote_ref_name),
+				&push_spec->roid, &push_spec->loid,
+				&push_spec->refspec, callbacks->payload);
+#ifndef GIT_DEPRECATE_HARD
+		else if (callbacks->update_tips)
+			error = callbacks->update_tips(
+				git_str_cstr(&remote_ref_name),
+				&push_spec->roid, &push_spec->loid,
+				callbacks->payload);
+#endif
+
+		if (error < 0) {
+			git_error_set_after_callback_function(error, "git_remote_push");
+			goto on_error;
 		}
 	}
 
@@ -275,6 +296,7 @@ static int queue_objects(git_push *push)
 
 	git_vector_foreach(&push->specs, i, spec) {
 		git_object_t type;
+		git_oid id;
 		size_t size;
 
 		if (git_oid_is_zero(&spec->loid))
@@ -296,20 +318,20 @@ static int queue_objects(git_push *push)
 			if ((error = enqueue_tag(&target, push, &spec->loid)) < 0)
 				goto on_error;
 
-			if (git_object_type(target) == GIT_OBJECT_COMMIT) {
-				if ((error = git_revwalk_push(rw, git_object_id(target))) < 0) {
-					git_object_free(target);
-					goto on_error;
-				}
-			} else {
-				if ((error = git_packbuilder_insert(
-					push->pb, git_object_id(target), NULL)) < 0) {
-					git_object_free(target);
-					goto on_error;
-				}
-			}
+			type = git_object_type(target);
+			git_oid_cpy(&id, git_object_id(target));
+
 			git_object_free(target);
-		} else if ((error = git_revwalk_push(rw, &spec->loid)) < 0)
+		} else {
+			git_oid_cpy(&id, &spec->loid);
+		}
+
+		if (type == GIT_OBJECT_COMMIT)
+			error = git_revwalk_push(rw, &id);
+		else
+			error = git_packbuilder_insert(push->pb, &id, NULL);
+
+		if (error < 0)
 			goto on_error;
 
 		if (!spec->refspec.force) {
@@ -444,10 +466,21 @@ static int do_push(git_push *push)
 	if ((error = calculate_work(push)) < 0)
 		goto on_error;
 
-	if (callbacks && callbacks->push_negotiation &&
-	    (error = callbacks->push_negotiation((const git_push_update **) push->updates.contents,
-					  push->updates.length, callbacks->payload)) < 0)
-	    goto on_error;
+	if (callbacks && callbacks->push_negotiation) {
+		git_error_clear();
+
+		error = callbacks->push_negotiation(
+			(const git_push_update **) push->updates.contents,
+			push->updates.length, callbacks->payload);
+
+		if (error < 0) {
+			git_error_set_after_callback_function(error,
+				"push_negotiation");
+			goto on_error;
+		}
+
+		error = 0;
+	}
 
 	if ((error = queue_objects(push)) < 0 ||
 	    (error = transport->push(transport, push)) < 0)
@@ -479,12 +512,24 @@ static int filter_refs(git_remote *remote)
 int git_push_finish(git_push *push)
 {
 	int error;
+	unsigned int remote_caps;
 
 	if (!git_remote_connected(push->remote)) {
 		git_error_set(GIT_ERROR_NET, "remote is disconnected");
 		return -1;
 	}
 
+	if ((error = git_remote_capabilities(&remote_caps, push->remote)) < 0) {
+		git_error_set(GIT_ERROR_INVALID, "remote capabilities not available");
+		return -1;
+	}
+
+	if (git_vector_length(&push->remote_push_options) > 0 &&
+	    !(remote_caps & GIT_REMOTE_CAPABILITY_PUSH_OPTIONS)) {
+		git_error_set(GIT_ERROR_INVALID, "push-options not supported by remote");
+		return -1;
+	}
+
 	if ((error = filter_refs(push->remote)) < 0 ||
 	    (error = do_push(push)) < 0)
 		return error;
@@ -528,6 +573,7 @@ void git_push_free(git_push *push)
 	push_spec *spec;
 	push_status *status;
 	git_push_update *update;
+	char *option;
 	unsigned int i;
 
 	if (push == NULL)
@@ -536,19 +582,24 @@ void git_push_free(git_push *push)
 	git_vector_foreach(&push->specs, i, spec) {
 		free_refspec(spec);
 	}
-	git_vector_free(&push->specs);
+	git_vector_dispose(&push->specs);
 
 	git_vector_foreach(&push->status, i, status) {
 		git_push_status_free(status);
 	}
-	git_vector_free(&push->status);
+	git_vector_dispose(&push->status);
 
 	git_vector_foreach(&push->updates, i, update) {
 		git__free(update->src_refname);
 		git__free(update->dst_refname);
 		git__free(update);
 	}
-	git_vector_free(&push->updates);
+	git_vector_dispose(&push->updates);
+
+	git_vector_foreach(&push->remote_push_options, i, option) {
+		git__free(option);
+	}
+	git_vector_dispose(&push->remote_push_options);
 
 	git__free(push);
 }

data/vendor/libgit2/src/libgit2/push.h

@@ -34,6 +34,7 @@ struct git_push {
 	git_vector specs;
 	git_vector updates;
 	bool report_status;
+	git_vector remote_push_options;
 
 	/* report-status */
 	bool unpack_ok;

data/vendor/libgit2/src/libgit2/refdb_fs.c

@@ -26,7 +26,6 @@
 #include <git2/branch.h>
 #include <git2/sys/refdb_backend.h>
 #include <git2/sys/refs.h>
-#include <git2/sys/reflog.h>
 
 #define DEFAULT_NESTING_LEVEL	5
 #define MAX_NESTING_LEVEL		10
@@ -62,8 +61,8 @@ typedef struct refdb_fs_backend {
 
 	git_oid_t oid_type;
 
-	int fsync : 1,
-	    sorted : 1;
+	unsigned int fsync : 1,
+	             sorted : 1;
 	int peeling_mode;
 	git_iterator_flag_t iterator_flags;
 	uint32_t direach_flags;
@@ -410,7 +409,9 @@ static const char *loose_parse_symbolic(git_str *file_content)
 static bool is_per_worktree_ref(const char *ref_name)
 {
 	return git__prefixcmp(ref_name, "refs/") != 0 ||
-	    git__prefixcmp(ref_name, "refs/bisect/") == 0;
+	       git__prefixcmp(ref_name, "refs/bisect/") == 0 ||
+	       git__prefixcmp(ref_name, "refs/worktree/") == 0 ||
+	       git__prefixcmp(ref_name, "refs/rewritten/") == 0;
 }
 
 static int loose_lookup(
@@ -799,89 +800,155 @@ static void refdb_fs_backend__iterator_free(git_reference_iterator *_iter)
 {
 	refdb_fs_iter *iter = GIT_CONTAINER_OF(_iter, refdb_fs_iter, parent);
 
-	git_vector_free(&iter->loose);
+	git_vector_dispose(&iter->loose);
 	git_pool_clear(&iter->pool);
 	git_sortedcache_free(iter->cache);
 	git__free(iter);
 }
 
-static int iter_load_loose_paths(
-	refdb_fs_backend *backend,
-	refdb_fs_iter *iter)
+struct iter_load_context {
+	refdb_fs_backend *backend;
+	refdb_fs_iter *iter;
+
+	/*
+	 * If we have a glob with a prefix (eg `refs/heads/ *`) then we can
+	 * optimize our prefix to avoid walking refs that we know won't
+	 * match. This is that prefix.
+	 */
+	const char *ref_prefix;
+	size_t ref_prefix_len;
+
+	/* Temporary variables to avoid unnecessary allocations */
+	git_str ref_name;
+	git_str path;
+};
+
+static void iter_load_optimize_prefix(struct iter_load_context *ctx)
 {
-	int error = 0;
-	git_str path = GIT_STR_INIT;
-	git_iterator *fsit = NULL;
-	git_iterator_options fsit_opts = GIT_ITERATOR_OPTIONS_INIT;
-	const git_index_entry *entry = NULL;
-	const char *ref_prefix = GIT_REFS_DIR;
-	size_t ref_prefix_len = strlen(ref_prefix);
+	const char *pos, *last_sep = NULL;
 
-	if (!backend->commonpath) /* do nothing if no commonpath for loose refs */
-		return 0;
+	if (!ctx->iter->glob)
+		return;
 
-	fsit_opts.flags = backend->iterator_flags;
-	fsit_opts.oid_type = backend->oid_type;
-
-	if (iter->glob) {
-		const char *last_sep = NULL;
-		const char *pos;
-		for (pos = iter->glob; *pos; ++pos) {
-			switch (*pos) {
-			case '?':
-			case '*':
-			case '[':
-			case '\\':
-				break;
-			case '/':
-				last_sep = pos;
-				/* FALLTHROUGH */
-			default:
-				continue;
-			}
+	for (pos = ctx->iter->glob; *pos; pos++) {
+		switch (*pos) {
+		case '?':
+		case '*':
+		case '[':
+		case '\\':
 			break;
+		case '/':
+			last_sep = pos;
+			/* FALLTHROUGH */
+		default:
+			continue;
 		}
-		if (last_sep) {
-			ref_prefix = iter->glob;
-			ref_prefix_len = (last_sep - ref_prefix) + 1;
-		}
+		break;
 	}
 
-	if ((error = git_str_puts(&path, backend->commonpath)) < 0 ||
-		(error = git_str_put(&path, ref_prefix, ref_prefix_len)) < 0) {
-		git_str_dispose(&path);
-		return error;
+	if (last_sep) {
+		ctx->ref_prefix = ctx->iter->glob;
+		ctx->ref_prefix_len = (last_sep - ctx->ref_prefix) + 1;
 	}
+}
+
+static int iter_load_paths(
+	struct iter_load_context *ctx,
+	const char *root_path,
+	bool worktree)
+{
+	git_iterator *fsit = NULL;
+	git_iterator_options fsit_opts = GIT_ITERATOR_OPTIONS_INIT;
+	const git_index_entry *entry;
+	int error = 0;
+
+	fsit_opts.flags = ctx->backend->iterator_flags;
+
+	git_str_clear(&ctx->path);
+	git_str_puts(&ctx->path, root_path);
+	git_str_put(&ctx->path, ctx->ref_prefix, ctx->ref_prefix_len);
+
+	fsit_opts.flags = ctx->backend->iterator_flags;
+	fsit_opts.oid_type = ctx->backend->oid_type;
+
+	if ((error = git_iterator_for_filesystem(&fsit, ctx->path.ptr, &fsit_opts)) < 0) {
+		/*
+		 * Subdirectories - either glob provided or per-worktree refs - need
+		 * not exist.
+		 */
+		if ((worktree || ctx->iter->glob) && error == GIT_ENOTFOUND)
+			error = 0;
 
-	if ((error = git_iterator_for_filesystem(&fsit, path.ptr, &fsit_opts)) < 0) {
-		git_str_dispose(&path);
-		return (iter->glob && error == GIT_ENOTFOUND)? 0 : error;
+		goto done;
 	}
 
-	error = git_str_sets(&path, ref_prefix);
+	git_str_clear(&ctx->ref_name);
+	git_str_put(&ctx->ref_name, ctx->ref_prefix, ctx->ref_prefix_len);
 
-	while (!error && !git_iterator_advance(&entry, fsit)) {
-		const char *ref_name;
+	while (git_iterator_advance(&entry, fsit) == 0) {
 		char *ref_dup;
 
-		git_str_truncate(&path, ref_prefix_len);
-		git_str_puts(&path, entry->path);
-		ref_name = git_str_cstr(&path);
+		git_str_truncate(&ctx->ref_name, ctx->ref_prefix_len);
+		git_str_puts(&ctx->ref_name, entry->path);
 
-		if (git__suffixcmp(ref_name, ".lock") == 0 ||
-			(iter->glob && wildmatch(iter->glob, ref_name, 0) != 0))
+		if (worktree) {
+			if (!is_per_worktree_ref(ctx->ref_name.ptr))
+				continue;
+		} else {
+			if (git_repository_is_worktree(ctx->backend->repo) &&
+			    is_per_worktree_ref(ctx->ref_name.ptr))
+				continue;
+		}
+
+		if (git__suffixcmp(ctx->ref_name.ptr, ".lock") == 0)
 			continue;
 
-		ref_dup = git_pool_strdup(&iter->pool, ref_name);
-		if (!ref_dup)
-			error = -1;
-		else
-			error = git_vector_insert(&iter->loose, ref_dup);
+		if (ctx->iter->glob && wildmatch(ctx->iter->glob, ctx->ref_name.ptr, 0))
+			continue;
+
+		ref_dup = git_pool_strdup(&ctx->iter->pool, ctx->ref_name.ptr);
+		GIT_ERROR_CHECK_ALLOC(ref_dup);
+
+		if ((error = git_vector_insert(&ctx->iter->loose, ref_dup)) < 0)
+			goto done;
 	}
 
+done:
 	git_iterator_free(fsit);
-	git_str_dispose(&path);
+	return error;
+}
 
+#define iter_load_context_init(b, i) { b, i, GIT_REFS_DIR, CONST_STRLEN(GIT_REFS_DIR) }
+#define iter_load_context_dispose(ctx) do {  \
+	git_str_dispose(&((ctx)->path));     \
+	git_str_dispose(&((ctx)->ref_name)); \
+} while(0)
+
+static int iter_load_loose_paths(
+	refdb_fs_backend *backend,
+	refdb_fs_iter *iter)
+{
+	struct iter_load_context ctx = iter_load_context_init(backend, iter);
+
+	int error = 0;
+
+	if (!backend->commonpath)
+		return 0;
+
+	iter_load_optimize_prefix(&ctx);
+
+	if ((error = iter_load_paths(&ctx,
+			backend->commonpath, false)) < 0)
+		goto done;
+
+	if (git_repository_is_worktree(backend->repo)) {
+		if ((error = iter_load_paths(&ctx,
+				backend->gitpath, true)) < 0)
+			goto done;
+	}
+
+done:
+	iter_load_context_dispose(&ctx);
 	return error;
 }
 

data/vendor/libgit2/src/libgit2/reflog.c

@@ -13,7 +13,6 @@
 #include "refdb.h"
 
 #include "git2/sys/refdb_backend.h"
-#include "git2/sys/reflog.h"
 
 void git_reflog_entry__free(git_reflog_entry *entry)
 {
@@ -40,7 +39,7 @@ void git_reflog_free(git_reflog *reflog)
 		git_reflog_entry__free(entry);
 	}
 
-	git_vector_free(&reflog->entries);
+	git_vector_dispose(&reflog->entries);
 	git__free(reflog->ref_name);
 	git__free(reflog);
 }

data/vendor/libgit2/src/libgit2/reflog.h

@@ -37,4 +37,6 @@ GIT_INLINE(size_t) reflog_inverse_index(size_t idx, size_t total)
 	return (total - 1) - idx;
 }
 
+void git_reflog_entry__free(git_reflog_entry *entry);
+
 #endif

data/vendor/libgit2/src/libgit2/refs.c

@@ -808,7 +808,7 @@ int git_reference_list(
 
 	if (git_reference_foreach_name(
 			repo, &cb__reflist_add, (void *)&ref_list) < 0) {
-		git_vector_free(&ref_list);
+		git_vector_dispose(&ref_list);
 		return -1;
 	}
 
@@ -819,7 +819,7 @@ int git_reference_list(
 
 static int is_valid_ref_char(char ch)
 {
-	if ((unsigned) ch <= ' ')
+	if ((unsigned) ch <= ' ' || ch == '\177') /* ASCII control characters */
 		return 0;
 
 	switch (ch) {
@@ -835,17 +835,20 @@ static int is_valid_ref_char(char ch)
 	}
 }
 
-static int ensure_segment_validity(const char *name, char may_contain_glob)
+static int ensure_segment_validity(const char *name, char may_contain_glob, bool allow_caret_prefix)
 {
 	const char *current = name;
+	const char *start = current;
 	char prev = '\0';
 	const int lock_len = (int)strlen(GIT_FILELOCK_EXTENSION);
 	int segment_len;
 
 	if (*current == '.')
 		return -1; /* Refname starts with "." */
+	if (allow_caret_prefix && *current == '^')
+		start++;
 
-	for (current = name; ; current++) {
+	for (current = start; ; current++) {
 		if (*current == '\0' || *current == '/')
 			break;
 
@@ -877,7 +880,7 @@ static int ensure_segment_validity(const char *name, char may_contain_glob)
 	return segment_len;
 }
 
-static bool is_all_caps_and_underscore(const char *name, size_t len)
+static bool is_valid_normalized_name(const char *name, size_t len)
 {
 	size_t i;
 	char c;
@@ -888,6 +891,12 @@ static bool is_all_caps_and_underscore(const char *name, size_t len)
 	for (i = 0; i < len; i++)
 	{
 		c = name[i];
+		if (i == 0 && c == '^')
+			continue; /* The first character is allowed to be "^" for negative refspecs */
+
+		if (len == 1 && c == '@')
+			return true; /* Abbreviation for HEAD */
+
 		if ((c < 'A' || c > 'Z') && c != '_')
 			return false;
 	}
@@ -908,6 +917,7 @@ int git_reference__normalize_name(
 	int segment_len, segments_count = 0, error = GIT_EINVALIDSPEC;
 	unsigned int process_flags;
 	bool normalize = (buf != NULL);
+	bool allow_caret_prefix = true;
 	bool validate = (flags & GIT_REFERENCE_FORMAT__VALIDATION_DISABLE) == 0;
 
 #ifdef GIT_USE_ICONV
@@ -945,7 +955,7 @@ int git_reference__normalize_name(
 	while (true) {
 		char may_contain_glob = process_flags & GIT_REFERENCE_FORMAT_REFSPEC_PATTERN;
 
-		segment_len = ensure_segment_validity(current, may_contain_glob);
+		segment_len = ensure_segment_validity(current, may_contain_glob, allow_caret_prefix);
 		if (segment_len < 0)
 			goto cleanup;
 
@@ -958,11 +968,16 @@ int git_reference__normalize_name(
 				process_flags &= ~GIT_REFERENCE_FORMAT_REFSPEC_PATTERN;
 
 			if (normalize) {
-				size_t cur_len = git_str_len(buf);
-
-				git_str_joinpath(buf, git_str_cstr(buf), current);
-				git_str_truncate(buf,
-					cur_len + segment_len + (segments_count ? 1 : 0));
+				/* `<empty>@` (i.e. just `@`) is an alias for `HEAD` */
+				if (segments_count == 0 && segment_len == 1 && current[0] == '@') {
+					git_str_sets(buf, GIT_HEAD_FILE);
+				} else {
+					size_t cur_len = git_str_len(buf);
+
+					git_str_joinpath(buf, git_str_cstr(buf), current);
+					git_str_truncate(buf,
+						cur_len + segment_len + (segments_count ? 1 : 0));
+				}
 
 				if (git_str_oom(buf)) {
 					error = -1;
@@ -981,6 +996,12 @@ int git_reference__normalize_name(
 			break;
 
 		current += segment_len + 1;
+
+		/*
+		 * A caret prefix is only allowed in the first segment to signify a
+		 * negative refspec.
+		 */
+		allow_caret_prefix = false;
 	}
 
 	/* A refname can not be empty */
@@ -1000,12 +1021,13 @@ int git_reference__normalize_name(
 
 	if ((segments_count == 1 ) &&
 	    !(flags & GIT_REFERENCE_FORMAT_REFSPEC_SHORTHAND) &&
-		!(is_all_caps_and_underscore(name, (size_t)segment_len) ||
+		!(is_valid_normalized_name(name, (size_t)segment_len) ||
 			((flags & GIT_REFERENCE_FORMAT_REFSPEC_PATTERN) && !strcmp("*", name))))
 			goto cleanup;
 
 	if ((segments_count > 1)
-		&& (is_all_caps_and_underscore(name, strchr(name, '/') - name)))
+		&& !(flags & GIT_REFERENCE_FORMAT_REFSPEC_SHORTHAND)
+		&& (is_valid_normalized_name(name, strchr(name, '/') - name)))
 			goto cleanup;
 
 	error = 0;
@@ -1080,6 +1102,12 @@ int git_reference_cmp(
 	return git_oid__cmp(&ref1->target.oid, &ref2->target.oid);
 }
 
+int git_reference__cmp_cb(const void *a, const void *b)
+{
+	return git_reference_cmp(
+		(const git_reference *)a, (const git_reference *)b);
+}
+
 /*
  * Starting with the reference given by `ref_name`, follows symbolic
  * references until a direct reference is found and updated the OID

data/vendor/libgit2/src/libgit2/refs.h

@@ -12,7 +12,6 @@
 #include "git2/oid.h"
 #include "git2/refs.h"
 #include "git2/refdb.h"
-#include "strmap.h"
 #include "str.h"
 #include "oid.h"
 
@@ -92,6 +91,12 @@ int git_reference__is_tag(const char *ref_name);
 int git_reference__is_note(const char *ref_name);
 const char *git_reference__shorthand(const char *name);
 
+/*
+ * A `git_reference_cmp` wrapper suitable for passing to generic
+ * comparators, like `vector_cmp` / `tsort` / etc.
+ */
+int git_reference__cmp_cb(const void *a, const void *b);
+
 /**
  * Lookup a reference by name and try to resolve to an OID.
  *

data/vendor/libgit2/src/libgit2/refspec.c

@@ -22,6 +22,7 @@ int git_refspec__parse(git_refspec *refspec, const char *input, bool is_fetch)
 	const char *lhs, *rhs;
 	int valid = 0;
 	unsigned int flags;
+	bool is_neg_refspec = false;
 
 	GIT_ASSERT_ARG(refspec);
 	GIT_ASSERT_ARG(input);
@@ -34,6 +35,9 @@ int git_refspec__parse(git_refspec *refspec, const char *input, bool is_fetch)
 		refspec->force = 1;
 		lhs++;
 	}
+	if (*lhs == '^') {
+		is_neg_refspec = true;
+	}
 
 	rhs = strrchr(lhs, ':');
 
@@ -62,7 +66,14 @@ int git_refspec__parse(git_refspec *refspec, const char *input, bool is_fetch)
 
 	llen = (rhs ? (size_t)(rhs - lhs - 1) : strlen(lhs));
 	if (1 <= llen && memchr(lhs, '*', llen)) {
-		if ((rhs && !is_glob) || (!rhs && is_fetch))
+		/*
+		 * If the lefthand side contains a glob, then one of the following must be
+		 * true, otherwise the spec is invalid
+		 *   1) the rhs exists and also contains a glob
+		 *   2) it is a negative refspec (i.e. no rhs)
+		 *   3) the rhs doesn't exist and we're fetching
+		 */
+		if ((rhs && !is_glob) || (rhs && is_neg_refspec) || (!rhs && is_fetch && !is_neg_refspec))
 			goto invalid;
 		is_glob = 1;
 	} else if (rhs && is_glob)
@@ -225,6 +236,14 @@ int git_refspec_force(const git_refspec *refspec)
 	return refspec->force;
 }
 
+int git_refspec_src_matches_negative(const git_refspec *refspec, const char *refname)
+{
+	if (refspec == NULL || refspec->src == NULL || !git_refspec_is_negative(refspec))
+		return false;
+
+	return (wildmatch(refspec->src + 1, refname, 0) == 0);
+}
+
 int git_refspec_src_matches(const git_refspec *refspec, const char *refname)
 {
 	if (refspec == NULL || refspec->src == NULL)
@@ -340,6 +359,14 @@ int git_refspec_is_wildcard(const git_refspec *spec)
 	return (spec->src[strlen(spec->src) - 1] == '*');
 }
 
+int git_refspec_is_negative(const git_refspec *spec)
+{
+	GIT_ASSERT_ARG(spec);
+	GIT_ASSERT_ARG(spec->src);
+
+	return (spec->src[0] == '^' && spec->dst == NULL);
+}
+
 git_direction git_refspec_direction(const git_refspec *spec)
 {
 	GIT_ASSERT_ARG(spec);