rugged 0.19.0 → 0.28.0

data/ext/rugged/rugged.c

@@ -1,52 +1,44 @@
 /*
- * The MIT License
+ * Copyright (C) the Rugged contributors.  All rights reserved.
  *
- * Copyright (c) 2013 GitHub, Inc
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
+ * This file is part of Rugged, distributed under the MIT license.
+ * For full terms see the included LICENSE file.
  */
 
 #include "rugged.h"
 
 const char *RUGGED_ERROR_NAMES[] = {
-	"NoMemError",      /* GITERR_NOMEMORY, */
-	"OSError",         /* GITERR_OS, */
-	"InvalidError",    /* GITERR_INVALID, */
-	"ReferenceError",  /* GITERR_REFERENCE, */
-	"ZlibError",       /* GITERR_ZLIB, */
-	"RepositoryError", /* GITERR_REPOSITORY, */
-	"ConfigError",     /* GITERR_CONFIG, */
-	"RegexError",      /* GITERR_REGEX, */
-	"OdbError",        /* GITERR_ODB, */
-	"IndexError",      /* GITERR_INDEX, */
-	"ObjectError",     /* GITERR_OBJECT, */
-	"NetworkError",    /* GITERR_NET, */
-	"TagError",        /* GITERR_TAG, */
-	"TreeError",       /* GITERR_TREE, */
-	"IndexerError",    /* GITERR_INDEXER, */
-	"SslError",        /* GITERR_SSL, */
-	"SubmoduleError",  /* GITERR_SUBMODULE, */
-	"ThreadError",     /* GITERR_THREAD, */
-	"StashError",      /* GITERR_STASH, */
-	"CheckoutError",   /* GITERR_CHECKOUT, */
-	"FetchheadError",  /* GITERR_FETCHHEAD, */
-	"MergeError",      /* GITERR_MERGE, */
+	"None",            /* GITERR_NONE */
+	"NoMemError",      /* GITERR_NOMEMORY */
+	"OSError",         /* GITERR_OS */
+	"InvalidError",    /* GITERR_INVALID */
+	"ReferenceError",  /* GITERR_REFERENCE */
+	"ZlibError",       /* GITERR_ZLIB */
+	"RepositoryError", /* GITERR_REPOSITORY */
+	"ConfigError",     /* GITERR_CONFIG */
+	"RegexError",      /* GITERR_REGEX */
+	"OdbError",        /* GITERR_ODB */
+	"IndexError",      /* GITERR_INDEX */
+	"ObjectError",     /* GITERR_OBJECT */
+	"NetworkError",    /* GITERR_NET */
+	"TagError",        /* GITERR_TAG */
+	"TreeError",       /* GITERR_TREE */
+	"IndexerError",    /* GITERR_INDEXER */
+	"SslError",        /* GITERR_SSL */
+	"SubmoduleError",  /* GITERR_SUBMODULE */
+	"ThreadError",     /* GITERR_THREAD */
+	"StashError",      /* GITERR_STASH */
+	"CheckoutError",   /* GITERR_CHECKOUT */
+	"FetchheadError",  /* GITERR_FETCHHEAD */
+	"MergeError",      /* GITERR_MERGE */
+	"SshError",        /* GITERR_SSH */
+	"FilterError",     /* GITERR_FILTER */
+	"RevertError",     /* GITERR_REVERT */
+	"CallbackError",   /* GITERR_CALLBACK */
+	"CherrypickError", /* GITERR_CHERRYPICK */
+	"DescribeError",   /* GITERR_DESCRIBE */
+	"RebaseError",     /* GITERR_REBASE */
+	"FilesystemError", /* GITERR_FILESYSTEM */
 };
 
 #define RUGGED_ERROR_COUNT (int)((sizeof(RUGGED_ERROR_NAMES)/sizeof(RUGGED_ERROR_NAMES[0])))
@@ -81,32 +73,54 @@ static VALUE rb_git_libgit2_version(VALUE self)
 
 /*
  *  call-seq:
- *     Rugged.capabilities -> capabilities
- *
- *  Returns an array representing the 'capabilities' that libgit2 was compiled
- *  with — this includes GIT_CAP_THREADS (thread support) and GIT_CAP_HTTPS (https).
- *  This is implemented in libgit2 with simple bitwise ops; we offer Rubyland an array
- *  of symbols representing the capabilities.
+ *     Rugged.features -> [feature, ...]
  *
- *  The possible capabilities are "threads" and "https".
+ *  Returns an array representing the features that libgit2 was compiled
+ *  with — this includes `:threads` (thread support), `:https` and `:ssh`.
  *
- *    Rugged.capabilities #=> [:threads, :https]
+ *    Rugged.features #=> [:threads, :https]
  */
-static VALUE rb_git_capabilities(VALUE self)
+static VALUE rb_git_features(VALUE self)
 {
 	VALUE ret_arr = rb_ary_new();
 
-	int caps = git_libgit2_capabilities();
+	int caps = git_libgit2_features();
 
-	if (caps & GIT_CAP_THREADS)
+	if (caps & GIT_FEATURE_THREADS)
 		rb_ary_push(ret_arr, CSTR2SYM("threads"));
 
-	if (caps & GIT_CAP_HTTPS)
+	if (caps & GIT_FEATURE_HTTPS)
 		rb_ary_push(ret_arr, CSTR2SYM("https"));
 
+	if (caps & GIT_FEATURE_SSH)
+		rb_ary_push(ret_arr, CSTR2SYM("ssh"));
+
 	return ret_arr;
 }
 
+/*
+ *  call-seq:
+ *    Rugged.valid_full_oid?(oid) -> true or false
+ *
+ *  Checks to see if a string contains a full 40-character sha1.
+ *
+ *    Rugged.valid_full_oid?('d8786bfc97485e8d7b19b21fb88c8ef1f199fc3f')
+ *    #=> true
+ */
+static VALUE rb_git_valid_full_oid(VALUE self, VALUE hex)
+{
+	git_oid oid;
+	int errorcode;
+
+	Check_Type(hex, T_STRING);
+	errorcode = git_oid_fromstr(&oid, StringValueCStr(hex));
+	if (errorcode < 0) {
+		return Qfalse;
+	} else {
+		return Qtrue;
+	}
+}
+
 /*
  *  call-seq:
  *    Rugged.hex_to_raw(oid) -> raw_buffer
@@ -150,33 +164,54 @@ static VALUE rb_git_raw_to_hex(VALUE self, VALUE raw)
 	git_oid_fromraw(&oid, (const unsigned char *)RSTRING_PTR(raw));
 	git_oid_fmt(out, &oid);
 
-	return rb_str_new(out, 40);
+	return rb_usascii_str_new(out, 40);
 }
 
 /*
  *  call-seq:
- *    Rugged.prettify_message(message, strip_comments) -> clean_message
+ *    Rugged.prettify_message(message, strip_comments = '#') -> clean_message
  *
  *  Process a commit or tag message into standard form, by stripping trailing spaces and
  *  comments, and making sure that the message has a proper header line.
  */
-static VALUE rb_git_prettify_message(VALUE self, VALUE rb_message, VALUE rb_strip_comments)
+static VALUE rb_git_prettify_message(int argc, VALUE *argv, VALUE self)
 {
-	char *message;
-	int strip_comments, message_len;
-	VALUE result;
+	char comment_char = '#';
+	int strip_comments = 1;
+
+	git_buf message = { NULL };
+	VALUE rb_message, rb_strip;
+	int error;
+	VALUE result = Qnil;
+
+	rb_scan_args(argc, argv, "11", &rb_message, &rb_strip);
 
 	Check_Type(rb_message, T_STRING);
-	strip_comments = rugged_parse_bool(rb_strip_comments);
 
-	message_len = (int)RSTRING_LEN(rb_message) + 2;
-	message = xmalloc(message_len);
+	switch (TYPE(rb_strip)) {
+	case T_FALSE:
+		strip_comments = 0;
+		break;
+
+	case T_STRING:
+		if (RSTRING_LEN(rb_strip) > 0)
+			comment_char = RSTRING_PTR(rb_strip)[0];
+		break;
+
+	case T_TRUE:
+	case T_NIL:
+	default:
+		break;
+	}
+
+	error = git_message_prettify(&message,
+				StringValueCStr(rb_message), strip_comments, comment_char);
 
-	message_len = git_message_prettify(message, message_len, StringValueCStr(rb_message), strip_comments);
-	rugged_exception_check(message_len);
+	if (!error)
+		result = rb_enc_str_new(message.ptr, message.size, rb_utf8_encoding());
 
-	result = rb_enc_str_new(message, message_len - 1, rb_utf8_encoding());
-	xfree(message);
+	git_buf_dispose(&message);
+	rugged_exception_check(error);
 
 	return result;
 }
@@ -276,7 +311,7 @@ static VALUE rb_git_minimize_oid(int argc, VALUE *argv, VALUE self)
 static void cleanup_cb(void *unused)
 {
 	(void)unused;
-	git_threads_shutdown();
+	git_libgit2_shutdown();
 }
 
 void rugged_exception_raise(void)
@@ -287,12 +322,12 @@ void rugged_exception_raise(void)
 
 	error = giterr_last();
 
-	if (error && error->klass >= 0 && error->klass < RUGGED_ERROR_COUNT) {
+	if (error && error->klass > 0 && error->klass < RUGGED_ERROR_COUNT) {
 		err_klass = rb_eRuggedErrors[error->klass];
 		err_message = error->message;
 	} else {
-		err_klass = rb_eRuggedErrors[2]; /* InvalidError */
-		err_message = "Unknown Error";
+		err_klass = rb_eRuntimeError;
+		err_message = "Rugged operation failed";
 	}
 
 	err_obj = rb_exc_new2(err_klass, err_message);
@@ -300,6 +335,25 @@ void rugged_exception_raise(void)
 	rb_exc_raise(err_obj);
 }
 
+VALUE rugged__block_yield_splat(VALUE args) {
+	VALUE block = rb_ary_shift(args);
+	int n = RARRAY_LENINT(args);
+
+	if (n == 0) {
+		return rb_funcall(block, rb_intern("call"), 0);
+	} else {
+		int i;
+		VALUE *argv;
+		argv = ALLOCA_N(VALUE, n);
+
+		for (i=0; i < n; i++) {
+			argv[i] = rb_ary_entry(args, i);
+		}
+
+		return rb_funcall2(block, rb_intern("call"), n, argv);
+	}
+}
+
 /*
  *  call-seq:
  *    Rugged.__cache_usage__ -> [current, max]
@@ -314,6 +368,29 @@ static VALUE rb_git_cache_usage(VALUE self)
 	return rb_ary_new3(2, LL2NUM(used), LL2NUM(max));
 }
 
+/*
+ *  call-seq:
+ *    Rugged.signature_from_buffer(buffer[, encoding_name]) -> signature
+ *
+ * Parse the signature from the given buffer. If an encoding is given, the
+ * strings will be tagged with that encoding.
+ *
+ *    commit.author #=> {:email=>"tanoku@gmail.com", :time=>Tue Jan 24 05:42:45 UTC 2012, :name=>"Vicent Mart\303\255"}
+ */
+static VALUE rb_git_signature_from_buffer(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_buffer, rb_encoding_name;
+	const char *buffer, *encoding_name = NULL;
+
+	rb_scan_args(argc, argv, "11", &rb_buffer, &rb_encoding_name);
+
+	buffer = StringValueCStr(rb_buffer);
+	if (!NIL_P(rb_encoding_name))
+		encoding_name = StringValueCStr(rb_encoding_name);
+
+	return rugged_signature_from_buffer(buffer, encoding_name);
+}
+
 VALUE rugged_strarray_to_rb_ary(git_strarray *str_array)
 {
 	VALUE rb_array = rb_ary_new2(str_array->count);
@@ -357,6 +434,129 @@ void rugged_rb_ary_to_strarray(VALUE rb_array, git_strarray *str_array)
 	}
 }
 
+void rugged_parse_merge_file_options(git_merge_file_options *opts, VALUE rb_options)
+{
+	VALUE rb_value;
+
+	Check_Type(rb_options, T_HASH);
+
+	rb_value = rb_hash_aref(rb_options, CSTR2SYM("ancestor_label"));
+	if (!NIL_P(rb_value)) {
+		Check_Type(rb_value, T_STRING);
+		opts->ancestor_label = StringValueCStr(rb_value);
+	}
+
+	rb_value = rb_hash_aref(rb_options, CSTR2SYM("our_label"));
+	if (!NIL_P(rb_value)) {
+		Check_Type(rb_value, T_STRING);
+		opts->our_label = StringValueCStr(rb_value);
+	}
+
+	rb_value = rb_hash_aref(rb_options, CSTR2SYM("their_label"));
+	if (!NIL_P(rb_value)) {
+		Check_Type(rb_value, T_STRING);
+		opts->their_label = StringValueCStr(rb_value);
+	}
+
+	rb_value = rb_hash_aref(rb_options, CSTR2SYM("favor"));
+	if (!NIL_P(rb_value)) {
+		ID id_favor;
+
+		Check_Type(rb_value, T_SYMBOL);
+		id_favor = SYM2ID(rb_value);
+
+		if (id_favor == rb_intern("normal")) {
+			opts->favor = GIT_MERGE_FILE_FAVOR_NORMAL;
+		} else if (id_favor == rb_intern("ours")) {
+			opts->favor = GIT_MERGE_FILE_FAVOR_OURS;
+		} else if (id_favor == rb_intern("theirs")) {
+			opts->favor = GIT_MERGE_FILE_FAVOR_THEIRS;
+		} else if (id_favor == rb_intern("union")) {
+			opts->favor = GIT_MERGE_FILE_FAVOR_UNION;
+		} else {
+			rb_raise(rb_eTypeError,
+				"Invalid favor mode. Expected `:normal`, `:ours`, `:theirs` or `:union`");
+		}
+	}
+
+	rb_value = rb_hash_aref(rb_options, CSTR2SYM("style"));
+	if (!NIL_P(rb_value)) {
+		ID id_style;
+
+		Check_Type(rb_value, T_SYMBOL);
+		id_style = SYM2ID(rb_value);
+
+		if (id_style == rb_intern("standard")) {
+			opts->flags |= GIT_MERGE_FILE_STYLE_MERGE;
+		} else if (id_style == rb_intern("diff3")) {
+			opts->flags |= GIT_MERGE_FILE_STYLE_DIFF3;
+		} else {
+			rb_raise(rb_eTypeError,
+				"Invalid style mode. Expected `:standard`, or `:diff3`");
+		}
+	} else {
+		opts->flags |= GIT_MERGE_FILE_STYLE_MERGE;
+	}
+
+	if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("simplify")))) {
+		opts->flags |= GIT_MERGE_FILE_SIMPLIFY_ALNUM;
+	}
+}
+
+VALUE rb_merge_file_result_fromC(const git_merge_file_result *result)
+{
+	VALUE rb_result = rb_hash_new();
+
+	rb_hash_aset(rb_result, CSTR2SYM("automergeable"), result->automergeable ? Qtrue : Qfalse);
+	rb_hash_aset(rb_result, CSTR2SYM("path"),          result->path ? rb_str_new_utf8(result->path) : Qnil);
+	rb_hash_aset(rb_result, CSTR2SYM("filemode"),      INT2FIX(result->mode));
+	rb_hash_aset(rb_result, CSTR2SYM("data"),          rb_str_new(result->ptr, result->len));
+
+	return rb_result;
+}
+
+static VALUE rb_git_path_is_dotgit_modules(VALUE self, VALUE rb_path)
+{
+	const char *path;
+	int is_dotgit;
+
+	Check_Type(rb_path, T_STRING);
+
+	path = StringValueCStr(rb_path);
+
+	is_dotgit = git_path_is_gitfile(path, strlen(path), GIT_PATH_GITFILE_GITMODULES, GIT_PATH_FS_GENERIC);
+
+	return is_dotgit ? Qtrue : Qfalse;
+}
+
+static VALUE rb_git_path_is_dotgit_ignore(VALUE self, VALUE rb_path)
+{
+	const char *path;
+	int is_dotgit;
+
+	Check_Type(rb_path, T_STRING);
+
+	path = StringValueCStr(rb_path);
+
+	is_dotgit = git_path_is_gitfile(path, strlen(path), GIT_PATH_GITFILE_GITIGNORE, GIT_PATH_FS_GENERIC);
+
+	return is_dotgit ? Qtrue : Qfalse;
+}
+
+static VALUE rb_git_path_is_dotgit_attributes(VALUE self, VALUE rb_path)
+{
+	const char *path;
+	int is_dotgit;
+
+	Check_Type(rb_path, T_STRING);
+
+	path = StringValueCStr(rb_path);
+
+	is_dotgit = git_path_is_gitfile(path, strlen(path), GIT_PATH_GITFILE_GITATTRIBUTES, GIT_PATH_FS_GENERIC);
+
+	return is_dotgit ? Qtrue : Qfalse;
+}
+
 void Init_rugged(void)
 {
 	rb_mRugged = rb_define_module("Rugged");
@@ -367,56 +567,94 @@ void Init_rugged(void)
 
 		rb_eRuggedError = rb_define_class_under(rb_mRugged, "Error", rb_eStandardError);
 
-		rb_eRuggedErrors[0] = rb_define_class_under(rb_mRugged, RUGGED_ERROR_NAMES[0], rb_eNoMemError);
-		rb_eRuggedErrors[1] = rb_define_class_under(rb_mRugged, RUGGED_ERROR_NAMES[1], rb_eIOError);
-		rb_eRuggedErrors[2] = rb_define_class_under(rb_mRugged, RUGGED_ERROR_NAMES[2], rb_eArgError);
+		rb_eRuggedErrors[0] = Qnil; /* 0 return value -- no exception */
+		rb_eRuggedErrors[1] = rb_define_class_under(rb_mRugged, RUGGED_ERROR_NAMES[1], rb_eNoMemError);
+		rb_eRuggedErrors[2] = rb_define_class_under(rb_mRugged, RUGGED_ERROR_NAMES[2], rb_eIOError);
+		rb_eRuggedErrors[3] = rb_define_class_under(rb_mRugged, RUGGED_ERROR_NAMES[3], rb_eArgError);
 
-		for (i = 3; i < RUGGED_ERROR_COUNT; ++i) {
+		for (i = 4; i < RUGGED_ERROR_COUNT; ++i) {
 			rb_eRuggedErrors[i] = rb_define_class_under(rb_mRugged, RUGGED_ERROR_NAMES[i], rb_eRuggedError);
 		}
 	}
 
 	rb_define_module_function(rb_mRugged, "libgit2_version", rb_git_libgit2_version, 0);
-	rb_define_module_function(rb_mRugged, "capabilities", rb_git_capabilities, 0);
+	rb_define_module_function(rb_mRugged, "features", rb_git_features, 0);
+	rb_define_module_function(rb_mRugged, "valid_full_oid?", rb_git_valid_full_oid, 1);
 	rb_define_module_function(rb_mRugged, "hex_to_raw", rb_git_hex_to_raw, 1);
 	rb_define_module_function(rb_mRugged, "raw_to_hex", rb_git_raw_to_hex, 1);
 	rb_define_module_function(rb_mRugged, "minimize_oid", rb_git_minimize_oid, -1);
-	rb_define_module_function(rb_mRugged, "prettify_message", rb_git_prettify_message, 2);
+	rb_define_module_function(rb_mRugged, "prettify_message", rb_git_prettify_message, -1);
 	rb_define_module_function(rb_mRugged, "__cache_usage__", rb_git_cache_usage, 0);
+	rb_define_module_function(rb_mRugged, "signature_from_buffer", rb_git_signature_from_buffer, -1);
+	rb_define_module_function(rb_mRugged, "dotgit_modules?", rb_git_path_is_dotgit_modules, 1);
+	rb_define_module_function(rb_mRugged, "dotgit_ignore?", rb_git_path_is_dotgit_ignore, 1);
+	rb_define_module_function(rb_mRugged, "dotgit_attributes?", rb_git_path_is_dotgit_attributes, 1);
+
+	Init_rugged_reference();
+	Init_rugged_reference_collection();
 
 	Init_rugged_object();
 	Init_rugged_commit();
 	Init_rugged_tree();
 	Init_rugged_tag();
+	Init_rugged_tag_collection();
 	Init_rugged_blob();
 
 	Init_rugged_index();
 	Init_rugged_repo();
 	Init_rugged_revwalk();
-	Init_rugged_reference();
 	Init_rugged_branch();
+	Init_rugged_branch_collection();
 	Init_rugged_config();
 	Init_rugged_remote();
+	Init_rugged_remote_collection();
 	Init_rugged_notes();
 	Init_rugged_settings();
+	Init_rugged_submodule();
+	Init_rugged_submodule_collection();
 	Init_rugged_diff();
-	Init_rugged_diff_patch();
+	Init_rugged_patch();
 	Init_rugged_diff_delta();
 	Init_rugged_diff_hunk();
 	Init_rugged_diff_line();
-
-	/* Constants */
-	rb_define_const(rb_mRugged, "SORT_NONE", INT2FIX(0));
-	rb_define_const(rb_mRugged, "SORT_TOPO", INT2FIX(1));
-	rb_define_const(rb_mRugged, "SORT_DATE", INT2FIX(2));
-	rb_define_const(rb_mRugged, "SORT_REVERSE", INT2FIX(4));
-
-	/* Initialize libgit2 */
-	git_threads_init();
+	Init_rugged_blame();
+	Init_rugged_cred();
+	Init_rugged_backend();
+	Init_rugged_rebase();
+
+	/*
+	 * Sort the output with the same default time-order method from git.
+	 * This is the default sorting for new walkers.
+	 */
+	rb_define_const(rb_mRugged, "SORT_NONE", INT2FIX(GIT_SORT_NONE));
+
+	/*
+	 * Sort the repository contents in topological order (parents before
+	 * children); this sorting mode can be combined with time sorting to
+	 * produce git's "time-order".
+	 */
+	rb_define_const(rb_mRugged, "SORT_TOPO", INT2FIX(GIT_SORT_TOPOLOGICAL));
+
+	/*
+	 * Sort the repository contents by commit time;
+	 * this sorting mode can be combined with
+	 * topological sorting.
+	 */
+	rb_define_const(rb_mRugged, "SORT_DATE", INT2FIX(GIT_SORT_TIME));
+
+	/*
+	 * Iterate through the repository contents in reverse
+	 * order; this sorting mode can be combined with
+	 * any of the above.
+	 */
+	rb_define_const(rb_mRugged, "SORT_REVERSE", INT2FIX(GIT_SORT_REVERSE));
+
+	/* Set the allocator and initialize libgit2 */
+	rugged_set_allocator();
+	git_libgit2_init();
 
 	/* Hook a global object to cleanup the library
 	 * on shutdown */
 	rb_mShutdownHook = Data_Wrap_Struct(rb_cObject, NULL, &cleanup_cb, NULL);
 	rb_global_variable(&rb_mShutdownHook);
 }
-