rugged 0.21.0 → 0.21.1b0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b0356879d784d17079ccdae0dfef24d5841c0774
-  data.tar.gz: 2a4d772157bcc8b25f61a7745d1694507bc56ca4
+  metadata.gz: 71c12ca95964095a5400cc76eeb9b98c1c116a69
+  data.tar.gz: 752fefe7898903eeeef4139198eb6a719b044059
 SHA512:
-  metadata.gz: d6f0d49db816f5337decf934efda9529ddbf8beaf6edfa72737f661e7b5759afd7b4f27f21734de0098e101bc7b714b90aad674c450344d7cd7865de5fe73e3b
-  data.tar.gz: cf7dca7617881507c212c4c813bd41494d31ed1c3d8579092dc138a5b449d89af5264c9b673cf938f39a8781c000c768bcf498bd82136afb167e950d617b88bc
+  metadata.gz: 4b16dedcf38b935c0d7a17c3b4c34c11f3280dafc6247f6b8ce88fa81e1f66696b3e2ae695405f75e3f8cc9c45eeff8017375156b6328fc3c8f285d31f3d1043
+  data.tar.gz: 3b0f3d1bc1f12cf4f8f65cafc7ea4028239787225e0b04aa5e9476e85171dcf5ed0e1621b03eb070fa2273d3c7a5307932a82602b5cc2e76972b5fd54af676cd

data/README.md

@@ -17,7 +17,12 @@ Rugged is a self-contained gem. You can install it by running:
 
     $ gem install rugged
 
-You need to have CMake installed on your system to be able to build the included version of `libgit2`. If you want to build Rugged with HTTPS and SSH support, check out the list of optional [libgit2 dependencies](https://github.com/libgit2/libgit2#optional-dependencies).
+You need to have CMake and `pkg-config` installed on your system to be able to build the included version of `libgit2`. On OS X, after installing [Homebrew](http://brew.sh/), you can get CMake with:
+```bash
+$ brew install cmake
+```
+
+If you want to build Rugged with HTTPS and SSH support, check out the list of optional [libgit2 dependencies](https://github.com/libgit2/libgit2#optional-dependencies).
 
 If you're using bundler and want to bundle `libgit2` with Rugged, you can use the `:submodules` option:
 
@@ -96,7 +101,7 @@ repo.bare?
 # => false
 repo.empty?
 # => true
-repo.head_orphan?
+repo.head_unborn?
 # => false
 repo.head_detached?
 # => false
@@ -109,13 +114,15 @@ repo.workdir
 
 # The HEAD of the repository.
 ref = repo.head
-# => #<Rugged::Reference:2228467240 {name: "refs/heads/master", target: "07b44cbda23b726e5d54e2ef383495922c024202"}>
+# => #<Rugged::Reference:2228467240 {name: "refs/heads/master", target:  #<Rugged::Commit:2228467250 {message: "helpful message", tree: #<Rugged::Tree:2228467260 {oid: 5d6f29220a0783b8085134df14ec4d960b6c3bf2}>}>
 
-# From the returned ref, you can also access the `name` and `target`:
+# From the returned ref, you can also access the `name`, `target`, and target SHA:
 ref.name
 # => "refs/heads/master"
 ref.target
-# => "07b44cbda23b726e5d54e2ef383495922c024202"
+# => #<Rugged::Commit:2228467250 {message: "helpful message", tree: #<Rugged::Tree:2228467260 {oid: 5d6f29220a0783b8085134df14ec4d960b6c3bf2}>}>
+ref.target_id
+# => "2bc6a70483369f33f641ca44873497f13a15cde5"
 
 # Reading an object
 object = repo.read('a0ae5566e3c8a3bddffab21022056f0b5e03ef07')

data/ext/rugged/extconf.rb

@@ -15,18 +15,10 @@ def sys(cmd)
   ret
 end
 
-if !find_executable('cmake')
-  abort "ERROR: CMake is required to build Rugged."
-end
-
 if !(MAKE = find_executable('gmake') || find_executable('make'))
   abort "ERROR: GNU make is required to build Rugged."
 end
 
-if !find_executable('pkg-config')
-  abort "ERROR: pkg-config is required to build Rugged."
-end
-
 if arg_config("--use-system-libraries", !!ENV['RUGGED_USE_SYSTEM_LIBRARIES'])
   puts "Building Rugged using system libraries.\n"
 
@@ -40,6 +32,14 @@ if arg_config("--use-system-libraries", !!ENV['RUGGED_USE_SYSTEM_LIBRARIES'])
 #endif
   SRC
 else
+  if !find_executable('cmake')
+    abort "ERROR: CMake is required to build Rugged."
+  end
+
+  if !find_executable('pkg-config')
+    abort "ERROR: pkg-config is required to build Rugged."
+  end
+
   CWD = File.expand_path(File.dirname(__FILE__))
   LIBGIT2_DIR = File.join(CWD, '..', '..', 'vendor', 'libgit2')
 

data/ext/rugged/rugged.h

@@ -120,7 +120,7 @@ static inline VALUE rugged_owner(VALUE object)
 static inline void rugged_validate_remote_url(VALUE rb_url)
 {
 	Check_Type(rb_url, T_STRING);
-	if (!git_remote_valid_url(StringValueCStr(rb_url)))
+	if (!git_remote_supported_url(StringValueCStr(rb_url)))
 		rb_raise(rb_eArgError, "Invalid URL format");
 }
 

data/ext/rugged/rugged_cred.c

@@ -88,19 +88,42 @@ static void rugged_cred_extract_default(git_cred **cred, VALUE rb_credential)
 	rugged_exception_check(git_cred_default_new(cred));
 }
 
+static void rugged_cred_extract_username(git_cred **cred, VALUE rb_credential)
+{
+	VALUE rb_username = rb_iv_get(rb_credential, "@username");
+	Check_Type(rb_username, T_STRING);
+
+	rugged_exception_check(git_cred_username_new(cred, StringValueCStr(rb_username)));
+}
+
 void rugged_cred_extract(git_cred **cred, int allowed_types, VALUE rb_credential)
 {
 	if (rb_obj_is_kind_of(rb_credential, rb_cRuggedCredUserPassword)) {
+		if (allowed_types & GIT_CREDTYPE_USERNAME) {
+			rugged_cred_extract_username(cred, rb_credential);
+			return;
+		}
+
 		if (!(allowed_types & GIT_CREDTYPE_USERPASS_PLAINTEXT))
 			rb_raise(rb_eArgError, "Invalid credential type");
 
 		rugged_cred_extract_userpass(cred, rb_credential);
 	} else if (rb_obj_is_kind_of(rb_credential, rb_cRuggedCredSshKey)) {
+		if (allowed_types & GIT_CREDTYPE_USERNAME) {
+			rugged_cred_extract_username(cred, rb_credential);
+			return;
+		}
+
 		if (!(allowed_types & GIT_CREDTYPE_SSH_KEY))
 			rb_raise(rb_eArgError, "Invalid credential type");
 
 		rugged_cred_extract_ssh_key(cred, rb_credential);
 	} else if (rb_obj_is_kind_of(rb_credential, rb_cRuggedCredSshKeyFromAgent)) {
+		if (allowed_types & GIT_CREDTYPE_USERNAME) {
+			rugged_cred_extract_username(cred, rb_credential);
+			return;
+		}
+
 		if (!(allowed_types & GIT_CREDTYPE_SSH_KEY))
 			rb_raise(rb_eArgError, "Invalid credential type");
 

data/ext/rugged/rugged_index.c

@@ -681,6 +681,10 @@ static VALUE rb_git_index_readtree(VALUE self, VALUE rb_tree)
 	Data_Get_Struct(self, git_index, index);
 	Data_Get_Struct(rb_tree, git_tree, tree);
 
+	if (!rb_obj_is_kind_of(rb_tree, rb_cRuggedTree)) {
+		rb_raise(rb_eTypeError, "A Rugged::Tree instance is required");
+	}
+
 	error = git_index_read_tree(index, tree);
 	rugged_exception_check(error);
 
@@ -831,7 +835,7 @@ static VALUE rb_git_index_diff(int argc, VALUE *argv, VALUE self)
 	xfree(opts.pathspec.strings);
 	rugged_exception_check(error);
 
-	return rugged_diff_new(rb_cRuggedDiff, self, diff);
+	return rugged_diff_new(rb_cRuggedDiff, owner, diff);
 }
 
 /*

data/ext/rugged/rugged_remote.c

@@ -535,6 +535,73 @@ static VALUE rb_git_remote_rename(VALUE self, VALUE rb_new_name)
 	return rb_result;
 }
 
+/*
+ *  call-seq:
+ *    remote.check_connection(direction, options = {}) -> boolean
+ *
+ *  Try to connect to the +remote+. Useful to simulate
+ *  <tt>git fetch --dry-run</tt> and <tt>git push --dry-run</tt>.
+ *
+ *  Returns +true+ if connection is successful, +false+ otherwise.
+ *
+ *  +direction+ must be either +:fetch+ or +:push+.
+ *
+ *  The following options can be passed in the +options+ Hash:
+ *
+ *  +credentials+ ::
+ *    The credentials to use for the connection. Can be either an instance of
+ *    one of the Rugged::Credentials types, or a proc returning one of the
+ *    former.
+ *    The proc will be called with the +url+, the +username+ from the url (if
+ *    applicable) and a list of applicable credential types.
+ *
+ *  Example:
+ *
+ *    remote = repo.remotes["origin"]
+ *    success = remote.check_connection(:fetch)
+ *    raise Error("Unable to pull without credentials") unless success
+ */
+static VALUE rb_git_remote_check_connection(int argc, VALUE *argv, VALUE self)
+{
+	git_remote *remote;
+	git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
+	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, 0 };
+	VALUE rb_direction, rb_options;
+	ID id_direction;
+	int error, direction;
+
+	Data_Get_Struct(self, git_remote, remote);
+	rb_scan_args(argc, argv, "01:", &rb_direction, &rb_options);
+
+	Check_Type(rb_direction, T_SYMBOL);
+	id_direction = SYM2ID(rb_direction);
+	if (id_direction == rb_intern("fetch"))
+		direction = GIT_DIRECTION_FETCH;
+	else if (id_direction == rb_intern("push"))
+		direction = GIT_DIRECTION_PUSH;
+	else
+		rb_raise(rb_eTypeError, "Invalid direction. Expected :fetch or :push");
+
+	if (!NIL_P(rb_options))
+		rugged_remote_init_callbacks_and_payload_from_options(rb_options, &callbacks, &payload);
+
+	if ((error = git_remote_set_callbacks(remote, &callbacks)) < 0)
+		goto cleanup;
+
+	if (git_remote_connect(remote, direction))
+		return Qfalse;
+	else {
+		git_remote_disconnect(remote);
+		return Qtrue;
+	}
+
+cleanup:
+	if (payload.exception)
+		rb_jump_tag(payload.exception);
+	rugged_exception_check(error);
+	return Qfalse;
+}
+
 /*
  *  call-seq:
  *    remote.fetch(refspecs = nil, options = {}) -> hash
@@ -827,6 +894,7 @@ void Init_rugged_remote(void)
 	rb_define_method(rb_cRuggedRemote, "add_fetch", rb_git_remote_add_fetch, 1);
 	rb_define_method(rb_cRuggedRemote, "add_push", rb_git_remote_add_push, 1);
 	rb_define_method(rb_cRuggedRemote, "ls", rb_git_remote_ls, -1);
+	rb_define_method(rb_cRuggedRemote, "check_connection", rb_git_remote_check_connection, -1);
 	rb_define_method(rb_cRuggedRemote, "fetch", rb_git_remote_fetch, -1);
 	rb_define_method(rb_cRuggedRemote, "push", rb_git_remote_push, -1);
 	rb_define_method(rb_cRuggedRemote, "clear_refspecs", rb_git_remote_clear_refspecs, 0);

data/ext/rugged/rugged_repo.c

@@ -643,9 +643,10 @@ static VALUE rb_git_repo_merge_commits(int argc, VALUE *argv, VALUE self)
  *    repo.exists?(oid) -> true or false
  *
  *  Return whether an object with the given SHA1 OID (represented as
- *  a 40-character string) exists in the repository.
+ *  a hex string of at least 7 characters) exists in the repository.
  *
  *    repo.include?("d8786bfc97485e8d7b19b21fb88c8ef1f199fc3f") #=> true
+ *    repo.include?("d8786bfc") #=> true
  */
 static VALUE rb_git_repo_exists(VALUE self, VALUE hex)
 {
@@ -653,21 +654,23 @@ static VALUE rb_git_repo_exists(VALUE self, VALUE hex)
 	git_odb *odb;
 	git_oid oid;
 	int error;
-	VALUE rb_result;
 
 	Data_Get_Struct(self, git_repository, repo);
 	Check_Type(hex, T_STRING);
 
-	error = git_oid_fromstr(&oid, StringValueCStr(hex));
+	error = git_oid_fromstrn(&oid, RSTRING_PTR(hex), RSTRING_LEN(hex));
 	rugged_exception_check(error);
 
 	error = git_repository_odb(&odb, repo);
 	rugged_exception_check(error);
 
-	rb_result = git_odb_exists(odb, &oid) ? Qtrue : Qfalse;
+	error = git_odb_exists_prefix(NULL, odb, &oid, RSTRING_LEN(hex));
 	git_odb_free(odb);
 
-	return rb_result;
+	if (error == 0 || error == GIT_EAMBIGUOUS)
+		return Qtrue;
+
+	return Qfalse;
 }
 
 /*
@@ -736,6 +739,107 @@ static VALUE rb_git_repo_read_header(VALUE self, VALUE hex)
 	return rb_hash;
 }
 
+/**
+ *  call-seq:
+ *    repo.expand_oids([oid..], object_type = :any) -> hash
+ *
+ *  Expand a list of short oids to their full value, assuming they exist
+ *  in the repository. If `object_type` is passed, OIDs are expected to be
+ *  of the given type.
+ *
+ *  Returns a hash of `{ short_oid => full_oid }` for the short OIDs which
+ *  exist in the repository and match the expected object type. Missing OIDs
+ *  will not appear in the resulting hash.
+ */
+static VALUE rb_git_repo_expand_oids(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_result, rb_oids, rb_expected_type;
+
+	git_otype expected_type = GIT_OBJ_ANY;
+
+	git_repository *repo;
+	git_oid oid;
+	git_odb *odb;
+	int i, error;
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	rb_scan_args(argc, argv, "11", &rb_oids, &rb_expected_type);
+
+	Check_Type(rb_oids, T_ARRAY);
+	expected_type = rugged_otype_get(rb_expected_type);
+
+	error = git_repository_odb(&odb, repo);
+	rugged_exception_check(error);
+
+	rb_result = rb_hash_new();
+
+	for (i = 0; i < RARRAY_LEN(rb_oids); ++i) {
+		VALUE hex_oid = rb_ary_entry(rb_oids, i);
+		git_oid found_oid;
+
+		if (TYPE(hex_oid) != T_STRING) {
+			git_odb_free(odb);
+			rb_raise(rb_eTypeError, "Expected a SHA1 OID");
+		}
+
+		error = git_oid_fromstrn(&oid, RSTRING_PTR(hex_oid), RSTRING_LEN(hex_oid));
+		if (error < 0) {
+			git_odb_free(odb);
+			rugged_exception_check(error);
+		}
+
+		error = git_odb_exists_prefix(&found_oid, odb, &oid, RSTRING_LEN(hex_oid));
+
+		if (!error) {
+			if (expected_type != GIT_OBJ_ANY) {
+				size_t found_size;
+				git_otype found_type;
+
+				if (git_odb_read_header(&found_size, &found_type, odb, &found_oid) < 0)
+					continue;
+
+				if (found_type != expected_type)
+					continue;
+			}
+
+			rb_hash_aset(rb_result, hex_oid, rugged_create_oid(&found_oid));
+		}
+	}
+
+	git_odb_free(odb);
+	return rb_result;
+}
+
+/*
+ *  call-seq:
+ *    repo.descendant_of?(commit, ancestor) -> true or false
+ *
+ *  +commit+ and +ancestor+ must be String commit OIDs or instances of Rugged::Commit.
+ *
+ *  Returns true if +commit+ is a descendant of +ancestor+, or false if not.
+ */
+static VALUE rb_git_repo_descendant_of(VALUE self, VALUE rb_commit, VALUE rb_ancestor)
+{
+	int result;
+	int error;
+	git_repository *repo;
+	git_oid commit, ancestor;
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	error = rugged_oid_get(&commit, repo, rb_commit);
+	rugged_exception_check(error);
+
+	error = rugged_oid_get(&ancestor, repo, rb_ancestor);
+	rugged_exception_check(error);
+
+	result = git_graph_descendant_of(repo, &commit, &ancestor);
+	rugged_exception_check(result);
+
+	return result ? Qtrue : Qfalse;
+}
+
 /*
  *  call-seq:
  *    Repository.hash_data(str, type) -> oid
@@ -1924,6 +2028,179 @@ static VALUE rb_git_repo_is_path_ignored(VALUE self, VALUE rb_path) {
 	return ignored ? Qtrue : Qfalse;
 }
 
+static void rugged_parse_cherrypick_options(git_cherrypick_options *opts, VALUE rb_options)
+{
+	VALUE rb_value;
+
+	if (NIL_P(rb_options))
+		return;
+
+	Check_Type(rb_options, T_HASH);
+
+	rb_value = rb_hash_aref(rb_options, CSTR2SYM("mainline"));
+	if (!NIL_P(rb_value)) {
+		opts->mainline = FIX2UINT(rb_value);
+	}
+}
+
+static VALUE rugged_create_attr(const char *attr)
+{
+	switch (git_attr_value(attr)) {
+	case GIT_ATTR_TRUE_T:
+		return Qtrue;
+
+	case GIT_ATTR_FALSE_T:
+		return Qfalse;
+
+	case GIT_ATTR_VALUE_T:
+		return rb_str_new2(attr);
+
+	case GIT_ATTR_UNSPECIFIED_T:
+	default:
+		return Qnil;
+	}
+}
+
+static int foreach_attr_hash(const char *name, const char *value, void *payload)
+{
+	VALUE rb_hash = (VALUE)payload;
+	rb_hash_aset(rb_hash, rb_str_new2(name), rugged_create_attr(value));
+	return 0;
+}
+
+static VALUE rb_git_repo_attributes(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_path, rb_names, rb_options;
+
+	git_repository *repo;
+	int error, options = 0;
+
+	rb_scan_args(argc, argv, "12", &rb_path, &rb_names, &rb_options);
+
+	Data_Get_Struct(self, git_repository, repo);
+	Check_Type(rb_path, T_STRING);
+
+	if (!NIL_P(rb_options)) {
+		Check_Type(rb_options, T_FIXNUM);
+		options = FIX2INT(rb_options);
+	}
+
+	switch (TYPE(rb_names)) {
+	case T_ARRAY:
+	{
+		VALUE rb_result;
+		const char **values;
+		const char **names;
+		int i, num_attr = RARRAY_LEN(rb_names);
+
+		if (num_attr > 32)
+			rb_raise(rb_eRuntimeError, "Too many attributes requested");
+
+		values = alloca(num_attr * sizeof(const char *));
+		names = alloca(num_attr * sizeof(const char *));
+
+		for (i = 0; i < num_attr; ++i) {
+			VALUE attr = rb_ary_entry(rb_names, i);
+			Check_Type(attr, T_STRING);
+			names[i] = StringValueCStr(attr);
+		}
+
+		error = git_attr_get_many(
+			values, repo, options,
+			StringValueCStr(rb_path),
+			(size_t)num_attr, names);
+
+		rugged_exception_check(error);
+
+		rb_result = rb_hash_new();
+		for (i = 0; i < num_attr; ++i) {
+			VALUE attr = rb_ary_entry(rb_names, i);
+			rb_hash_aset(rb_result, attr, rugged_create_attr(values[i]));
+		}
+		return rb_result;
+	}
+
+	case T_STRING:
+	{
+		const char *value;
+
+		error = git_attr_get(
+			&value, repo, options,
+			StringValueCStr(rb_path),
+			StringValueCStr(rb_names));
+
+		rugged_exception_check(error);
+
+		return rugged_create_attr(value);
+	}
+
+	case T_NIL:
+	{
+		VALUE rb_result = rb_hash_new();
+
+		error = git_attr_foreach(
+			repo, options,
+			StringValueCStr(rb_path),
+			&foreach_attr_hash,
+			(void *)rb_result);
+
+		rugged_exception_check(error);
+		return rb_result;
+	}
+
+	default:
+		rb_raise(rb_eTypeError,
+			"Invalid attribute name (expected String or Array)");
+	}
+}
+
+/*
+ *  call-seq:
+ *    repo.cherrypick(commit[, options]) -> nil
+ *
+ *  Cherry-pick the given commit and update the index and working
+ *  directory accordingly.
+ *
+ *  `commit` can be either a string containing a commit id or a
+ *  `Rugged::Commit` object.
+ *
+ *  The following options can be passed in the +options+ Hash:
+ *
+ *  :mainline ::
+ *    When cherry-picking a merge, you need to specify the parent number
+ *    (starting from 1) which should be considered the mainline.
+ */
+static VALUE rb_git_repo_cherrypick(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_options, rb_commit;
+
+	git_repository *repo;
+	git_commit *commit;
+	git_cherrypick_options opts = GIT_CHERRYPICK_OPTIONS_INIT;
+
+	int error;
+
+	rb_scan_args(argc, argv, "10:", &rb_commit, &rb_options);
+
+	if (TYPE(rb_commit) == T_STRING) {
+		rb_commit = rugged_object_rev_parse(self, rb_commit, 1);
+	}
+
+	if (!rb_obj_is_kind_of(rb_commit, rb_cRuggedCommit)) {
+		rb_raise(rb_eArgError, "Expected a Rugged::Commit.");
+	}
+
+	Data_Get_Struct(self, git_repository, repo);
+	Data_Get_Struct(rb_commit, git_commit, commit);
+
+	rugged_parse_cherrypick_options(&opts, rb_options);
+
+	error = git_cherrypick(repo, commit, &opts);
+	rugged_exception_check(error);
+
+	return Qnil;
+}
+
 void Init_rugged_repo(void)
 {
 	id_call = rb_intern("call");
@@ -1942,6 +2219,8 @@ void Init_rugged_repo(void)
 
 	rb_define_method(rb_cRuggedRepo, "exists?", rb_git_repo_exists, 1);
 	rb_define_method(rb_cRuggedRepo, "include?", rb_git_repo_exists, 1);
+	rb_define_method(rb_cRuggedRepo, "expand_oids", rb_git_repo_expand_oids, -1);
+	rb_define_method(rb_cRuggedRepo, "descendant_of?", rb_git_repo_descendant_of, 2);
 
 	rb_define_method(rb_cRuggedRepo, "read",   rb_git_repo_read,   1);
 	rb_define_method(rb_cRuggedRepo, "read_header",   rb_git_repo_read_header,   1);
@@ -1986,6 +2265,9 @@ void Init_rugged_repo(void)
 	rb_define_method(rb_cRuggedRepo, "checkout_tree", rb_git_checkout_tree, -1);
 	rb_define_method(rb_cRuggedRepo, "checkout_head", rb_git_checkout_head, -1);
 
+	rb_define_method(rb_cRuggedRepo, "cherrypick", rb_git_repo_cherrypick, -1);
+	rb_define_method(rb_cRuggedRepo, "fetch_attributes", rb_git_repo_attributes, -1);
+
 	rb_cRuggedOdbObject = rb_define_class_under(rb_mRugged, "OdbObject", rb_cObject);
 	rb_define_method(rb_cRuggedOdbObject, "data",  rb_git_odbobj_data,  0);
 	rb_define_method(rb_cRuggedOdbObject, "len",  rb_git_odbobj_size,  0);