rugged 1.3.1 → 1.9.0

data/vendor/libgit2/src/libgit2/config_list.c

@@ -0,0 +1,285 @@
+/*
+ * 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_list.h"
+#include "hashmap_str.h"
+
+typedef struct config_entry_list {
+	struct config_entry_list *next;
+	struct config_entry_list *last;
+	git_config_list_entry *entry;
+} config_entry_list;
+
+typedef struct {
+	git_config_list_entry *entry;
+	bool multivar;
+} config_entry_map_head;
+
+typedef struct config_list_iterator {
+	git_config_iterator parent;
+	git_config_list *list;
+	config_entry_list *head;
+} config_list_iterator;
+
+GIT_HASHMAP_STR_SETUP(git_config_list_pathmap, char *);
+GIT_HASHMAP_STR_SETUP(git_config_list_headmap, config_entry_map_head *);
+
+struct git_config_list {
+	git_refcount rc;
+
+	/* Interned strings - paths to config files or backend types */
+	git_config_list_pathmap strings;
+
+	/* Config entries */
+	git_config_list_headmap map;
+	config_entry_list *entries;
+};
+
+int git_config_list_new(git_config_list **out)
+{
+	git_config_list *config_list;
+
+	config_list = git__calloc(1, sizeof(git_config_list));
+	GIT_ERROR_CHECK_ALLOC(config_list);
+	GIT_REFCOUNT_INC(config_list);
+
+	*out = config_list;
+	return 0;
+}
+
+int git_config_list_dup_entry(git_config_list *config_list, const git_config_entry *entry)
+{
+	git_config_list_entry *duplicated;
+	int error;
+
+	duplicated = git__calloc(1, sizeof(git_config_list_entry));
+	GIT_ERROR_CHECK_ALLOC(duplicated);
+
+	duplicated->base.entry.name = git__strdup(entry->name);
+	GIT_ERROR_CHECK_ALLOC(duplicated->base.entry.name);
+
+	if (entry->value) {
+		duplicated->base.entry.value = git__strdup(entry->value);
+		GIT_ERROR_CHECK_ALLOC(duplicated->base.entry.value);
+	}
+
+	duplicated->base.entry.backend_type = git_config_list_add_string(config_list, entry->backend_type);
+	GIT_ERROR_CHECK_ALLOC(duplicated->base.entry.backend_type);
+
+	if (entry->origin_path) {
+		duplicated->base.entry.origin_path = git_config_list_add_string(config_list, entry->origin_path);
+		GIT_ERROR_CHECK_ALLOC(duplicated->base.entry.origin_path);
+	}
+
+	duplicated->base.entry.level = entry->level;
+	duplicated->base.entry.include_depth = entry->include_depth;
+	duplicated->base.free = git_config_list_entry_free;
+	duplicated->config_list = config_list;
+
+	if ((error = git_config_list_append(config_list, duplicated)) < 0)
+		goto out;
+
+out:
+	if (error && duplicated) {
+		git__free((char *) duplicated->base.entry.name);
+		git__free((char *) duplicated->base.entry.value);
+		git__free(duplicated);
+	}
+	return error;
+}
+
+int git_config_list_dup(git_config_list **out, git_config_list *config_list)
+{
+	git_config_list *result = NULL;
+	config_entry_list *head;
+	int error;
+
+	if ((error = git_config_list_new(&result)) < 0)
+		goto out;
+
+	for (head = config_list->entries; head; head = head->next)
+		if ((git_config_list_dup_entry(result, &head->entry->base.entry)) < 0)
+			goto out;
+
+	*out = result;
+	result = NULL;
+
+out:
+	git_config_list_free(result);
+	return error;
+}
+
+void git_config_list_incref(git_config_list *config_list)
+{
+	GIT_REFCOUNT_INC(config_list);
+}
+
+static void config_list_free(git_config_list *config_list)
+{
+	config_entry_list *entry_list = NULL, *next;
+	config_entry_map_head *head;
+	char *str;
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
+
+	while (git_config_list_pathmap_iterate(&iter, NULL, &str, &config_list->strings) == 0)
+		git__free(str);
+
+	git_config_list_pathmap_dispose(&config_list->strings);
+
+	iter = GIT_HASHMAP_ITER_INIT;
+	while (git_config_list_headmap_iterate(&iter, NULL, &head, &config_list->map) == 0) {
+		git__free((char *) head->entry->base.entry.name);
+		git__free(head);
+	}
+	git_config_list_headmap_dispose(&config_list->map);
+
+	entry_list = config_list->entries;
+	while (entry_list != NULL) {
+		next = entry_list->next;
+		git__free((char *) entry_list->entry->base.entry.value);
+		git__free(entry_list->entry);
+		git__free(entry_list);
+		entry_list = next;
+	}
+
+	git__free(config_list);
+}
+
+void git_config_list_free(git_config_list *config_list)
+{
+	if (config_list)
+		GIT_REFCOUNT_DEC(config_list, config_list_free);
+}
+
+int git_config_list_append(git_config_list *config_list, git_config_list_entry *entry)
+{
+	config_entry_list *list_head;
+	config_entry_map_head *map_head;
+
+	if (git_config_list_headmap_get(&map_head, &config_list->map, entry->base.entry.name) == 0) {
+		map_head->multivar = true;
+		/*
+		 * 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 list, we can just free
+		 * all except the first entry's name and just re-use it.
+		 */
+		git__free((char *) entry->base.entry.name);
+		entry->base.entry.name = map_head->entry->base.entry.name;
+	} else {
+		map_head = git__calloc(1, sizeof(*map_head));
+		if ((git_config_list_headmap_put(&config_list->map, entry->base.entry.name, map_head)) < 0)
+			return -1;
+	}
+	map_head->entry = entry;
+
+	list_head = git__calloc(1, sizeof(config_entry_list));
+	GIT_ERROR_CHECK_ALLOC(list_head);
+	list_head->entry = entry;
+
+	if (config_list->entries)
+		config_list->entries->last->next = list_head;
+	else
+		config_list->entries = list_head;
+	config_list->entries->last = list_head;
+
+	return 0;
+}
+
+int git_config_list_get(git_config_list_entry **out, git_config_list *config_list, const char *key)
+{
+	config_entry_map_head *entry;
+
+	if (git_config_list_headmap_get(&entry, &config_list->map, key) != 0)
+		return GIT_ENOTFOUND;
+
+	*out = entry->entry;
+	return 0;
+}
+
+int git_config_list_get_unique(git_config_list_entry **out, git_config_list *config_list, const char *key)
+{
+	config_entry_map_head *entry;
+
+	if (git_config_list_headmap_get(&entry, &config_list->map, key) != 0)
+		return GIT_ENOTFOUND;
+
+	if (entry->multivar) {
+		git_error_set(GIT_ERROR_CONFIG, "entry is not unique due to being a multivar");
+		return -1;
+	}
+
+	if (entry->entry->base.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_list_iterator *it = (config_list_iterator *) iter;
+	git_config_list_free(it->list);
+	git__free(it);
+}
+
+static int config_iterator_next(
+	git_config_backend_entry **entry,
+	git_config_iterator *iter)
+{
+	config_list_iterator *it = (config_list_iterator *) iter;
+
+	if (!it->head)
+		return GIT_ITEROVER;
+
+	*entry = &it->head->entry->base;
+	it->head = it->head->next;
+
+	return 0;
+}
+
+int git_config_list_iterator_new(git_config_iterator **out, git_config_list *config_list)
+{
+	config_list_iterator *it;
+
+	it = git__calloc(1, sizeof(config_list_iterator));
+	GIT_ERROR_CHECK_ALLOC(it);
+	it->parent.next = config_iterator_next;
+	it->parent.free = config_iterator_free;
+	it->head = config_list->entries;
+	it->list = config_list;
+
+	git_config_list_incref(config_list);
+	*out = &it->parent;
+
+	return 0;
+}
+
+/* release the map containing the entry as an equivalent to freeing it */
+void git_config_list_entry_free(git_config_backend_entry *e)
+{
+	git_config_list_entry *entry = (git_config_list_entry *)e;
+	git_config_list_free(entry->config_list);
+}
+
+const char *git_config_list_add_string(
+	git_config_list *config_list,
+	const char *str)
+{
+	char *s;
+
+	if (git_config_list_pathmap_get(&s, &config_list->strings, str) == 0)
+		return s;
+
+	if ((s = git__strdup(str)) == NULL ||
+	     git_config_list_pathmap_put(&config_list->strings, s, s) < 0)
+		return NULL;
+
+	return s;
+}

data/vendor/libgit2/src/libgit2/config_list.h

@@ -0,0 +1,32 @@
+/*
+ * 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_list git_config_list;
+
+typedef struct {
+	git_config_backend_entry base;
+	git_config_list *config_list;
+} git_config_list_entry;
+
+int git_config_list_new(git_config_list **out);
+int git_config_list_dup(git_config_list **out, git_config_list *list);
+int git_config_list_dup_entry(git_config_list *list, const git_config_entry *entry);
+void git_config_list_incref(git_config_list *list);
+void git_config_list_free(git_config_list *list);
+/* Add or append the new config option */
+int git_config_list_append(git_config_list *list, git_config_list_entry *entry);
+int git_config_list_get(git_config_list_entry **out, git_config_list *list, const char *key);
+int git_config_list_get_unique(git_config_list_entry **out, git_config_list *list, const char *key);
+int git_config_list_iterator_new(git_config_iterator **out, git_config_list *list);
+const char *git_config_list_add_string(git_config_list *list, const char *str);
+
+void git_config_list_entry_free(git_config_backend_entry *entry);

data/vendor/libgit2/src/libgit2/config_mem.c

@@ -0,0 +1,374 @@
+/*
+ * 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.h"
+
+#include "config_backend.h"
+#include "config_parse.h"
+#include "config_list.h"
+#include "strlist.h"
+
+typedef struct {
+	git_config_backend parent;
+
+	char *backend_type;
+	char *origin_path;
+
+	git_config_list *config_list;
+
+	/* Configuration data in the config file format */
+	git_str cfg;
+
+	/* Array of key=value pairs */
+	char **values;
+	size_t values_len;
+} config_memory_backend;
+
+typedef struct {
+	const char *backend_type;
+	const char *origin_path;
+	git_config_list *config_list;
+	git_config_level_t level;
+} config_memory_parse_data;
+
+static int config_error_readonly(void)
+{
+	git_error_set(GIT_ERROR_CONFIG, "this backend is read-only");
+	return -1;
+}
+
+static int read_variable_cb(
+	git_config_parser *reader,
+	const char *current_section,
+	const char *var_name,
+	const char *var_value,
+	const char *line,
+	size_t line_len,
+	void *payload)
+{
+	config_memory_parse_data *parse_data = (config_memory_parse_data *) payload;
+	git_str buf = GIT_STR_INIT;
+	git_config_list_entry *entry;
+	const char *c;
+	int result;
+
+	GIT_UNUSED(reader);
+	GIT_UNUSED(line);
+	GIT_UNUSED(line_len);
+
+	if (current_section) {
+		/* TODO: Once warnings land, we should likely warn
+		 * here. Git appears to warn in most cases if it sees
+		 * un-namespaced config options.
+		 */
+		git_str_puts(&buf, current_section);
+		git_str_putc(&buf, '.');
+	}
+
+	for (c = var_name; *c; c++)
+		git_str_putc(&buf, git__tolower(*c));
+
+	if (git_str_oom(&buf))
+		return -1;
+
+	entry = git__calloc(1, sizeof(git_config_list_entry));
+	GIT_ERROR_CHECK_ALLOC(entry);
+	entry->base.entry.name = git_str_detach(&buf);
+	entry->base.entry.value = var_value ? git__strdup(var_value) : NULL;
+	entry->base.entry.level = parse_data->level;
+	entry->base.entry.include_depth = 0;
+	entry->base.entry.backend_type = parse_data->backend_type;
+	entry->base.entry.origin_path = parse_data->origin_path;
+	entry->base.free = git_config_list_entry_free;
+	entry->config_list = parse_data->config_list;
+
+	if ((result = git_config_list_append(parse_data->config_list, entry)) < 0)
+		return result;
+
+	return result;
+}
+
+static int parse_config(
+	config_memory_backend *memory_backend,
+	git_config_level_t level)
+{
+	git_config_parser parser = GIT_PARSE_CTX_INIT;
+	config_memory_parse_data parse_data;
+	int error;
+
+	if ((error = git_config_parser_init(&parser, "in-memory",
+		memory_backend->cfg.ptr, memory_backend->cfg.size)) < 0)
+		goto out;
+
+	parse_data.backend_type = git_config_list_add_string(
+		memory_backend->config_list, memory_backend->backend_type);
+	parse_data.origin_path = memory_backend->origin_path ?
+		git_config_list_add_string(memory_backend->config_list,
+			memory_backend->origin_path) :
+		NULL;
+	parse_data.config_list = memory_backend->config_list;
+	parse_data.level = level;
+
+	if ((error = git_config_parse(&parser, NULL, read_variable_cb,
+		NULL, NULL, &parse_data)) < 0)
+		goto out;
+
+out:
+	git_config_parser_dispose(&parser);
+	return error;
+}
+
+static int parse_values(
+	config_memory_backend *memory_backend,
+	git_config_level_t level)
+{
+	git_config_list_entry *entry;
+	const char *eql, *backend_type, *origin_path;
+	size_t name_len, i;
+
+	backend_type = git_config_list_add_string(
+		memory_backend->config_list, memory_backend->backend_type);
+	GIT_ERROR_CHECK_ALLOC(backend_type);
+
+	origin_path = memory_backend->origin_path ?
+		git_config_list_add_string(memory_backend->config_list,
+			memory_backend->origin_path) :
+		NULL;
+
+	for (i = 0; i < memory_backend->values_len; i++) {
+		eql = strchr(memory_backend->values[i], '=');
+		name_len = eql - memory_backend->values[i];
+
+		if (name_len == 0) {
+			git_error_set(GIT_ERROR_CONFIG, "empty config key");
+			return -1;
+		}
+
+		entry = git__calloc(1, sizeof(git_config_list_entry));
+		GIT_ERROR_CHECK_ALLOC(entry);
+
+		entry->base.entry.name = git__strndup(memory_backend->values[i], name_len);
+		GIT_ERROR_CHECK_ALLOC(entry->base.entry.name);
+
+		if (eql) {
+			entry->base.entry.value = git__strdup(eql + 1);
+			GIT_ERROR_CHECK_ALLOC(entry->base.entry.value);
+		}
+
+		entry->base.entry.level = level;
+		entry->base.entry.include_depth = 0;
+		entry->base.entry.backend_type = backend_type;
+		entry->base.entry.origin_path = origin_path;
+		entry->base.free = git_config_list_entry_free;
+		entry->config_list = memory_backend->config_list;
+
+		if (git_config_list_append(memory_backend->config_list, entry) < 0)
+			return -1;
+	}
+
+	return 0;
+}
+
+static int config_memory_open(git_config_backend *backend, git_config_level_t level, const git_repository *repo)
+{
+	config_memory_backend *memory_backend = (config_memory_backend *) backend;
+
+	GIT_UNUSED(repo);
+
+	if (memory_backend->cfg.size > 0 &&
+	    parse_config(memory_backend, level) < 0)
+		return -1;
+
+	if (memory_backend->values_len > 0 &&
+	    parse_values(memory_backend, level) < 0)
+		return -1;
+
+	return 0;
+}
+
+static int config_memory_get(git_config_backend *backend, const char *key, git_config_backend_entry **out)
+{
+	config_memory_backend *memory_backend = (config_memory_backend *) backend;
+	git_config_list_entry *entry;
+	int error;
+
+	if ((error = git_config_list_get(&entry, memory_backend->config_list, key)) != 0)
+		return error;
+
+	*out = &entry->base;
+	return 0;
+}
+
+static int config_memory_iterator(
+	git_config_iterator **iter,
+	git_config_backend *backend)
+{
+	config_memory_backend *memory_backend = (config_memory_backend *) backend;
+	git_config_list *config_list;
+	int error;
+
+	if ((error = git_config_list_dup(&config_list, memory_backend->config_list)) < 0)
+		goto out;
+
+	if ((error = git_config_list_iterator_new(iter, config_list)) < 0)
+		goto out;
+
+out:
+	/* Let iterator delete duplicated config_list when it's done */
+	git_config_list_free(config_list);
+	return error;
+}
+
+static int config_memory_set(git_config_backend *backend, const char *name, const char *value)
+{
+	GIT_UNUSED(backend);
+	GIT_UNUSED(name);
+	GIT_UNUSED(value);
+	return config_error_readonly();
+}
+
+static int config_memory_set_multivar(
+	git_config_backend *backend, const char *name, const char *regexp, const char *value)
+{
+	GIT_UNUSED(backend);
+	GIT_UNUSED(name);
+	GIT_UNUSED(regexp);
+	GIT_UNUSED(value);
+	return config_error_readonly();
+}
+
+static int config_memory_delete(git_config_backend *backend, const char *name)
+{
+	GIT_UNUSED(backend);
+	GIT_UNUSED(name);
+	return config_error_readonly();
+}
+
+static int config_memory_delete_multivar(git_config_backend *backend, const char *name, const char *regexp)
+{
+	GIT_UNUSED(backend);
+	GIT_UNUSED(name);
+	GIT_UNUSED(regexp);
+	return config_error_readonly();
+}
+
+static int config_memory_lock(git_config_backend *backend)
+{
+	GIT_UNUSED(backend);
+	return config_error_readonly();
+}
+
+static int config_memory_unlock(git_config_backend *backend, int success)
+{
+	GIT_UNUSED(backend);
+	GIT_UNUSED(success);
+	return config_error_readonly();
+}
+
+static void config_memory_free(git_config_backend *_backend)
+{
+	config_memory_backend *backend = (config_memory_backend *)_backend;
+
+	if (backend == NULL)
+		return;
+
+	git__free(backend->origin_path);
+	git__free(backend->backend_type);
+	git_config_list_free(backend->config_list);
+	git_strlist_free(backend->values, backend->values_len);
+	git_str_dispose(&backend->cfg);
+	git__free(backend);
+}
+
+static config_memory_backend *config_backend_new(
+	git_config_backend_memory_options *opts)
+{
+	config_memory_backend *backend;
+
+	if ((backend = git__calloc(1, sizeof(config_memory_backend))) == NULL)
+		return NULL;
+
+	if (git_config_list_new(&backend->config_list) < 0)
+		goto on_error;
+
+	backend->parent.version = GIT_CONFIG_BACKEND_VERSION;
+	backend->parent.readonly = 1;
+	backend->parent.open = config_memory_open;
+	backend->parent.get = config_memory_get;
+	backend->parent.set = config_memory_set;
+	backend->parent.set_multivar = config_memory_set_multivar;
+	backend->parent.del = config_memory_delete;
+	backend->parent.del_multivar = config_memory_delete_multivar;
+	backend->parent.iterator = config_memory_iterator;
+	backend->parent.lock = config_memory_lock;
+	backend->parent.unlock = config_memory_unlock;
+	backend->parent.snapshot = git_config_backend_snapshot;
+	backend->parent.free = config_memory_free;
+
+	backend->backend_type = git__strdup(opts && opts->backend_type ?
+		opts->backend_type : "in-memory");
+
+	if (backend->backend_type == NULL)
+		goto on_error;
+
+	if (opts && opts->origin_path &&
+	    (backend->origin_path = git__strdup(opts->origin_path)) == NULL)
+		goto on_error;
+
+	return backend;
+
+on_error:
+	git_config_list_free(backend->config_list);
+	git__free(backend->origin_path);
+	git__free(backend->backend_type);
+	git__free(backend);
+	return NULL;
+}
+
+int git_config_backend_from_string(
+	git_config_backend **out,
+	const char *cfg,
+	size_t len,
+	git_config_backend_memory_options *opts)
+{
+	config_memory_backend *backend;
+
+	if ((backend = config_backend_new(opts)) == NULL)
+		return -1;
+
+	if (git_str_set(&backend->cfg, cfg, len) < 0) {
+		git_config_list_free(backend->config_list);
+		git__free(backend);
+		return -1;
+	}
+
+	*out = (git_config_backend *)backend;
+	return 0;
+}
+
+int git_config_backend_from_values(
+	git_config_backend **out,
+	const char **values,
+	size_t len,
+	git_config_backend_memory_options *opts)
+{
+	config_memory_backend *backend;
+
+	if ((backend = config_backend_new(opts)) == NULL)
+		return -1;
+
+	if (git_strlist_copy(&backend->values, values, len) < 0) {
+		git_config_list_free(backend->config_list);
+		git__free(backend);
+		return -1;
+	}
+
+	backend->values_len = len;
+
+	*out = (git_config_backend *)backend;
+	return 0;
+}