rugged 0.23.0b2 → 0.23.0b4

data/ext/rugged/rugged_repo.c

@@ -410,7 +410,6 @@ static VALUE rb_git_repo_init_at(int argc, VALUE *argv, VALUE klass)
 
 static void parse_clone_options(git_clone_options *ret, VALUE rb_options, struct rugged_remote_cb_payload *remote_payload)
 {
-	git_remote_callbacks remote_callbacks = GIT_REMOTE_CALLBACKS_INIT;
 	VALUE val;
 
 	if (NIL_P(rb_options))
@@ -426,9 +425,7 @@ static void parse_clone_options(git_clone_options *ret, VALUE rb_options, struct
 		ret->checkout_branch = StringValueCStr(val);
 	}
 
-	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &remote_callbacks, remote_payload);
-
-	ret->remote_callbacks = remote_callbacks;
+	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &ret->fetch_opts.callbacks, remote_payload);
 }
 
 /*
@@ -593,6 +590,75 @@ static VALUE rb_git_repo_get_config(VALUE self)
 	RB_GIT_REPO_OWNED_GET(rb_cRuggedConfig, config);
 }
 
+/*
+ *  call-seq:
+ *    repo.ident = ident
+ *
+ *  Set the identity to be used for writing reflogs.
+ *
+ *  +ident+ can be either +nil+ or a Hash containing +name+ and/or +email+ entries.
+ */
+static VALUE rb_git_repo_set_ident(VALUE self, VALUE rb_ident) {
+	VALUE rb_val;
+
+	git_repository *repo;
+	const char *name = NULL, *email = NULL;
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	if (!NIL_P(rb_ident)) {
+		Check_Type(rb_ident, T_HASH);
+
+		if (!NIL_P(rb_val = rb_hash_aref(rb_ident, CSTR2SYM("name")))) {
+			Check_Type(rb_val, T_STRING);
+			name = StringValueCStr(rb_val);
+		}
+
+		if (!NIL_P(rb_val = rb_hash_aref(rb_ident, CSTR2SYM("email")))) {
+			Check_Type(rb_val, T_STRING);
+			email = StringValueCStr(rb_val);
+		}
+	}
+
+	rugged_exception_check(
+		git_repository_set_ident(repo, name, email)
+	);
+
+	return Qnil;
+}
+
+/*
+ *  call-seq:
+ *    repo.ident -> ident
+ *
+ *  Return a Hash containing the identity that is used to write reflogs.
+ *
+ *  +ident+ is a Hash containing +name+ and/or +email+ entries, or `nil`.
+ */
+static VALUE rb_git_repo_get_ident(VALUE self)
+{
+	VALUE rb_ident = rb_hash_new();
+
+	git_repository *repo;
+	const char *name = NULL, *email = NULL;
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	rugged_exception_check(
+		git_repository_ident(&name, &email, repo)
+	);
+
+	if (name) {
+		rb_hash_aset(rb_ident, CSTR2SYM("name"), rb_str_new_utf8(name));
+	}
+
+	if (email) {
+		rb_hash_aset(rb_ident, CSTR2SYM("email"), rb_str_new_utf8(email));
+	}
+
+	return rb_ident;
+}
+
 /*
  *  call-seq:
  *    repo.merge_base(oid1, oid2, ...)
@@ -2240,7 +2306,7 @@ static VALUE rb_git_repo_attributes(int argc, VALUE *argv, VALUE self)
 		VALUE rb_result;
 		const char **values;
 		const char **names;
-		int i, num_attr = RARRAY_LEN(rb_names);
+		long i, num_attr = RARRAY_LEN(rb_names);
 
 		if (num_attr > 32)
 			rb_raise(rb_eRuntimeError, "Too many attributes requested");
@@ -2386,6 +2452,9 @@ void Init_rugged_repo(void)
 	rb_define_method(rb_cRuggedRepo, "config",  rb_git_repo_get_config,  0);
 	rb_define_method(rb_cRuggedRepo, "config=",  rb_git_repo_set_config,  1);
 
+	rb_define_method(rb_cRuggedRepo, "ident", rb_git_repo_get_ident, 0);
+	rb_define_method(rb_cRuggedRepo, "ident=", rb_git_repo_set_ident, 1);
+
 	rb_define_method(rb_cRuggedRepo, "bare?",  rb_git_repo_is_bare,  0);
 	rb_define_method(rb_cRuggedRepo, "shallow?",  rb_git_repo_is_shallow,  0);
 	rb_define_method(rb_cRuggedRepo, "empty?",  rb_git_repo_is_empty,  0);

data/ext/rugged/rugged_submodule.c

@@ -164,13 +164,18 @@ static VALUE submodule_status_flags_to_rb(unsigned int flags)
  */
 static VALUE rb_git_submodule_status(VALUE self)
 {
+	VALUE rb_repo = rugged_owner(self);
 	git_submodule *submodule;
+	git_repository *repo;
 	unsigned int flags;
 
+	rugged_check_repo(rb_repo);
+	Data_Get_Struct(rb_repo, git_repository, repo);
 	Data_Get_Struct(self, git_submodule, submodule);
 
 	rugged_exception_check(
-		git_submodule_status(&flags, submodule)
+		git_submodule_status(&flags, repo, git_submodule_name(submodule),
+			GIT_SUBMODULE_IGNORE_UNSPECIFIED)
 	);
 
 	return submodule_status_flags_to_rb(flags);
@@ -231,11 +236,16 @@ static VALUE rb_git_submodule_status_in_workdir(VALUE self)
 }
 
 #define RB_GIT_SUBMODULE_STATUS_FLAG_CHECK(flag) \
+	VALUE rb_repo = rugged_owner(self); \
+	git_repository *repo; \
 	git_submodule *submodule; \
 	unsigned int flags; \
+	rugged_check_repo(rb_repo); \
+	Data_Get_Struct(rb_repo, git_repository, repo); \
 	Data_Get_Struct(self, git_submodule, submodule); \
 	rugged_exception_check( \
-		git_submodule_status(&flags, submodule) \
+		git_submodule_status(&flags, repo, git_submodule_name(submodule), \
+			GIT_SUBMODULE_IGNORE_UNSPECIFIED) \
 	); \
 	return (flags & flag) ? Qtrue : Qfalse; \
 
@@ -350,11 +360,16 @@ static VALUE rb_git_submodule_status_untracked_files_in_workdir(VALUE self)
 }
 
 #define RB_GIT_SUBMODULE_STATUS_CHECK(check) \
+	VALUE rb_repo = rugged_owner(self); \
+	git_repository *repo; \
 	git_submodule *submodule; \
 	unsigned int flags; \
+	rugged_check_repo(rb_repo); \
+	Data_Get_Struct(rb_repo, git_repository, repo); \
 	Data_Get_Struct(self, git_submodule, submodule); \
 	rugged_exception_check( \
-		git_submodule_status(&flags, submodule) \
+		git_submodule_status(&flags, repo, git_submodule_name(submodule), \
+			GIT_SUBMODULE_IGNORE_UNSPECIFIED) \
 	); \
 	return check(flags) ? Qtrue : Qfalse; \
 
@@ -442,27 +457,6 @@ static VALUE rb_git_submodule_reload(VALUE self)
 	return self;
 }
 
-/*
- *  call-seq:
- *    submodule.save -> submodule
- *
- *  Write submodule settings to +.gitmodules+ file.
- *
- *  This commits any in-memory changes to the submodule to the +.gitmodules+
- *  file on disk.
- */
-static VALUE rb_git_submodule_save(VALUE self)
-{
-	git_submodule *submodule;
-	Data_Get_Struct(self, git_submodule, submodule);
-
-	rugged_exception_check(
-		git_submodule_save(submodule)
-	);
-
-	return self;
-}
-
 /*
  *  call-seq:
  *    submodule.sync -> submodule
@@ -563,33 +557,6 @@ static VALUE rb_git_submodule_url(VALUE self)
 	return url ? rb_str_new_utf8(url) : Qnil;
 }
 
-/*
- *  call-seq:
- *    submodule.url = url -> url
- *
- *  Set the URL in memory for the submodule.
- *
- *  This will be used for any following submodule actions while this submodule
- *  data is in memory.
- *
- *  After calling this, #save can be called to write the changes back to
- *  the +.gitmodules+ file and #sync to write the changes to the checked out
- *  submodule repository.
- */
-static VALUE rb_git_submodule_set_url(VALUE self, VALUE rb_url)
-{
-	git_submodule *submodule;
-
-	Check_Type(rb_url, T_STRING);
-
-	Data_Get_Struct(self, git_submodule, submodule);
-
-	rugged_exception_check(
-		git_submodule_set_url(submodule, StringValueCStr(rb_url))
-	);
-	return rb_url;
-}
-
 /*
  *  call-seq:
  *    submodule.path -> string
@@ -680,28 +647,6 @@ static VALUE rb_git_submodule_fetch_recurse_submodules(VALUE self)
 	return git_submodule_fetch_recurse_submodules(submodule) ? Qtrue : Qfalse;
 }
 
-/*
- *  call-seq:
- *    submodule.fetch_recurse_submodules= bool -> bool
- *
- *  Set the +fetchRecurseSubmodules+ rule in memory for a submodule.
- *
- *  This sets the <tt>submodule.<name>.fetchRecurseSubmodules</tt> value for
- *  the submodule. #save can be called to persist the new value.
- */
-static VALUE rb_git_submodule_set_fetch_recurse_submodules(VALUE self, VALUE rb_fetch_recursive)
-{
-	git_submodule *submodule;
-	Data_Get_Struct(self, git_submodule, submodule);
-
-	git_submodule_set_fetch_recurse_submodules(
-			submodule,
-			rugged_parse_bool(rb_fetch_recursive)
-	);
-
-	return rb_fetch_recursive;
-}
-
 static VALUE rb_git_subm_ignore_rule_fromC(git_submodule_ignore_t rule)
 {
 	switch(rule) {
@@ -754,72 +699,6 @@ static VALUE rb_git_submodule_ignore_rule(VALUE self)
 	return rb_git_subm_ignore_rule_fromC(ignore);
 }
 
-static git_submodule_ignore_t rb_git_subm_ignore_rule_toC(VALUE rb_ignore_rule)
-{
-	ID id_ignore_rule;
-
-	Check_Type(rb_ignore_rule, T_SYMBOL);
-	id_ignore_rule = SYM2ID(rb_ignore_rule);
-
-	if (id_ignore_rule == id_ignore_none) {
-		return GIT_SUBMODULE_IGNORE_NONE;
-	} else if (id_ignore_rule == id_ignore_untracked) {
-		return GIT_SUBMODULE_IGNORE_UNTRACKED;
-	} else if (id_ignore_rule == id_ignore_dirty) {
-		return GIT_SUBMODULE_IGNORE_DIRTY;
-	} else if (id_ignore_rule == id_ignore_all) {
-		return GIT_SUBMODULE_IGNORE_ALL;
-	} else {
-		rb_raise(rb_eArgError, "Invalid submodule ignore rule type.");
-	}
-}
-
-/*
- *  call-seq:
- *    submodule.ignore_rule = rule -> rule
- *
- *  Set the ignore_rule to +rule+ in memory for a submodule.
- *  See #ignore for a list of accepted rules.
- *
- *  This will be used for any following actions (such as
- *  #status) while the submodule is in memory. The ignore
- *  rule can be persisted to the config with #save.
- *
- *  Calling #reset_ignore_rule or #reload will
- *  revert the rule to the value that was in the config.
- */
-static VALUE rb_git_submodule_set_ignore_rule(VALUE self, VALUE rb_ignore_rule)
-{
-	git_submodule *submodule;
-
-	Data_Get_Struct(self, git_submodule, submodule);
-
-	git_submodule_set_ignore(
-		submodule,
-		rb_git_subm_ignore_rule_toC(rb_ignore_rule)
-	);
-
-	return rb_ignore_rule;
-}
-
-/*
- *  call-seq:
- *    submodule.reset_ignore_rule -> submodule
- *
- *  Revert the ignore rule set by #ignore_rule= to the value that
- *  was in the config.
- */
-static VALUE rb_git_submodule_reset_ignore_rule(VALUE self)
-{
-	git_submodule *submodule;
-
-	Data_Get_Struct(self, git_submodule, submodule);
-
-	git_submodule_set_ignore(submodule, GIT_SUBMODULE_IGNORE_RESET);
-
-	return self;
-}
-
 static VALUE rb_git_subm_update_rule_fromC(git_submodule_update_t rule)
 {
 	switch(rule) {
@@ -867,68 +746,6 @@ static VALUE rb_git_submodule_update_rule(VALUE self)
 	return rb_git_subm_update_rule_fromC(update);
 }
 
-static git_submodule_update_t rb_git_subm_update_rule_toC(VALUE rb_update_rule)
-{
-	ID id_update_rule;
-
-	Check_Type(rb_update_rule, T_SYMBOL);
-	id_update_rule = SYM2ID(rb_update_rule);
-
-	if (id_update_rule == id_update_checkout) {
-		return GIT_SUBMODULE_UPDATE_CHECKOUT;
-	} else if (id_update_rule == id_update_rebase) {
-		return GIT_SUBMODULE_UPDATE_REBASE;
-	} else if (id_update_rule == id_update_merge) {
-		return GIT_SUBMODULE_UPDATE_MERGE;
-	} else if (id_update_rule == id_update_none) {
-		return GIT_SUBMODULE_UPDATE_NONE;
-	} else {
-		rb_raise(rb_eArgError, "Invalid submodule update rule type.");
-	}
-}
-
-/*
- *  call-seq:
- *    submodule.update_rule = rule -> rule
- *
- *  Set the update_rule to +rule+ in memory for a submodule.
- *  See #update_rule for a list of accepted rules.
- *
- *  Calling #reset_update_rule or #reload will
- *  revert the +rule+ to the value that was in the config.
- */
-static VALUE rb_git_submodule_set_update_rule(VALUE self, VALUE rb_update_rule)
-{
-	git_submodule *submodule;
-
-	Data_Get_Struct(self, git_submodule, submodule);
-
-	git_submodule_set_update(
-		submodule,
-		rb_git_subm_update_rule_toC(rb_update_rule)
-	);
-
-	return rb_update_rule;
-}
-
-/*
- *  call-seq:
- *    submodule.reset_update_rule -> submodule
- *
- *  Revert the update rule set by #update_rule= to the value that
- *  was in the config.
- */
-static VALUE rb_git_submodule_reset_update_rule(VALUE self)
-{
-	git_submodule *submodule;
-
-	Data_Get_Struct(self, git_submodule, submodule);
-
-	git_submodule_set_update(submodule, GIT_SUBMODULE_UPDATE_RESET);
-
-	return self;
-}
-
 /*
  *  call-seq:
  *    submodule.repository -> repository
@@ -997,17 +814,11 @@ void Init_rugged_submodule(void)
 
 	rb_define_method(rb_cRuggedSubmodule, "name", rb_git_submodule_name, 0);
 	rb_define_method(rb_cRuggedSubmodule, "url", rb_git_submodule_url, 0);
-	rb_define_method(rb_cRuggedSubmodule, "url=", rb_git_submodule_set_url, 1);
 	rb_define_method(rb_cRuggedSubmodule, "path", rb_git_submodule_path, 0);
 	rb_define_method(rb_cRuggedSubmodule, "fetch_recurse_submodules?", rb_git_submodule_fetch_recurse_submodules, 0);
-	rb_define_method(rb_cRuggedSubmodule, "fetch_recurse_submodules=", rb_git_submodule_set_fetch_recurse_submodules, 1);
 
 	rb_define_method(rb_cRuggedSubmodule, "ignore_rule", rb_git_submodule_ignore_rule, 0);
-	rb_define_method(rb_cRuggedSubmodule, "ignore_rule=", rb_git_submodule_set_ignore_rule, 1);
-	rb_define_method(rb_cRuggedSubmodule, "reset_ignore_rule", rb_git_submodule_reset_ignore_rule, 0);
 	rb_define_method(rb_cRuggedSubmodule, "update_rule", rb_git_submodule_update_rule, 0);
-	rb_define_method(rb_cRuggedSubmodule, "update_rule=", rb_git_submodule_set_update_rule, 1);
-	rb_define_method(rb_cRuggedSubmodule, "reset_update_rule", rb_git_submodule_reset_update_rule, 0);
 
 	rb_define_method(rb_cRuggedSubmodule, "head_oid", rb_git_submodule_head_id, 0);
 	rb_define_method(rb_cRuggedSubmodule, "index_oid", rb_git_submodule_index_id, 0);
@@ -1036,7 +847,6 @@ void Init_rugged_submodule(void)
 
 	rb_define_method(rb_cRuggedSubmodule, "add_to_index", rb_git_submodule_add_to_index, -1);
 	rb_define_method(rb_cRuggedSubmodule, "reload", rb_git_submodule_reload, 0);
-	rb_define_method(rb_cRuggedSubmodule, "save", rb_git_submodule_save, 0);
 	rb_define_method(rb_cRuggedSubmodule, "sync", rb_git_submodule_sync, 0);
 	rb_define_method(rb_cRuggedSubmodule, "init", rb_git_submodule_init, -1);
 }

data/ext/rugged/rugged_submodule_collection.c

@@ -224,6 +224,151 @@ static VALUE rb_git_submodule_setup_add(int argc, VALUE *argv, VALUE self)
 	return rugged_submodule_new(rb_repo, submodule);
 }
 
+static git_submodule_ignore_t rb_git_subm_ignore_rule_toC(VALUE rb_ignore_rule)
+{
+	ID id_ignore_rule;
+
+	Check_Type(rb_ignore_rule, T_SYMBOL);
+	id_ignore_rule = SYM2ID(rb_ignore_rule);
+
+	if (id_ignore_rule == rb_intern("none")) {
+		return GIT_SUBMODULE_IGNORE_NONE;
+	} else if (id_ignore_rule == rb_intern("untracked")) {
+		return GIT_SUBMODULE_IGNORE_UNTRACKED;
+	} else if (id_ignore_rule == rb_intern("dirty")) {
+		return GIT_SUBMODULE_IGNORE_DIRTY;
+	} else if (id_ignore_rule == rb_intern("all")) {
+		return GIT_SUBMODULE_IGNORE_ALL;
+	} else {
+		rb_raise(rb_eArgError, "Invalid submodule ignore rule type.");
+	}
+}
+
+static git_submodule_update_t rb_git_subm_update_rule_toC(VALUE rb_update_rule)
+{
+	ID id_update_rule;
+
+	Check_Type(rb_update_rule, T_SYMBOL);
+	id_update_rule = SYM2ID(rb_update_rule);
+
+	if (id_update_rule == rb_intern("checkout")) {
+		return GIT_SUBMODULE_UPDATE_CHECKOUT;
+	} else if (id_update_rule == rb_intern("rebase")) {
+		return GIT_SUBMODULE_UPDATE_REBASE;
+	} else if (id_update_rule == rb_intern("merge")) {
+		return GIT_SUBMODULE_UPDATE_MERGE;
+	} else if (id_update_rule == rb_intern("none")) {
+		return GIT_SUBMODULE_UPDATE_NONE;
+	} else {
+		rb_raise(rb_eArgError, "Invalid submodule update rule type.");
+	}
+}
+
+/*
+ *  call-seq:
+ *    submodules.update(submodule, settings) -> nil
+ *    submodules.update(name, settings) -> nil
+ *
+ *  Update settings for the given submodule in the submodule config.
+ *
+ *  Existing `Rugged::Submodule` instances are not updated, but can be
+ *  reloaded by calling `#reload`.
+ *
+ *  The following options can be passed in the +settings+ Hash:
+ *
+ *  :url ::
+ *    Updates the URL for the submodule.
+ *
+ *  :ignore_rule ::
+ *    See `Rugged::Submodule#ignore_rule` for a list of accepted rules.
+ *
+ *  :update_rule ::
+ *    See `Rugged::Submodule#update_rule` for a list of accepted rules.
+ *
+ *  :fetch_recurse_submodules ::
+ *    Updates the +fetchRecurseSubmodules+ rule.
+ */
+static VALUE rb_git_submodule_update(VALUE self, VALUE rb_name_or_submodule, VALUE rb_settings)
+{
+	git_repository *repo;
+	git_submodule_ignore_t ignore_rule;
+	git_submodule_update_t update_rule;
+	const char *submodule_name;
+	int fetch_recurse_submodules;
+	VALUE rb_repo = rugged_owner(self);
+	VALUE rb_url, rb_fetch_recurse_submodules, rb_ignore_rule, rb_update_rule;
+
+	rugged_check_repo(rb_repo);
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	if (rb_obj_is_kind_of(rb_name_or_submodule, rb_cRuggedSubmodule))
+		rb_name_or_submodule = rb_funcall(rb_name_or_submodule, rb_intern("name"), 0);
+
+	if (TYPE(rb_name_or_submodule) != T_STRING)
+		rb_raise(rb_eTypeError, "Expecting a String or Rugged::Submodule instance");
+
+	rb_url = rb_hash_aref(rb_settings, CSTR2SYM("url"));
+	rb_fetch_recurse_submodules = rb_hash_aref(rb_settings, CSTR2SYM("fetch_recurse_submodules"));
+	rb_ignore_rule = rb_hash_aref(rb_settings, CSTR2SYM("ignore_rule"));
+	rb_update_rule = rb_hash_aref(rb_settings, CSTR2SYM("update_rule"));
+
+	if (!NIL_P(rb_url)) {
+		Check_Type(rb_url, T_STRING);
+	}
+
+	if (!NIL_P(rb_fetch_recurse_submodules)) {
+		fetch_recurse_submodules = rugged_parse_bool(rb_fetch_recurse_submodules);
+	}
+
+	if (!NIL_P(rb_ignore_rule)) {
+		ignore_rule = rb_git_subm_ignore_rule_toC(rb_ignore_rule);
+	}
+
+	if (!NIL_P(rb_update_rule)) {
+		update_rule = rb_git_subm_update_rule_toC(rb_update_rule);
+	}
+
+	submodule_name = StringValueCStr(rb_name_or_submodule);
+
+	if (!NIL_P(rb_url)) {
+		rugged_exception_check(
+			git_submodule_set_url(repo,
+				submodule_name,
+				StringValueCStr(rb_url)
+			)
+		);
+	}
+
+	if (!NIL_P(rb_fetch_recurse_submodules)) {
+		rugged_exception_check(
+			git_submodule_set_fetch_recurse_submodules(repo,
+				submodule_name,
+				fetch_recurse_submodules
+			)
+		);
+	}
+
+	if (!NIL_P(rb_ignore_rule)) {
+		rugged_exception_check(
+			git_submodule_set_ignore(repo,
+				submodule_name,
+				ignore_rule
+			)
+		);
+	}
+
+	if (!NIL_P(rb_update_rule)) {
+		rugged_exception_check(
+			git_submodule_set_update(repo,
+				submodule_name,
+				update_rule
+			)
+		);
+	}
+
+	return Qnil;
+}
+
 void Init_rugged_submodule_collection(void)
 {
 	rb_cRuggedSubmoduleCollection = rb_define_class_under(rb_mRugged, "SubmoduleCollection", rb_cObject);
@@ -232,5 +377,8 @@ void Init_rugged_submodule_collection(void)
 	rb_define_method(rb_cRuggedSubmoduleCollection, "initialize", rb_git_submodule_collection_initialize, 1);
 	rb_define_method(rb_cRuggedSubmoduleCollection, "[]",         rb_git_submodule_collection_aref, 1);
 	rb_define_method(rb_cRuggedSubmoduleCollection, "each",       rb_git_submodule_collection_each, 0);
+
+	rb_define_method(rb_cRuggedSubmoduleCollection, "update",     rb_git_submodule_update, 2);
+
 	rb_define_method(rb_cRuggedSubmoduleCollection, "setup_add",  rb_git_submodule_setup_add, -1);
 }