Merge pull request #4767 from pks-t/pks/config-mem

In-memory configuration

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 */

src/config_file.h → src/config_backend.h

@@ -12,36 +12,57 @@
 #include "git2/sys/config.h"
 #include "git2/config.h"
 
-GIT_INLINE(int) git_config_file_open(git_config_backend *cfg, unsigned int level, const git_repository *repo)
+/**
+ * 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 an in-memory configuration file backend
+ *
+ * @param out the new backend
+ * @param cfg the configuration that is to be parsed
+ */
+extern int git_config_backend_from_string(git_config_backend **out, const char *cfg);
+
+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_file_free(git_config_backend *cfg)
+GIT_INLINE(void) git_config_backend_free(git_config_backend *cfg)
 {
 	if (cfg)
 		cfg->free(cfg);
 }
 
-GIT_INLINE(int) git_config_file_get_string(
+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_file_set_string(
+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_file_delete(
+GIT_INLINE(int) git_config_backend_delete(
 	git_config_backend *cfg, const char *name)
 {
 	return cfg->del(cfg, name);
 }
 
-GIT_INLINE(int) git_config_file_foreach(
+GIT_INLINE(int) git_config_backend_foreach(
 	git_config_backend *cfg,
 	int (*fn)(const git_config_entry *entry, void *data),
 	void *data)
@@ -49,25 +70,14 @@ GIT_INLINE(int) git_config_file_foreach(
 	return git_config_backend_foreach_match(cfg, NULL, fn, data);
 }
 
-GIT_INLINE(int) git_config_file_foreach_match(
-	git_config_backend *cfg,
-	const char *regexp,
-	int (*fn)(const git_config_entry *entry, void *data),
-	void *data)
-{
-	return git_config_backend_foreach_match(cfg, regexp, fn, data);
-}
-
-GIT_INLINE(int) git_config_file_lock(git_config_backend *cfg)
+GIT_INLINE(int) git_config_backend_lock(git_config_backend *cfg)
 {
 	return cfg->lock(cfg);
 }
 
-GIT_INLINE(int) git_config_file_unlock(git_config_backend *cfg, int success)
+GIT_INLINE(int) git_config_backend_unlock(git_config_backend *cfg, int success)
 {
 	return cfg->unlock(cfg, success);
 }
 
-extern int git_config_file_normalize_section(char *start, char *end);
-
 #endif

src/config_entries.c

+/*
+ * 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;
+} 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;
+};
+
+static void config_entry_list_free(config_entry_list *list)
+{
+	config_entry_list *next;
+
+	while (list != NULL) {
+		next = list->next;
+
+		git__free((char*) list->entry->name);
+		git__free((char *) list->entry->value);
+		git__free(list->entry);
+		git__free(list);
+
+		list = next;
+	};
+}
+
+static void config_entry_list_append(config_entry_list **list, config_entry_list *entry)
+{
+	if (*list)
+		(*list)->last->next = entry;
+	else
+		*list = entry;
+	(*list)->last = entry;
+}
+
+int git_config_entries_new(git_config_entries **out)
+{
+	git_config_entries *entries;
+	int error;
+
+	entries = git__calloc(1, sizeof(git_config_entries));
+	GITERR_CHECK_ALLOC(entries);
+	GIT_REFCOUNT_INC(entries);
+
+	if ((error = git_strmap_alloc(&entries->map)) < 0)
+		git__free(entries);
+	else
+		*out = entries;
+
+	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) {
+		git_config_entry *dup;
+
+		dup = git__calloc(1, sizeof(git_config_entry));
+		dup->name = git__strdup(head->entry->name);
+		GITERR_CHECK_ALLOC(dup->name);
+		if (head->entry->value) {
+			dup->value = git__strdup(head->entry->value);
+			GITERR_CHECK_ALLOC(dup->value);
+		}
+		dup->level = head->entry->level;
+		dup->include_depth = head->entry->include_depth;
+
+		if ((error = git_config_entries_append(result, dup)) < 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_foreach_value(entries->map, list, config_entry_list_free(list));
+	git_strmap_free(entries->map);
+
+	list = entries->list;
+	while (list != NULL) {
+		next = list->next;
+		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)
+{
+	git_strmap_iter pos;
+	config_entry_list *existing, *var;
+	int error = 0;
+
+	var = git__calloc(1, sizeof(config_entry_list));
+	GITERR_CHECK_ALLOC(var);
+	var->entry = entry;
+
+	pos = git_strmap_lookup_index(entries->map, entry->name);
+	if (!git_strmap_valid_index(entries->map, pos)) {
+		/*
+		 * We only ever inspect `last` from the first config
+		 * entry in a multivar. In case where this new entry is
+		 * the first one in the entry map, it will also be the
+		 * last one at the time of adding it, which is
+		 * why we set `last` here to itself. Otherwise we
+		 * do not have to set `last` and leave it set to
+		 * `NULL`.
+		 */
+		var->last = var;
+
+		git_strmap_insert(entries->map, entry->name, var, &error);
+
+		if (error > 0)
+			error = 0;
+	} else {
+		existing = git_strmap_value_at(entries->map, pos);
+		config_entry_list_append(&existing, var);
+	}
+
+	var = git__calloc(1, sizeof(config_entry_list));
+	GITERR_CHECK_ALLOC(var);
+	var->entry = entry;
+	config_entry_list_append(&entries->list, var);
+
+	return error;
+}
+
+int config_entry_get(config_entry_list **out, git_config_entries *entries, const char *key)
+{
+	khiter_t pos;
+
+	pos = git_strmap_lookup_index(entries->map, key);
+
+	/* no error message; the config system will write one */
+	if (!git_strmap_valid_index(entries->map, pos))
+		return GIT_ENOTFOUND;
+
+	*out = git_strmap_value_at(entries->map, pos);
+
+	return 0;
+}
+
+int git_config_entries_get(git_config_entry **out, git_config_entries *entries, const char *key)
+{
+	config_entry_list *entry;
+	int error;
+
+	if ((error = config_entry_get(&entry, entries, key)) < 0)
+		return error;
+	*out = entry->last->entry;
+
+	return 0;
+}
+
+int git_config_entries_get_unique(git_config_entry **out, git_config_entries *entries, const char *key)
+{
+	config_entry_list *entry;
+	int error;
+
+	if ((error = config_entry_get(&entry, entries, key)) < 0)
+		return error;
+
+	if (entry->next != NULL) {
+		giterr_set(GITERR_CONFIG, "entry is not unique due to being a multivar");
+		return -1;
+	}
+
+	if (entry->entry->include_depth) {
+		giterr_set(GITERR_CONFIG, "entry is not unique due to being included");
+		return -1;
+	}
+
+	*out = entry->entry;
+
+	return 0;
+}
+
+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);
+}
+
+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));
+	GITERR_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;
+}

src/config_entries.h

+/*
+ * 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);
+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);

src/config_mem.c

+/*
+ * 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_entries.h"
+
+typedef struct {
+	git_config_backend parent;
+	git_config_entries *entries;
+	git_buf cfg;
+} config_memory_backend;
+
+typedef struct {
+	git_config_entries *entries;
+	git_config_level_t level;
+} config_memory_parse_data;
+
+static int config_error_readonly(void)
+{
+	giterr_set(GITERR_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_buf buf = GIT_BUF_INIT;
+	git_config_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_buf_puts(&buf, current_section);
+		git_buf_putc(&buf, '.');
+	}
+
+	for (c = var_name; *c; c++)
+		git_buf_putc(&buf, git__tolower(*c));
+
+	if (git_buf_oom(&buf))
+		return -1;
+
+	entry = git__calloc(1, sizeof(git_config_entry));
+	GITERR_CHECK_ALLOC(entry);
+	entry->name = git_buf_detach(&buf);
+	entry->value = var_value ? git__strdup(var_value) : NULL;
+	entry->level = parse_data->level;
+	entry->include_depth = 0;
+
+	if ((result = git_config_entries_append(parse_data->entries, entry)) < 0)
+		return result;
+
+	return result;
+}
+
+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;
+	config_memory_parse_data parse_data;
+	git_config_parser reader;
+
+	GIT_UNUSED(repo);
+
+	if (memory_backend->cfg.size == 0)
+		return 0;
+
+	git_parse_ctx_init(&reader.ctx, memory_backend->cfg.ptr, memory_backend->cfg.size);
+	reader.file = NULL;
+	parse_data.entries = memory_backend->entries;
+	parse_data.level = level;
+
+	return git_config_parse(&reader, NULL, read_variable_cb, NULL, NULL, &parse_data);
+}
+
+static int config_memory_get(git_config_backend *backend, const char *key, git_config_entry **out)
+{
+	config_memory_backend *memory_backend = (config_memory_backend *) backend;
+	return git_config_entries_get(out, memory_backend->entries, key);
+}
+
+static int config_memory_iterator(
+	git_config_iterator **iter,
+	git_config_backend *backend)
+{
+	config_memory_backend *memory_backend = (config_memory_backend *) backend;
+	git_config_entries *entries;
+	int error;
+
+	if ((error = git_config_entries_dup(&entries, memory_backend->entries)) < 0)
+		goto out;
+
+	if ((error = git_config_entries_iterator_new(iter, entries)) < 0)
+		goto out;
+
+out:
+	/* Let iterator delete duplicated entries when it's done */
+	git_config_entries_free(entries);
+	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 int config_memory_snapshot(git_config_backend **out, git_config_backend *backend)
+{
+	GIT_UNUSED(out);
+	GIT_UNUSED(backend);
+	giterr_set(GITERR_CONFIG, "this backend does not support snapshots");
+	return -1;
+}
+
+static void config_memory_free(git_config_backend *_backend)
+{
+	config_memory_backend *backend = (config_memory_backend *)_backend;
+
+	if (backend == NULL)
+		return;
+
+	git_config_entries_free(backend->entries);
+	git_buf_dispose(&backend->cfg);
+	git__free(backend);
+}
+
+int git_config_backend_from_string(git_config_backend **out, const char *cfg)
+{
+	config_memory_backend *backend;
+
+	backend = git__calloc(1, sizeof(config_memory_backend));
+	GITERR_CHECK_ALLOC(backend);
+
+	if (git_config_entries_new(&backend->entries) < 0) {
+		git__free(backend);
+		return -1;
+	}
+
+	if (git_buf_sets(&backend->cfg, cfg) < 0) {
+		git_config_entries_free(backend->entries);
+		git__free(backend);
+		return -1;
+	}
+
+	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 = config_memory_snapshot;
+	backend->parent.free = config_memory_free;
+
+	*out = (git_config_backend *)backend;
+
+	return 0;
+}

src/config_parse.c

@@ -11,10 +11,14 @@
 
 #include <ctype.h>
 
+const char *git_config_escapes = "ntb\"\\";
+const char *git_config_escaped = "\n\t\b\"\\";
+
 static void set_parse_error(git_config_parser *reader, int col, const char *error_str)
 {
+	const char *file = reader->file ? reader->file->path : "in-memory";
 	giterr_set(GITERR_CONFIG, "failed to parse config file: %s (in %s:%"PRIuZ", column %d)",
-		error_str, reader->file->path, reader->ctx.line_num, col);
+		error_str, file, reader->ctx.line_num, col);
 }
 
 

src/config_parse.h

@@ -12,8 +12,8 @@
 #include "oid.h"
 #include "parse.h"
 
-static const char *git_config_escapes = "ntb\"\\";
-static const char *git_config_escaped = "\n\t\b\"\\";
+extern const char *git_config_escapes;
+extern const char *git_config_escaped;
 
 typedef struct config_file {
 	git_oid checksum;

src/submodule.c

@@ -15,7 +15,7 @@
 #include "buf_text.h"
 #include "vector.h"
 #include "posix.h"
-#include "config_file.h"
+#include "config_backend.h"
 #include "config.h"
 #include "repository.h"
 #include "tree.h"
@@ -199,13 +199,15 @@ out:
  */
 static void free_submodule_names(git_strmap *names)
 {
-	git_buf *name;
+	const char *key;
+	char *value;
 
 	if (names == NULL)
 		return;
 
-	git_strmap_foreach_value(names, name, {
-		git__free(name);
+	git_strmap_foreach(names, key, value, {
+		git__free((char *) key);
+		git__free(value);
 	});
 	git_strmap_free(names);
 
@@ -257,7 +259,7 @@ static int load_submodule_names(git_strmap **out, git_repository *repo, git_conf
 		if (!isvalid)
 			continue;
 
-		git_strmap_insert(names, entry->value, git_buf_detach(&buf), &rval);
+		git_strmap_insert(names, git__strdup(entry->value), git_buf_detach(&buf), &rval);
 		if (rval < 0) {
 			giterr_set(GITERR_NOMEMORY, "error inserting submodule into hash table");
 			error = -1;
@@ -333,9 +335,9 @@ int git_submodule_lookup(
 		mods = open_gitmodules(repo, GITMODULES_EXISTING);
 
 		if (mods)
-			error = git_config_file_foreach_match(mods, pattern, find_by_path, &data);
+			error = git_config_backend_foreach_match(mods, pattern, find_by_path, &data);
 
-		git_config_file_free(mods);
+		git_config_backend_free(mods);
 
 		if (error < 0) {
 			git_submodule_free(sm);
@@ -792,11 +794,11 @@ int git_submodule_add_setup(
 	}
 
 	if ((error = git_buf_printf(&name, "submodule.%s.path", path)) < 0 ||
-		(error = git_config_file_set_string(mods, name.ptr, path)) < 0)
+		(error = git_config_backend_set_string(mods, name.ptr, path)) < 0)
 		goto cleanup;
 
 	if ((error = submodule_config_key_trunc_puts(&name, "url")) < 0 ||
-		(error = git_config_file_set_string(mods, name.ptr, url)) < 0)
+		(error = git_config_backend_set_string(mods, name.ptr, url)) < 0)
 		goto cleanup;
 
 	git_buf_clear(&name);
@@ -834,7 +836,7 @@ cleanup:
 	if (out != NULL)
 		*out = sm;
 
-	git_config_file_free(mods);
+	git_config_backend_free(mods);
 	git_repository_free(subrepo);
 	git_buf_dispose(&real_url);
 	git_buf_dispose(&name);
@@ -1033,14 +1035,14 @@ static int write_var(git_repository *repo, const char *name, const char *var, co
 		goto cleanup;
 
 	if (val)
-		error = git_config_file_set_string(mods, key.ptr, val);
+		error = git_config_backend_set_string(mods, key.ptr, val);
 	else
-		error = git_config_file_delete(mods, key.ptr);
+		error = git_config_backend_delete(mods, key.ptr);
 
 	git_buf_dispose(&key);
 
 cleanup:
-	git_config_file_free(mods);
+	git_config_backend_free(mods);
 	return error;
 }
 
@@ -2070,12 +2072,12 @@ static git_config_backend *open_gitmodules(
 			return NULL;
 
 		if (okay_to_create || git_path_isfile(path.ptr)) {
-			/* git_config_file__ondisk should only fail if OOM */
-			if (git_config_file__ondisk(&mods, path.ptr) < 0)
+			/* git_config_backend_from_file should only fail if OOM */
+			if (git_config_backend_from_file(&mods, path.ptr) < 0)
 				mods = NULL;
 			/* open should only fail here if the file is malformed */
-			else if (git_config_file_open(mods, GIT_CONFIG_LEVEL_LOCAL, repo) < 0) {
-				git_config_file_free(mods);
+			else if (git_config_backend_open(mods, GIT_CONFIG_LEVEL_LOCAL, repo) < 0) {
+				git_config_backend_free(mods);
 				mods = NULL;
 			}
 		}

tests/config/memory.c

+#include "clar_libgit2.h"
+
+#include "config_backend.h"
+
+static git_config_backend *backend;
+
+void test_config_memory__initialize(void)
+{
+	backend = NULL;
+}
+
+void test_config_memory__cleanup(void)
+{
+	git_config_backend_free(backend);
+}
+
+static void assert_config_contains(git_config_backend *backend,
+	const char *name, const char *value)
+{
+	git_config_entry *entry;
+	cl_git_pass(git_config_backend_get_string(&entry, backend, name));
+	cl_assert_equal_s(entry->value, value);
+}
+
+struct expected_entry {
+	const char *name;
+	const char *value;
+	int seen;
+};
+
+static int contains_all_cb(const git_config_entry *entry, void *payload)
+{
+	struct expected_entry *entries = (struct expected_entry *) payload;
+	int i;
+
+	for (i = 0; entries[i].name; i++) {
+		if (strcmp(entries[i].name, entry->name) ||
+		    strcmp(entries[i].value , entry->value))
+			continue;
+
+		if (entries[i].seen)
+			cl_fail("Entry seen more than once");
+		entries[i].seen = 1;
+		return 0;
+	}
+
+	cl_fail("Unexpected entry");
+	return -1;
+}
+
+static void assert_config_contains_all(git_config_backend *backend,
+	struct expected_entry *entries)
+{
+	int i;
+
+	cl_git_pass(git_config_backend_foreach(backend, contains_all_cb, entries));
+
+	for (i = 0; entries[i].name; i++)
+		cl_assert(entries[i].seen);
+}
+
+static void setup_backend(const char *cfg)
+{
+	cl_git_pass(git_config_backend_from_string(&backend, cfg));
+	cl_git_pass(git_config_backend_open(backend, 0, NULL));
+}
+
+void test_config_memory__write_operations_fail(void)
+{
+	setup_backend("");
+	cl_git_fail(git_config_backend_set_string(backend, "general.foo", "var"));
+	cl_git_fail(git_config_backend_delete(backend, "general.foo"));
+	cl_git_fail(git_config_backend_lock(backend));
+	cl_git_fail(git_config_backend_unlock(backend, 0));
+}
+
+void test_config_memory__simple(void)
+{
+	setup_backend(
+		"[general]\n"
+		"foo=bar\n");
+
+	assert_config_contains(backend, "general.foo", "bar");
+}
+
+void test_config_memory__malformed_fails_to_open(void)
+{
+	cl_git_pass(git_config_backend_from_string(&backend,
+		"[general\n"
+		"foo=bar\n"));
+	cl_git_fail(git_config_backend_open(backend, 0, NULL));
+}
+
+void test_config_memory__multiple_vars(void)
+{
+	setup_backend(
+		"[general]\n"
+		"foo=bar\n"
+		"key=value\n");
+	assert_config_contains(backend, "general.foo", "bar");
+	assert_config_contains(backend, "general.key", "value");
+}
+
+void test_config_memory__multiple_sections(void)
+{
+	setup_backend(
+		"[general]\n"
+		"foo=bar\n"
+		"\n"
+		"[other]\n"
+		"key=value\n");
+	assert_config_contains(backend, "general.foo", "bar");
+	assert_config_contains(backend, "other.key", "value");
+}
+
+void test_config_memory__multivar_gets_correct_string(void)
+{
+	setup_backend(
+		"[general]\n"
+		"foo=bar1\n"
+		"foo=bar2\n");
+	assert_config_contains(backend, "general.foo", "bar2");
+}
+
+void test_config_memory__foreach_sees_multivar(void)
+{
+	struct expected_entry entries[] = {
+		{ "general.foo", "bar1", 0 },
+		{ "general.foo", "bar2", 0 },
+		{ NULL, NULL, 0 },
+	};
+
+	setup_backend(
+		"[general]\n"
+		"foo=bar1\n"
+		"foo=bar2\n");
+	assert_config_contains_all(backend, entries);
+}

tests/config/readonly.c

 #include "clar_libgit2.h"
-#include "config_file.h"
+#include "config_backend.h"
 #include "config.h"
 #include "path.h"
 
@@ -20,7 +20,7 @@ void test_config_readonly__writing_to_readonly_fails(void)
 {
 	git_config_backend *backend;
 
-	cl_git_pass(git_config_file__ondisk(&backend, "global"));
+	cl_git_pass(git_config_backend_from_file(&backend, "global"));
 	backend->readonly = 1;
 	cl_git_pass(git_config_add_backend(cfg, backend, GIT_CONFIG_LEVEL_GLOBAL, NULL, 0));
 
@@ -32,11 +32,11 @@ void test_config_readonly__writing_to_cfg_with_rw_precedence_succeeds(void)
 {
 	git_config_backend *backend;
 
-	cl_git_pass(git_config_file__ondisk(&backend, "global"));
+	cl_git_pass(git_config_backend_from_file(&backend, "global"));
 	backend->readonly = 1;
 	cl_git_pass(git_config_add_backend(cfg, backend, GIT_CONFIG_LEVEL_GLOBAL, NULL, 0));
 
-	cl_git_pass(git_config_file__ondisk(&backend, "local"));
+	cl_git_pass(git_config_backend_from_file(&backend, "local"));
 	cl_git_pass(git_config_add_backend(cfg, backend, GIT_CONFIG_LEVEL_LOCAL, NULL, 0));
 
 	cl_git_pass(git_config_set_string(cfg, "foo.bar", "baz"));
@@ -50,11 +50,11 @@ void test_config_readonly__writing_to_cfg_with_ro_precedence_succeeds(void)
 {
 	git_config_backend *backend;
 
-	cl_git_pass(git_config_file__ondisk(&backend, "local"));
+	cl_git_pass(git_config_backend_from_file(&backend, "local"));
 	backend->readonly = 1;
 	cl_git_pass(git_config_add_backend(cfg, backend, GIT_CONFIG_LEVEL_LOCAL, NULL, 0));
 
-	cl_git_pass(git_config_file__ondisk(&backend, "global"));
+	cl_git_pass(git_config_backend_from_file(&backend, "global"));
 	cl_git_pass(git_config_add_backend(cfg, backend, GIT_CONFIG_LEVEL_GLOBAL, NULL, 0));
 
 	cl_git_pass(git_config_set_string(cfg, "foo.bar", "baz"));

tests/config/write.c

@@ -2,7 +2,6 @@
 #include "buffer.h"
 #include "fileops.h"
 #include "git2/sys/config.h"
-#include "config_file.h"
 #include "config.h"
 
 void test_config_write__initialize(void)