Class: Rugged::Reference

Inherits:

Object

• Object
• Rugged::Reference

Defined in:

ext/rugged/rugged_reference.c

Class Method Summary

• .create(*args) ⇒ Object
• .each(*args) ⇒ Object
• .lookup(rb_repo, rb_name) ⇒ Object
• .pack_all(rb_repo) ⇒ Object

Instance Method Summary

• #delete! ⇒ Object
• #log ⇒ Object
• #log!(rb_oid_old, rb_committer, rb_message) ⇒ Object
• #name ⇒ Object
• #packed? ⇒ Boolean
• #reload! ⇒ Object
• #rename(*args) ⇒ Object
• #resolve ⇒ Object
• #target ⇒ Object
• #target=(rb_target) ⇒ Object
• #type ⇒ Object

Class Method Details

.create(*args) ⇒ Object

# File 'ext/rugged/rugged_reference.c', line 130

static VALUE rb_git_ref_create(int argc, VALUE *argv, VALUE klass)
{
	VALUE rb_repo, rb_name, rb_target, rb_force;
	git_repository *repo;
	git_reference *ref;
	git_oid oid;
	int error, force = 0;

	rb_scan_args(argc, argv, "31", &rb_repo, &rb_name, &rb_target, &rb_force);

	Data_Get_Struct(rb_repo, git_repository, repo);
	Check_Type(rb_name, T_STRING);
	Check_Type(rb_target, T_STRING);

	if (!NIL_P(rb_force))
		force = rugged_parse_bool(rb_force);

	if (git_oid_fromstr(&oid, StringValueCStr(rb_target)) == GIT_SUCCESS) {
		error = git_reference_create_oid(
			&ref, repo, StringValueCStr(rb_name), &oid, force);
	} else {
		error = git_reference_create_symbolic(
			&ref, repo, StringValueCStr(rb_name), RSTRING_PTR(rb_target), force);
	}

	rugged_exception_check(error);

	return rugged_ref_new(klass, rb_repo, ref);
}

.each(*args) ⇒ Object

# File 'ext/rugged/rugged_reference.c', line 78

static VALUE rb_git_ref_each(int argc, VALUE *argv, VALUE self)
{
	git_repository *repo;
	int error, flags = 0;
	VALUE rb_repo, rb_list, rb_block;

	rb_scan_args(argc, argv, "11&", &rb_repo, &rb_list, &rb_block);

	if (!rb_block_given_p())
		return rb_funcall(self, rb_intern("to_enum"), 3, CSTR2SYM("each"), rb_repo, rb_list);

	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);

	if (!NIL_P(rb_list)) {
		ID list;

		Check_Type(rb_list, T_SYMBOL);
		list = SYM2ID(rb_list);

		if (list == rb_intern("all"))
			flags = GIT_REF_LISTALL;
		else if (list == rb_intern("direct"))
			flags = GIT_REF_OID|GIT_REF_PACKED;
		else if (list == rb_intern("symbolic"))
			flags = GIT_REF_SYMBOLIC|GIT_REF_PACKED;
	} else {
		flags = GIT_REF_LISTALL;
	}

	error = git_reference_foreach(repo, flags, &ref_foreach__block, (void *)rb_block);
	rugged_exception_check(error);
	return Qnil;
}

.lookup(rb_repo, rb_name) ⇒ Object

# File 'ext/rugged/rugged_reference.c', line 115

static VALUE rb_git_ref_lookup(VALUE klass, VALUE rb_repo, VALUE rb_name)
{
	git_repository *repo;
	git_reference *ref;
	int error;

	Data_Get_Struct(rb_repo, git_repository, repo);
	Check_Type(rb_name, T_STRING);

	error = git_reference_lookup(&ref, repo, StringValueCStr(rb_name));
	rugged_exception_check(error);

	return rugged_ref_new(klass, rb_repo, ref);
}

.pack_all(rb_repo) ⇒ Object

# File 'ext/rugged/rugged_reference.c', line 50

static VALUE rb_git_ref_packall(VALUE klass, VALUE rb_repo)
{
	git_repository *repo;
	int error;

	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);

	error = git_reference_packall(repo);
	rugged_exception_check(error);

	return Qnil;
}

Instance Method Details

#delete! ⇒ Object

# File 'ext/rugged/rugged_reference.c', line 267

static VALUE rb_git_ref_delete(VALUE self)
{
	git_reference *ref;
	int error;

	UNPACK_REFERENCE(self, ref);

	error = git_reference_delete(ref);
	rugged_exception_check(error);

	DATA_PTR(self) = NULL; /* this reference has been free'd */
	rugged_set_owner(self, Qnil); /* and is no longer owned */
	return Qnil;
}

#log ⇒ Object

# File 'ext/rugged/rugged_reference.c', line 309

static VALUE rb_git_reflog(VALUE self)
{
	git_reflog *reflog;
	git_reference *ref;
	int error;
	VALUE rb_log;
	unsigned int i, ref_count;

	UNPACK_REFERENCE(self, ref);

	error = git_reflog_read(&reflog, ref);
	rugged_exception_check(error);

	ref_count = git_reflog_entrycount(reflog);
	rb_log = rb_ary_new2(ref_count);

	for (i = 0; i < ref_count; ++i) {
		const git_reflog_entry *entry =
			git_reflog_entry_byindex(reflog, i);

		rb_ary_push(rb_log, reflog_entry_new(entry));
	}

	git_reflog_free(reflog);
	return rb_log;
}

#log!(rb_oid_old, rb_committer, rb_message) ⇒ Object

# File 'ext/rugged/rugged_reference.c', line 336

static VALUE rb_git_reflog_write(
	VALUE self,
	VALUE rb_oid_old,
	VALUE rb_committer,
	VALUE rb_message)
{
	git_reference *ref;
	int error;
	git_signature *committer;
	const char *message = NULL;
	git_oid oid_old;

	UNPACK_REFERENCE(self, ref);

	if (!NIL_P(rb_message)) {
		Check_Type(rb_message, T_STRING);
		message = StringValueCStr(rb_message);
	}

	if (!NIL_P(rb_oid_old)) {
		Check_Type(rb_oid_old, T_STRING);
		error = git_oid_fromstr(&oid_old, StringValueCStr(rb_oid_old));
		rugged_exception_check(error);
	}

	committer = rugged_signature_get(rb_committer);

	error = git_reflog_write(
		ref,
		NIL_P(rb_oid_old) ? NULL : &oid_old,
		committer,
		message
	);

	git_signature_free(committer);

	rugged_exception_check(error);
	return Qnil;
}

#name ⇒ Object

# File 'ext/rugged/rugged_reference.c', line 227

static VALUE rb_git_ref_name(VALUE self)
{
	git_reference *ref;
	UNPACK_REFERENCE(self, ref);
	return rugged_str_new2(git_reference_name(ref), NULL);
}

#packed? ⇒ Boolean

Returns:

• (Boolean)

# File 'ext/rugged/rugged_reference.c', line 203

static VALUE rb_git_ref_packed(VALUE self)
{
	git_reference *ref;
	UNPACK_REFERENCE(self, ref);

	return git_reference_is_packed(ref) ? Qtrue : Qfalse;
}

#reload! ⇒ Object

# File 'ext/rugged/rugged_reference.c', line 211

static VALUE rb_git_ref_reload(VALUE self)
{
	int error;
	git_reference *ref;
	UNPACK_REFERENCE(self, ref);

	error = git_reference_reload(ref);

	/* If reload fails, the reference is invalidated */
	if (error < GIT_SUCCESS)
		ref = NULL;

	rugged_exception_check(error);
	return Qnil;
}

#rename(*args) ⇒ Object

# File 'ext/rugged/rugged_reference.c', line 248

static VALUE rb_git_ref_rename(int argc, VALUE *argv, VALUE self)
{
	git_reference *ref;
	VALUE rb_name, rb_force;
	int error, force = 0;

	UNPACK_REFERENCE(self, ref);
	rb_scan_args(argc, argv, "11", &rb_name, &rb_force);

	Check_Type(rb_name, T_STRING);
	if (!NIL_P(rb_force))
		force = rugged_parse_bool(rb_force);

	error = git_reference_rename(ref, StringValueCStr(rb_name), force);
	rugged_exception_check(error);

	return Qnil;
}

#resolve ⇒ Object

# File 'ext/rugged/rugged_reference.c', line 234

static VALUE rb_git_ref_resolve(VALUE self)
{
	git_reference *ref;
	git_reference *resolved;
	int error;

	UNPACK_REFERENCE(self, ref);

	error = git_reference_resolve(&resolved, ref);
	rugged_exception_check(error);

	return rugged_ref_new(rb_cRuggedReference, rugged_owner(self), resolved);
}

#target ⇒ Object

# File 'ext/rugged/rugged_reference.c', line 160

static VALUE rb_git_ref_target(VALUE self)
{
	git_reference *ref;

	UNPACK_REFERENCE(self, ref);

	if (git_reference_type(ref) == GIT_REF_OID) {
		return rugged_create_oid(git_reference_oid(ref));
	} else {
		return rugged_str_new2(git_reference_target(ref), NULL);
	}
}

#target=(rb_target) ⇒ Object

# File 'ext/rugged/rugged_reference.c', line 173

static VALUE rb_git_ref_set_target(VALUE self, VALUE rb_target)
{
	git_reference *ref;
	int error;

	UNPACK_REFERENCE(self, ref);
	Check_Type(rb_target, T_STRING);

	if (git_reference_type(ref) == GIT_REF_OID) {
		git_oid target;

		error = git_oid_fromstr(&target, StringValueCStr(rb_target));
		rugged_exception_check(error);

		error = git_reference_set_oid(ref, &target);
	} else {
		error = git_reference_set_target(ref, StringValueCStr(rb_target));
	}

	rugged_exception_check(error);
	return Qnil;
}

#type ⇒ Object

# File 'ext/rugged/rugged_reference.c', line 196

static VALUE rb_git_ref_type(VALUE self)
{
	git_reference *ref;
	UNPACK_REFERENCE(self, ref);
	return rugged_str_new2(git_object_type2string(git_reference_type(ref)), NULL);
}