/*
* call-seq:
* rebase.inmemory_index -> index
*
* Gets the index produced by the last operation, which is the result
* of +next+ and which will be committed by the next invocation of
* +commit+. This is useful for resolving conflicts in an in-memory
* rebase before committing them.
*
* This is only applicable for in-memory rebases; for rebases within
* a working directory, the changes were applied to the repository's
* index.
*/
static VALUE rb_git_rebase_inmemory_index(VALUE self)
{
git_rebase *rebase;
git_index *index;
Data_Get_Struct(self, git_rebase, rebase);
rugged_exception_check(git_rebase_inmemory_index(&index, rebase));
return rugged_index_new(rb_cRuggedIndex, self, index);
}
/*
* tree.merge(other_tree[, ancestor_tree[, options]]) -> Rugged::Index
* tree.merge(other_tree[, options]) -> Rugged::Index
*
* Merges two trees and returns the a Rugged::Index object that reflects
* the result of the merge.
*
* The following options can be passed in the +options+ Hash:
*
* :renames ::
* If true, looking for renames will be enabled (`--find-renames`).
*
* :rename_threshold ::
* An integer specifying the minimum similarity of a file to be
* seen as an eligible rename source (default 50).
*
* :target_limit ::
* An integer specifying the maximum byte size of a file before a it will
* be treated as binary. The default value is 512MB.
*
* :favor ::
* Specifies how and if conflicts are auto-resolved by favoring a specific
* file output. Can be one of `:normal`, `:ours`, `:theirs` or `:union`.
*
*/
static VALUE rb_git_tree_merge(int argc, VALUE *argv, VALUE self)
{
VALUE rb_other_tree, rb_ancestor_tree, rb_options;
VALUE rb_repo = rugged_owner(self);
git_tree *tree, *other_tree, *ancestor_tree;
git_repository *repo;
git_index *index;
git_merge_options opts = GIT_MERGE_OPTIONS_INIT;
int error;
if (rb_scan_args(argc, argv, "12", &rb_other_tree, &rb_ancestor_tree, &rb_options) == 2) {
if (TYPE(rb_ancestor_tree) == T_HASH) {
rb_options = rb_ancestor_tree;
rb_ancestor_tree = Qnil;
}
}
if (!NIL_P(rb_options)) {
Check_Type(rb_options, T_HASH);
rugged_parse_merge_options(&opts, rb_options);
}
if (!rb_obj_is_kind_of(rb_other_tree, rb_cRuggedTree))
rb_raise(rb_eTypeError, "Expecting a Rugged::Tree instance");
else if (!NIL_P(rb_ancestor_tree) && !rb_obj_is_kind_of(rb_ancestor_tree, rb_cRuggedTree))
rb_raise(rb_eTypeError, "Expecting a Rugged::Tree instance");
Data_Get_Struct(self, git_tree, tree);
Data_Get_Struct(rb_repo, git_repository, repo);
Data_Get_Struct(rb_other_tree, git_tree, other_tree);
if (!NIL_P(rb_ancestor_tree))
Data_Get_Struct(rb_ancestor_tree, git_tree, ancestor_tree);
else
ancestor_tree = NULL;
error = git_merge_trees(&index, repo, ancestor_tree, tree, other_tree, &opts);
if (error == GIT_EMERGECONFLICT)
return Qnil;
rugged_exception_check(error);
return rugged_index_new(rb_cRuggedIndex, rb_repo, index);
}
/*
* call-seq:
* Index.new([path])
*
* Create a bare index object based on the index file at +path+.
*
* Any index methods that rely on the ODB or a working directory (e.g. #add)
* will raise a Rugged::IndexError.
*/
static VALUE rb_git_index_new(int argc, VALUE *argv, VALUE klass)
{
git_index *index;
int error;
VALUE rb_path;
const char *path = NULL;
if (rb_scan_args(argc, argv, "01", &rb_path) == 1) {
Check_Type(rb_path, T_STRING);
path = StringValueCStr(rb_path);
}
error = git_index_open(&index, path);
rugged_exception_check(error);
return rugged_index_new(klass, Qnil, index);
}
