rugged 0.17.0.b6 → 0.17.0.b7

data/README.md

@@ -126,7 +126,7 @@ these methods should be useful in their derived classes.
 ```ruby
 obj = repo.lookup(sha)
 obj.oid  # object sha
-obj.type [OBJ_COMMIT, OBJ_TREE, OBJ_BLOB, OBJ_TAG]
+obj.type # One of :commit, :tree, :blob or :tag
 
 robj = obj.read_raw
 str  = robj.data
@@ -196,7 +196,7 @@ tree.count
 tree[0]           # or...
 tree.first        # or...
 tree.get_entry(0)
-# => {:type=>:blob, :oid=>"99e7edb53db9355f10c6f2dfaa5a183f205d93bf", :attributes=>33188, :name=>".gitignore"}
+# => {:type=>:blob, :oid=>"99e7edb53db9355f10c6f2dfaa5a183f205d93bf", :filemode=>33188, :name=>".gitignore"}
 ```
 
 The tree object is an Enumerable, so you can also do stuff like this:
@@ -219,7 +219,7 @@ You can also write trees with the `TreeBuilder`:
 entry = {:type => :blob,
          :name => "README.txt",
          :oid  => "1385f264afb75a56a5bec74243be9b367ba4ca08",
-         :attributes => 33188}
+         :filemode => 33188}
 
 builder = Rugged::Tree::Builder.new
 builder << entry

data/Rakefile

@@ -16,7 +16,9 @@ end
 
 desc "checkout libgit2 source"
 task :checkout do
-  sh "git submodule update --init"
+  if !ENV['LIBGIT2_DEV']
+    sh "git submodule update --init"
+  end
 end
 Rake::Task[:compile].prerequisites.insert(0, :checkout)
 

data/ext/rugged/rugged.c

@@ -96,6 +96,34 @@ static VALUE rb_git_raw_to_hex(VALUE self, VALUE raw)
 	return rugged_str_new(out, 40, NULL);
 }
 
+/*
+ *	call-seq:
+ *		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)
+{
+	char *message;
+	int strip_comments, message_len;
+	VALUE result;
+
+	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);
+
+	message_len = git_message_prettify(message, message_len, StringValueCStr(rb_message), strip_comments);
+	rugged_exception_check(message_len);
+
+	result = rugged_str_new(message, message_len - 1, rb_utf8_encoding());
+	xfree(message);
+
+	return result;
+}
+
 static VALUE minimize_cb(VALUE rb_oid, git_oid_shorten *shortener)
 {
 	Check_Type(rb_oid, T_STRING);
@@ -232,6 +260,7 @@ void Init_rugged()
 	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);
 
 	Init_rugged_object();
 	Init_rugged_commit();
@@ -243,6 +272,7 @@ void Init_rugged()
 	Init_rugged_repo();
 	Init_rugged_revwalk();
 	Init_rugged_reference();
+	Init_rugged_branch();
 	Init_rugged_config();
 	Init_rugged_remote();
 

data/ext/rugged/rugged.h

@@ -46,6 +46,7 @@
  * Initialization functions
  */
 void Init_rugged_object();
+void Init_rugged_branch();
 void Init_rugged_commit();
 void Init_rugged_tree();
 void Init_rugged_tag();
@@ -66,6 +67,7 @@ VALUE rugged_signature_new(const git_signature *sig, const char *encoding_name);
 VALUE rugged_index_new(VALUE klass, VALUE owner, git_index *index);
 VALUE rugged_object_new(VALUE owner, git_object *object);
 VALUE rugged_config_new(VALUE klass, VALUE owner, git_config *cfg);
+VALUE rugged_ref_new(VALUE klass, VALUE owner, git_reference *ref);
 
 VALUE rugged_otype_new(git_otype t);
 git_otype rugged_otype_get(VALUE rb_type);
@@ -118,4 +120,11 @@ static inline VALUE rugged_create_oid(const git_oid *oid)
 	return rugged_str_new(out, 40, NULL);
 }
 
+#define RUGGED_UNPACK_REFERENCE(_rb_obj, _rugged_obj) {\
+	if (DATA_PTR(_rb_obj) == NULL)\
+		rb_raise(rb_eRuntimeError,\
+			"This Git Reference has been deleted and no longer exists on the repository");\
+	Data_Get_Struct(_rb_obj, git_reference, _rugged_obj);\
+}
+
 #endif

data/ext/rugged/rugged_branch.c

@@ -0,0 +1,306 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2012 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.
+ */
+
+#include "rugged.h"
+
+extern VALUE rb_mRugged;
+extern VALUE rb_cRuggedRepo;
+extern VALUE rb_cRuggedObject;
+extern VALUE rb_cRuggedReference;
+VALUE rb_cRuggedBranch;
+
+static inline VALUE rugged_branch_new(VALUE owner, git_reference *ref)
+{
+	return rugged_ref_new(rb_cRuggedBranch, owner, ref);
+}
+
+static int parse_branch_type(VALUE rb_filter)
+{
+	ID id_filter;
+
+	Check_Type(rb_filter, T_SYMBOL);
+	id_filter = SYM2ID(rb_filter);
+
+	if (id_filter == rb_intern("local")) {
+		return GIT_BRANCH_LOCAL;
+	} else if (id_filter == rb_intern("remote")) {
+		return GIT_BRANCH_REMOTE;
+	} else {
+		rb_raise(rb_eTypeError,
+			"Invalid branch filter. Expected `:remote`, `:local` or `nil`");
+	}
+}
+
+/*
+ *	call-seq:
+ *		Branch.create(repository, name, target, force = false) -> branch
+ *
+ *	Create a new branch in +repository+, with the given +name+, and pointing
+ *	to the +target+.
+ *
+ *	+name+ needs to be a branch name, not an absolute reference path
+ *	(e.g. 'development' instead of '/refs/heads/development')
+ *
+ *	+target+ needs to be an existing object (of any type) in the given +repository+.
+ *
+ *	If +force+ is +true+, any existing branches will be overwritten.
+ *
+ *	Returns a Rugged::Branch object with the newly created branch.
+ */
+static VALUE rb_git_branch_create(int argc, VALUE *argv, VALUE self)
+{
+	git_reference *branch;
+	git_object *target = NULL;
+	git_repository *repo = NULL;
+	int error, force = 0;
+
+	VALUE rb_repo, rb_name, rb_target, rb_force;
+
+	rb_scan_args(argc, argv, "31", &rb_repo, &rb_name, &rb_target, &rb_force);
+
+	if (!rb_obj_is_kind_of(rb_repo, rb_cRuggedRepo)) {
+		rb_raise(rb_eTypeError, "Expecting a Rugged::Repository instance");
+	}
+
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	Check_Type(rb_name, T_STRING);
+
+	target = rugged_object_load(repo, rb_target, GIT_OBJ_ANY);
+
+	if (!NIL_P(rb_force)) {
+		force = rugged_parse_bool(rb_force);
+	}
+
+	error = git_branch_create(&branch, repo, StringValueCStr(rb_name), target, force);
+	git_object_free(target);
+
+	rugged_exception_check(error);
+
+	return rugged_branch_new(rb_repo, branch);
+}
+
+/*
+ *	call-seq:
+ *		Branch.lookup(repository, name, branch_type = :local) -> branch
+ *
+ *	Lookup a branch in +repository+, with the given +name+.
+ *
+ *	+name+ needs to be a branch name, not an absolute reference path
+ *	(e.g. 'development' instead of '/refs/heads/development')
+ *
+ *	+branch_type+ specifies whether the looked up branch is a local branch
+ *	or a remote one. It defaults to looking up local branches.
+ *
+ *	Returns the looked up branch, or +nil+ if the branch doesn't exist.
+ */
+static VALUE rb_git_branch_lookup(int argc, VALUE *argv, VALUE self)
+{
+	git_reference *branch;
+	git_repository *repo;
+
+	VALUE rb_repo, rb_name, rb_type;
+	int error;
+	int branch_type = GIT_BRANCH_LOCAL;
+
+	rb_scan_args(argc, argv, "21", &rb_repo, &rb_name, &rb_type);
+
+	if (!rb_obj_is_kind_of(rb_repo, rb_cRuggedRepo)) {
+		rb_raise(rb_eTypeError, "Expecting a Rugged::Repository instance");
+	}
+
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	Check_Type(rb_name, T_STRING);
+	
+	if (!NIL_P(rb_type))
+		branch_type = parse_branch_type(rb_type);
+
+	error = git_branch_lookup(&branch, repo, StringValueCStr(rb_name), branch_type);
+	if (error == GIT_ENOTFOUND)
+		return Qnil;
+
+	rugged_exception_check(error);
+
+	return rugged_branch_new(rb_repo, branch);
+}
+
+/*
+ *	call-seq:
+ *		branch.delete!
+ *
+ *	Remove a branch from the repository. The branch object will become invalidated
+ *	and won't be able to be used for any other operations.
+ */
+static VALUE rb_git_branch_delete(VALUE self)
+{
+	git_reference *branch = NULL;
+
+	RUGGED_UNPACK_REFERENCE(self, branch);
+
+	rugged_exception_check(
+		git_branch_delete(branch)
+	);
+
+	DATA_PTR(self) = NULL; /* this reference has been free'd */
+	rugged_set_owner(self, Qnil); /* and is no longer owned */
+	return Qnil;
+}
+
+static int cb_branch__each_name(const char *branch_name, git_branch_t branch_type, void *payload)
+{
+	rb_yield(rugged_str_new2(branch_name, rb_utf8_encoding()));
+	return GIT_OK;
+}
+
+static int cb_branch__each_obj(const char *branch_name, git_branch_t branch_type, void *payload)
+{
+	VALUE rb_repo = (VALUE)payload;
+
+	git_reference *branch;
+	git_repository *repo;
+
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	rugged_exception_check(
+		git_branch_lookup(&branch, repo, branch_name, branch_type)
+	);
+
+	rb_yield(rugged_branch_new(rb_repo, branch));
+	return GIT_OK;
+}
+
+static VALUE each_branch(int argc, VALUE *argv, VALUE self, int branch_names_only)
+{
+	VALUE rb_repo, rb_filter;
+	git_repository *repo;
+	int error;
+	int filter = (GIT_BRANCH_LOCAL | GIT_BRANCH_REMOTE);
+
+	rb_scan_args(argc, argv, "11", &rb_repo, &rb_filter);
+
+	if (!rb_block_given_p()) {
+		VALUE symbol = branch_names_only ? CSTR2SYM("each_name") : CSTR2SYM("each");
+		return rb_funcall(self, rb_intern("to_enum"), 3, symbol, rb_repo, rb_filter);
+	}
+
+	if (!rb_obj_is_kind_of(rb_repo, rb_cRuggedRepo)) {
+		rb_raise(rb_eTypeError, "Expecting a Rugged::Repository instance");
+	}
+
+	if (!NIL_P(rb_filter))
+		filter = parse_branch_type(rb_filter);
+
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	if (branch_names_only) {
+		error = git_branch_foreach(repo, filter, &cb_branch__each_name, NULL);
+	} else {
+		error = git_branch_foreach(repo, filter, &cb_branch__each_obj, (void *)rb_repo);
+	}
+
+	rugged_exception_check(error);
+	return Qnil;
+}
+
+/*
+ *	call-seq:
+ *		Branch.each_name(repository, filter = :all) { |branch_name| block }
+ *		Branch.each_name(repository, filter = :all) -> Iterator
+ *
+ *	Iterate through the names of the branches in +repository+. Iteration can be
+ *	optionally filtered to yield only +:local+ or +:remote+ branches.
+ *
+ *	The given block will be called once with the name of each branch as a +String+.
+ *	If no block is given, an iterator will be returned.
+ */
+static VALUE rb_git_branch_each_name(int argc, VALUE *argv, VALUE self)
+{
+	return each_branch(argc, argv, self, 1);
+}
+
+
+/*
+ *	call-seq:
+ *		Branch.each(repository, filter = :all) { |branch| block }
+ *		Branch.each(repository, filter = :all) -> Iterator
+ *
+ *	Iterate through the branches in +repository+. Iteration can be
+ *	optionally filtered to yield only +:local+ or +:remote+ branches.
+ *
+ *	The given block will be called once with a +Rugged::Branch+ object
+ *	for each branch in the repository. If no block is given, an iterator
+ *	will be returned.
+ */
+static VALUE rb_git_branch_each(int argc, VALUE *argv, VALUE self)
+{
+	return each_branch(argc, argv, self, 0);
+}
+
+/*
+ *	call-seq:
+ *		branch.move(new_name, force = false)
+ *		branch.rename(new_name, force = false)
+ *
+ *	Rename a branch to +new_name+.
+ *
+ *	+new_name+ needs to be a branch name, not an absolute reference path
+ *	(e.g. 'development' instead of '/refs/heads/development')
+ *
+ *	If +force+ is +true+, the branch will be renamed even if a branch
+ *	with +new_name+ already exists.
+ */
+static VALUE rb_git_branch_move(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_new_branch_name, rb_force;
+	git_reference *old_branch = NULL;
+	int error, force = 0;
+
+	rb_scan_args(argc, argv, "11", &rb_new_branch_name, &rb_force);
+
+	RUGGED_UNPACK_REFERENCE(self, old_branch);
+	Check_Type(rb_new_branch_name, T_STRING);
+
+	if (!NIL_P(rb_force))
+		force = rugged_parse_bool(rb_force);
+
+	error = git_branch_move(old_branch, StringValueCStr(rb_new_branch_name), force);
+	rugged_exception_check(error);
+
+	return Qnil;
+}
+
+void Init_rugged_branch()
+{
+	rb_cRuggedBranch = rb_define_class_under(rb_mRugged, "Branch", rb_cRuggedReference);
+
+	rb_define_singleton_method(rb_cRuggedBranch, "create", rb_git_branch_create, -1);
+	rb_define_singleton_method(rb_cRuggedBranch, "lookup", rb_git_branch_lookup, -1);
+	rb_define_singleton_method(rb_cRuggedBranch, "each_name", rb_git_branch_each_name, -1);
+	rb_define_singleton_method(rb_cRuggedBranch, "each", rb_git_branch_each, -1);
+
+	rb_define_method(rb_cRuggedBranch, "delete!", rb_git_branch_delete, 0);
+	rb_define_method(rb_cRuggedBranch, "rename", rb_git_branch_move, -1);
+	rb_define_method(rb_cRuggedBranch, "move", rb_git_branch_move, -1);
+}

data/ext/rugged/rugged_config.c

@@ -59,7 +59,7 @@ static VALUE rb_git_config_new(VALUE klass, VALUE rb_path)
 		for (i = 0; i < RARRAY_LEN(rb_path); ++i) {
 			VALUE f = rb_ary_entry(rb_path, i);
 			Check_Type(f, T_STRING);
-			error = git_config_add_file_ondisk(config, StringValueCStr(f), i + 1);
+			error = git_config_add_file_ondisk(config, StringValueCStr(f), i + 1, 1);
 			rugged_exception_check(error);
 		}
 	} else if (TYPE(rb_path) == T_STRING) {
@@ -178,26 +178,26 @@ static VALUE rb_git_config_delete(VALUE self, VALUE rb_key)
 	return Qtrue;
 }
 
-static int cb_config__each_key(const char *key, const char *value, void *opaque)
+static int cb_config__each_key(const git_config_entry *entry, void *opaque)
 {
-	rb_funcall((VALUE)opaque, rb_intern("call"), 1, rugged_str_new2(key, NULL));
+	rb_funcall((VALUE)opaque, rb_intern("call"), 1, rugged_str_new2(entry->name, NULL));
 	return GIT_OK;
 }
 
-static int cb_config__each_pair(const char *key, const char *value, void *opaque)
+static int cb_config__each_pair(const git_config_entry *entry, void *opaque)
 {
 	rb_funcall((VALUE)opaque, rb_intern("call"), 2,
-		rugged_str_new2(key, NULL),
-		rugged_str_new2(value, NULL));
+		rugged_str_new2(entry->name, NULL),
+		rugged_str_new2(entry->value, NULL));
 
 	return GIT_OK;
 }
 
-static int cb_config__to_hash(const char *key, const char *value, void *opaque)
+static int cb_config__to_hash(const git_config_entry *entry, void *opaque)
 {
 	rb_hash_aset((VALUE)opaque,
-		rugged_str_new2(key, NULL),
-		rugged_str_new2(value, NULL));
+		rugged_str_new2(entry->name, NULL),
+		rugged_str_new2(entry->value, NULL));
 
 	return GIT_OK;
 }
@@ -284,18 +284,19 @@ static VALUE rb_git_config_to_hash(VALUE self)
 
 /*
  *	call-seq:
+ *		Config.global() -> new_config
  *		Config.open_global() -> new_config
  *
- *	Open the global config file as a new +Rugged::Config+ object.
+ *	Open the default global config file as a new +Rugged::Config+ object.
  *	An exception will be raised if the global config file doesn't
  *	exist.
  */
-static VALUE rb_git_config_open_global(VALUE klass)
+static VALUE rb_git_config_open_default(VALUE klass)
 {
 	git_config *cfg;
 	int error;
 
-	error = git_config_open_global(&cfg);
+	error = git_config_open_default(&cfg);
 	rugged_exception_check(error);
 
 	return rugged_config_new(klass, Qnil, cfg);
@@ -308,7 +309,9 @@ void Init_rugged_config()
 	 */
 	rb_cRuggedConfig = rb_define_class_under(rb_mRugged, "Config", rb_cObject);
 	rb_define_singleton_method(rb_cRuggedConfig, "new", rb_git_config_new, 1);
-	rb_define_singleton_method(rb_cRuggedConfig, "open_global", rb_git_config_open_global, 0);
+
+	rb_define_singleton_method(rb_cRuggedConfig, "global", rb_git_config_open_default, 0);
+	rb_define_singleton_method(rb_cRuggedConfig, "open_global", rb_git_config_open_default, 0);
 
 	rb_define_method(rb_cRuggedConfig, "delete", rb_git_config_delete, 1);