class Rugged::BranchCollection

Public Class Methods

new(repo) → refs click to toggle source

Creates and returns a new collection of branches for the given repo.

static VALUE rb_git_branch_collection_initialize(VALUE self, VALUE repo)
{
        rugged_set_owner(self, repo);
        return self;
}

Public Instance Methods

branches[name] → branch click to toggle source

Return the branch with the given name.

Branches can be looked up by their relative (development) or absolute (refs/heads/development) branch name.

If a local branch and a remote branch both share the same short name (e.g. refs/heads/origin/master and refs/remotes/origin/master), passing origin/master as the name will return the local branch. You can explicitly request the local branch by passing heads/origin/master, or the remote branch through remotes/origin/master.

Returns the looked up branch, or nil if the branch doesn’t exist.

static VALUE rb_git_branch_collection_aref(VALUE self, VALUE rb_name) {
        git_reference *branch;
        git_repository *repo;

        VALUE rb_repo = rugged_owner(self);
        int error;

        rugged_check_repo(rb_repo);
        Data_Get_Struct(rb_repo, git_repository, repo);

        Check_Type(rb_name, T_STRING);

        error = rugged_branch_lookup(&branch, repo, rb_name);
        if (error == GIT_ENOTFOUND)
                return Qnil;

        rugged_exception_check(error);
        return rugged_branch_new(rb_repo, branch);
}
create(name, target, options = {}) → branch click to toggle source

Create a new branch with the given name, 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 commit in the given repository.

The following options can be passed in the options Hash:

:force

Overwrites the branch with the given name, if it already exists, instead of raising an exception.

If a branch with the given name already exists and :force is not true, an exception will be raised.

Returns a Rugged::Branch for the newly created branch.

static VALUE rb_git_branch_collection_create(int argc, VALUE *argv, VALUE self)
{
        VALUE rb_repo = rugged_owner(self), rb_name, rb_target, rb_options;
        git_repository *repo;
        git_reference *branch;
        git_commit *target;
        int error, force = 0;

        rb_scan_args(argc, argv, "20:", &rb_name, &rb_target, &rb_options);

        rugged_check_repo(rb_repo);
        Data_Get_Struct(rb_repo, git_repository, repo);

        Check_Type(rb_name, T_STRING);
        Check_Type(rb_target, T_STRING);

        if (!NIL_P(rb_options)) {
                force = RTEST(rb_hash_aref(rb_options, CSTR2SYM("force")));
        }

        target = (git_commit *)rugged_object_get(repo, rb_target, GIT_OBJ_COMMIT);

        error = git_branch_create(&branch, repo, StringValueCStr(rb_name), target, force);

        git_commit_free(target);

        rugged_exception_check(error);

        return rugged_branch_new(rb_repo, branch);
}
delete(branch) → nil click to toggle source
delete(name) → nil

Delete the specified branch.

If a Rugged::Branch object was passed, the object will become invalidated and won’t be able to be used for any other operations.

static VALUE rb_git_branch_collection_delete(VALUE self, VALUE rb_name_or_branch)
{
        git_reference *branch;
        git_repository *repo;

        VALUE rb_repo = rugged_owner(self);
        int error;

        rugged_check_repo(rb_repo);
        Data_Get_Struct(rb_repo, git_repository, repo);

        error = rugged_branch_lookup(&branch, repo, rb_name_or_branch);
        rugged_exception_check(error);

        error = git_branch_delete(branch);
        git_reference_free(branch);
        rugged_exception_check(error);

        return Qnil;
}
each([filter]) { |branch| block } click to toggle source
each([filter]) → enumerator

Iterate through the branches in the collection. 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 enumerator will be returned.

static VALUE rb_git_branch_collection_each(int argc, VALUE *argv, VALUE self)
{
        return each_branch(argc, argv, self, 0);
}
each_name([filter]) { |branch_name| block } click to toggle source
each_name([filter]) → enumerator

Iterate through the names of the branches in the collection. 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 enumerator will be returned.

static VALUE rb_git_branch_collection_each_name(int argc, VALUE *argv, VALUE self)
{
        return each_branch(argc, argv, self, 1);
}
exist?(name) → true or false click to toggle source

Check if a branch exists with the given name.

static VALUE rb_git_branch_collection_exist_p(VALUE self, VALUE rb_name)
{
        VALUE rb_repo = rugged_owner(self);
        git_repository *repo;
        git_reference *branch;
        int error;

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

        error = rugged_branch_lookup(&branch, repo, rb_name);
        git_reference_free(branch);

        if (error == GIT_ENOTFOUND)
                return Qfalse;
        else
                rugged_exception_check(error);

        return Qtrue;
}
Also aliased as: exists?
exists?(name) → true or false

Check if a branch exists with the given name.

Alias for: exist?
move(old_name, new_name, options = {}) → new_branch click to toggle source
move(branch, new_name, options = {}) → new_branch

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

The following options can be passed in the options Hash:

:force

Overwrites the branch with the given name, if it already exists, instead of raising an exception.

If a branch with the given new_name already exists and :force is not true, an exception will be raised.

A new Rugged::Branch object for the renamed branch will be returned.

static VALUE rb_git_branch_collection_move(int argc, VALUE *argv, VALUE self)
{
        VALUE rb_repo = rugged_owner(self), rb_name_or_branch, rb_new_branch_name, rb_options;
        git_reference *old_branch = NULL, *new_branch = NULL;
        git_repository *repo;
        int error, force = 0;

        rb_scan_args(argc, argv, "20:", &rb_name_or_branch, &rb_new_branch_name, &rb_options);
        Check_Type(rb_new_branch_name, T_STRING);

        rugged_check_repo(rb_repo);
        Data_Get_Struct(rb_repo, git_repository, repo);

        error = rugged_branch_lookup(&old_branch, repo, rb_name_or_branch);
        rugged_exception_check(error);

        if (!NIL_P(rb_options)) {
                force = RTEST(rb_hash_aref(rb_options, CSTR2SYM("force")));
        }

        error = git_branch_move(&new_branch, old_branch, StringValueCStr(rb_new_branch_name), force);

        git_reference_free(old_branch);

        rugged_exception_check(error);

        return rugged_branch_new(rugged_owner(self), new_branch);
}
Also aliased as: rename
rename(old_name, new_name, options = {}) → new_branch
rename(branch, new_name, options = {}) → new_branch

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

The following options can be passed in the options Hash:

:force

Overwrites the branch with the given name, if it already exists, instead of raising an exception.

If a branch with the given new_name already exists and :force is not true, an exception will be raised.

A new Rugged::Branch object for the renamed branch will be returned.

Alias for: move