rugged 0.16.0 → 0.17.0b1

data/ext/rugged/vendor/libgit2-dist/src/config.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2011 the libgit2 contributors
+ * Copyright (C) 2009-2012 the libgit2 contributors
  *
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
@@ -7,7 +7,6 @@
 
 #include "common.h"
 #include "fileops.h"
-#include "hashtable.h"
 #include "config.h"
 #include "git2/config.h"
 #include "vector.h"
@@ -60,84 +59,77 @@ int git_config_new(git_config **out)
 	git_config *cfg;
 
 	cfg = git__malloc(sizeof(git_config));
-	if (cfg == NULL)
-		return GIT_ENOMEM;
+	GITERR_CHECK_ALLOC(cfg);
 
 	memset(cfg, 0x0, sizeof(git_config));
 
 	if (git_vector_init(&cfg->files, 3, config_backend_cmp) < 0) {
 		git__free(cfg);
-		return GIT_ENOMEM;
+		return -1;
 	}
 
 	*out = cfg;
 	GIT_REFCOUNT_INC(cfg);
-	return GIT_SUCCESS;
+	return 0;
 }
 
 int git_config_add_file_ondisk(git_config *cfg, const char *path, int priority)
 {
 	git_config_file *file = NULL;
-	int error;
 
-	error = git_config_file__ondisk(&file, path);
-	if (error < GIT_SUCCESS)
-		return error;
+	if (git_config_file__ondisk(&file, path) < 0)
+		return -1;
 
-	error = git_config_add_file(cfg, file, priority);
-	if (error < GIT_SUCCESS) {
+	if (git_config_add_file(cfg, file, priority) < 0) {
 		/*
 		 * free manually; the file is not owned by the config
 		 * instance yet and will not be freed on cleanup
 		 */
 		file->free(file);
-		return error;
+		return -1;
 	}
 
-	return GIT_SUCCESS;
+	return 0;
 }
 
 int git_config_open_ondisk(git_config **cfg, const char *path)
 {
-	int error;
-
-	error = git_config_new(cfg);
-	if (error < GIT_SUCCESS)
-		return error;
+	if (git_config_new(cfg) < 0)
+		return -1;
 
-	error = git_config_add_file_ondisk(*cfg, path, 1);
-	if (error < GIT_SUCCESS)
+	if (git_config_add_file_ondisk(*cfg, path, 1) < 0) {
 		git_config_free(*cfg);
+		return -1;
+	}
 
-	return error;
+	return 0;
 }
 
 int git_config_add_file(git_config *cfg, git_config_file *file, int priority)
 {
 	file_internal *internal;
-	int error;
+	int result;
 
 	assert(cfg && file);
 
-	if ((error = file->open(file)) < GIT_SUCCESS)
-		return git__rethrow(error, "Failed to open config file");
+	if ((result = file->open(file)) < 0)
+		return result;
 
 	internal = git__malloc(sizeof(file_internal));
-	if (internal == NULL)
-		return GIT_ENOMEM;
+	GITERR_CHECK_ALLOC(internal);
 
 	internal->file = file;
 	internal->priority = priority;
 
 	if (git_vector_insert(&cfg->files, internal) < 0) {
 		git__free(internal);
-		return GIT_ENOMEM;
+		return -1;
 	}
 
 	git_vector_sort(&cfg->files);
 	internal->file->cfg = cfg;
 
-	return GIT_SUCCESS;
+	return 0;
 }
 
 /*
@@ -146,7 +138,7 @@ int git_config_add_file(git_config *cfg, git_config_file *file, int priority)
 
 int git_config_foreach(git_config *cfg, int (*fn)(const char *, const char *, void *), void *data)
 {
-	int ret = GIT_SUCCESS;
+	int ret = 0;
 	unsigned int i;
 	file_internal *internal;
 	git_config_file *file;
@@ -162,7 +154,15 @@ int git_config_foreach(git_config *cfg, int (*fn)(const char *, const char *, vo
 
 int git_config_delete(git_config *cfg, const char *name)
 {
-	return git_config_set_string(cfg, name, NULL);
+	file_internal *internal;
+	git_config_file *file;
+
+	assert(cfg->files.length);
+
+	internal = git_vector_get(&cfg->files, 0);
+	file = internal->file;
+
+	return file->del(file, name);
 }
 
 /**************
@@ -191,8 +191,7 @@ int git_config_set_string(git_config *cfg, const char *name, const char *value)
 	file_internal *internal;
 	git_config_file *file;
 
-	if (cfg->files.length == 0)
-		return git__throw(GIT_EINVALIDARGS, "Cannot set variable value; no files open in the `git_config` instance");
+	assert(cfg->files.length);
 
 	internal = git_vector_get(&cfg->files, 0);
 	file = internal->file;
@@ -200,23 +199,13 @@ int git_config_set_string(git_config *cfg, const char *name, const char *value)
 	return file->set(file, name, value);
 }
 
-/***********
- * Getters
- ***********/
-
-int git_config_get_int64(git_config *cfg, const char *name, int64_t *out)
+static int parse_int64(int64_t *out, const char *value)
 {
-	const char *value, *num_end;
-	int ret;
+	const char *num_end;
 	int64_t num;
 
-	ret = git_config_get_string(cfg, name, &value);
-	if (ret < GIT_SUCCESS)
-		return git__rethrow(ret, "Failed to retrieve value for '%s'", name);
-
-	ret = git__strtol64(&num, value, &num_end, 0);
-	if (ret < GIT_SUCCESS)
-		return git__rethrow(ret, "Failed to convert value for '%s'", name);
+	if (git__strtol64(&num, value, &num_end, 0) < 0)
+		return -1;
 
 	switch (*num_end) {
 	case 'g':
@@ -236,183 +225,283 @@ int git_config_get_int64(git_config *cfg, const char *name, int64_t *out)
 		/* check that that there are no more characters after the
 		 * given modifier suffix */
 		if (num_end[1] != '\0')
-			return git__throw(GIT_EINVALIDTYPE,
-				"Failed to get value for '%s'. Invalid type suffix", name);
+			return -1;
 
 		/* fallthrough */
 
 	case '\0':
 		*out = num;
-		return GIT_SUCCESS;
+		return 0;
 
 	default:
-		return git__throw(GIT_EINVALIDTYPE,
-			"Failed to get value for '%s'. Value is of invalid type", name);
+		return -1;
 	}
 }
 
-int git_config_get_int32(git_config *cfg, const char *name, int32_t *out)
+static int parse_int32(int32_t *out, const char *value)
 {
-	int64_t tmp_long;
-	int32_t tmp_int;
+	int64_t tmp;
+	int32_t truncate;
+
+	if (parse_int64(&tmp, value) < 0)
+		return -1;
+
+	truncate = tmp & 0xFFFFFFFF;
+	if (truncate != tmp)
+		return -1;
+
+	*out = truncate;
+	return 0;
+}
+
+/***********
+ * Getters
+ ***********/
+int git_config_lookup_map_value(
+	git_cvar_map *maps, size_t map_n, const char *value, int *out)
+{
+	size_t i;
+
+	if (!value)
+		return GIT_ENOTFOUND;
+
+	for (i = 0; i < map_n; ++i) {
+		git_cvar_map *m = maps + i;
+
+		switch (m->cvar_type) {
+		case GIT_CVAR_FALSE:
+		case GIT_CVAR_TRUE: {
+			int bool_val;
+
+			if (git__parse_bool(&bool_val, value) == 0 &&
+				bool_val == (int)m->cvar_type) {
+				*out = m->map_value;
+				return 0;
+			}
+			break;
+		}
+
+		case GIT_CVAR_INT32:
+			if (parse_int32(out, value) == 0)
+				return 0;
+			break;
+
+		case GIT_CVAR_STRING:
+			if (strcasecmp(value, m->str_match) == 0) {
+				*out = m->map_value;
+				return 0;
+			}
+			break;
+		}
+	}
+
+	return GIT_ENOTFOUND;
+}
+
+int git_config_get_mapped(
+	int *out,
+	git_config *cfg,
+	const char *name,
+	git_cvar_map *maps,
+	size_t map_n)
+{
+	const char *value;
 	int ret;
 
-	ret = git_config_get_int64(cfg, name, &tmp_long);
-	if (ret < GIT_SUCCESS)
-		return git__rethrow(ret, "Failed to convert value for '%s'", name);
-	
-	tmp_int = tmp_long & 0xFFFFFFFF;
-	if (tmp_int != tmp_long)
-		return git__throw(GIT_EOVERFLOW, "Value for '%s' is too large", name);
+	ret = git_config_get_string(&value, cfg, name);
+	if (ret < 0)
+		return ret;
 
-	*out = tmp_int;
+	if (!git_config_lookup_map_value(maps, map_n, value, out))
+		return 0;
 
-	return ret;
+	giterr_set(GITERR_CONFIG,
+		"Failed to map the '%s' config variable with a valid value", name);
+	return -1;
 }
 
-int git_config_get_bool(git_config *cfg, const char *name, int *out)
+int git_config_get_int64(int64_t *out, git_config *cfg, const char *name)
 {
 	const char *value;
-	int error = GIT_SUCCESS;
+	int ret;
 
-	error = git_config_get_string(cfg, name, &value);
-	if (error < GIT_SUCCESS)
-		return git__rethrow(error, "Failed to get value for %s", name);
+	ret = git_config_get_string(&value, cfg, name);
+	if (ret < 0)
+		return ret;
 
-	/* A missing value means true */
-	if (value == NULL) {
-		*out = 1;
-		return GIT_SUCCESS;
+	if (parse_int64(out, value) < 0) {
+		giterr_set(GITERR_CONFIG, "Failed to parse '%s' as an integer", value);
+		return -1;
 	}
 
-	if (!strcasecmp(value, "true") ||
-		!strcasecmp(value, "yes") ||
-		!strcasecmp(value, "on")) {
-		*out = 1;
-		return GIT_SUCCESS;
-	}
-	if (!strcasecmp(value, "false") ||
-		!strcasecmp(value, "no") ||
-		!strcasecmp(value, "off")) {
-		*out = 0;
-		return GIT_SUCCESS;
+	return 0;
+}
+
+int git_config_get_int32(int32_t *out, git_config *cfg, const char *name)
+{
+	const char *value;
+	int ret;
+
+	ret = git_config_get_string(&value, cfg, name);
+	if (ret < 0)
+		return ret;
+
+	if (parse_int32(out, value) < 0) {
+		giterr_set(GITERR_CONFIG, "Failed to parse '%s' as a 32-bit integer", value);
+		return -1;
 	}
 
-	/* Try to parse it as an integer */
-	error = git_config_get_int32(cfg, name, out);
-	if (error == GIT_SUCCESS)
+	return 0;
+}
+
+int git_config_get_bool(int *out, git_config *cfg, const char *name)
+{
+	const char *value;
+	int ret;
+
+	ret = git_config_get_string(&value, cfg, name);
+	if (ret < 0)
+		return ret;
+
+	if (git__parse_bool(out, value) == 0)
+		return 0;
+
+	if (parse_int32(out, value) == 0) {
 		*out = !!(*out);
+		return 0;
+	}
 
-	if (error < GIT_SUCCESS)
-		return git__rethrow(error, "Failed to get value for %s", name);
-	return error;
+	giterr_set(GITERR_CONFIG, "Failed to parse '%s' as a boolean value", value);
+	return -1;
 }
 
-int git_config_get_string(git_config *cfg, const char *name, const char **out)
+int git_config_get_string(const char **out, git_config *cfg, const char *name)
 {
 	file_internal *internal;
-	git_config_file *file;
-	int error = GIT_ENOTFOUND;
 	unsigned int i;
 
-	if (cfg->files.length == 0)
-		return git__throw(GIT_EINVALIDARGS, "Cannot get variable value; no files open in the `git_config` instance");
+	assert(cfg->files.length);
 
-	for (i = 0; i < cfg->files.length; ++i) {
-		internal = git_vector_get(&cfg->files, i);
-		file = internal->file;
-		if ((error = file->get(file, name, out)) == GIT_SUCCESS)
-			return GIT_SUCCESS;
+	*out = NULL;
+
+	git_vector_foreach(&cfg->files, i, internal) {
+		git_config_file *file = internal->file;
+		int ret = file->get(file, name, out);
+		if (ret != GIT_ENOTFOUND)
+			return ret;
 	}
 
-	return git__throw(error, "Config value '%s' not found", name);
+	return GIT_ENOTFOUND;
 }
 
-int git_config_find_global(char *global_config_path)
+int git_config_get_multivar(git_config *cfg, const char *name, const char *regexp,
+			    int (*fn)(const char *value, void *data), void *data)
 {
-	const char *home;
+	file_internal *internal;
+	git_config_file *file;
+	int ret = GIT_ENOTFOUND;
+	unsigned int i;
 
-	home = getenv("HOME");
+	assert(cfg->files.length);
 
-#ifdef GIT_WIN32
-	if (home == NULL)
-		home = getenv("USERPROFILE");
-#endif
+	/*
+	 * This loop runs the "wrong" way 'round because we need to
+	 * look at every value from the most general to most specific
+	 */
+	for (i = cfg->files.length; i > 0; --i) {
+		internal = git_vector_get(&cfg->files, i - 1);
+		file = internal->file;
+		ret = file->get_multivar(file, name, regexp, fn, data);
+		if (ret < 0 && ret != GIT_ENOTFOUND)
+			return ret;
+	}
 
-	if (home == NULL)
-		return git__throw(GIT_EOSERR, "Failed to open global config file. Cannot locate the user's home directory");
+	return 0;
+}
 
-	git_path_join(global_config_path, home, GIT_CONFIG_FILENAME);
+int git_config_set_multivar(git_config *cfg, const char *name, const char *regexp, const char *value)
+{
+	file_internal *internal;
+	git_config_file *file;
+	int ret = GIT_ENOTFOUND;
+	unsigned int i;
 
-	if (git_futils_exists(global_config_path) < GIT_SUCCESS)
-		return git__throw(GIT_EOSERR, "Failed to open global config file. The file does not exist");
+	for (i = cfg->files.length; i > 0; --i) {
+		internal = git_vector_get(&cfg->files, i - 1);
+		file = internal->file;
+		ret = file->set_multivar(file, name, regexp, value);
+		if (ret < 0 && ret != GIT_ENOTFOUND)
+			return ret;
+	}
 
-	return GIT_SUCCESS;
+	return 0;
 }
 
+int git_config_find_global_r(git_buf *path)
+{
+	return git_futils_find_global_file(path, GIT_CONFIG_FILENAME);
+}
 
-
-#if GIT_WIN32
-static int win32_find_system(char *system_config_path)
+int git_config_find_global(char *global_config_path, size_t length)
 {
-	const wchar_t *query = L"%PROGRAMFILES%\\Git\\etc\\gitconfig";
-	wchar_t *apphome_utf16;
-	char *apphome_utf8;
-	DWORD size, ret;
-
-	size = ExpandEnvironmentStringsW(query, NULL, 0);
-	/* The function gave us the full size of the buffer in chars, including NUL */
-	apphome_utf16 = git__malloc(size * sizeof(wchar_t));
-	if (apphome_utf16 == NULL)
-		return GIT_ENOMEM;
-
-	ret = ExpandEnvironmentStringsW(query, apphome_utf16, size);
-	if (ret != size)
-		return git__throw(GIT_ERROR, "Failed to expand environment strings");
-
-	if (_waccess(apphome_utf16, F_OK) < 0) {
-		git__free(apphome_utf16);
-		return GIT_ENOTFOUND;
-	}
+	git_buf path  = GIT_BUF_INIT;
+	int     ret = git_config_find_global_r(&path);
 
-	apphome_utf8 = gitwin_from_utf16(apphome_utf16);
-	git__free(apphome_utf16);
+	if (ret < 0) {
+		git_buf_free(&path);
+		return ret;
+	}
 
-	if (strlen(apphome_utf8) >= GIT_PATH_MAX) {
-		git__free(apphome_utf8);
-		return git__throw(GIT_ESHORTBUFFER, "Path is too long");
+	if (path.size >= length) {
+		git_buf_free(&path);
+		giterr_set(GITERR_NOMEMORY,
+			"Path is to long to fit on the given buffer");
+		return -1;
 	}
 
-	strcpy(system_config_path, apphome_utf8);
-	git__free(apphome_utf8);
-	return GIT_SUCCESS;
+	git_buf_copy_cstr(global_config_path, length, &path);
+	git_buf_free(&path);
+	return 0;
+}
+
+int git_config_find_system_r(git_buf *path)
+{
+	return git_futils_find_system_file(path, GIT_CONFIG_FILENAME_SYSTEM);
 }
-#endif
 
-int git_config_find_system(char *system_config_path)
+int git_config_find_system(char *system_config_path, size_t length)
 {
-	const char *etc = "/etc/gitconfig";
+	git_buf path  = GIT_BUF_INIT;
+	int     ret = git_config_find_system_r(&path);
 
-	if (git_futils_exists(etc) == GIT_SUCCESS) {
-		memcpy(system_config_path, etc, strlen(etc) + 1);
-		return GIT_SUCCESS;
+	if (ret < 0) {
+		git_buf_free(&path);
+		return ret;
 	}
 
-#if GIT_WIN32
-	return win32_find_system(system_config_path);
-#else
-	return GIT_ENOTFOUND;
-#endif
+	if (path.size >= length) {
+		git_buf_free(&path);
+		giterr_set(GITERR_NOMEMORY,
+			"Path is to long to fit on the given buffer");
+		return -1;
+	}
+
+	git_buf_copy_cstr(system_config_path, length, &path);
+	git_buf_free(&path);
+	return 0;
 }
 
 int git_config_open_global(git_config **out)
 {
 	int error;
-	char global_path[GIT_PATH_MAX];
+	git_buf path = GIT_BUF_INIT;
 
-	if ((error = git_config_find_global(global_path)) < GIT_SUCCESS)
+	if ((error = git_config_find_global_r(&path)) < 0)
 		return error;
 
-	return git_config_open_ondisk(out, global_path);
+	error = git_config_open_ondisk(out, git_buf_cstr(&path));
+	git_buf_free(&path);
+
+	return error;
 }
 

data/ext/rugged/vendor/libgit2-dist/src/config.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2011 the libgit2 contributors
+ * Copyright (C) 2009-2012 the libgit2 contributors
  *
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
@@ -14,6 +14,7 @@
 
 #define GIT_CONFIG_FILENAME ".gitconfig"
 #define GIT_CONFIG_FILENAME_INREPO "config"
+#define GIT_CONFIG_FILENAME_SYSTEM "gitconfig"
 #define GIT_CONFIG_FILE_MODE 0666
 
 struct git_config {
@@ -21,4 +22,12 @@ struct git_config {
 	git_vector files;
 };
 
+extern int git_config_find_global_r(git_buf *global_config_path);
+extern int git_config_find_system_r(git_buf *system_config_path);
+
+extern int git_config_parse_bool(int *out, const char *bool_string);
+
+extern int git_config_lookup_map_value(
+	git_cvar_map *maps, size_t map_n, const char *value, int *out);
+
 #endif

data/ext/rugged/vendor/libgit2-dist/src/config_cache.c

@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2009-2012 the libgit2 contributors
+ *
+ * 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 "fileops.h"
+#include "config.h"
+#include "git2/config.h"
+#include "vector.h"
+#include "filter.h"
+#include "repository.h"
+
+struct map_data {
+	const char *cvar_name;
+	git_cvar_map *maps;
+	size_t map_count;
+	int default_value;
+};
+
+/*
+ *	core.eol
+ *		Sets the line ending type to use in the working directory for
+ *	files that have the text property set. Alternatives are lf, crlf
+ *	and native, which uses the platform’s native line ending. The default
+ *	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}
+};
+
+/*
+ *	core.autocrlf
+ *		Setting this variable to "true" is almost the same as setting 
+ *	the text attribute to "auto" on all files except that text files are
+ *	not guaranteed to be normalized: files that contain CRLF in the
+ *	repository will not be touched. Use this setting if you want to have
+ *	CRLF line endings in your working directory even though the repository
+ *	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 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}
+};
+
+int git_repository__cvar(int *out, git_repository *repo, git_cvar_cached cvar)
+{
+	*out = repo->cvar_cache[(int)cvar];
+
+	if (*out == GIT_CVAR_NOT_CACHED) {
+		struct map_data *data = &_cvar_maps[(int)cvar];
+		git_config *config;
+		int error;
+
+		error = git_repository_config__weakptr(&config, repo);
+		if (error < 0)
+			return error;
+
+		error = git_config_get_mapped(out,
+			config, data->cvar_name, data->maps, data->map_count);
+
+		if (error == GIT_ENOTFOUND)
+			*out = data->default_value;
+
+		else if (error < 0)
+			return error;
+
+		repo->cvar_cache[(int)cvar] = *out;
+	}
+
+	return 0;
+}
+
+void git_repository__cvar_cache_clear(git_repository *repo)
+{
+	int i;
+
+	for (i = 0; i < GIT_CVAR_CACHE_MAX; ++i)
+		repo->cvar_cache[i] = GIT_CVAR_NOT_CACHED;
+}
+