rugged 0.18.0.gh.de28323 → 0.19.0

data/ext/rugged/rugged_tree.c

@@ -27,6 +27,9 @@
 extern VALUE rb_mRugged;
 extern VALUE rb_cRuggedObject;
 extern VALUE rb_cRuggedRepo;
+extern VALUE rb_cRuggedDiff;
+extern VALUE rb_cRuggedIndex;
+extern VALUE rb_cRuggedCommit;
 
 VALUE rb_cRuggedTree;
 VALUE rb_cRuggedTreeBuilder;
@@ -41,7 +44,7 @@ static VALUE rb_git_treeentry_fromC(const git_tree_entry *entry)
 
 	rb_entry = rb_hash_new();
 
-	rb_hash_aset(rb_entry, CSTR2SYM("name"), rugged_str_new2(git_tree_entry_name(entry), NULL));
+	rb_hash_aset(rb_entry, CSTR2SYM("name"), rb_str_new_utf8(git_tree_entry_name(entry)));
 	rb_hash_aset(rb_entry, CSTR2SYM("oid"), rugged_create_oid(git_tree_entry_id(entry)));
 
 	rb_hash_aset(rb_entry, CSTR2SYM("filemode"), INT2FIX(git_tree_entry_filemode(entry)));
@@ -69,14 +72,14 @@ static VALUE rb_git_treeentry_fromC(const git_tree_entry *entry)
  */
 
 /*
- *	call-seq:
- *		tree.count -> count
- *		tree.length -> count
+ *  call-seq:
+ *    tree.count -> count
+ *    tree.length -> count
  *
- *	Return the number of entries contained in the tree.
+ *  Return the number of entries contained in the tree.
  *
- *	Note that this only applies to entries in the root of the tree,
- *	not any other entries contained in sub-folders.
+ *  Note that this only applies to entries in the root of the tree,
+ *  not any other entries contained in sub-folders.
  */
 static VALUE rb_git_tree_entrycount(VALUE self)
 {
@@ -87,21 +90,19 @@ static VALUE rb_git_tree_entrycount(VALUE self)
 }
 
 /*
- *	call-seq:
- *		tree[e] -> entry
- *		tree.get_entry(e) -> entry
+ *  call-seq:
+ *    tree[e] -> entry
+ *    tree.get_entry(e) -> entry
  *
- *	Return one of the entries from a tree as a +Hash+. If +e+ is a number, the +e+nth entry
- *	from the tree will be returned. If +e+ is a string, the entry with that name
- *	will be returned.
+ *  Return one of the entries from a tree as a +Hash+. If +e+ is a number, the +e+nth entry
+ *  from the tree will be returned. If +e+ is a string, the entry with that name
+ *  will be returned.
  *
- *	If the entry doesn't exist, +nil+ will be returned.
+ *  If the entry doesn't exist, +nil+ will be returned.
  *
- *		tree[3] #=> {:name => "foo.txt", :type => :blob, :oid => "d8786bfc97485e8d7b19b21fb88c8ef1f199fc3f", :filemode => 0}
- *
- *		tree['bar.txt'] #=> {:name => "bar.txt", :type => :blob, :oid => "de5ba987198bcf2518885f0fc1350e5172cded78", :filemode => 0}
- *
- *		tree['baz.txt'] #=> nil
+ *    tree[3] #=> {:name => "foo.txt", :type => :blob, :oid => "d8786bfc97485e8d7b19b21fb88c8ef1f199fc3f", :filemode => 0}
+ *    tree['bar.txt'] #=> {:name => "bar.txt", :type => :blob, :oid => "de5ba987198bcf2518885f0fc1350e5172cded78", :filemode => 0}
+ *    tree['baz.txt'] #=> nil
  */
 static VALUE rb_git_tree_get_entry(VALUE self, VALUE entry_id)
 {
@@ -119,18 +120,18 @@ static VALUE rb_git_tree_get_entry(VALUE self, VALUE entry_id)
 }
 
 /*
- *	call-seq:
- *		tree.get_entry_by_oid(rb_oid) -> entry
+ *  call-seq:
+ *    tree.get_entry_by_oid(rb_oid) -> entry
+ *
+ *  Return one of the entries from a tree as a +Hash+, based off the oid SHA.
  *
- *	Return one of the entries from a tree as a +Hash+, based off the oid SHA.
- *	
- *	If the entry doesn't exist, +nil+ will be returned.
+ *  If the entry doesn't exist, +nil+ will be returned.
  *
- *	This does a full traversal of the every element in the tree, so this method
- *	is not especially fast.
+ *  This does a full traversal of the every element in the tree, so this method
+ *  is not especially fast.
  *
- *		tree.get_entry_by_oid("d8786bfc97485e8d7b19b21fb88c8ef1f199fc3f") 
- *		#=> {:name => "foo.txt", :type => :blob, :oid => "d8786bfc97485e8d7b19b21fb88c8ef1f199fc3f", :filemode => 0}
+ *    tree.get_entry_by_oid("d8786bfc97485e8d7b19b21fb88c8ef1f199fc3f")
+ *    #=> {:name => "foo.txt", :type => :blob, :oid => "d8786bfc97485e8d7b19b21fb88c8ef1f199fc3f", :filemode => 0}
  *
  */
 static VALUE rb_git_tree_get_entry_by_oid(VALUE self, VALUE rb_oid)
@@ -146,23 +147,23 @@ static VALUE rb_git_tree_get_entry_by_oid(VALUE self, VALUE rb_oid)
 }
 
 /*
- *	call-seq:
- *		tree.each { |entry| block }
- *		tree.each -> Iterator
+ *  call-seq:
+ *    tree.each { |entry| block }
+ *    tree.each -> enumerator
  *
- *	Call +block+ with each of the entries of the subtree as a +Hash+. If no +block+
- *	is given, an +Iterator+ is returned instead.
+ *  Call +block+ with each of the entries of the subtree as a +Hash+. If no +block+
+ *  is given, an +enumerator+ is returned instead.
  *
- *	Note that only the entries in the root of the tree are yielded; if you need to
- *	list also entries in subfolders, use +tree.walk+ instead.
+ *  Note that only the entries in the root of the tree are yielded; if you need to
+ *  list also entries in subfolders, use +tree.walk+ instead.
  *
- *		tree.each { |entry| puts entry.inspect }
+ *    tree.each { |entry| puts entry.inspect }
  *
- *	generates:
+ *  generates:
  *
- *		{:name => "foo.txt", :type => :blob, :oid => "d8786bfc97485e8d7b19b21fb88c8ef1f199fc3f", :filemode => 0}
- *		{:name => "bar.txt", :type => :blob, :oid => "de5ba987198bcf2518885f0fc1350e5172cded78", :filemode => 0}
- *		...
+ *    {:name => "foo.txt", :type => :blob, :oid => "d8786bfc97485e8d7b19b21fb88c8ef1f199fc3f", :filemode => 0}
+ *    {:name => "bar.txt", :type => :blob, :oid => "de5ba987198bcf2518885f0fc1350e5172cded78", :filemode => 0}
+ *    ...
  */
 static VALUE rb_git_tree_each(VALUE self)
 {
@@ -186,33 +187,34 @@ static VALUE rb_git_tree_each(VALUE self)
 static int rugged__treewalk_cb(const char *root, const git_tree_entry *entry, void *proc)
 {
 	rb_funcall((VALUE)proc, rb_intern("call"), 2,
-		rugged_str_new2(root, NULL),
-		rb_git_treeentry_fromC(entry));
+		rb_str_new_utf8(root),
+		rb_git_treeentry_fromC(entry)
+	);
 
 	return GIT_OK;
 }
 
 /*
- *	call-seq:
- *		tree.walk(mode) { |root, entry| block }
- *		tree.walk(mode) -> Iterator
+ *  call-seq:
+ *    tree.walk(mode) { |root, entry| block }
+ *    tree.walk(mode) -> Iterator
  *
- *	Walk +tree+ with the given mode (either +:preorder+ or +:postorder+) and yield
- *	to +block+ every entry in +tree+ and all its subtrees, as a +Hash+. The +block+
- *	also takes a +root+, the relative path in the traversal, starting from the root
- *	of the original tree.
+ *  Walk +tree+ with the given mode (either +:preorder+ or +:postorder+) and yield
+ *  to +block+ every entry in +tree+ and all its subtrees, as a +Hash+. The +block+
+ *  also takes a +root+, the relative path in the traversal, starting from the root
+ *  of the original tree.
  *
- *	If no +block+ is given, an +Iterator+ is returned instead.
+ *  If no +block+ is given, an +Iterator+ is returned instead.
  *
- *		tree.walk(:postorder) { |root, entry| puts "#{root}#{entry[:name]} [#{entry[:oid]}]" }
+ *    tree.walk(:postorder) { |root, entry| puts "#{root}#{entry[:name]} [#{entry[:oid]}]" }
  *
- *	generates:
+ *  generates:
  *
- *		USAGE.rb [02bae86c91f96b5fdb6b1cf06f5aa3612139e318]
- *		ext [23f135b3c576b6ac4785821888991d7089f35db1]
- *		ext/rugged [25c88faa9302e34e16664eb9c990deb2bcf77849]
- *		ext/rugged/extconf.rb [40c1aa8a8cec8ca444ed5758e3f00ecff093070a]
- *		...
+ *    USAGE.rb [02bae86c91f96b5fdb6b1cf06f5aa3612139e318]
+ *    ext [23f135b3c576b6ac4785821888991d7089f35db1]
+ *    ext/rugged [25c88faa9302e34e16664eb9c990deb2bcf77849]
+ *    ext/rugged/extconf.rb [40c1aa8a8cec8ca444ed5758e3f00ecff093070a]
+ *    ...
  */
 static VALUE rb_git_tree_walk(VALUE self, VALUE rb_mode)
 {
@@ -242,6 +244,12 @@ static VALUE rb_git_tree_walk(VALUE self, VALUE rb_mode)
 	return Qnil;
 }
 
+/*
+ *  call-seq:
+ *    tree.path(path) -> entry
+ *
+ *  Retrieve and return a tree entry by its relative path.
+ */
 static VALUE rb_git_tree_path(VALUE self, VALUE rb_path)
 {
 	int error;
@@ -260,6 +268,207 @@ static VALUE rb_git_tree_path(VALUE self, VALUE rb_path)
 	return rb_entry;
 }
 
+/*
+ *  call-seq:
+ *    tree.diff(diffable[, options]) -> diff
+ *
+ *  Returns a diff between the tree and the diffable object that was given.
+ *  +diffable+ can either be a +Rugged::Commit+, a +Rugged::Tree+, a +Rugged::Index+,
+ *  or +nil+.
+ *
+ *  The +tree+ object will be used as the "old file" side of the diff, while the
+ *  parent tree or the +diffable+ object will be used for the "new file" side.
+ *
+ *  If +diffable+ is nil, it will be treated as an empty tree.
+ *
+ *  The following options can be passed in the +options+ Hash:
+ *
+ *  :paths ::
+ *    An array of paths / fnmatch patterns to constrain the diff to a specific
+ *    set of files. Also see +:disable_pathspec_match+.
+ *
+ *  :max_size ::
+ *    An integer specifying the maximum byte size of a file before a it will
+ *    be treated as binary. The default value is 512MB.
+ *
+ *  :context_lines ::
+ *    The number of unchanged lines that define the boundary of a hunk (and
+ *    to display before and after the actual changes). The default is 3.
+ *
+ *  :interhunk_lines ::
+ *    The maximum number of unchanged lines between hunk boundaries before the hunks
+ *    will be merged into a one. The default is 0.
+ *
+ *  :reverse ::
+ *    If true, the sides of the diff will be reversed.
+ *
+ *  :force_text ::
+ *    If true, all files will be treated as text, disabling binary attributes & detection.
+ *
+ *  :ignore_whitespace ::
+ *    If true, all whitespace will be ignored.
+ *
+ *  :ignore_whitespace_change ::
+ *    If true, changes in amount of whitespace will be ignored.
+ *
+ *  :ignore_whitespace_eol ::
+ *    If true, whitespace at end of line will be ignored.
+ *
+ *  :ignore_submodules ::
+ *    if true, submodules will be excluded from the diff completely.
+ *
+ *  :patience ::
+ *    If true, the "patience diff" algorithm will be used (currenlty unimplemented).
+ *
+ *  :include_ignored ::
+ *    If true, ignored files will be included in the diff.
+ *
+ *  :include_untracked ::
+ *   If true, untracked files will be included in the diff.
+ *
+ *  :include_unmodified ::
+ *    If true, unmodified files will be included in the diff.
+ *
+ *  :recurse_untracked_dirs ::
+ *    Even if +:include_untracked+ is true, untracked directories will only be
+ *    marked with a single entry in the diff. If this flag is set to true,
+ *    all files under ignored directories will be included in the diff, too.
+ *
+ *  :disable_pathspec_match ::
+ *    If true, the given +:paths+ will be applied as exact matches, instead of
+ *    as fnmatch patterns.
+ *
+ *  :deltas_are_icase ::
+ *    If true, filename comparisons will be made with case-insensitivity.
+ *
+ *  :include_untracked_content ::
+ *    if true, untracked content will be contained in the the diff patch text.
+ *
+ *  :skip_binary_check ::
+ *    If true, diff deltas will be generated without spending time on binary
+ *    detection. This is useful to improve performance in cases where the actual
+ *    file content difference is not needed.
+ *
+ *  :include_typechange ::
+ *    If true, type changes for files will not be interpreted as deletion of
+ *    the "old file" and addition of the "new file", but will generate
+ *    typechange records.
+ *
+ *  :include_typechange_trees ::
+ *    Even if +:include_typechange+ is true, blob -> tree changes will still
+ *    usually be handled as a deletion of the blob. If this flag is set to true,
+ *    blob -> tree changes will be marked as typechanges.
+ *
+ *  :ignore_filemode ::
+ *    If true, file mode changes will be ignored.
+ *
+ *  :recurse_ignored_dirs ::
+ *    Even if +:include_ignored+ is true, ignored directories will only be
+ *    marked with a single entry in the diff. If this flag is set to true,
+ *    all files under ignored directories will be included in the diff, too.
+ *
+ *  Examples:
+ *
+ *    # Emulating `git diff <treeish>`
+ *    tree = Rugged::Tree.lookup(repo, "d70d245ed97ed2aa596dd1af6536e4bfdb047b69")
+ *    diff = tree.diff(repo.index)
+ *    diff.merge!(tree.diff)
+ *
+ *    # Tree-to-Tree Diff
+ *    tree = Rugged::Tree.lookup(repo, "d70d245ed97ed2aa596dd1af6536e4bfdb047b69")
+ *    other_tree = Rugged::Tree.lookup(repo, "7a9e0b02e63179929fed24f0a3e0f19168114d10")
+ *    diff = tree.diff(other_tree)
+ */
+static VALUE rb_git_tree_diff(int argc, VALUE *argv, VALUE self)
+{
+	git_tree *tree;
+	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
+	git_repository *repo;
+	git_diff_list *diff = NULL;
+	VALUE owner, rb_other, rb_options;
+	int error;
+
+	rb_scan_args(argc, argv, "10:", &rb_other, &rb_options);
+	rugged_parse_diff_options(&opts, rb_options);
+
+	Data_Get_Struct(self, git_tree, tree);
+	owner = rugged_owner(self);
+	Data_Get_Struct(owner, git_repository, repo);
+
+	if (NIL_P(rb_other)) {
+		error = git_diff_tree_to_tree(&diff, repo, tree, NULL, &opts);
+	} else {
+		if (TYPE(rb_other) == T_STRING) {
+			rb_other = rugged_object_rev_parse(owner, rb_other, 1);
+		}
+
+		if (rb_obj_is_kind_of(rb_other, rb_cRuggedCommit)) {
+			git_tree *other_tree;
+			git_commit *commit;
+
+			Data_Get_Struct(rb_other, git_commit, commit);
+			error = git_commit_tree(&other_tree, commit);
+
+			if (!error) {
+				error = git_diff_tree_to_tree(&diff, repo, tree, other_tree, &opts);
+				git_tree_free(other_tree);
+			}
+		} else if (rb_obj_is_kind_of(rb_other, rb_cRuggedTree)) {
+			git_tree *other_tree;
+
+			Data_Get_Struct(rb_other, git_tree, other_tree);
+			error = git_diff_tree_to_tree(&diff, repo, tree, other_tree, &opts);
+		} else if (rb_obj_is_kind_of(rb_other, rb_cRuggedIndex)) {
+			git_index *index;
+			Data_Get_Struct(rb_other, git_index, index);
+			error = git_diff_tree_to_index(&diff, repo, tree, index, &opts);
+		} else {
+			xfree(opts.pathspec.strings);
+			rb_raise(rb_eTypeError, "A Rugged::Commit, Rugged::Tree or Rugged::Index instance is required");
+		}
+	}
+
+	xfree(opts.pathspec.strings);
+	rugged_exception_check(error);
+
+	return rugged_diff_new(rb_cRuggedDiff, self, diff);
+}
+
+/*
+ *  call-seq:
+ *    tree.diff_workdir([options]) -> diff
+ *
+ *  Returns a diff between a tree and the current workdir.
+ *
+ *  The +tree+ object will be used as the "old file" side of the diff, while the
+ *  content of the current workdir will be used for the "new file" side.
+ *
+ *  See Rugged::Tree#diff for a list of options that can be passed.
+ */
+static VALUE rb_git_tree_diff_workdir(int argc, VALUE *argv, VALUE self)
+{
+	git_tree *tree;
+	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
+	git_repository *repo;
+	git_diff_list *diff;
+	VALUE owner, rb_options;
+	int error;
+
+	rb_scan_args(argc, argv, "00:", &rb_options);
+	rugged_parse_diff_options(&opts, rb_options);
+
+	Data_Get_Struct(self, git_tree, tree);
+	owner = rugged_owner(self);
+	Data_Get_Struct(owner, git_repository, repo);
+
+	error = git_diff_tree_to_workdir(&diff, repo, tree, &opts);
+
+	xfree(opts.pathspec.strings);
+	rugged_exception_check(error);
+
+	return rugged_diff_new(rb_cRuggedDiff, self, diff);
+}
+
 static void rb_git_treebuilder_free(git_treebuilder *bld)
 {
 	git_treebuilder_free(bld);
@@ -270,6 +479,16 @@ static VALUE rb_git_treebuilder_allocate(VALUE klass)
 	return Data_Wrap_Struct(klass, NULL, &rb_git_treebuilder_free, NULL);
 }
 
+/*
+ *  call-seq:
+ *    TreeBuilder.new([tree])
+ *
+ *  Create a new Rugged::Trebuilder instance.
+ *
+ *  If an optional +tree+ is given, the returned TreeBuilder will be
+ *  initialized with the entry of +tree+. Otherwise, the TreeBuilder
+ *  will be empty and has to be filled manually.
+ */
 static VALUE rb_git_treebuilder_init(int argc, VALUE *argv, VALUE self)
 {
 	git_treebuilder *builder;
@@ -291,6 +510,12 @@ static VALUE rb_git_treebuilder_init(int argc, VALUE *argv, VALUE self)
 	return Qnil;
 }
 
+/*
+ *  call-seq:
+ *    builder.clear -> nil
+ *
+ *  Clear all entries in +builder+.
+ */
 static VALUE rb_git_treebuilder_clear(VALUE self)
 {
 	git_treebuilder *builder;
@@ -299,6 +524,12 @@ static VALUE rb_git_treebuilder_clear(VALUE self)
 	return Qnil;
 }
 
+/*
+ *  call-seq:
+ *    builder[path] -> entry
+ *
+ *  Return an entry from +builder+ based on its relative path.
+ */
 static VALUE rb_git_treebuilder_get(VALUE self, VALUE path)
 {
 	git_treebuilder *builder;
@@ -309,6 +540,13 @@ static VALUE rb_git_treebuilder_get(VALUE self, VALUE path)
 	return rb_git_treeentry_fromC(git_treebuilder_get(builder, StringValueCStr(path)));
 }
 
+/*
+ *  call-seq:
+ *    builder << entry      -> nil
+ *    builder.insert(entry) -> nil
+ *
+ *  Inser a new entry into +builder+.
+ */
 static VALUE rb_git_treebuilder_insert(VALUE self, VALUE rb_entry)
 {
 	git_treebuilder *builder;
@@ -339,6 +577,15 @@ static VALUE rb_git_treebuilder_insert(VALUE self, VALUE rb_entry)
 	return Qnil;
 }
 
+/*
+ *  call-seq:
+ *    builder.remove(path) -> true or false
+ *
+ *  Remove an entry from +builder+ by its relative +path+.
+ *
+ *  Returns +true+ if the entry was successfully removed,
+ *  or +false+ if the entry was not found.
+ */
 static VALUE rb_git_treebuilder_remove(VALUE self, VALUE path)
 {
 	git_treebuilder *builder;
@@ -355,6 +602,13 @@ static VALUE rb_git_treebuilder_remove(VALUE self, VALUE path)
 	return Qtrue;
 }
 
+/*
+ *  call-seq:
+ *    builder.write(repo) -> oid
+ *
+ *  Write +builder+'s content as a tree to the given +repo+
+ *  and return the +oid+ for the newly created tree.
+ */
 static VALUE rb_git_treebuilder_write(VALUE self, VALUE rb_repo)
 {
 	git_treebuilder *builder;
@@ -381,6 +635,13 @@ static int treebuilder_cb(const git_tree_entry *entry, void *opaque)
 	return rugged_parse_bool(ret);
 }
 
+/*
+ *  call-seq:
+ *    builder.reject! { |entry| block } -> nil
+ *
+ *  Deletes every tree +entry+ from +builder+ for which
+ *  the given +block+ evaluates to true.
+ */
 static VALUE rb_git_treebuilder_filter(VALUE self)
 {
 	git_treebuilder *builder;
@@ -392,7 +653,7 @@ static VALUE rb_git_treebuilder_filter(VALUE self)
 	return Qnil;
 }
 
-void Init_rugged_tree()
+void Init_rugged_tree(void)
 {
 	/*
 	 * Tree
@@ -403,6 +664,8 @@ void Init_rugged_tree()
 	rb_define_method(rb_cRuggedTree, "get_entry", rb_git_tree_get_entry, 1);
 	rb_define_method(rb_cRuggedTree, "get_entry_by_oid", rb_git_tree_get_entry_by_oid, 1);
 	rb_define_method(rb_cRuggedTree, "path", rb_git_tree_path, 1);
+	rb_define_method(rb_cRuggedTree, "diff", rb_git_tree_diff, -1);
+	rb_define_method(rb_cRuggedTree, "diff_workdir", rb_git_tree_diff_workdir, -1);
 	rb_define_method(rb_cRuggedTree, "[]", rb_git_tree_get_entry, 1);
 	rb_define_method(rb_cRuggedTree, "each", rb_git_tree_each, 0);
 	rb_define_method(rb_cRuggedTree, "walk", rb_git_tree_walk, 1);