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.



83
84
85
86
87
 
# File 'ext/rugged/rugged_branch_collection.c', line 83

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.



176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
 
# File 'ext/rugged/rugged_branch_collection.c', line 176

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.



128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
 
# File 'ext/rugged/rugged_branch_collection.c', line 128

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) 


287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
 
# File 'ext/rugged/rugged_branch_collection.c', line 287

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) 


256
257
258
259
 
# File 'ext/rugged/rugged_branch_collection.c', line 256

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) 


272
273
274
275
 
# File 'ext/rugged/rugged_branch_collection.c', line 272

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) 


368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
 
# File 'ext/rugged/rugged_branch_collection.c', line 368

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) 


368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
 
# File 'ext/rugged/rugged_branch_collection.c', line 368

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.



332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
 
# File 'ext/rugged/rugged_branch_collection.c', line 332

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.



332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
 
# File 'ext/rugged/rugged_branch_collection.c', line 332

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