/**
* ggit_ref_is_remote:
* @ref: a #GgitRef.
*
* Check whether the reference is a remote.
*
* Returns: %TRUE if the reference is a remote, %FALSE otherwise.
*
**/
gboolean
ggit_ref_is_remote (GgitRef *ref)
{
g_return_val_if_fail (ref != NULL, FALSE);
return git_reference_is_remote (_ggit_native_get (ref));
}
/**
* Get head of repository
*
* @param repo S4 class git_repository
* @return R_NilValue if unborn branch or not found. S4 class
* git_branch if not a detached head. S4 class git_commit if detached
* head
*/
SEXP git2r_repository_head(SEXP repo)
{
int err;
SEXP result = R_NilValue;
git_commit *commit = NULL;
git_reference *reference = NULL;
git_repository *repository = NULL;
repository= git2r_repository_open(repo);
if (!repository)
git2r_error(git2r_err_invalid_repository, __func__, NULL);
err = git_repository_head(&reference, repository);
if (GIT_OK != err) {
if (GIT_EUNBORNBRANCH == err || GIT_ENOTFOUND == err)
err = GIT_OK;
goto cleanup;
}
if (git_reference_is_branch(reference)) {
git_branch_t type = GIT_BRANCH_LOCAL;
if (git_reference_is_remote(reference))
type = GIT_BRANCH_REMOTE;
PROTECT(result = NEW_OBJECT(MAKE_CLASS("git_branch")));
err = git2r_branch_init(reference, type, repo, result);
} else {
err = git_commit_lookup(
&commit,
repository,
git_reference_target(reference));
if (GIT_OK != err)
goto cleanup;
PROTECT(result = NEW_OBJECT(MAKE_CLASS("git_commit")));
git2r_commit_init(commit, repo, result);
}
cleanup:
if (commit)
git_commit_free(commit);
if (reference)
git_reference_free(reference);
if (repository)
git_repository_free(repository);
if (R_NilValue != result)
UNPROTECT(1);
if (GIT_OK != err)
git2r_error(git2r_err_from_libgit2, __func__, giterr_last()->message);
return result;
}
/*
* call-seq:
* branch.upstream -> branch
*
* Returns the remote tracking branch, or +nil+ if the branch is
* remote or has no tracking branch.
*/
static VALUE rb_git_branch_upstream(VALUE self)
{
git_reference *branch, *upstream_branch;
int error;
Data_Get_Struct(self, git_reference, branch);
if (git_reference_is_remote(branch))
return Qnil;
error = git_branch_upstream(&upstream_branch, branch);
if (error == GIT_ENOTFOUND)
return Qnil;
rugged_exception_check(error);
return rugged_branch_new(rugged_owner(self), upstream_branch);
}
int git_branch_name(const char **out, git_reference *ref)
{
const char *branch_name;
assert(out && ref);
branch_name = ref->name;
if (git_reference_is_branch(ref)) {
branch_name += strlen(GIT_REFS_HEADS_DIR);
} else if (git_reference_is_remote(ref)) {
branch_name += strlen(GIT_REFS_REMOTES_DIR);
} else {
giterr_set(GITERR_INVALID,
"Reference '%s' is neither a local nor a remote branch.", ref->name);
return -1;
}
*out = branch_name;
return 0;
}
int git_branch_delete(git_reference *branch)
{
int is_head;
git_buf config_section = GIT_BUF_INIT;
int error = -1;
assert(branch);
if (!git_reference_is_branch(branch) &&
!git_reference_is_remote(branch)) {
giterr_set(GITERR_INVALID, "Reference '%s' is not a valid branch.", git_reference_name(branch));
return -1;
}
if ((is_head = git_branch_is_head(branch)) < 0)
return is_head;
if (is_head) {
giterr_set(GITERR_REFERENCE,
"Cannot delete branch '%s' as it is the current HEAD of the repository.", git_reference_name(branch));
return -1;
}
if (git_buf_printf(&config_section, "branch.%s", git_reference_name(branch) + strlen(GIT_REFS_HEADS_DIR)) < 0)
goto on_error;
if (git_config_rename_section(
git_reference_owner(branch),
git_buf_cstr(&config_section),
NULL) < 0)
goto on_error;
if (git_reference_delete(branch) < 0)
goto on_error;
error = 0;
on_error:
git_buf_free(&config_section);
return error;
}
/*
* call-seq:
* branch.remote_name -> string
*
* Get the name of the remote the branch belongs to.
*
* If +branch+ is a remote branch, the name of the remote it belongs to is
* returned. If +branch+ is a tracking branch, the name of the remote
* of the tracked branch is returned.
*
* Otherwise, +nil+ is returned.
*/
static VALUE rb_git_branch_remote_name(VALUE self)
{
git_reference *branch, *remote_ref;
int error = 0;
Data_Get_Struct(self, git_reference, branch);
if (git_reference_is_remote(branch)) {
remote_ref = branch;
} else {
error = git_branch_upstream(&remote_ref, branch);
if (error == GIT_ENOTFOUND)
return Qnil;
rugged_exception_check(error);
}
return rb_git_branch__remote_name(
rugged_owner(self),
git_reference_name(remote_ref));
}
/*
* call-seq:
* reference.remote? -> true or false
*
* Returns +true+ if +reference+ is a remote branch, false otherwise.
*/
static VALUE rb_git_ref_is_remote(VALUE self)
{
git_reference *ref;
Data_Get_Struct(self, git_reference, ref);
return git_reference_is_remote(ref) ? Qtrue : Qfalse;
}