rdavila-rugged 0.24.0b13

data/ext/rugged/rugged_revwalk.c

@@ -0,0 +1,495 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2014 GitHub, Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "rugged.h"
+
+extern VALUE rb_mRugged;
+extern VALUE rb_cRuggedObject;
+VALUE rb_cRuggedWalker;
+
+static void rb_git_walk__free(git_revwalk *walk)
+{
+	git_revwalk_free(walk);
+}
+
+VALUE rugged_walker_new(VALUE klass, VALUE owner, git_revwalk *walk)
+{
+	VALUE rb_walk = Data_Wrap_Struct(klass, NULL, &rb_git_walk__free, walk);
+	rugged_set_owner(rb_walk, owner);
+	return rb_walk;
+}
+
+static void push_commit_oid(git_revwalk *walk, const git_oid *oid, int hide)
+{
+	int error;
+	if (hide) error = git_revwalk_hide(walk, oid);
+	else error = git_revwalk_push(walk, oid);
+	rugged_exception_check(error);
+}
+
+static void push_commit_ref(git_revwalk *walk, const char *ref, int hide)
+{
+	int error;
+	if (hide) error = git_revwalk_hide_ref(walk, ref);
+	else error = git_revwalk_push_ref(walk, ref);
+	rugged_exception_check(error);
+}
+
+static void push_commit_1(git_revwalk *walk, VALUE rb_commit, int hide)
+{
+	if (rb_obj_is_kind_of(rb_commit, rb_cRuggedObject)) {
+		git_object *object;
+		Data_Get_Struct(rb_commit, git_object, object);
+
+		push_commit_oid(walk, git_object_id(object), hide);
+		return;
+	}
+
+	Check_Type(rb_commit, T_STRING);
+
+	if (RSTRING_LEN(rb_commit) == 40) {
+		git_oid commit_oid;
+		if (git_oid_fromstr(&commit_oid, RSTRING_PTR(rb_commit)) == 0) {
+			push_commit_oid(walk, &commit_oid, hide);
+			return;
+		}
+	}
+
+	push_commit_ref(walk, StringValueCStr(rb_commit), hide);
+}
+
+static void push_commit(git_revwalk *walk, VALUE rb_commit, int hide)
+{
+	if (rb_type(rb_commit) == T_ARRAY) {
+		long i;
+		for (i = 0; i < RARRAY_LEN(rb_commit); ++i)
+			push_commit_1(walk, rb_ary_entry(rb_commit, i), hide);
+
+		return;
+	}
+
+	push_commit_1(walk, rb_commit, hide);
+}
+
+/*
+ *  call-seq:
+ *    Walker.new(repository) -> walker
+ *
+ *  Create a new +Walker+ instance able to walk commits found
+ *  in +repository+, which is a <tt>Rugged::Repository</tt> instance.
+ */
+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);;
+}
+
+/*
+ *  call-seq:
+ *    walker.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 <tt>Rugged::Commit</tt>
+ *  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")
+ */
+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;
+}
+
+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;
+}
+
+/*
+ *  call-seq:
+ *    walker.hide(commit) -> nil
+ *
+ *  Hide the given +commit+ (and all its parents) from the
+ *  output in the revision walk.
+ */
+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;
+}
+
+/*
+ *  call-seq:
+ *    walker.sorting(sort_mode) -> nil
+ *
+ *  Change the sorting mode for the revision walk.
+ *
+ *  This will cause +walker+ to be reset.
+ */
+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;
+}
+
+/*
+ *  call-seq:
+ *    walker.simplify_first_parent() -> nil
+ *
+ *  Simplify the walk to the first parent of each commit.
+ */
+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;
+}
+
+/*
+ *  call-seq:
+ *    walker.reset -> nil
+ *
+ *  Remove all pushed and hidden commits and reset the +walker+
+ *  back into a blank state.
+ */
+static VALUE rb_git_walker_reset(VALUE self)
+{
+	git_revwalk *walk;
+	Data_Get_Struct(self, git_revwalk, walk);
+	git_revwalk_reset(walk);
+	return Qnil;
+}
+
+struct walk_options {
+	VALUE rb_owner;
+	VALUE rb_options;
+
+	git_repository *repo;
+	git_revwalk *walk;
+	int oid_only;
+	uint64_t offset, limit;
+};
+
+static void load_walk_limits(struct walk_options *w, VALUE rb_options)
+{
+	VALUE rb_value = rb_hash_lookup(rb_options, CSTR2SYM("offset"));
+	if (!NIL_P(rb_value)) {
+		Check_Type(rb_value, T_FIXNUM);
+		w->offset = FIX2ULONG(rb_value);
+	}
+
+	rb_value = rb_hash_lookup(rb_options, CSTR2SYM("limit"));
+	if (!NIL_P(rb_value)) {
+		Check_Type(rb_value, T_FIXNUM);
+		w->limit = FIX2ULONG(rb_value);
+	}
+}
+
+static VALUE load_all_options(VALUE _payload)
+{
+	struct walk_options *w = (struct walk_options *)_payload;
+	VALUE rb_options = w->rb_options;
+	VALUE rb_show, rb_hide, rb_sort, rb_simp, rb_oid_only;
+
+	load_walk_limits(w, rb_options);
+
+	rb_sort = rb_hash_lookup(rb_options, CSTR2SYM("sort"));
+	if (!NIL_P(rb_sort)) {
+		Check_Type(rb_sort, T_FIXNUM);
+		git_revwalk_sorting(w->walk, FIX2INT(rb_sort));
+	}
+
+	rb_show = rb_hash_lookup(rb_options, CSTR2SYM("show"));
+	if (!NIL_P(rb_show)) {
+		push_commit(w->walk, rb_show, 0);
+	}
+
+	rb_hide = rb_hash_lookup(rb_options, CSTR2SYM("hide"));
+	if (!NIL_P(rb_hide)) {
+		push_commit(w->walk, rb_hide, 1);
+	}
+
+	rb_simp = rb_hash_lookup(rb_options, CSTR2SYM("simplify"));
+	if (RTEST(rb_simp)) {
+		git_revwalk_simplify_first_parent(w->walk);
+	}
+
+	rb_oid_only = rb_hash_lookup(rb_options, CSTR2SYM("oid_only"));
+	if (RTEST(rb_oid_only)) {
+		w->oid_only = 1;
+	}
+
+	return Qnil;
+}
+
+static VALUE do_walk(VALUE _payload)
+{
+	struct walk_options *w = (struct walk_options *)_payload;
+	int error;
+	git_oid commit_oid;
+
+	while ((error = git_revwalk_next(&commit_oid, w->walk)) == 0) {
+		if (w->offset > 0) {
+			w->offset--;
+			continue;
+		}
+
+		if (w->oid_only) {
+			rb_yield(rugged_create_oid(&commit_oid));
+		} else {
+			git_commit *commit;
+
+			error = git_commit_lookup(&commit, w->repo, &commit_oid);
+			rugged_exception_check(error);
+
+			rb_yield(
+				rugged_object_new(w->rb_owner, (git_object *)commit)
+			);
+		}
+
+		if (--w->limit == 0)
+			break;
+	}
+
+	if (error != GIT_ITEROVER)
+		rugged_exception_check(error);
+
+	return Qnil;
+}
+
+/*
+ *  call-seq:
+ *    Rugged::Walker.walk(repo, options={}) { |commit| block }
+ *
+ *	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
+ *    ...
+ */
+static VALUE rb_git_walk(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_repo, rb_options;
+	struct walk_options w;
+	int exception = 0;
+
+	rb_scan_args(argc, argv, "10:", &rb_repo, &rb_options);
+
+	if (!rb_block_given_p()) {
+		ID iter_method = ID2SYM(rb_intern("walk"));
+		return rb_funcall(self, rb_intern("to_enum"), 3,
+			iter_method, 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;
+}
+
+static VALUE rb_git_walk_with_opts(int argc, VALUE *argv, VALUE self, int oid_only)
+{
+	VALUE rb_options;
+	struct walk_options w;
+
+	rb_scan_args(argc, argv, "01", &rb_options);
+
+	if (!rb_block_given_p()) {
+		ID iter_method = ID2SYM(rb_intern(oid_only ? "each_oid" : "each"));
+		return rb_funcall(self, rb_intern("to_enum"), 2, iter_method, rb_options);
+	}
+
+	Data_Get_Struct(self, git_revwalk, w.walk);
+	w.repo = git_revwalk_repository(w.walk);
+
+	w.rb_owner = rugged_owner(self);
+	w.rb_options = Qnil;
+
+	w.oid_only = oid_only;
+	w.offset = 0;
+	w.limit = UINT64_MAX;
+
+	if (!NIL_P(rb_options))
+		load_walk_limits(&w, rb_options);
+
+	return do_walk((VALUE)&w);
+}
+
+/*
+ *  call-seq:
+ *    walker.each { |commit| block }
+ *    walker.each -> Iterator
+ *
+ *  Perform the walk through the repository, yielding each
+ *  one of the commits found as a <tt>Rugged::Commit</tt> instance
+ *  to +block+.
+ *
+ *  If no +block+ is given, an +Iterator+ 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
+ *    ...
+ */
+static VALUE rb_git_walker_each(int argc, VALUE *argv, VALUE self)
+{
+	return rb_git_walk_with_opts(argc, argv, self, 0);
+}
+
+/*
+ *  call-seq:
+ *    walker.each_oid { |commit| block }
+ *    walker.each_oid -> Iterator
+ *
+ *  Perform the walk through the repository, yielding each
+ *  one of the commit oids found as a <tt>String</tt>
+ *  to +block+.
+ *
+ *  If no +block+ is given, an +Iterator+ 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
+ *    ...
+ */
+static VALUE rb_git_walker_each_oid(int argc, VALUE *argv, VALUE self)
+{
+	return rb_git_walk_with_opts(argc, argv, self, 1);
+}
+
+
+
+void Init_rugged_revwalk(void)
+{
+	rb_cRuggedWalker = rb_define_class_under(rb_mRugged, "Walker", rb_cObject);
+	rb_define_singleton_method(rb_cRuggedWalker, "new", rb_git_walker_new, 1);
+	rb_define_singleton_method(rb_cRuggedWalker, "walk", rb_git_walk, -1);
+
+	rb_define_method(rb_cRuggedWalker, "push", rb_git_walker_push, 1);
+	rb_define_method(rb_cRuggedWalker, "push_range", rb_git_walker_push_range, 1);
+	rb_define_method(rb_cRuggedWalker, "each", rb_git_walker_each, -1);
+	rb_define_method(rb_cRuggedWalker, "each_oid", rb_git_walker_each_oid, -1);
+	rb_define_method(rb_cRuggedWalker, "walk", rb_git_walker_each, -1);
+	rb_define_method(rb_cRuggedWalker, "hide", rb_git_walker_hide, 1);
+	rb_define_method(rb_cRuggedWalker, "reset", rb_git_walker_reset, 0);
+	rb_define_method(rb_cRuggedWalker, "sorting", rb_git_walker_sorting, 1);
+	rb_define_method(rb_cRuggedWalker, "simplify_first_parent", rb_git_walker_simplify_first_parent, 0);
+}