Class: Rugged::Walker

Inherits:
Object
  • Object
show all
Includes:
Enumerable
Defined in:
lib/rugged/walker.rb,
ext/rugged/rugged_revwalk.c

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.new(repository) ⇒ Object

Create a new Walker instance able to walk commits found in repository, which is a Rugged::Repository instance.


85
86
87
88
89
90
91
92
93
94
95
96
97
# File 'ext/rugged/rugged_revwalk.c', line 85

static VALUE rb_git_walker_new(VALUE klass, VALUE rb_repo)
{
  git_repository *repo;
  git_revwalk *walk;
  int error;

  Data_Get_Struct(rb_repo, git_repository, repo);

  error = git_revwalk_new(&walk, repo);
  rugged_exception_check(error);

  return rugged_walker_new(klass, rb_repo, walk);;
}

.Rugged::Walker.walk(repo, options = ) { ... } ⇒ Object

Create a Walker object, initialize it with the given options and perform a walk on the repository; the lifetime of the walker is bound to the call and it is immediately cleaned up after the walk is over.

The following options are available:

  • sort: Sorting mode for the walk (or an OR combination

of several sorting modes).

  • show: Tips of the repository that will be walked;

this is necessary for the walk to yield any results. A tip can be a 40-char object ID, an existing Rugged::Commit object, a reference, or an Array of several of these (if you'd like to walk several tips in parallel).

  • hide: Same as show, but hides the given tips instead

so they don't appear on the walk.

  • oid_only: if true, the walker will yield 40-char OIDs

for each commit, instead of real Rugged::Commit objects. Defaults to false.

  • simplify: if true, the walk will be simplified

to the first parent of each commit.

Example:

Rugged::Walker.walk(repo,
        show: "92b22bbcb37caf4f6f53d30292169e84f5e4283b",
        sort: Rugged::SORT_DATE|Rugged::SORT_TOPO,
        oid_only: true) do |commit_oid|
    puts commit_oid
end

generates:

92b22bbcb37caf4f6f53d30292169e84f5e4283b
6b750d5800439b502de669465b385e5f469c78b6
ef9207141549f4ffcd3c4597e270d32e10d0a6bc
cb75e05f0f8ac3407fb3bd0ebd5ff07573b16c9f
...

Yields:


362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
# File 'ext/rugged/rugged_revwalk.c', line 362

static VALUE rb_git_walk(int argc, VALUE *argv, VALUE self)
{
  VALUE rb_repo, rb_options;
  struct walk_options w;
  int exception = 0;

  RETURN_ENUMERATOR(self, argc, argv);
  rb_scan_args(argc, argv, "10:", &rb_repo, &rb_options);

  Data_Get_Struct(rb_repo, git_repository, w.repo);
  rugged_exception_check(git_revwalk_new(&w.walk, w.repo));

  w.rb_owner = rb_repo;
  w.rb_options = rb_options;

  w.oid_only = 0;
  w.offset = 0;
  w.limit = UINT64_MAX;

  if (!NIL_P(w.rb_options))
    rb_protect(load_all_options, (VALUE)&w, &exception);

  if (!exception)
    rb_protect(do_walk, (VALUE)&w, &exception);

  git_revwalk_free(w.walk);

  if (exception)
    rb_jump_tag(exception);

  return Qnil;
}

Instance Method Details

#countFixnum

Returns the amount of objects a walker iterated over. If an argument or block is given this method delegates to Enumerable#count.

Returns:

  • (Fixnum)

183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
# File 'ext/rugged/rugged_revwalk.c', line 183

static VALUE rb_git_walker_count(int argc, VALUE *argv, VALUE self)
{
  git_revwalk *walk;
  git_oid commit_oid;
  int error = 0;
  uint64_t count = 0;

  if (argc > 0 || rb_block_given_p())
    return rb_call_super(argc, argv);

  Data_Get_Struct(self, git_revwalk, walk);

  while (((error = git_revwalk_next(&commit_oid, walk)) == 0) && ++count != UINT64_MAX);

  if (error != GIT_ITEROVER)
    rugged_exception_check(error);

  return ULONG2NUM(count);
}

#each {|commit| ... } ⇒ Object #eachEnumerator

Perform the walk through the repository, yielding each one of the commits found as a Rugged::Commit instance to block.

If no block is given, an Enumerator will be returned.

The walker must have been previously set-up before a walk can be performed (i.e. at least one commit must have been pushed).

walker.push("92b22bbcb37caf4f6f53d30292169e84f5e4283b")
walker.each { |commit| puts commit.oid }

generates:

92b22bbcb37caf4f6f53d30292169e84f5e4283b
6b750d5800439b502de669465b385e5f469c78b6
ef9207141549f4ffcd3c4597e270d32e10d0a6bc
cb75e05f0f8ac3407fb3bd0ebd5ff07573b16c9f
...

Overloads:

  • #each {|commit| ... } ⇒ Object

    Yields:

    • (commit)
  • #eachEnumerator

    Returns:

    • (Enumerator)

444
445
446
447
# File 'ext/rugged/rugged_revwalk.c', line 444

static VALUE rb_git_walker_each(int argc, VALUE *argv, VALUE self)
{
  return rb_git_walk_with_opts(argc, argv, self, 0);
}

#each_oid {|commit| ... } ⇒ Object #each_oidEnumerator

Perform the walk through the repository, yielding each one of the commit oids found as a String to block.

If no block is given, an Enumerator will be returned.

The walker must have been previously set-up before a walk can be performed (i.e. at least one commit must have been pushed).

walker.push("92b22bbcb37caf4f6f53d30292169e84f5e4283b")
walker.each { |commit_oid| puts commit_oid }

generates:

92b22bbcb37caf4f6f53d30292169e84f5e4283b
6b750d5800439b502de669465b385e5f469c78b6
ef9207141549f4ffcd3c4597e270d32e10d0a6bc
cb75e05f0f8ac3407fb3bd0ebd5ff07573b16c9f
...

Overloads:

  • #each_oid {|commit| ... } ⇒ Object

    Yields:

    • (commit)
  • #each_oidEnumerator

    Returns:

    • (Enumerator)

474
475
476
477
# File 'ext/rugged/rugged_revwalk.c', line 474

static VALUE rb_git_walker_each_oid(int argc, VALUE *argv, VALUE self)
{
  return rb_git_walk_with_opts(argc, argv, self, 1);
}

#hide(commit) ⇒ nil

Hide the given commit (and all its parents) from the output in the revision walk.

Returns:

  • (nil)

138
139
140
141
142
143
144
# File 'ext/rugged/rugged_revwalk.c', line 138

static VALUE rb_git_walker_hide(VALUE self, VALUE rb_commit)
{
  git_revwalk *walk;
  Data_Get_Struct(self, git_revwalk, walk);
  push_commit(walk, rb_commit, 1);
  return Qnil;
}

#push(commit) ⇒ nil

Push one new commit to start the walk from. commit must be a String with the OID of a commit in the repository, or a Rugged::Commit instance.

More than one commit may be pushed to the walker (to walk several branches simulataneously).

Duplicate pushed commits will be ignored; at least one commit must have been pushed as a starting point before the walk can begin.

walker.push("92b22bbcb37caf4f6f53d30292169e84f5e4283b")

Returns:

  • (nil)

115
116
117
118
119
120
121
# File 'ext/rugged/rugged_revwalk.c', line 115

static VALUE rb_git_walker_push(VALUE self, VALUE rb_commit)
{
  git_revwalk *walk;
  Data_Get_Struct(self, git_revwalk, walk);
  push_commit(walk, rb_commit, 0);
  return Qnil;
}

#push_range(range) ⇒ Object


123
124
125
126
127
128
129
# File 'ext/rugged/rugged_revwalk.c', line 123

static VALUE rb_git_walker_push_range(VALUE self, VALUE range)
{
  git_revwalk *walk;
  Data_Get_Struct(self, git_revwalk, walk);
  rugged_exception_check(git_revwalk_push_range(walk, StringValueCStr(range)));
  return Qnil;
}

#resetnil

Remove all pushed and hidden commits and reset the walker back into a blank state.

Returns:

  • (nil)

210
211
212
213
214
215
216
# File 'ext/rugged/rugged_revwalk.c', line 210

static VALUE rb_git_walker_reset(VALUE self)
{
  git_revwalk *walk;
  Data_Get_Struct(self, git_revwalk, walk);
  git_revwalk_reset(walk);
  return Qnil;
}

#simplify_first_parentnil

Simplify the walk to the first parent of each commit.

Returns:

  • (nil)

168
169
170
171
172
173
174
# File 'ext/rugged/rugged_revwalk.c', line 168

static VALUE rb_git_walker_simplify_first_parent(VALUE self)
{
  git_revwalk *walk;
  Data_Get_Struct(self, git_revwalk, walk);
  git_revwalk_simplify_first_parent(walk);
  return Qnil;
}

#sorting(sort_mode) ⇒ nil

Change the sorting mode for the revision walk.

This will cause walker to be reset.

Returns:

  • (nil)

154
155
156
157
158
159
160
# File 'ext/rugged/rugged_revwalk.c', line 154

static VALUE rb_git_walker_sorting(VALUE self, VALUE ruby_sort_mode)
{
  git_revwalk *walk;
  Data_Get_Struct(self, git_revwalk, walk);
  git_revwalk_sorting(walk, FIX2INT(ruby_sort_mode));
  return Qnil;
}

#each {|commit| ... } ⇒ Object #eachEnumerator

Perform the walk through the repository, yielding each one of the commits found as a Rugged::Commit instance to block.

If no block is given, an Enumerator will be returned.

The walker must have been previously set-up before a walk can be performed (i.e. at least one commit must have been pushed).

walker.push("92b22bbcb37caf4f6f53d30292169e84f5e4283b")
walker.each { |commit| puts commit.oid }

generates:

92b22bbcb37caf4f6f53d30292169e84f5e4283b
6b750d5800439b502de669465b385e5f469c78b6
ef9207141549f4ffcd3c4597e270d32e10d0a6bc
cb75e05f0f8ac3407fb3bd0ebd5ff07573b16c9f
...

Overloads:

  • #each {|commit| ... } ⇒ Object

    Yields:

    • (commit)
  • #eachEnumerator

    Returns:

    • (Enumerator)

444
445
446
447
# File 'ext/rugged/rugged_revwalk.c', line 444

static VALUE rb_git_walker_each(int argc, VALUE *argv, VALUE self)
{
  return rb_git_walk_with_opts(argc, argv, self, 0);
}