Class: Rugged::BranchCollection

Inherits:
Object
  • Object
show all
Includes:
Enumerable
Defined in:
ext/rugged/rugged_branch_collection.c

Instance Method Summary collapse

Constructor Details

#new(repo) ⇒ Object

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


66
67
68
69
70
# File 'ext/rugged/rugged_branch_collection.c', line 66

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

Instance Method Details

#[](name) ⇒ Object

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.


159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
# File 'ext/rugged/rugged_branch_collection.c', line 159

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 = {}) ⇒ Object

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.


111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
# File 'ext/rugged/rugged_branch_collection.c', line 111

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

Overloads:

  • #delete(branch) ⇒ nil

    Returns:

    • (nil)
  • #delete(name) ⇒ nil

    Returns:

    • (nil)

267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
# File 'ext/rugged/rugged_branch_collection.c', line 267

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| ... } ⇒ Object #each([filter]) ⇒ Object

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.

Overloads:

  • #each([filter]) {|branch| ... } ⇒ Object

    Yields:

    • (branch)

236
237
238
239
# File 'ext/rugged/rugged_branch_collection.c', line 236

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| ... } ⇒ Object #each_name([filter]) ⇒ Object

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.

Overloads:

  • #each_name([filter]) {|branch_name| ... } ⇒ Object

    Yields:

    • (branch_name)

252
253
254
255
# File 'ext/rugged/rugged_branch_collection.c', line 252

static VALUE rb_git_branch_collection_each_name(int argc, VALUE *argv, VALUE self)
{
	return each_branch(argc, argv, self, 1);
}

#exist?(name) ⇒ Boolean #exists?(name) ⇒ Boolean

Check if a branch exists with the given name.

Overloads:

  • #exist?(name) ⇒ Boolean

    Returns:

    • (Boolean)
  • #exists?(name) ⇒ Boolean

    Returns:

    • (Boolean)

348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
# File 'ext/rugged/rugged_branch_collection.c', line 348

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

#exist?(name) ⇒ Boolean #exists?(name) ⇒ Boolean

Check if a branch exists with the given name.

Overloads:

  • #exist?(name) ⇒ Boolean

    Returns:

    • (Boolean)
  • #exists?(name) ⇒ Boolean

    Returns:

    • (Boolean)

348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
# File 'ext/rugged/rugged_branch_collection.c', line 348

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

#move(old_name, new_name, options = {}) ⇒ Object #move(branch, new_name, options = {}) ⇒ Object #rename(old_name, new_name, options = {}) ⇒ Object #rename(branch, new_name, options = {}) ⇒ Object

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.


312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
# File 'ext/rugged/rugged_branch_collection.c', line 312

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

#move(old_name, new_name, options = {}) ⇒ Object #move(branch, new_name, options = {}) ⇒ Object #rename(old_name, new_name, options = {}) ⇒ Object #rename(branch, new_name, options = {}) ⇒ Object

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.


312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
# File 'ext/rugged/rugged_branch_collection.c', line 312

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