rugged 1.5.1 → 1.6.2

data/vendor/libgit2/src/libgit2/remote.h

@@ -17,6 +17,7 @@
 #include "refspec.h"
 #include "vector.h"
 #include "net.h"
+#include "proxy.h"
 
 #define GIT_REMOTE_ORIGIN "origin"
 
@@ -56,5 +57,44 @@ int git_remote_connect_options_normalize(
 	const git_remote_connect_options *src);
 
 int git_remote_capabilities(unsigned int *out, git_remote *remote);
+int git_remote_oid_type(git_oid_t *out, git_remote *remote);
+
+
+#define git_remote_connect_options__copy_opts(out, in) \
+	if (in) { \
+		(out)->callbacks = (in)->callbacks; \
+		(out)->proxy_opts = (in)->proxy_opts; \
+		(out)->custom_headers = (in)->custom_headers; \
+		(out)->follow_redirects = (in)->follow_redirects; \
+	}
+
+GIT_INLINE(int) git_remote_connect_options__from_fetch_opts(
+	git_remote_connect_options *out,
+	git_remote *remote,
+	const git_fetch_options *fetch_opts)
+{
+	git_remote_connect_options tmp = GIT_REMOTE_CONNECT_OPTIONS_INIT;
+	git_remote_connect_options__copy_opts(&tmp, fetch_opts);
+	return git_remote_connect_options_normalize(out, remote->repo, &tmp);
+}
+
+GIT_INLINE(int) git_remote_connect_options__from_push_opts(
+	git_remote_connect_options *out,
+	git_remote *remote,
+	const git_push_options *push_opts)
+{
+	git_remote_connect_options tmp = GIT_REMOTE_CONNECT_OPTIONS_INIT;
+	git_remote_connect_options__copy_opts(&tmp, push_opts);
+	return git_remote_connect_options_normalize(out, remote->repo, &tmp);
+}
+
+#undef git_remote_connect_options__copy_opts
+
+GIT_INLINE(void) git_remote_connect_options__dispose(
+	git_remote_connect_options *opts)
+{
+	git_proxy_options_dispose(&opts->proxy_opts);
+	git_strarray_dispose(&opts->custom_headers);
+}
 
 #endif

data/vendor/libgit2/src/libgit2/repository.c

@@ -67,6 +67,7 @@ static const struct {
 static int check_repositoryformatversion(int *version, git_config *config);
 static int check_extensions(git_config *config, int version);
 static int load_global_config(git_config **config);
+static int load_objectformat(git_repository *repo, git_config *config);
 
 #define GIT_COMMONDIR_FILE "commondir"
 #define GIT_GITDIR_FILE "gitdir"
@@ -75,8 +76,8 @@ static int load_global_config(git_config **config);
 
 #define GIT_BRANCH_DEFAULT "master"
 
-#define GIT_REPO_VERSION 0
-#define GIT_REPO_MAX_VERSION 1
+#define GIT_REPO_VERSION_DEFAULT 0
+#define GIT_REPO_VERSION_MAX 1
 
 git_str git_repository__reserved_names_win32[] = {
 	{ DOT_GIT, 0, CONST_STRLEN(DOT_GIT) },
@@ -240,7 +241,7 @@ GIT_INLINE(int) validate_repo_path(git_str *path)
 	 */
 	static size_t suffix_len =
 		CONST_STRLEN("objects/pack/pack-.pack.lock") +
-		GIT_OID_HEXSZ;
+		GIT_OID_MAX_HEXSIZE;
 
 	return git_fs_path_validate_str_length_with_suffix(
 		path, suffix_len);
@@ -495,12 +496,47 @@ static int validate_ownership_cb(const git_config_entry *entry, void *payload)
 {
 	validate_ownership_data *data = payload;
 
-	if (strcmp(entry->value, "") == 0)
+	if (strcmp(entry->value, "") == 0) {
 		*data->is_safe = false;
-
-	if (git_fs_path_prettify_dir(&data->tmp, entry->value, NULL) == 0 &&
-	    strcmp(data->tmp.ptr, data->repo_path) == 0)
+	} else if (strcmp(entry->value, "*") == 0) {
 		*data->is_safe = true;
+	} else {
+		const char *test_path = entry->value;
+
+#ifdef GIT_WIN32
+		/*
+		 * Git for Windows does some truly bizarre things with
+		 * paths that start with a forward slash; and expects you
+		 * to escape that with `%(prefix)`. This syntax generally
+		 * means to add the prefix that Git was installed to -- eg
+		 * `/usr/local` -- unless it's an absolute path, in which
+		 * case the leading `%(prefix)/` is just removed. And Git
+		 * for Windows expects you to use this syntax for absolute
+		 * Unix-style paths (in "Git Bash" or Windows Subsystem for
+		 * Linux).
+		 *
+		 * Worse, the behavior used to be that a leading `/` was
+		 * not absolute. It would indicate that Git for Windows
+		 * should add the prefix. So `//` is required for absolute
+		 * Unix-style paths. Yes, this is truly horrifying.
+		 *
+		 * Emulate that behavior, I guess, but only for absolute
+		 * paths. We won't deal with the Git install prefix. Also,
+		 * give WSL users an escape hatch where they don't have to
+		 * think about this and can use the literal path that the
+		 * filesystem APIs provide (`//wsl.localhost/...`).
+		 */
+		if (strncmp(test_path, "%(prefix)//", strlen("%(prefix)//")) == 0)
+			test_path += strlen("%(prefix)/");
+		else if (strncmp(test_path, "//", 2) == 0 &&
+		         strncmp(test_path, "//wsl.localhost/", strlen("//wsl.localhost/")) != 0)
+			test_path++;
+#endif
+
+		if (git_fs_path_prettify_dir(&data->tmp, test_path, NULL) == 0 &&
+		    strcmp(data->tmp.ptr, data->repo_path) == 0)
+			*data->is_safe = true;
+	}
 
 	return 0;
 }
@@ -521,6 +557,9 @@ static int validate_ownership_config(bool *is_safe, const char *path)
 		validate_ownership_cb,
 		&ownership_data);
 
+	if (error == GIT_ENOTFOUND)
+		error = 0;
+
 	git_config_free(config);
 	git_str_dispose(&ownership_data.tmp);
 
@@ -541,6 +580,9 @@ static int validate_ownership_path(bool *is_safe, const char *path)
 	if (error == GIT_ENOTFOUND) {
 		*is_safe = true;
 		error = 0;
+	} else if (error == GIT_EINVALID) {
+		*is_safe = false;
+		error = 0;
 	}
 
 	return error;
@@ -727,6 +769,43 @@ out:
 	return error;
 }
 
+static int obtain_config_and_set_oid_type(
+	git_config **config_ptr,
+	git_repository *repo)
+{
+	int error;
+	git_config *config = NULL;
+	int version = 0;
+
+	/*
+	 * We'd like to have the config, but git doesn't particularly
+	 * care if it's not there, so we need to deal with that.
+	 */
+
+	error = git_repository_config_snapshot(&config, repo);
+	if (error < 0 && error != GIT_ENOTFOUND)
+		goto out;
+
+	if (config &&
+		(error = check_repositoryformatversion(&version, config)) < 0)
+		goto out;
+
+	if ((error = check_extensions(config, version)) < 0)
+		goto out;
+
+	if (version > 0) {
+		if ((error = load_objectformat(repo, config)) < 0)
+			goto out;
+	} else {
+		repo->oid_type = GIT_OID_SHA1;
+	}
+
+out:
+	*config_ptr = config;
+
+	return error;
+}
+
 int git_repository_open_bare(
 	git_repository **repo_ptr,
 	const char *bare_path)
@@ -735,6 +814,7 @@ int git_repository_open_bare(
 	git_repository *repo = NULL;
 	bool is_valid;
 	int error;
+	git_config *config;
 
 	if ((error = git_fs_path_prettify_dir(&path, bare_path, NULL)) < 0 ||
 	    (error = is_valid_repository_path(&is_valid, &path, &common_path)) < 0)
@@ -760,8 +840,15 @@ int git_repository_open_bare(
 	repo->is_worktree = 0;
 	repo->workdir = NULL;
 
+	if ((error = obtain_config_and_set_oid_type(&config, repo)) < 0)
+		goto cleanup;
+
 	*repo_ptr = repo;
-	return 0;
+
+cleanup:
+	git_config_free(config);
+
+	return error;
 }
 
 static int _git_repository_open_ext_from_env(
@@ -843,7 +930,7 @@ static int _git_repository_open_ext_from_env(
 	else if (error < 0)
 		goto error;
 	else {
-		error = git_odb_open(&odb, git_str_cstr(&object_dir_buf));
+		error = git_odb__open(&odb, git_str_cstr(&object_dir_buf), NULL);
 		if (error < 0)
 			goto error;
 	}
@@ -968,7 +1055,6 @@ int git_repository_open_ext(
 		gitlink = GIT_STR_INIT, commondir = GIT_STR_INIT;
 	git_repository *repo = NULL;
 	git_config *config = NULL;
-	int version = 0;
 
 	if (flags & GIT_REPOSITORY_OPEN_FROM_ENV)
 		return _git_repository_open_ext_from_env(repo_ptr, start_path);
@@ -1001,19 +1087,8 @@ int git_repository_open_ext(
 		goto cleanup;
 	repo->is_worktree = is_worktree;
 
-	/*
-	 * We'd like to have the config, but git doesn't particularly
-	 * care if it's not there, so we need to deal with that.
-	 */
-
-	error = git_repository_config_snapshot(&config, repo);
-	if (error < 0 && error != GIT_ENOTFOUND)
-		goto cleanup;
-
-	if (config && (error = check_repositoryformatversion(&version, config)) < 0)
-		goto cleanup;
-
-	if ((error = check_extensions(config, version)) < 0)
+	error = obtain_config_and_set_oid_type(&config, repo);
+	if (error < 0)
 		goto cleanup;
 
 	if ((flags & GIT_REPOSITORY_OPEN_BARE) != 0) {
@@ -1264,11 +1339,14 @@ int git_repository_odb__weakptr(git_odb **out, git_repository *repo)
 	*out = git_atomic_load(repo->_odb);
 	if (*out == NULL) {
 		git_str odb_path = GIT_STR_INIT;
+		git_odb_options odb_opts = GIT_ODB_OPTIONS_INIT;
 		git_odb *odb;
 
+		odb_opts.oid_type = repo->oid_type;
+
 		if ((error = git_repository__item_path(&odb_path, repo,
 				GIT_REPOSITORY_ITEM_OBJECTS)) < 0 ||
-			(error = git_odb_new(&odb)) < 0)
+			(error = git_odb__new(&odb, &odb_opts)) < 0)
 			return error;
 
 		GIT_REFCOUNT_OWN(odb, repo);
@@ -1526,6 +1604,7 @@ static int check_repositoryformatversion(int *version, git_config *config)
 	int error;
 
 	error = git_config_get_int32(version, config, "core.repositoryformatversion");
+
 	/* git ignores this if the config variable isn't there */
 	if (error == GIT_ENOTFOUND)
 		return 0;
@@ -1533,10 +1612,15 @@ static int check_repositoryformatversion(int *version, git_config *config)
 	if (error < 0)
 		return -1;
 
-	if (GIT_REPO_MAX_VERSION < *version) {
+	if (*version < 0) {
+		git_error_set(GIT_ERROR_REPOSITORY,
+			"invalid repository version %d", *version);
+	}
+
+	if (GIT_REPO_VERSION_MAX < *version) {
 		git_error_set(GIT_ERROR_REPOSITORY,
 			"unsupported repository version %d; only versions up to %d are supported",
-			*version, GIT_REPO_MAX_VERSION);
+			*version, GIT_REPO_VERSION_MAX);
 		return -1;
 	}
 
@@ -1544,7 +1628,8 @@ static int check_repositoryformatversion(int *version, git_config *config)
 }
 
 static const char *builtin_extensions[] = {
-	"noop"
+	"noop",
+	"objectformat"
 };
 
 static git_vector user_extensions = GIT_VECTOR_INIT;
@@ -1608,6 +1693,79 @@ static int check_extensions(git_config *config, int version)
 	return git_config_foreach_match(config, "^extensions\\.", check_valid_extension, NULL);
 }
 
+static int load_objectformat(git_repository *repo, git_config *config)
+{
+	git_config_entry *entry = NULL;
+	int error;
+
+	if ((error = git_config_get_entry(&entry, config, "extensions.objectformat")) < 0) {
+		if (error == GIT_ENOTFOUND) {
+			repo->oid_type = GIT_OID_SHA1;
+			git_error_clear();
+			error = 0;
+		}
+
+		goto done;
+	}
+
+	if ((repo->oid_type = git_oid_type_fromstr(entry->value)) == 0) {
+		git_error_set(GIT_ERROR_REPOSITORY,
+			"unknown object format '%s'", entry->value);
+		error = GIT_EINVALID;
+	}
+
+done:
+	git_config_entry_free(entry);
+	return error;
+}
+
+int git_repository__set_objectformat(
+	git_repository *repo,
+	git_oid_t oid_type)
+{
+	git_config *cfg;
+
+	/*
+	 * Older clients do not necessarily understand the
+	 * `objectformat` extension, even when it's set to an
+	 * object format that they understand (SHA1). Do not set
+	 * the objectformat extension unless we're not using the
+	 * default object format.
+	 */
+	if (oid_type == GIT_OID_DEFAULT)
+		return 0;
+
+	if (!git_repository_is_empty(repo) && repo->oid_type != oid_type) {
+		git_error_set(GIT_ERROR_REPOSITORY,
+			"cannot change object id type of existing repository");
+		return -1;
+	}
+
+	if (git_repository_config__weakptr(&cfg, repo) < 0)
+		return -1;
+
+	if (git_config_set_int32(cfg,
+			"core.repositoryformatversion", 1) < 0 ||
+	    git_config_set_string(cfg, "extensions.objectformat",
+			git_oid_type_name(oid_type)) < 0)
+		return -1;
+
+	/*
+	 * During repo init, we may create some backends with the
+	 * default oid type. Clear them so that we create them with
+	 * the proper oid type.
+	 */
+	if (repo->oid_type != oid_type) {
+		set_index(repo, NULL);
+		set_odb(repo, NULL);
+		set_refdb(repo, NULL);
+
+		repo->oid_type = oid_type;
+	}
+
+	return 0;
+}
+
 int git_repository__extensions(char ***out, size_t *out_len)
 {
 	git_vector extensions;
@@ -1886,19 +2044,21 @@ static int repo_init_config(
 	const char *repo_dir,
 	const char *work_dir,
 	uint32_t flags,
-	uint32_t mode)
+	uint32_t mode,
+	git_oid_t oid_type)
 {
 	int error = 0;
 	git_str cfg_path = GIT_STR_INIT, worktree_path = GIT_STR_INIT;
 	git_config *config = NULL;
 	bool is_bare = ((flags & GIT_REPOSITORY_INIT_BARE) != 0);
 	bool is_reinit = ((flags & GIT_REPOSITORY_INIT__IS_REINIT) != 0);
-	int version = 0;
+	int version = GIT_REPO_VERSION_DEFAULT;
 
 	if ((error = repo_local_config(&config, &cfg_path, NULL, repo_dir)) < 0)
 		goto cleanup;
 
-	if (is_reinit && (error = check_repositoryformatversion(&version, config)) < 0)
+	if (is_reinit &&
+	    (error = check_repositoryformatversion(&version, config)) < 0)
 		goto cleanup;
 
 	if ((error = check_extensions(config, version)) < 0)
@@ -1909,7 +2069,7 @@ static int repo_init_config(
 		goto cleanup; } while (0)
 
 	SET_REPO_CONFIG(bool, "core.bare", is_bare);
-	SET_REPO_CONFIG(int32, "core.repositoryformatversion", GIT_REPO_VERSION);
+	SET_REPO_CONFIG(int32, "core.repositoryformatversion", version);
 
 	if ((error = repo_init_fs_configs(
 			config, cfg_path.ptr, repo_dir, work_dir, !is_reinit)) < 0)
@@ -1942,6 +2102,11 @@ static int repo_init_config(
 		SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true);
 	}
 
+	if (oid_type != GIT_OID_SHA1) {
+		SET_REPO_CONFIG(int32, "core.repositoryformatversion", 1);
+		SET_REPO_CONFIG(string, "extensions.objectformat", git_oid_type_name(oid_type));
+	}
+
 cleanup:
 	git_str_dispose(&cfg_path);
 	git_str_dispose(&worktree_path);
@@ -2422,6 +2587,7 @@ int git_repository_init_ext(
 		common_path = GIT_STR_INIT;
 	const char *wd;
 	bool is_valid;
+	git_oid_t oid_type = GIT_OID_DEFAULT;
 	int error;
 
 	GIT_ASSERT_ARG(out);
@@ -2430,6 +2596,11 @@ int git_repository_init_ext(
 
 	GIT_ERROR_CHECK_VERSION(opts, GIT_REPOSITORY_INIT_OPTIONS_VERSION, "git_repository_init_options");
 
+#ifdef GIT_EXPERIMENTAL_SHA256
+	if (opts->oid_type)
+		oid_type = opts->oid_type;
+#endif
+
 	if ((error = repo_init_directories(&repo_path, &wd_path, given_repo, opts)) < 0)
 		goto out;
 
@@ -2448,13 +2619,13 @@ int git_repository_init_ext(
 
 		opts->flags |= GIT_REPOSITORY_INIT__IS_REINIT;
 
-		if ((error = repo_init_config(repo_path.ptr, wd, opts->flags, opts->mode)) < 0)
+		if ((error = repo_init_config(repo_path.ptr, wd, opts->flags, opts->mode, oid_type)) < 0)
 			goto out;
 
 		/* TODO: reinitialize the templates */
 	} else {
 		if ((error = repo_init_structure(repo_path.ptr, wd, opts)) < 0 ||
-		    (error = repo_init_config(repo_path.ptr, wd, opts->flags, opts->mode)) < 0 ||
+		    (error = repo_init_config(repo_path.ptr, wd, opts->flags, opts->mode, oid_type)) < 0 ||
 		    (error = repo_init_head(repo_path.ptr, opts->initial_head)) < 0)
 			goto out;
 	}
@@ -2917,14 +3088,14 @@ int git_repository__set_orig_head(git_repository *repo, const git_oid *orig_head
 {
 	git_filebuf file = GIT_FILEBUF_INIT;
 	git_str file_path = GIT_STR_INIT;
-	char orig_head_str[GIT_OID_HEXSZ];
+	char orig_head_str[GIT_OID_MAX_HEXSIZE];
 	int error = 0;
 
 	git_oid_fmt(orig_head_str, orig_head);
 
 	if ((error = git_str_joinpath(&file_path, repo->gitdir, GIT_ORIG_HEAD_FILE)) == 0 &&
 		(error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_CREATE_LEADING_DIRS, GIT_MERGE_FILE_MODE)) == 0 &&
-		(error = git_filebuf_printf(&file, "%.*s\n", GIT_OID_HEXSZ, orig_head_str)) == 0)
+		(error = git_filebuf_printf(&file, "%.*s\n", (int)git_oid_hexsize(repo->oid_type), orig_head_str)) == 0)
 		error = git_filebuf_commit(&file);
 
 	if (error < 0)
@@ -3037,7 +3208,7 @@ int git_repository_hashfile(
 		goto cleanup;
 	}
 
-	error = git_odb__hashfd_filtered(out, fd, (size_t)len, type, fl);
+	error = git_odb__hashfd_filtered(out, fd, (size_t)len, type, repo->oid_type, fl);
 
 cleanup:
 	if (fd >= 0)
@@ -3384,3 +3555,8 @@ int git_repository_submodule_cache_clear(git_repository *repo)
 	repo->submodule_cache = NULL;
 	return error;
 }
+
+git_oid_t git_repository_oid_type(git_repository *repo)
+{
+	return repo ? repo->oid_type : 0;
+}

data/vendor/libgit2/src/libgit2/repository.h

@@ -153,6 +153,7 @@ struct git_repository {
 
 	unsigned is_bare:1;
 	unsigned is_worktree:1;
+	git_oid_t oid_type;
 
 	unsigned int lru_counter;
 
@@ -256,4 +257,12 @@ int git_repository__extensions(char ***out, size_t *out_len);
 int git_repository__set_extensions(const char **extensions, size_t len);
 void git_repository__free_extensions(void);
 
+/*
+ * Set the object format (OID type) for a repository; this will set
+ * both the configuration and the internal value for the oid type.
+ */
+int git_repository__set_objectformat(
+	git_repository *repo,
+	git_oid_t oid_type);
+
 #endif

data/vendor/libgit2/src/libgit2/reset.c

@@ -188,9 +188,9 @@ int git_reset(
 	git_reset_t reset_type,
 	const git_checkout_options *checkout_opts)
 {
-	char to[GIT_OID_HEXSZ + 1];
+	char to[GIT_OID_SHA1_HEXSIZE + 1];
 
-	git_oid_tostr(to, GIT_OID_HEXSZ + 1, git_object_id(target));
+	git_oid_tostr(to, GIT_OID_SHA1_HEXSIZE + 1, git_object_id(target));
 	return reset(repo, target, to, reset_type, checkout_opts);
 }
 

data/vendor/libgit2/src/libgit2/revert.c

@@ -107,10 +107,10 @@ static int revert_state_cleanup(git_repository *repo)
 
 static int revert_seterr(git_commit *commit, const char *fmt)
 {
-	char commit_oidstr[GIT_OID_HEXSZ + 1];
+	char commit_oidstr[GIT_OID_SHA1_HEXSIZE + 1];
 
 	git_oid_fmt(commit_oidstr, git_commit_id(commit));
-	commit_oidstr[GIT_OID_HEXSZ] = '\0';
+	commit_oidstr[GIT_OID_SHA1_HEXSIZE] = '\0';
 
 	git_error_set(GIT_ERROR_REVERT, fmt, commit_oidstr);
 
@@ -176,7 +176,7 @@ int git_revert(
 	git_revert_options opts;
 	git_reference *our_ref = NULL;
 	git_commit *our_commit = NULL;
-	char commit_oidstr[GIT_OID_HEXSZ + 1];
+	char commit_oidstr[GIT_OID_SHA1_HEXSIZE + 1];
 	const char *commit_msg;
 	git_str their_label = GIT_STR_INIT;
 	git_index *index = NULL;
@@ -192,7 +192,7 @@ int git_revert(
 		return error;
 
 	git_oid_fmt(commit_oidstr, git_commit_id(commit));
-	commit_oidstr[GIT_OID_HEXSZ] = '\0';
+	commit_oidstr[GIT_OID_SHA1_HEXSIZE] = '\0';
 
 	if ((commit_msg = git_commit_summary(commit)) == NULL) {
 		error = -1;

data/vendor/libgit2/src/libgit2/revparse.c

@@ -15,21 +15,28 @@
 
 #include "git2.h"
 
-static int maybe_sha_or_abbrev(git_object **out, git_repository *repo, const char *spec, size_t speclen)
+static int maybe_sha_or_abbrev(
+	git_object **out,
+	git_repository *repo,
+	const char *spec,
+	size_t speclen)
 {
 	git_oid oid;
 
-	if (git_oid_fromstrn(&oid, spec, speclen) < 0)
+	if (git_oid__fromstrn(&oid, spec, speclen, repo->oid_type) < 0)
 		return GIT_ENOTFOUND;
 
 	return git_object_lookup_prefix(out, repo, &oid, speclen, GIT_OBJECT_ANY);
 }
 
-static int maybe_sha(git_object **out, git_repository *repo, const char *spec)
+static int maybe_sha(
+	git_object **out,
+	git_repository *repo,
+	const char *spec)
 {
 	size_t speclen = strlen(spec);
 
-	if (speclen != GIT_OID_HEXSZ)
+	if (speclen != git_oid_hexsize(repo->oid_type))
 		return GIT_ENOTFOUND;
 
 	return maybe_sha_or_abbrev(out, repo, spec, speclen);
@@ -110,8 +117,8 @@ static int revparse_lookup_object(
 	if (error != GIT_ENOTFOUND)
 		return error;
 
-	if ((strlen(spec) < GIT_OID_HEXSZ) &&
-		((error = maybe_abbrev(object_out, repo, spec)) != GIT_ENOTFOUND))
+	if ((strlen(spec) < git_oid_hexsize(repo->oid_type)) &&
+	    ((error = maybe_abbrev(object_out, repo, spec)) != GIT_ENOTFOUND))
 			return error;
 
 	if ((error = maybe_describe(object_out, repo, spec)) != GIT_ENOTFOUND)
@@ -268,7 +275,16 @@ static int retrieve_revobject_from_reflog(git_object **out, git_reference **base
 	int error = -1;
 
 	if (*base_ref == NULL) {
-		if ((error = git_reference_dwim(&ref, repo, identifier)) < 0)
+		/*
+		 * When HEAD@{n} is specified, do not use dwim, which would resolve the
+		 * reference (to the current branch that HEAD is pointing to).
+		 */
+		if (position > 0 && strcmp(identifier, GIT_HEAD_FILE) == 0)
+			error = git_reference_lookup(&ref, repo, GIT_HEAD_FILE);
+		else
+			error = git_reference_dwim(&ref, repo, identifier);
+
+		if (error < 0)
 			return error;
 	} else {
 		ref = *base_ref;

data/vendor/libgit2/src/libgit2/revwalk.c

@@ -121,8 +121,12 @@ int git_revwalk__push_ref(git_revwalk *walk, const char *refname, const git_revw
 {
 	git_oid oid;
 
-	if (git_reference_name_to_id(&oid, walk->repo, refname) < 0)
+	int error = git_reference_name_to_id(&oid, walk->repo, refname);
+	if (opts->from_glob && (error == GIT_ENOTFOUND || error == GIT_EINVALIDSPEC || error == GIT_EPEEL)) {
+		return 0;
+	} else if (error < 0) {
 		return -1;
+	}
 
 	return git_revwalk__push_commit(walk, &oid, opts);
 }