rugged 1.1.0 → 1.2.0

data/vendor/libgit2/src/describe.c

@@ -655,7 +655,8 @@ int git_describe_commit(
 	int error = -1;
 	git_describe_options normalized;
 
-	assert(committish);
+	GIT_ASSERT_ARG(result);
+	GIT_ASSERT_ARG(committish);
 
 	data.result = git__calloc(1, sizeof(git_describe_result));
 	GIT_ERROR_CHECK_ALLOC(data.result);
@@ -775,12 +776,14 @@ int git_describe_format(git_buf *out, const git_describe_result *result, const g
 	struct commit_name *name;
 	git_describe_format_options opts;
 
-	assert(out && result);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(result);
 
 	GIT_ERROR_CHECK_VERSION(given, GIT_DESCRIBE_FORMAT_OPTIONS_VERSION, "git_describe_format_options");
 	normalize_format_options(&opts, given);
 
-	git_buf_sanitize(out);
+	if ((error = git_buf_sanitize(out)) < 0)
+		return error;
 
 
 	if (opts.always_use_long_format && opts.abbreviated_size == 0) {

data/vendor/libgit2/src/diff.c

@@ -77,7 +77,7 @@ void git_diff_addref(git_diff *diff)
 
 size_t git_diff_num_deltas(const git_diff *diff)
 {
-	assert(diff);
+	GIT_ASSERT_ARG(diff);
 	return diff->deltas.length;
 }
 
@@ -86,7 +86,7 @@ size_t git_diff_num_deltas_of_type(const git_diff *diff, git_delta_t type)
 	size_t i, count = 0;
 	const git_diff_delta *delta;
 
-	assert(diff);
+	GIT_ASSERT_ARG(diff);
 
 	git_vector_foreach(&diff->deltas, i, delta) {
 		count += (delta->status == type);
@@ -97,7 +97,7 @@ size_t git_diff_num_deltas_of_type(const git_diff *diff, git_delta_t type)
 
 const git_diff_delta *git_diff_get_delta(const git_diff *diff, size_t idx)
 {
-	assert(diff);
+	GIT_ASSERT_ARG_WITH_RETVAL(diff, NULL);
 	return git_vector_get(&diff->deltas, idx);
 }
 
@@ -108,7 +108,7 @@ int git_diff_is_sorted_icase(const git_diff *diff)
 
 int git_diff_get_perfdata(git_diff_perfdata *out, const git_diff *diff)
 {
-	assert(out);
+	GIT_ASSERT_ARG(out);
 	GIT_ERROR_CHECK_VERSION(out, GIT_DIFF_PERFDATA_VERSION, "git_diff_perfdata");
 	out->stat_calls = diff->perf.stat_calls;
 	out->oid_calculations = diff->perf.oid_calculations;
@@ -127,7 +127,7 @@ int git_diff_foreach(
 	git_diff_delta *delta;
 	size_t idx;
 
-	assert(diff);
+	GIT_ASSERT_ARG(diff);
 
 	git_vector_foreach(&diff->deltas, idx, delta) {
 		git_patch *patch;
@@ -243,8 +243,9 @@ int git_diff_format_email(
 	size_t allocsize;
 	int error;
 
-	assert(out && diff && opts);
-	assert(opts->summary && opts->id && opts->author);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(diff);
+	GIT_ASSERT_ARG(opts && opts->summary && opts->id && opts->author);
 
 	GIT_ERROR_CHECK_VERSION(opts,
 		GIT_DIFF_FORMAT_EMAIL_OPTIONS_VERSION,
@@ -326,7 +327,9 @@ int git_diff_commit_as_email(
 		GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
 	int error;
 
-	assert (out && repo && commit);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(repo);
+	GIT_ASSERT_ARG(commit);
 
 	opts.flags = flags;
 	opts.patch_no = patch_no;

data/vendor/libgit2/src/diff_driver.c

@@ -13,7 +13,6 @@
 #include "diff.h"
 #include "strmap.h"
 #include "map.h"
-#include "buf_text.h"
 #include "config.h"
 #include "regexp.h"
 #include "repository.h"
@@ -142,18 +141,23 @@ static int diff_driver_funcname(const git_config_entry *entry, void *payload)
 static git_diff_driver_registry *git_repository_driver_registry(
 	git_repository *repo)
 {
-	if (!repo->diff_drivers) {
-		git_diff_driver_registry *reg = git_diff_driver_registry_new();
-		reg = git__compare_and_swap(&repo->diff_drivers, NULL, reg);
+	git_diff_driver_registry *reg = git_atomic_load(repo->diff_drivers), *newreg;
+	if (reg)
+		return reg;
 
-		if (reg != NULL) /* if we race, free losing allocation */
-			git_diff_driver_registry_free(reg);
-	}
-
-	if (!repo->diff_drivers)
+	newreg = git_diff_driver_registry_new();
+	if (!newreg) {
 		git_error_set(GIT_ERROR_REPOSITORY, "unable to create diff driver registry");
-
-	return repo->diff_drivers;
+		return newreg;
+	}
+	reg = git_atomic_compare_and_swap(&repo->diff_drivers, NULL, newreg);
+	if (!reg) {
+		reg = newreg;
+	} else {
+		/* if we race, free losing allocation */
+		git_diff_driver_registry_free(newreg);
+	}
+	return reg;
 }
 
 static int diff_driver_alloc(
@@ -358,7 +362,7 @@ int git_diff_driver_lookup(
 	int error = 0;
 	const char *values[1], *attrs[] = { "diff" };
 
-	assert(out);
+	GIT_ASSERT_ARG(out);
 	*out = NULL;
 
 	if (!repo || !path || !strlen(path))
@@ -390,13 +394,13 @@ int git_diff_driver_lookup(
 
 void git_diff_driver_free(git_diff_driver *driver)
 {
-	size_t i;
+	git_diff_driver_pattern *pat;
 
 	if (!driver)
 		return;
 
-	for (i = 0; i < git_array_size(driver->fn_patterns); ++i)
-		git_regexp_dispose(& git_array_get(driver->fn_patterns, i)->re);
+	while ((pat = git_array_pop(driver->fn_patterns)) != NULL)
+		git_regexp_dispose(&pat->re);
 	git_array_clear(driver->fn_patterns);
 
 	git_regexp_dispose(&driver->word_pattern);
@@ -428,8 +432,8 @@ int git_diff_driver_content_is_binary(
 	 * let's just use the simple NUL-byte detection that core git uses.
 	 */
 
-	/* previously was: if (git_buf_text_is_binary(&search)) */
-	if (git_buf_text_contains_nul(&search))
+	/* previously was: if (git_buf_is_binary(&search)) */
+	if (git_buf_contains_nul(&search))
 		return 1;
 
 	return 0;

data/vendor/libgit2/src/diff_file.c

@@ -362,10 +362,7 @@ static int diff_file_content_load_workdir_file(
 	if (!(error = git_futils_readbuffer_fd(&raw, fd, (size_t)fc->file->size))) {
 		git_buf out = GIT_BUF_INIT;
 
-		error = git_filter_list_apply_to_data(&out, fl, &raw);
-
-		if (out.ptr != raw.ptr)
-			git_buf_dispose(&raw);
+		error = git_filter_list__convert_buf(&out, fl, &raw);
 
 		if (!error) {
 			fc->map.len  = out.size;
@@ -394,8 +391,7 @@ static int diff_file_content_load_workdir(
 	if (fc->file->mode == GIT_FILEMODE_TREE)
 		return 0;
 
-	if (git_buf_joinpath(
-			&path, git_repository_workdir(fc->repo), fc->file->path) < 0)
+	if (git_repository_workdir_path(&path, fc->repo, fc->file->path) < 0)
 		return -1;
 
 	if (S_ISLNK(fc->file->mode))

data/vendor/libgit2/src/diff_generate.c

@@ -128,7 +128,7 @@ static int diff_delta__from_one(
 	git_diff_delta *delta;
 	const char *matched_pathspec;
 
-	assert((oitem != NULL) ^ (nitem != NULL));
+	GIT_ASSERT_ARG((oitem != NULL) ^ (nitem != NULL));
 
 	if (oitem) {
 		entry = oitem;
@@ -160,7 +160,7 @@ static int diff_delta__from_one(
 	GIT_ERROR_CHECK_ALLOC(delta);
 
 	/* This fn is just for single-sided diffs */
-	assert(status != GIT_DELTA_MODIFIED);
+	GIT_ASSERT(status != GIT_DELTA_MODIFIED);
 	delta->nfiles = 1;
 
 	if (has_old) {
@@ -408,7 +408,9 @@ static git_diff_generated *diff_generated_alloc(
 	git_diff_generated *diff;
 	git_diff_options dflt = GIT_DIFF_OPTIONS_INIT;
 
-	assert(repo && old_iter && new_iter);
+	GIT_ASSERT_ARG_WITH_RETVAL(repo, NULL);
+	GIT_ASSERT_ARG_WITH_RETVAL(old_iter, NULL);
+	GIT_ASSERT_ARG_WITH_RETVAL(new_iter, NULL);
 
 	if ((diff = git__calloc(1, sizeof(git_diff_generated))) == NULL)
 		return NULL;
@@ -589,13 +591,12 @@ int git_diff__oid_for_entry(
 	git_filter_list *fl = NULL;
 	int error = 0;
 
-	assert(d->type == GIT_DIFF_TYPE_GENERATED);
+	GIT_ASSERT(d->type == GIT_DIFF_TYPE_GENERATED);
 	diff = (git_diff_generated *)d;
 
 	memset(out, 0, sizeof(*out));
 
-	if (git_buf_joinpath(&full_path,
-		git_repository_workdir(diff->base.repo), entry.path) < 0)
+	if (git_repository_workdir_path(&full_path, diff->base.repo, entry.path) < 0)
 		return -1;
 
 	if (!mode) {
@@ -678,6 +679,8 @@ typedef struct {
 	git_iterator *new_iter;
 	const git_index_entry *oitem;
 	const git_index_entry *nitem;
+	git_strmap *submodule_cache;
+	bool submodule_cache_initialized;
 } diff_in_progress;
 
 #define MODE_BITS_MASK 0000777
@@ -692,6 +695,7 @@ static int maybe_modified_submodule(
 	git_submodule *sub;
 	unsigned int sm_status = 0;
 	git_submodule_ignore_t ign = diff->base.opts.ignore_submodules;
+	git_strmap *submodule_cache = NULL;
 
 	*status = GIT_DELTA_UNMODIFIED;
 
@@ -699,8 +703,23 @@ static int maybe_modified_submodule(
 		ign == GIT_SUBMODULE_IGNORE_ALL)
 		return 0;
 
-	if ((error = git_submodule_lookup(
-			&sub, diff->base.repo, info->nitem->path)) < 0) {
+	if (diff->base.repo->submodule_cache != NULL) {
+		submodule_cache = diff->base.repo->submodule_cache;
+	} else {
+		if (!info->submodule_cache_initialized) {
+			info->submodule_cache_initialized = true;
+			/*
+			 * Try to cache the submodule information to avoid having to parse it for
+			 * every submodule. It is okay if it fails, the cache will still be NULL
+			 * and the submodules will be attempted to be looked up individually.
+			 */
+			git_submodule_cache_init(&info->submodule_cache, diff->base.repo);
+		}
+		submodule_cache = info->submodule_cache;
+	}
+
+	if ((error = git_submodule__lookup_with_cache(
+			&sub, diff->base.repo, info->nitem->path, submodule_cache)) < 0) {
 
 		/* GIT_EEXISTS means dir with .git in it was found - ignore it */
 		if (error == GIT_EEXISTS) {
@@ -1190,7 +1209,7 @@ int git_diff__from_iterators(
 	const git_diff_options *opts)
 {
 	git_diff_generated *diff;
-	diff_in_progress info;
+	diff_in_progress info = {0};
 	int error = 0;
 
 	*out = NULL;
@@ -1204,8 +1223,9 @@ int git_diff__from_iterators(
 
 	/* make iterators have matching icase behavior */
 	if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_IGNORE_CASE)) {
-		git_iterator_set_ignore_case(old_iter, true);
-		git_iterator_set_ignore_case(new_iter, true);
+		if ((error = git_iterator_set_ignore_case(old_iter, true)) < 0 ||
+		    (error = git_iterator_set_ignore_case(new_iter, true)) < 0)
+			goto cleanup;
 	}
 
 	/* finish initialization */
@@ -1257,6 +1277,8 @@ cleanup:
 		*out = &diff->base;
 	else
 		git_diff_free(&diff->base);
+	if (info.submodule_cache)
+		git_submodule_cache_free(info.submodule_cache);
 
 	return error;
 }
@@ -1302,7 +1324,8 @@ int git_diff_tree_to_tree(
 	char *prefix = NULL;
 	int error = 0;
 
-	assert(out && repo);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(repo);
 
 	*out = NULL;
 
@@ -1358,7 +1381,8 @@ int git_diff_tree_to_index(
 	bool index_ignore_case = false;
 	int error = 0;
 
-	assert(out && repo);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(repo);
 
 	*out = NULL;
 
@@ -1401,7 +1425,8 @@ int git_diff_index_to_workdir(
 	char *prefix = NULL;
 	int error = 0;
 
-	assert(out && repo);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(repo);
 
 	*out = NULL;
 
@@ -1444,7 +1469,8 @@ int git_diff_tree_to_workdir(
 	git_index *index;
 	int error;
 
-	assert(out && repo);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(repo);
 
 	*out = NULL;
 
@@ -1477,7 +1503,8 @@ int git_diff_tree_to_workdir_with_index(
 	git_index *index = NULL;
 	int error = 0;
 
-	assert(out && repo);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(repo);
 
 	*out = NULL;
 
@@ -1513,7 +1540,9 @@ int git_diff_index_to_index(
 	char *prefix = NULL;
 	int error;
 
-	assert(out && old_index && new_index);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(old_index);
+	GIT_ASSERT_ARG(new_index);
 
 	*out = NULL;
 

data/vendor/libgit2/src/diff_print.c

@@ -95,7 +95,7 @@ static int diff_print_info_init_frompatch(
 	git_diff_line_cb cb,
 	void *payload)
 {
-	assert(patch);
+	GIT_ASSERT_ARG(patch);
 
 	memset(pi, 0, sizeof(diff_print_info));
 
@@ -764,8 +764,14 @@ int git_diff_print_callback__to_file_handle(
 /* print a git_diff to a git_buf */
 int git_diff_to_buf(git_buf *out, git_diff *diff, git_diff_format_t format)
 {
-	assert(out && diff);
-	git_buf_sanitize(out);
+	int error;
+
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(diff);
+
+	if ((error = git_buf_sanitize(out)) < 0)
+		return error;
+
 	return git_diff_print(diff, format, git_diff_print_callback__to_buf, out);
 }
 
@@ -779,7 +785,8 @@ int git_patch_print(
 	diff_print_info pi;
 	int error;
 
-	assert(patch && print_cb);
+	GIT_ASSERT_ARG(patch);
+	GIT_ASSERT_ARG(print_cb);
 
 	if ((error = diff_print_info_init_frompatch(&pi, &temp, patch,
 						    GIT_DIFF_FORMAT_PATCH, print_cb, payload)) < 0)
@@ -799,7 +806,13 @@ out:
 /* print a git_patch to a git_buf */
 int git_patch_to_buf(git_buf *out, git_patch *patch)
 {
-	assert(out && patch);
-	git_buf_sanitize(out);
+	int error;
+
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(patch);
+
+	if ((error = git_buf_sanitize(out)) < 0)
+		return error;
+
 	return git_patch_print(patch, git_diff_print_callback__to_buf, out);
 }

data/vendor/libgit2/src/diff_stats.c

@@ -183,7 +183,8 @@ int git_diff_get_stats(
 	git_diff_stats *stats = NULL;
 	int error = 0;
 
-	assert(out && diff);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(diff);
 
 	stats = git__calloc(1, sizeof(git_diff_stats));
 	GIT_ERROR_CHECK_ALLOC(stats);
@@ -251,7 +252,7 @@ int git_diff_get_stats(
 size_t git_diff_stats_files_changed(
 	const git_diff_stats *stats)
 {
-	assert(stats);
+	GIT_ASSERT_ARG(stats);
 
 	return stats->files_changed;
 }
@@ -259,7 +260,7 @@ size_t git_diff_stats_files_changed(
 size_t git_diff_stats_insertions(
 	const git_diff_stats *stats)
 {
-	assert(stats);
+	GIT_ASSERT_ARG(stats);
 
 	return stats->insertions;
 }
@@ -267,7 +268,7 @@ size_t git_diff_stats_insertions(
 size_t git_diff_stats_deletions(
 	const git_diff_stats *stats)
 {
-	assert(stats);
+	GIT_ASSERT_ARG(stats);
 
 	return stats->deletions;
 }
@@ -282,7 +283,8 @@ int git_diff_stats_to_buf(
 	size_t i;
 	const git_diff_delta *delta;
 
-	assert(out && stats);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(stats);
 
 	if (format & GIT_DIFF_STATS_NUMBER) {
 		for (i = 0; i < stats->files_changed; ++i) {

data/vendor/libgit2/src/diff_tform.c

@@ -87,7 +87,7 @@ git_diff_delta *git_diff__merge_like_cgit(
 		a->status == GIT_DELTA_UNREADABLE)
 		return dup;
 
-	assert(b->status != GIT_DELTA_UNMODIFIED);
+	GIT_ASSERT_WITH_RETVAL(b->status != GIT_DELTA_UNMODIFIED, NULL);
 
 	/* A cgit exception is that the diff of a file that is only in the
 	 * index (i.e. not in HEAD nor workdir) is given as empty.
@@ -121,7 +121,8 @@ int git_diff__merge(
 	bool ignore_case, reversed;
 	unsigned int i, j;
 
-	assert(onto && from);
+	GIT_ASSERT_ARG(onto);
+	GIT_ASSERT_ARG(from);
 
 	if (!from->deltas.length)
 		return 0;
@@ -475,8 +476,8 @@ static int similarity_sig(
 	git_diff_file *file = info->file;
 
 	if (info->src == GIT_ITERATOR_WORKDIR) {
-		if ((error = git_buf_joinpath(
-			&info->data, git_repository_workdir(info->repo), file->path)) < 0)
+		if ((error = git_repository_workdir_path(
+			&info->data, info->repo, file->path)) < 0)
 			return error;
 
 		/* if path is not a regular file, just skip this item */
@@ -815,7 +816,7 @@ int git_diff_find_similar(
 	diff_find_match *best_match;
 	git_diff_file swap;
 
-	assert(diff);
+	GIT_ASSERT_ARG(diff);
 
 	if ((error = normalize_find_opts(diff, &opts, given_opts)) < 0)
 		return error;
@@ -978,7 +979,7 @@ find_best_matches:
 				src->flags |= GIT_DIFF_FLAG__TO_DELETE;
 				num_rewrites++;
 			} else {
-				assert(delta_is_split(tgt));
+				GIT_ASSERT(delta_is_split(tgt));
 
 				if (best_match->similarity < opts.rename_from_rewrite_threshold)
 					continue;
@@ -988,7 +989,7 @@ find_best_matches:
 				delta_make_rename(tgt, src, best_match->similarity);
 				num_rewrites--;
 
-				assert(src->status == GIT_DELTA_DELETED);
+				GIT_ASSERT(src->status == GIT_DELTA_DELETED);
 				memcpy(&src->old_file, &swap, sizeof(src->old_file));
 				memset(&src->new_file, 0, sizeof(src->new_file));
 				src->new_file.path = src->old_file.path;
@@ -1024,7 +1025,7 @@ find_best_matches:
 
 				num_updates++;
 			} else {
-				assert(delta_is_split(src));
+				GIT_ASSERT(delta_is_split(src));
 
 				if (best_match->similarity < opts.rename_from_rewrite_threshold)
 					continue;
@@ -1038,7 +1039,7 @@ find_best_matches:
 				memcpy(&src->old_file, &swap, sizeof(src->old_file));
 
 				/* if we've just swapped the new element into the correct
-				 * place, clear the SPLIT flag
+				 * place, clear the SPLIT and RENAME_TARGET flags
 				 */
 				if (tgt2src[s].idx == t &&
 					tgt2src[s].similarity >
@@ -1046,7 +1047,7 @@ find_best_matches:
 					src->status     = GIT_DELTA_RENAMED;
 					src->similarity = tgt2src[s].similarity;
 					tgt2src[s].similarity = 0;
-					src->flags &= ~GIT_DIFF_FLAG__TO_SPLIT;
+					src->flags &= ~(GIT_DIFF_FLAG__TO_SPLIT | GIT_DIFF_FLAG__IS_RENAME_TARGET);
 					num_rewrites--;
 				}
 				/* otherwise, if we just overwrote a source, update mapping */

data/vendor/libgit2/src/diff_xdiff.c

@@ -6,7 +6,6 @@
  */
 
 #include "diff_xdiff.h"
-#include "util.h"
 
 #include "git2/errors.h"
 #include "diff.h"
@@ -128,7 +127,7 @@ static int git_xdiff_cb(void *priv, mmbuffer_t *bufs, int len)
 			info->hunk.header_len = sizeof(info->hunk.header) - 1;
 
 		/* Sanitize the hunk header in case there is invalid Unicode */
-		buffer_len = git__utf8_valid_buf_length((const uint8_t *) bufs[0].ptr, info->hunk.header_len);
+		buffer_len = git_utf8_valid_buf_length(bufs[0].ptr, info->hunk.header_len);
 		/* Sanitizing the hunk header may delete the newline, so add it back again if there is room */
 		if (buffer_len < info->hunk.header_len) {
 			bufs[0].ptr[buffer_len] = '\n';
@@ -259,5 +258,8 @@ void git_xdiff_init(git_xdiff_output *xo, const git_diff_options *opts)
 	if (flags & GIT_DIFF_MINIMAL)
 		xo->params.flags |= XDF_NEED_MINIMAL;
 
+	if (flags & GIT_DIFF_IGNORE_BLANK_LINES)
+		xo->params.flags |= XDF_IGNORE_BLANK_LINES;
+
 	xo->callback.outf = git_xdiff_cb;
 }

data/vendor/libgit2/src/diff_xdiff.h

@@ -16,7 +16,7 @@
 /* xdiff cannot cope with large files.  these files should not be passed to
  * xdiff.  callers should treat these large files as binary.
  */
-#define GIT_XDIFF_MAX_SIZE (1024LL * 1024 * 1023)
+#define GIT_XDIFF_MAX_SIZE (INT64_C(1024) * 1024 * 1023)
 
 /* A git_xdiff_output is a git_patch_generate_output with extra fields
  * necessary to use libxdiff.  Calling git_xdiff_init() will set the diff_cb

data/vendor/libgit2/src/errors.c

@@ -7,9 +7,10 @@
 
 #include "common.h"
 
-#include "global.h"
+#include "threadstate.h"
 #include "posix.h"
 #include "buffer.h"
+#include "libgit2.h"
 
 /********************************************
  * New error handling
@@ -20,20 +21,25 @@ static git_error g_git_oom_error = {
 	GIT_ERROR_NOMEMORY
 };
 
+static git_error g_git_uninitialized_error = {
+	"libgit2 has not been initialized; you must call git_libgit2_init",
+	GIT_ERROR_INVALID
+};
+
 static void set_error_from_buffer(int error_class)
 {
-	git_error *error = &GIT_GLOBAL->error_t;
-	git_buf *buf = &GIT_GLOBAL->error_buf;
+	git_error *error = &GIT_THREADSTATE->error_t;
+	git_buf *buf = &GIT_THREADSTATE->error_buf;
 
 	error->message = buf->ptr;
 	error->klass = error_class;
 
-	GIT_GLOBAL->last_error = error;
+	GIT_THREADSTATE->last_error = error;
 }
 
 static void set_error(int error_class, char *string)
 {
-	git_buf *buf = &GIT_GLOBAL->error_buf;
+	git_buf *buf = &GIT_THREADSTATE->error_buf;
 
 	git_buf_clear(buf);
 	if (string) {
@@ -46,7 +52,7 @@ static void set_error(int error_class, char *string)
 
 void git_error_set_oom(void)
 {
-	GIT_GLOBAL->last_error = &g_git_oom_error;
+	GIT_THREADSTATE->last_error = &g_git_oom_error;
 }
 
 void git_error_set(int error_class, const char *fmt, ...)
@@ -64,7 +70,7 @@ void git_error_vset(int error_class, const char *fmt, va_list ap)
 	DWORD win32_error_code = (error_class == GIT_ERROR_OS) ? GetLastError() : 0;
 #endif
 	int error_code = (error_class == GIT_ERROR_OS) ? errno : 0;
-	git_buf *buf = &GIT_GLOBAL->error_buf;
+	git_buf *buf = &GIT_THREADSTATE->error_buf;
 
 	git_buf_clear(buf);
 	if (fmt) {
@@ -97,14 +103,9 @@ void git_error_vset(int error_class, const char *fmt, va_list ap)
 
 int git_error_set_str(int error_class, const char *string)
 {
-	git_buf *buf = &GIT_GLOBAL->error_buf;
-
-	assert(string);
+	git_buf *buf = &GIT_THREADSTATE->error_buf;
 
-	if (!string) {
-		git_error_set(GIT_ERROR_INVALID, "unspecified caller error");
-		return -1;
-	}
+	GIT_ASSERT_ARG(string);
 
 	git_buf_clear(buf);
 	git_buf_puts(buf, string);
@@ -118,9 +119,9 @@ int git_error_set_str(int error_class, const char *string)
 
 void git_error_clear(void)
 {
-	if (GIT_GLOBAL->last_error != NULL) {
+	if (GIT_THREADSTATE->last_error != NULL) {
 		set_error(0, NULL);
-		GIT_GLOBAL->last_error = NULL;
+		GIT_THREADSTATE->last_error = NULL;
 	}
 
 	errno = 0;
@@ -131,13 +132,17 @@ void git_error_clear(void)
 
 const git_error *git_error_last(void)
 {
-	return GIT_GLOBAL->last_error;
+	/* If the library is not initialized, return a static error. */
+	if (!git_libgit2_init_count())
+		return &g_git_uninitialized_error;
+
+	return GIT_THREADSTATE->last_error;
 }
 
 int git_error_state_capture(git_error_state *state, int error_code)
 {
-	git_error *error = GIT_GLOBAL->last_error;
-	git_buf *error_buf = &GIT_GLOBAL->error_buf;
+	git_error *error = GIT_THREADSTATE->last_error;
+	git_buf *error_buf = &GIT_THREADSTATE->error_buf;
 
 	memset(state, 0, sizeof(git_error_state));