/*
* call-seq:
* index.clear -> nil
*
* Clear the contents (remove all entries) of the index object. Changes are in-memory only
* and can be saved by calling #write.
*/
static VALUE rb_git_index_clear(VALUE self)
{
git_index *index;
Data_Get_Struct(self, git_index, index);
git_index_clear(index);
return Qnil;
}
void test_index_names__roundtrip(void)
{
const git_index_name_entry *conflict_name;
cl_git_pass(git_index_name_add(repo_index, "ancestor", "ours", "theirs"));
cl_git_pass(git_index_name_add(repo_index, "ancestor2", "ours2", NULL));
cl_git_pass(git_index_name_add(repo_index, "ancestor3", NULL, "theirs3"));
cl_git_pass(git_index_write(repo_index));
git_index_clear(repo_index);
cl_assert(git_index_name_entrycount(repo_index) == 0);
cl_git_pass(git_index_read(repo_index, true));
cl_assert(git_index_name_entrycount(repo_index) == 3);
conflict_name = git_index_name_get_byindex(repo_index, 0);
cl_assert(strcmp(conflict_name->ancestor, "ancestor") == 0);
cl_assert(strcmp(conflict_name->ours, "ours") == 0);
cl_assert(strcmp(conflict_name->theirs, "theirs") == 0);
conflict_name = git_index_name_get_byindex(repo_index, 1);
cl_assert(strcmp(conflict_name->ancestor, "ancestor2") == 0);
cl_assert(strcmp(conflict_name->ours, "ours2") == 0);
cl_assert(conflict_name->theirs == NULL);
conflict_name = git_index_name_get_byindex(repo_index, 2);
cl_assert(strcmp(conflict_name->ancestor, "ancestor3") == 0);
cl_assert(conflict_name->ours == NULL);
cl_assert(strcmp(conflict_name->theirs, "theirs3") == 0);
}
void git_index_free(git_index *index)
{
if (index == NULL)
return;
git_index_clear(index);
free(index->index_file_path);
free(index);
}
ERL_NIF_TERM
geef_index_clear(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
geef_index *index;
if (!enif_get_resource(env, argv[0], geef_index_type, (void **) &index))
return enif_make_badarg(env);
git_index_clear(index->index);
return atoms.ok;
}
int git_index_read(git_index *index)
{
struct stat indexst;
int error = GIT_SUCCESS;
assert(index->index_file_path);
if (!index->on_disk || git_futils_exists(index->index_file_path) < 0) {
git_index_clear(index);
index->on_disk = 0;
return GIT_SUCCESS;
}
if (p_stat(index->index_file_path, &indexst) < 0)
return git__throw(GIT_EOSERR, "Failed to read index. %s does not exist or is corrupted", index->index_file_path);
if (!S_ISREG(indexst.st_mode))
return git__throw(GIT_ENOTFOUND, "Failed to read index. %s is not an index file", index->index_file_path);
if (indexst.st_mtime != index->last_modified) {
git_fbuffer buffer;
if ((error = git_futils_readbuffer(&buffer, index->index_file_path)) < GIT_SUCCESS)
return git__rethrow(error, "Failed to read index");
git_index_clear(index);
error = parse_index(index, buffer.data, buffer.len);
if (error == GIT_SUCCESS)
index->last_modified = indexst.st_mtime;
git_futils_freebuffer(&buffer);
}
if (error < GIT_SUCCESS)
return git__rethrow(error, "Failed to read index");
return error;
}
int git_index_read(git_index *index)
{
struct stat indexst;
int error = 0;
assert(index->index_file_path);
if (!index->on_disk || gitfo_exists(index->index_file_path) < 0) {
git_index_clear(index);
index->on_disk = 0;
return 0;
}
if (gitfo_stat(index->index_file_path, &indexst) < 0)
return GIT_EOSERR;
if (!S_ISREG(indexst.st_mode))
return GIT_ENOTFOUND;
if (indexst.st_mtime != index->last_modified) {
gitfo_buf buffer;
if (gitfo_read_file(&buffer, index->index_file_path) < 0)
return GIT_EOSERR;
git_index_clear(index);
error = git_index__parse(index, buffer.data, buffer.len);
if (error == 0)
index->last_modified = indexst.st_mtime;
gitfo_free_buf(&buffer);
}
return error;
}
static int build_untracked_tree(
git_tree **tree_out,
git_index *index,
git_commit *i_commit,
uint32_t flags)
{
git_tree *i_tree = NULL;
git_diff_list *diff = NULL;
git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
struct cb_data data = {0};
int error;
git_index_clear(index);
data.index = index;
if (flags & GIT_STASH_INCLUDE_UNTRACKED) {
opts.flags |= GIT_DIFF_INCLUDE_UNTRACKED |
GIT_DIFF_RECURSE_UNTRACKED_DIRS;
data.include_untracked = true;
}
if (flags & GIT_STASH_INCLUDE_IGNORED) {
opts.flags |= GIT_DIFF_INCLUDE_IGNORED;
data.include_ignored = true;
}
if ((error = git_commit_tree(&i_tree, i_commit)) < 0)
goto cleanup;
if ((error = git_diff_tree_to_workdir(
&diff, git_index_owner(index), i_tree, &opts)) < 0)
goto cleanup;
if ((error = git_diff_foreach(
diff, update_index_cb, NULL, NULL, &data)) < 0)
{
if (error == GIT_EUSER)
error = data.error;
goto cleanup;
}
error = build_tree_from_index(tree_out, index);
cleanup:
git_diff_list_free(diff);
git_tree_free(i_tree);
return error;
}
int cmd_read_tree(int argc, const char **argv)
{
please_git_do_it_for_me();
if (argc != 2)
please_git_do_it_for_me();
/* Find the current repository */
repo = get_git_repository();
/*Find the tree*/
git_tree *tree;
git_oid oid_tree;
switch (git_oid_fromstr(&oid_tree, (const char *)argv[argc-1])) {
case GIT_ENOTOID:
please_git_do_it_for_me();
break;
case GIT_SUCCESS:
break;
default:
libgit_error();
}
e = git_tree_lookup(&tree, repo, &oid_tree);
if (e) {
if (e == GIT_EINVALIDTYPE || e == GIT_ENOTFOUND) {
error("Tree object not found");
} else {
libgit_error();
}
}
/* Open the index */
if (git_repository_index(&index_cur, repo) < 0)
libgit_error();
/* Clear the index */
git_index_clear(index_cur);
/* add objects of the tree to the index */
add_tree_to_index(tree, "");
/* write the index */
git_index_write(index_cur);
return EXIT_SUCCESS;
}
void test_checkout_index__can_overcome_name_clashes(void)
{
git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
git_index *index;
cl_git_pass(git_repository_index(&index, g_repo));
git_index_clear(index);
cl_git_mkfile("./testrepo/path0", "content\r\n");
cl_git_pass(p_mkdir("./testrepo/path1", 0777));
cl_git_mkfile("./testrepo/path1/file1", "content\r\n");
cl_git_pass(git_index_add_bypath(index, "path0"));
cl_git_pass(git_index_add_bypath(index, "path1/file1"));
cl_git_pass(p_unlink("./testrepo/path0"));
cl_git_pass(git_futils_rmdir_r(
"./testrepo/path1", NULL, GIT_RMDIR_REMOVE_FILES));
cl_git_mkfile("./testrepo/path1", "content\r\n");
cl_git_pass(p_mkdir("./testrepo/path0", 0777));
cl_git_mkfile("./testrepo/path0/file0", "content\r\n");
cl_assert(git_path_isfile("./testrepo/path1"));
cl_assert(git_path_isfile("./testrepo/path0/file0"));
opts.checkout_strategy =
GIT_CHECKOUT_SAFE |
GIT_CHECKOUT_RECREATE_MISSING |
GIT_CHECKOUT_ALLOW_CONFLICTS;
cl_git_pass(git_checkout_index(g_repo, index, &opts));
cl_assert(git_path_isfile("./testrepo/path1"));
cl_assert(git_path_isfile("./testrepo/path0/file0"));
opts.checkout_strategy = GIT_CHECKOUT_FORCE;
cl_git_pass(git_checkout_index(g_repo, index, &opts));
cl_assert(git_path_isfile("./testrepo/path0"));
cl_assert(git_path_isfile("./testrepo/path1/file1"));
git_index_free(index);
}
/**
* Creates a git tree object representing the state of the working directory.
*/
static int sync_workdir_tree(git_oid *out,
git_repository *repo)
{
int e = 0;
git_index *index = NULL;
git_check(git_repository_index(&index, repo));
git_check(git_index_clear(index));
git_strarray paths = {NULL, 0};
git_check(git_index_add_all(index, &paths, 0, NULL, NULL));
git_check(git_index_write_tree(out, index));
if (!git_repository_is_bare(repo))
{
git_check(git_index_write(index));
}
exit:
if (index) git_index_free(index);
return e;
}
void test_index_reuc__updates_existing(void)
{
const git_index_reuc_entry *reuc;
git_oid ancestor_oid, our_oid, their_oid, oid;
int index_caps;
git_index_clear(repo_index);
index_caps = git_index_caps(repo_index);
index_caps |= GIT_INDEXCAP_IGNORE_CASE;
cl_git_pass(git_index_set_caps(repo_index, index_caps));
git_oid_fromstr(&ancestor_oid, TWO_ANCESTOR_OID);
git_oid_fromstr(&our_oid, TWO_OUR_OID);
git_oid_fromstr(&their_oid, TWO_THEIR_OID);
cl_git_pass(git_index_reuc_add(repo_index, "two.txt",
0100644, &ancestor_oid,
0100644, &our_oid,
0100644, &their_oid));
cl_git_pass(git_index_reuc_add(repo_index, "TWO.txt",
0100644, &our_oid,
0100644, &their_oid,
0100644, &ancestor_oid));
cl_assert_equal_i(1, git_index_reuc_entrycount(repo_index));
cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 0));
cl_assert(strcmp(reuc->path, "TWO.txt") == 0);
git_oid_fromstr(&oid, TWO_OUR_OID);
cl_assert(git_oid_cmp(&reuc->oid[0], &oid) == 0);
git_oid_fromstr(&oid, TWO_THEIR_OID);
cl_assert(git_oid_cmp(&reuc->oid[1], &oid) == 0);
git_oid_fromstr(&oid, TWO_ANCESTOR_OID);
cl_assert(git_oid_cmp(&reuc->oid[2], &oid) == 0);
}
void test_index_reuc__write(void)
{
git_oid ancestor_oid, our_oid, their_oid;
const git_index_reuc_entry *reuc;
git_index_clear(repo_index);
/* Write out of order to ensure sorting is correct */
git_oid_fromstr(&ancestor_oid, TWO_ANCESTOR_OID);
git_oid_fromstr(&our_oid, TWO_OUR_OID);
git_oid_fromstr(&their_oid, TWO_THEIR_OID);
cl_git_pass(git_index_reuc_add(repo_index, "two.txt",
0100644, &ancestor_oid,
0100644, &our_oid,
0100644, &their_oid));
git_oid_fromstr(&ancestor_oid, ONE_ANCESTOR_OID);
git_oid_fromstr(&our_oid, ONE_OUR_OID);
git_oid_fromstr(&their_oid, ONE_THEIR_OID);
cl_git_pass(git_index_reuc_add(repo_index, "one.txt",
0100644, &ancestor_oid,
0100644, &our_oid,
0100644, &their_oid));
cl_git_pass(git_index_write(repo_index));
cl_git_pass(git_index_read(repo_index));
cl_assert_equal_i(2, git_index_reuc_entrycount(repo_index));
/* ensure sort order was round-tripped correct */
cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 0));
cl_assert(strcmp(reuc->path, "one.txt") == 0);
cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 1));
cl_assert(strcmp(reuc->path, "two.txt") == 0);
}
void Index::clear()
{
int res = git_index_clear(index_.get());
assert(res == 0);
}
void Index::clear()
{
git_index_clear(data());
}
PyObject *
Index_clear(Index *self)
{
git_index_clear(self->index);
Py_RETURN_NONE;
}