rugged 0.27.7 → 0.27.10

data/vendor/libgit2/src/config.h

@@ -24,7 +24,7 @@
 
 struct git_config {
 	git_refcount rc;
-	git_vector files;
+	git_vector backends;
 };
 
 extern int git_config__global_location(git_buf *buf);
@@ -34,19 +34,6 @@ extern int git_config_rename_section(
 	const char *old_section_name,	/* eg "branch.dummy" */
 	const char *new_section_name);	/* NULL to drop the old section */
 
-/**
- * Create a configuration file backend for ondisk files
- *
- * These are the normal `.gitconfig` files that Core Git
- * processes. Note that you first have to add this file to a
- * configuration object before you can query it for configuration
- * variables.
- *
- * @param out the new backend
- * @param path where the config file is located
- */
-extern int git_config_file__ondisk(git_config_backend **out, const char *path);
-
 extern int git_config__normalize_name(const char *in, char **out);
 
 /* internal only: does not normalize key and sets out to NULL if not found */
@@ -79,18 +66,19 @@ extern int git_config__get_bool_force(
 extern int git_config__get_int_force(
 	const git_config *cfg, const char *key, int fallback_value);
 
-/* API for repository cvar-style lookups from config - not cached, but
- * uses cvar value maps and fallbacks
+/* API for repository configmap-style lookups from config - not cached, but
+ * uses configmap value maps and fallbacks
  */
-extern int git_config__cvar(
-	int *out, git_config *config, git_cvar_cached cvar);
+extern int git_config__configmap_lookup(
+	int *out, git_config *config, git_configmap_item item);
 
 /**
  * The opposite of git_config_lookup_map_value, we take an enum value
  * and map it to the string or bool value on the config.
  */
-int git_config_lookup_map_enum(git_cvar_t *type_out, const char **str_out,
-			       const git_cvar_map *maps, size_t map_n, int enum_val);
+int git_config_lookup_map_enum(git_configmap_t *type_out,
+	const char **str_out, const git_configmap *maps,
+	size_t map_n, int enum_val);
 
 /**
  * Unlock the backend with the highest priority

data/vendor/libgit2/src/config_backend.h

@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_config_file_h__
+#define INCLUDE_config_file_h__
+
+#include "common.h"
+
+#include "git2/sys/config.h"
+#include "git2/config.h"
+
+/**
+ * Create a configuration file backend for ondisk files
+ *
+ * These are the normal `.gitconfig` files that Core Git
+ * processes. Note that you first have to add this file to a
+ * configuration object before you can query it for configuration
+ * variables.
+ *
+ * @param out the new backend
+ * @param path where the config file is located
+ */
+extern int git_config_backend_from_file(git_config_backend **out, const char *path);
+
+/**
+ * Create a readonly configuration file backend from another backend
+ *
+ * This copies the complete contents of the source backend to the
+ * new backend. The new backend will be completely read-only and
+ * cannot be modified.
+ *
+ * @param out the new snapshotted backend
+ * @param source the backend to copy
+ */
+extern int git_config_backend_snapshot(git_config_backend **out, git_config_backend *source);
+
+/**
+ * Create an in-memory configuration file backend
+ *
+ * @param out the new backend
+ * @param cfg the configuration that is to be parsed
+ * @param len the length of the string pointed to by `cfg`
+ */
+extern int git_config_backend_from_string(git_config_backend **out, const char *cfg, size_t len);
+
+GIT_INLINE(int) git_config_backend_open(git_config_backend *cfg, unsigned int level, const git_repository *repo)
+{
+	return cfg->open(cfg, level, repo);
+}
+
+GIT_INLINE(void) git_config_backend_free(git_config_backend *cfg)
+{
+	if (cfg)
+		cfg->free(cfg);
+}
+
+GIT_INLINE(int) git_config_backend_get_string(
+	git_config_entry **out, git_config_backend *cfg, const char *name)
+{
+	return cfg->get(cfg, name, out);
+}
+
+GIT_INLINE(int) git_config_backend_set_string(
+	git_config_backend *cfg, const char *name, const char *value)
+{
+	return cfg->set(cfg, name, value);
+}
+
+GIT_INLINE(int) git_config_backend_delete(
+	git_config_backend *cfg, const char *name)
+{
+	return cfg->del(cfg, name);
+}
+
+GIT_INLINE(int) git_config_backend_foreach(
+	git_config_backend *cfg,
+	int (*fn)(const git_config_entry *entry, void *data),
+	void *data)
+{
+	return git_config_backend_foreach_match(cfg, NULL, fn, data);
+}
+
+GIT_INLINE(int) git_config_backend_lock(git_config_backend *cfg)
+{
+	return cfg->lock(cfg);
+}
+
+GIT_INLINE(int) git_config_backend_unlock(git_config_backend *cfg, int success)
+{
+	return cfg->unlock(cfg, success);
+}
+
+#endif

data/vendor/libgit2/src/config_cache.c

@@ -7,7 +7,7 @@
 
 #include "common.h"
 
-#include "fileops.h"
+#include "futils.h"
 #include "repository.h"
 #include "config.h"
 #include "git2/config.h"
@@ -15,8 +15,8 @@
 #include "filter.h"
 
 struct map_data {
-	const char *cvar_name;
-	git_cvar_map *maps;
+	const char *name;
+	git_configmap *maps;
 	size_t map_count;
 	int default_value;
 };
@@ -29,11 +29,11 @@ struct map_data {
  *	value is native. See gitattributes(5) for more information on
  *	end-of-line conversion.
  */
-static git_cvar_map _cvar_map_eol[] = {
-	{GIT_CVAR_FALSE, NULL, GIT_EOL_UNSET},
-	{GIT_CVAR_STRING, "lf", GIT_EOL_LF},
-	{GIT_CVAR_STRING, "crlf", GIT_EOL_CRLF},
-	{GIT_CVAR_STRING, "native", GIT_EOL_NATIVE}
+static git_configmap _configmap_eol[] = {
+	{GIT_CONFIGMAP_FALSE, NULL, GIT_EOL_UNSET},
+	{GIT_CONFIGMAP_STRING, "lf", GIT_EOL_LF},
+	{GIT_CONFIGMAP_STRING, "crlf", GIT_EOL_CRLF},
+	{GIT_CONFIGMAP_STRING, "native", GIT_EOL_NATIVE}
 };
 
 /*
@@ -46,49 +46,55 @@ static git_cvar_map _cvar_map_eol[] = {
  *	does not have normalized line endings. This variable can be set to input,
  *	in which case no output conversion is performed.
  */
-static git_cvar_map _cvar_map_autocrlf[] = {
-	{GIT_CVAR_FALSE, NULL, GIT_AUTO_CRLF_FALSE},
-	{GIT_CVAR_TRUE, NULL, GIT_AUTO_CRLF_TRUE},
-	{GIT_CVAR_STRING, "input", GIT_AUTO_CRLF_INPUT}
+static git_configmap _configmap_autocrlf[] = {
+	{GIT_CONFIGMAP_FALSE, NULL, GIT_AUTO_CRLF_FALSE},
+	{GIT_CONFIGMAP_TRUE, NULL, GIT_AUTO_CRLF_TRUE},
+	{GIT_CONFIGMAP_STRING, "input", GIT_AUTO_CRLF_INPUT}
 };
 
-static git_cvar_map _cvar_map_safecrlf[] = {
-	{GIT_CVAR_FALSE, NULL, GIT_SAFE_CRLF_FALSE},
-	{GIT_CVAR_TRUE, NULL, GIT_SAFE_CRLF_FAIL},
-	{GIT_CVAR_STRING, "warn", GIT_SAFE_CRLF_WARN}
+static git_configmap _configmap_safecrlf[] = {
+	{GIT_CONFIGMAP_FALSE, NULL, GIT_SAFE_CRLF_FALSE},
+	{GIT_CONFIGMAP_TRUE, NULL, GIT_SAFE_CRLF_FAIL},
+	{GIT_CONFIGMAP_STRING, "warn", GIT_SAFE_CRLF_WARN}
+};
+
+static git_configmap _configmap_logallrefupdates[] = {
+	{GIT_CONFIGMAP_FALSE, NULL, GIT_LOGALLREFUPDATES_FALSE},
+	{GIT_CONFIGMAP_TRUE, NULL, GIT_LOGALLREFUPDATES_TRUE},
+	{GIT_CONFIGMAP_STRING, "always", GIT_LOGALLREFUPDATES_ALWAYS},
 };
 
 /*
  * Generic map for integer values
  */
-static git_cvar_map _cvar_map_int[] = {
-	{GIT_CVAR_INT32, NULL, 0},
+static git_configmap _configmap_int[] = {
+	{GIT_CONFIGMAP_INT32, NULL, 0},
 };
 
-static struct map_data _cvar_maps[] = {
-	{"core.autocrlf", _cvar_map_autocrlf, ARRAY_SIZE(_cvar_map_autocrlf), GIT_AUTO_CRLF_DEFAULT},
-	{"core.eol", _cvar_map_eol, ARRAY_SIZE(_cvar_map_eol), GIT_EOL_DEFAULT},
+static struct map_data _configmaps[] = {
+	{"core.autocrlf", _configmap_autocrlf, ARRAY_SIZE(_configmap_autocrlf), GIT_AUTO_CRLF_DEFAULT},
+	{"core.eol", _configmap_eol, ARRAY_SIZE(_configmap_eol), GIT_EOL_DEFAULT},
 	{"core.symlinks", NULL, 0, GIT_SYMLINKS_DEFAULT },
 	{"core.ignorecase", NULL, 0, GIT_IGNORECASE_DEFAULT },
 	{"core.filemode", NULL, 0, GIT_FILEMODE_DEFAULT },
 	{"core.ignorestat", NULL, 0, GIT_IGNORESTAT_DEFAULT },
 	{"core.trustctime", NULL, 0, GIT_TRUSTCTIME_DEFAULT },
-	{"core.abbrev", _cvar_map_int, 1, GIT_ABBREV_DEFAULT },
+	{"core.abbrev", _configmap_int, 1, GIT_ABBREV_DEFAULT },
 	{"core.precomposeunicode", NULL, 0, GIT_PRECOMPOSE_DEFAULT },
-	{"core.safecrlf", _cvar_map_safecrlf, ARRAY_SIZE(_cvar_map_safecrlf), GIT_SAFE_CRLF_DEFAULT},
-	{"core.logallrefupdates", NULL, 0, GIT_LOGALLREFUPDATES_DEFAULT },
+	{"core.safecrlf", _configmap_safecrlf, ARRAY_SIZE(_configmap_safecrlf), GIT_SAFE_CRLF_DEFAULT},
+	{"core.logallrefupdates", _configmap_logallrefupdates, ARRAY_SIZE(_configmap_logallrefupdates), GIT_LOGALLREFUPDATES_DEFAULT},
 	{"core.protecthfs", NULL, 0, GIT_PROTECTHFS_DEFAULT },
 	{"core.protectntfs", NULL, 0, GIT_PROTECTNTFS_DEFAULT },
 	{"core.fsyncobjectfiles", NULL, 0, GIT_FSYNCOBJECTFILES_DEFAULT },
 };
 
-int git_config__cvar(int *out, git_config *config, git_cvar_cached cvar)
+int git_config__configmap_lookup(int *out, git_config *config, git_configmap_item item)
 {
 	int error = 0;
-	struct map_data *data = &_cvar_maps[(int)cvar];
+	struct map_data *data = &_configmaps[(int)item];
 	git_config_entry *entry;
 
-	if ((error = git_config__lookup_entry(&entry, config, data->cvar_name, false)) < 0)
+	if ((error = git_config__lookup_entry(&entry, config, data->name, false)) < 0)
 		return error;
 
 	if (!entry)
@@ -103,29 +109,29 @@ int git_config__cvar(int *out, git_config *config, git_cvar_cached cvar)
 	return error;
 }
 
-int git_repository__cvar(int *out, git_repository *repo, git_cvar_cached cvar)
+int git_repository__configmap_lookup(int *out, git_repository *repo, git_configmap_item item)
 {
-	*out = repo->cvar_cache[(int)cvar];
+	*out = repo->configmap_cache[(int)item];
 
-	if (*out == GIT_CVAR_NOT_CACHED) {
+	if (*out == GIT_CONFIGMAP_NOT_CACHED) {
 		int error;
 		git_config *config;
 
 		if ((error = git_repository_config__weakptr(&config, repo)) < 0 ||
-			(error = git_config__cvar(out, config, cvar)) < 0)
+			(error = git_config__configmap_lookup(out, config, item)) < 0)
 			return error;
 
-		repo->cvar_cache[(int)cvar] = *out;
+		repo->configmap_cache[(int)item] = *out;
 	}
 
 	return 0;
 }
 
-void git_repository__cvar_cache_clear(git_repository *repo)
+void git_repository__configmap_lookup_cache_clear(git_repository *repo)
 {
 	int i;
 
-	for (i = 0; i < GIT_CVAR_CACHE_MAX; ++i)
-		repo->cvar_cache[i] = GIT_CVAR_NOT_CACHED;
+	for (i = 0; i < GIT_CONFIGMAP_CACHE_MAX; ++i)
+		repo->configmap_cache[i] = GIT_CONFIGMAP_NOT_CACHED;
 }
 

data/vendor/libgit2/src/config_entries.c

@@ -0,0 +1,229 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "config_entries.h"
+
+typedef struct config_entry_list {
+	struct config_entry_list *next;
+	struct config_entry_list *last;
+	git_config_entry *entry;
+	bool first;
+} config_entry_list;
+
+typedef struct config_entries_iterator {
+	git_config_iterator parent;
+	git_config_entries *entries;
+	config_entry_list *head;
+} config_entries_iterator;
+
+struct git_config_entries {
+	git_refcount rc;
+	git_strmap *map;
+	config_entry_list *list;
+};
+
+int git_config_entries_new(git_config_entries **out)
+{
+	git_config_entries *entries;
+	int error;
+
+	entries = git__calloc(1, sizeof(git_config_entries));
+	GIT_ERROR_CHECK_ALLOC(entries);
+	GIT_REFCOUNT_INC(entries);
+
+	if ((error = git_strmap_new(&entries->map)) < 0)
+		git__free(entries);
+	else
+		*out = entries;
+
+	return error;
+}
+
+int git_config_entries_dup_entry(git_config_entries *entries, const git_config_entry *entry)
+{
+	git_config_entry *duplicated;
+	int error;
+
+	duplicated = git__calloc(1, sizeof(git_config_entry));
+	GIT_ERROR_CHECK_ALLOC(duplicated);
+
+	duplicated->name = git__strdup(entry->name);
+	GIT_ERROR_CHECK_ALLOC(duplicated->name);
+
+	if (entry->value) {
+		duplicated->value = git__strdup(entry->value);
+		GIT_ERROR_CHECK_ALLOC(duplicated->value);
+	}
+	duplicated->level = entry->level;
+	duplicated->include_depth = entry->include_depth;
+
+	if ((error = git_config_entries_append(entries, duplicated)) < 0)
+		goto out;
+
+out:
+	if (error && duplicated) {
+		git__free((char *) duplicated->name);
+		git__free((char *) duplicated->value);
+		git__free(duplicated);
+	}
+	return error;
+}
+
+int git_config_entries_dup(git_config_entries **out, git_config_entries *entries)
+{
+	git_config_entries *result = NULL;
+	config_entry_list *head;
+	int error;
+
+	if ((error = git_config_entries_new(&result)) < 0)
+		goto out;
+
+	for (head = entries->list; head; head = head->next)
+		if ((git_config_entries_dup_entry(result, head->entry)) < 0)
+			goto out;
+
+	*out = result;
+	result = NULL;
+
+out:
+	git_config_entries_free(result);
+	return error;
+}
+
+void git_config_entries_incref(git_config_entries *entries)
+{
+	GIT_REFCOUNT_INC(entries);
+}
+
+static void config_entries_free(git_config_entries *entries)
+{
+	config_entry_list *list = NULL, *next;
+
+	git_strmap_free(entries->map);
+
+	list = entries->list;
+	while (list != NULL) {
+		next = list->next;
+		if (list->first)
+			git__free((char *) list->entry->name);
+		git__free((char *) list->entry->value);
+		git__free(list->entry);
+		git__free(list);
+		list = next;
+	}
+
+	git__free(entries);
+}
+
+void git_config_entries_free(git_config_entries *entries)
+{
+	if (entries)
+		GIT_REFCOUNT_DEC(entries, config_entries_free);
+}
+
+int git_config_entries_append(git_config_entries *entries, git_config_entry *entry)
+{
+	config_entry_list *existing, *head;
+
+	head = git__calloc(1, sizeof(config_entry_list));
+	GIT_ERROR_CHECK_ALLOC(head);
+	head->entry = entry;
+
+	/*
+	 * This is a micro-optimization for configuration files
+	 * with a lot of same keys. As for multivars the entry's
+	 * key will be the same for all entries, we can just free
+	 * all except the first entry's name and just re-use it.
+	 */
+	if ((existing = git_strmap_get(entries->map, entry->name)) != NULL) {
+		git__free((char *) entry->name);
+		entry->name = existing->entry->name;
+	} else {
+		head->first = 1;
+	}
+
+	if (entries->list)
+		entries->list->last->next = head;
+	else
+		entries->list = head;
+	entries->list->last = head;
+
+	if (git_strmap_set(entries->map, entry->name, head) < 0)
+		return -1;
+
+	return 0;
+}
+
+int git_config_entries_get(git_config_entry **out, git_config_entries *entries, const char *key)
+{
+	config_entry_list *entry;
+	if ((entry = git_strmap_get(entries->map, key)) == NULL)
+		return GIT_ENOTFOUND;
+	*out = entry->entry;
+	return 0;
+}
+
+int git_config_entries_get_unique(git_config_entry **out, git_config_entries *entries, const char *key)
+{
+	config_entry_list *entry;
+
+	if ((entry = git_strmap_get(entries->map, key)) == NULL)
+		return GIT_ENOTFOUND;
+
+	if (!entry->first) {
+		git_error_set(GIT_ERROR_CONFIG, "entry is not unique due to being a multivar");
+		return -1;
+	}
+
+	if (entry->entry->include_depth) {
+		git_error_set(GIT_ERROR_CONFIG, "entry is not unique due to being included");
+		return -1;
+	}
+
+	*out = entry->entry;
+
+	return 0;
+}
+
+static void config_iterator_free(git_config_iterator *iter)
+{
+	config_entries_iterator *it = (config_entries_iterator *) iter;
+	git_config_entries_free(it->entries);
+	git__free(it);
+}
+
+static int config_iterator_next(
+	git_config_entry **entry,
+	git_config_iterator *iter)
+{
+	config_entries_iterator *it = (config_entries_iterator *) iter;
+
+	if (!it->head)
+		return GIT_ITEROVER;
+
+	*entry = it->head->entry;
+	it->head = it->head->next;
+
+	return 0;
+}
+
+int git_config_entries_iterator_new(git_config_iterator **out, git_config_entries *entries)
+{
+	config_entries_iterator *it;
+
+	it = git__calloc(1, sizeof(config_entries_iterator));
+	GIT_ERROR_CHECK_ALLOC(it);
+	it->parent.next = config_iterator_next;
+	it->parent.free = config_iterator_free;
+	it->head = entries->list;
+	it->entries = entries;
+
+	git_config_entries_incref(entries);
+	*out = &it->parent;
+
+	return 0;
+}

data/vendor/libgit2/src/config_entries.h

@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "common.h"
+
+#include "git2/sys/config.h"
+#include "config.h"
+
+typedef struct git_config_entries git_config_entries;
+
+int git_config_entries_new(git_config_entries **out);
+int git_config_entries_dup(git_config_entries **out, git_config_entries *entries);
+int git_config_entries_dup_entry(git_config_entries *entries, const git_config_entry *entry);
+void git_config_entries_incref(git_config_entries *entries);
+void git_config_entries_free(git_config_entries *entries);
+/* Add or append the new config option */
+int git_config_entries_append(git_config_entries *entries, git_config_entry *entry);
+int git_config_entries_get(git_config_entry **out, git_config_entries *entries, const char *key);
+int git_config_entries_get_unique(git_config_entry **out, git_config_entries *entries, const char *key);
+int git_config_entries_iterator_new(git_config_iterator **out, git_config_entries *entries);