From 5735bf5e6ab4da347b601d4b85c09c5c701dc002 Mon Sep 17 00:00:00 2001 From: Russell Belfer Date: Tue, 13 Nov 2012 13:58:29 -0800 Subject: [PATCH] Fix diff API to better parameter order The diff API is not in the parameter order one would expect from other libgit2 APIs. This fixes that. --- include/git2/diff.h | 36 +++++------ src/checkout.c | 2 +- src/diff.c | 119 +++++++++++++------------------------ src/stash.c | 7 ++- src/status.c | 4 +- src/submodule.c | 4 +- tests-clar/diff/diffiter.c | 18 +++--- tests-clar/diff/index.c | 6 +- tests-clar/diff/patch.c | 4 +- tests-clar/diff/rename.c | 4 +- tests-clar/diff/tree.c | 16 ++--- tests-clar/diff/workdir.c | 53 +++++++++-------- 12 files changed, 120 insertions(+), 153 deletions(-) diff --git a/include/git2/diff.h b/include/git2/diff.h index 9b11f169b..a220c2e9b 100644 --- a/include/git2/diff.h +++ b/include/git2/diff.h @@ -317,52 +317,52 @@ GIT_EXTERN(void) git_diff_list_free(git_diff_list *diff); * * This is equivalent to `git diff ` * + * @param diff Output pointer to a git_diff_list pointer to be allocated. * @param repo The repository containing the trees. - * @param opts Structure with options to influence diff or NULL for defaults. * @param old_tree A git_tree object to diff from. * @param new_tree A git_tree object to diff to. - * @param diff A pointer to a git_diff_list pointer that will be allocated. + * @param opts Structure with options to influence diff or NULL for defaults. */ GIT_EXTERN(int) git_diff_tree_to_tree( + git_diff_list **diff, git_repository *repo, - const git_diff_options *opts, /**< can be NULL for defaults */ git_tree *old_tree, git_tree *new_tree, - git_diff_list **diff); + const git_diff_options *opts); /**< can be NULL for defaults */ /** - * Compute a difference between a tree and the index. + * Compute a difference between a tree and the repository index. * * This is equivalent to `git diff --cached ` or if you pass * the HEAD tree, then like `git diff --cached`. * + * @param diff Output pointer to a git_diff_list pointer to be allocated. * @param repo The repository containing the tree and index. - * @param opts Structure with options to influence diff or NULL for defaults. * @param old_tree A git_tree object to diff from. - * @param diff A pointer to a git_diff_list pointer that will be allocated. + * @param opts Structure with options to influence diff or NULL for defaults. */ GIT_EXTERN(int) git_diff_index_to_tree( + git_diff_list **diff, git_repository *repo, - const git_diff_options *opts, /**< can be NULL for defaults */ git_tree *old_tree, - git_diff_list **diff); + const git_diff_options *opts); /**< can be NULL for defaults */ /** - * Compute a difference between the working directory and the index. + * Compute a difference between the working directory and the repository index. * * This matches the `git diff` command. See the note below on * `git_diff_workdir_to_tree` for a discussion of the difference between * `git diff` and `git diff HEAD` and how to emulate a `git diff ` * using libgit2. * + * @param diff Output pointer to a git_diff_list pointer to be allocated. * @param repo The repository. * @param opts Structure with options to influence diff or NULL for defaults. - * @param diff A pointer to a git_diff_list pointer that will be allocated. */ GIT_EXTERN(int) git_diff_workdir_to_index( + git_diff_list **diff, git_repository *repo, - const git_diff_options *opts, /**< can be NULL for defaults */ - git_diff_list **diff); + const git_diff_options *opts); /**< can be NULL for defaults */ /** * Compute a difference between the working directory and a tree. @@ -386,16 +386,16 @@ GIT_EXTERN(int) git_diff_workdir_to_index( * The tree-to-workdir diff for that file is 'modified', but core git would * show status 'deleted' since there is a pending deletion in the index. * - * @param repo The repository containing the tree. - * @param opts Structure with options to influence diff or NULL for defaults. - * @param old_tree A git_tree object to diff from. * @param diff A pointer to a git_diff_list pointer that will be allocated. + * @param repo The repository containing the tree. + * @param old_tree A git_tree object to diff from. + * @param opts Structure with options to influence diff or NULL for defaults. */ GIT_EXTERN(int) git_diff_workdir_to_tree( + git_diff_list **diff, git_repository *repo, - const git_diff_options *opts, /**< can be NULL for defaults */ git_tree *old_tree, - git_diff_list **diff); + const git_diff_options *opts); /**< can be NULL for defaults */ /** * Merge one diff list into another. diff --git a/src/checkout.c b/src/checkout.c index 0d14e2625..bf1ff4f12 100644 --- a/src/checkout.c +++ b/src/checkout.c @@ -625,7 +625,7 @@ int git_checkout_index( if (opts && opts->paths.count > 0) diff_opts.pathspec = opts->paths; - if ((error = git_diff_workdir_to_index(repo, &diff_opts, &diff)) < 0) + if ((error = git_diff_workdir_to_index(&diff, repo, &diff_opts)) < 0) goto cleanup; if ((error = git_buf_puts(&workdir, git_repository_workdir(repo))) < 0) diff --git a/src/diff.c b/src/diff.c index 6f48d72a2..b75ada1e0 100644 --- a/src/diff.c +++ b/src/diff.c @@ -568,11 +568,11 @@ static int diff_list_init_from_iterators( } static int diff_from_iterators( + git_diff_list **diff_ptr, git_repository *repo, - const git_diff_options *opts, /**< can be NULL for defaults */ git_iterator *old_iter, git_iterator *new_iter, - git_diff_list **diff_ptr) + const git_diff_options *opts) { int error = 0; const git_index_entry *oitem, *nitem; @@ -747,108 +747,71 @@ fail: error = -1; } - git_iterator_free(old_iter); - git_iterator_free(new_iter); git_buf_free(&ignore_prefix); return error; } +#define DIFF_FROM_ITERATORS(SETUP, MAKE_FIRST, MAKE_SECOND) \ + int error; \ + git_iterator *a = NULL, *b = NULL; \ + char *pfx = opts ? git_pathspec_prefix(&opts->pathspec) : NULL; \ + SETUP; \ + if (!(error = MAKE_FIRST) && !(error = MAKE_SECOND)) \ + error = diff_from_iterators(diff, repo, a, b, opts); \ + git__free(pfx); git_iterator_free(a); git_iterator_free(b); \ + return error + int git_diff_tree_to_tree( + git_diff_list **diff, git_repository *repo, - const git_diff_options *opts, /**< can be NULL for defaults */ git_tree *old_tree, git_tree *new_tree, - git_diff_list **diff) + const git_diff_options *opts) { - git_iterator *a = NULL, *b = NULL; - char *pfx = opts ? git_pathspec_prefix(&opts->pathspec) : NULL; - - assert(repo && old_tree && new_tree && diff); - - if (git_iterator_for_tree_range(&a, repo, old_tree, pfx, pfx) < 0 || - git_iterator_for_tree_range(&b, repo, new_tree, pfx, pfx) < 0) - return -1; - - git__free(pfx); - - return diff_from_iterators(repo, opts, a, b, diff); + DIFF_FROM_ITERATORS( + assert(repo && old_tree && new_tree && diff), + git_iterator_for_tree_range(&a, repo, old_tree, pfx, pfx), + git_iterator_for_tree_range(&b, repo, new_tree, pfx, pfx) + ); } int git_diff_index_to_tree( + git_diff_list **diff, git_repository *repo, - const git_diff_options *opts, git_tree *old_tree, - git_diff_list **diff) + const git_diff_options *opts) { - git_iterator *a = NULL, *b = NULL; - char *pfx = opts ? git_pathspec_prefix(&opts->pathspec) : NULL; - - assert(repo && diff); - - if (git_iterator_for_tree_range(&a, repo, old_tree, pfx, pfx) < 0 || - git_iterator_for_index_range(&b, repo, pfx, pfx) < 0) - goto on_error; - - git__free(pfx); - - return diff_from_iterators(repo, opts, a, b, diff); - -on_error: - git__free(pfx); - git_iterator_free(a); - return -1; + DIFF_FROM_ITERATORS( + assert(repo && diff), + git_iterator_for_tree_range(&a, repo, old_tree, pfx, pfx), + git_iterator_for_index_range(&b, repo, pfx, pfx) + ); } int git_diff_workdir_to_index( + git_diff_list **diff, git_repository *repo, - const git_diff_options *opts, - git_diff_list **diff) + const git_diff_options *opts) { - int error; - git_iterator *a = NULL, *b = NULL; - char *pfx = opts ? git_pathspec_prefix(&opts->pathspec) : NULL; - - assert(repo && diff); - - if ((error = git_iterator_for_index_range(&a, repo, pfx, pfx)) < 0 || - (error = git_iterator_for_workdir_range(&b, repo, pfx, pfx)) < 0) - goto on_error; - - git__free(pfx); - - return diff_from_iterators(repo, opts, a, b, diff); - -on_error: - git__free(pfx); - git_iterator_free(a); - return error; + DIFF_FROM_ITERATORS( + assert(repo && diff), + git_iterator_for_index_range(&a, repo, pfx, pfx), + git_iterator_for_workdir_range(&b, repo, pfx, pfx) + ); } int git_diff_workdir_to_tree( + git_diff_list **diff, git_repository *repo, - const git_diff_options *opts, - git_tree *tree, - git_diff_list **diff) + git_tree *old_tree, + const git_diff_options *opts) { - int error; - git_iterator *a = NULL, *b = NULL; - char *pfx = opts ? git_pathspec_prefix(&opts->pathspec) : NULL; - - assert(repo && tree && diff); - - if ((error = git_iterator_for_tree_range(&a, repo, tree, pfx, pfx)) < 0 || - (error = git_iterator_for_workdir_range(&b, repo, pfx, pfx)) < 0) - goto on_error; - - git__free(pfx); - - return diff_from_iterators(repo, opts, a, b, diff); - -on_error: - git__free(pfx); - git_iterator_free(a); - return error; + DIFF_FROM_ITERATORS( + assert(repo && diff), + git_iterator_for_tree_range(&a, repo, old_tree, pfx, pfx), + git_iterator_for_workdir_range(&b, repo, pfx, pfx) + ); } diff --git a/src/stash.c b/src/stash.c index 7bff466d1..2af3ca9fa 100644 --- a/src/stash.c +++ b/src/stash.c @@ -250,7 +250,7 @@ static int build_untracked_tree( if (git_commit_tree(&i_tree, i_commit) < 0) goto cleanup; - if (git_diff_workdir_to_tree(git_index_owner(index), &opts, i_tree, &diff) < 0) + if (git_diff_workdir_to_tree(&diff, git_index_owner(index), i_tree, &opts) < 0) goto cleanup; if (git_diff_foreach(diff, &data, update_index_cb, NULL, NULL) < 0) @@ -312,6 +312,7 @@ static int build_workdir_tree( git_index *index, git_commit *b_commit) { + git_repository *repo = git_index_owner(index); git_tree *b_tree = NULL; git_diff_list *diff = NULL, *diff2 = NULL; git_diff_options opts = {0}; @@ -321,10 +322,10 @@ static int build_workdir_tree( if (git_commit_tree(&b_tree, b_commit) < 0) goto cleanup; - if (git_diff_index_to_tree(git_index_owner(index), &opts, b_tree, &diff) < 0) + if (git_diff_index_to_tree(&diff, repo, b_tree, &opts) < 0) goto cleanup; - if (git_diff_workdir_to_index(git_index_owner(index), &opts, &diff2) < 0) + if (git_diff_workdir_to_index(&diff2, repo, &opts) < 0) goto cleanup; if (git_diff_merge(diff, diff2) < 0) diff --git a/src/status.c b/src/status.c index 0bd170e6d..9140ac2a8 100644 --- a/src/status.c +++ b/src/status.c @@ -142,11 +142,11 @@ int git_status_foreach_ext( /* TODO: support EXCLUDE_SUBMODULES flag */ if (show != GIT_STATUS_SHOW_WORKDIR_ONLY && - (err = git_diff_index_to_tree(repo, &diffopt, head, &idx2head)) < 0) + (err = git_diff_index_to_tree(&idx2head, repo, head, &diffopt)) < 0) goto cleanup; if (show != GIT_STATUS_SHOW_INDEX_ONLY && - (err = git_diff_workdir_to_index(repo, &diffopt, &wd2idx)) < 0) + (err = git_diff_workdir_to_index(&wd2idx, repo, &diffopt)) < 0) goto cleanup; usercb.cb = cb; diff --git a/src/submodule.c b/src/submodule.c index 1364b6881..1bd8c42da 100644 --- a/src/submodule.c +++ b/src/submodule.c @@ -1455,7 +1455,7 @@ static int submodule_wd_status(unsigned int *status, git_submodule *sm) if (sm->ignore == GIT_SUBMODULE_IGNORE_NONE) opt.flags |= GIT_DIFF_INCLUDE_UNTRACKED; - error = git_diff_index_to_tree(sm_repo, &opt, sm_head, &diff); + error = git_diff_index_to_tree(&diff, sm_repo, sm_head, &opt); if (!error) { if (git_diff_num_deltas(diff) > 0) @@ -1472,7 +1472,7 @@ static int submodule_wd_status(unsigned int *status, git_submodule *sm) /* perform index-to-workdir diff on submodule */ - error = git_diff_workdir_to_index(sm_repo, &opt, &diff); + error = git_diff_workdir_to_index(&diff, sm_repo, &opt); if (!error) { size_t untracked = diff --git a/tests-clar/diff/diffiter.c b/tests-clar/diff/diffiter.c index 86e8d1f57..f021d46f4 100644 --- a/tests-clar/diff/diffiter.c +++ b/tests-clar/diff/diffiter.c @@ -16,7 +16,7 @@ void test_diff_diffiter__create(void) git_diff_list *diff; size_t d, num_d; - cl_git_pass(git_diff_workdir_to_index(repo, NULL, &diff)); + cl_git_pass(git_diff_workdir_to_index(&diff, repo, NULL)); num_d = git_diff_num_deltas(diff); for (d = 0; d < num_d; ++d) { @@ -34,7 +34,7 @@ void test_diff_diffiter__iterate_files(void) size_t d, num_d; int count = 0; - cl_git_pass(git_diff_workdir_to_index(repo, NULL, &diff)); + cl_git_pass(git_diff_workdir_to_index(&diff, repo, NULL)); num_d = git_diff_num_deltas(diff); cl_assert_equal_i(6, (int)num_d); @@ -57,7 +57,7 @@ void test_diff_diffiter__iterate_files_2(void) size_t d, num_d; int count = 0; - cl_git_pass(git_diff_workdir_to_index(repo, NULL, &diff)); + cl_git_pass(git_diff_workdir_to_index(&diff, repo, NULL)); num_d = git_diff_num_deltas(diff); cl_assert_equal_i(8, (int)num_d); @@ -85,7 +85,7 @@ void test_diff_diffiter__iterate_files_and_hunks(void) opts.interhunk_lines = 1; opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED; - cl_git_pass(git_diff_workdir_to_index(repo, &opts, &diff)); + cl_git_pass(git_diff_workdir_to_index(&diff, repo, &opts)); num_d = git_diff_num_deltas(diff); @@ -138,7 +138,7 @@ void test_diff_diffiter__max_size_threshold(void) opts.interhunk_lines = 1; opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED; - cl_git_pass(git_diff_workdir_to_index(repo, &opts, &diff)); + cl_git_pass(git_diff_workdir_to_index(&diff, repo, &opts)); num_d = git_diff_num_deltas(diff); for (d = 0; d < num_d; ++d) { @@ -173,7 +173,7 @@ void test_diff_diffiter__max_size_threshold(void) opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED; opts.max_size = 50; /* treat anything over 50 bytes as binary! */ - cl_git_pass(git_diff_workdir_to_index(repo, &opts, &diff)); + cl_git_pass(git_diff_workdir_to_index(&diff, repo, &opts)); num_d = git_diff_num_deltas(diff); for (d = 0; d < num_d; ++d) { @@ -216,7 +216,7 @@ void test_diff_diffiter__iterate_all(void) opts.interhunk_lines = 1; opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED; - cl_git_pass(git_diff_workdir_to_index(repo, &opts, &diff)); + cl_git_pass(git_diff_workdir_to_index(&diff, repo, &opts)); num_d = git_diff_num_deltas(diff); for (d = 0; d < num_d; ++d) { @@ -292,7 +292,7 @@ void test_diff_diffiter__iterate_randomly_while_saving_state(void) opts.interhunk_lines = 1; opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED; - cl_git_pass(git_diff_workdir_to_index(repo, &opts, &diff)); + cl_git_pass(git_diff_workdir_to_index(&diff, repo, &opts)); num_d = git_diff_num_deltas(diff); @@ -419,7 +419,7 @@ void test_diff_diffiter__iterate_and_generate_patch_text(void) git_diff_list *diff; size_t d, num_d; - cl_git_pass(git_diff_workdir_to_index(repo, NULL, &diff)); + cl_git_pass(git_diff_workdir_to_index(&diff, repo, NULL)); num_d = git_diff_num_deltas(diff); cl_assert_equal_i(8, (int)num_d); diff --git a/tests-clar/diff/index.c b/tests-clar/diff/index.c index eda8f066a..dede9419b 100644 --- a/tests-clar/diff/index.c +++ b/tests-clar/diff/index.c @@ -32,7 +32,7 @@ void test_diff_index__0(void) memset(&exp, 0, sizeof(exp)); - cl_git_pass(git_diff_index_to_tree(g_repo, &opts, a, &diff)); + cl_git_pass(git_diff_index_to_tree(&diff, g_repo, a, &opts)); cl_git_pass(git_diff_foreach( diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn)); @@ -60,7 +60,7 @@ void test_diff_index__0(void) diff = NULL; memset(&exp, 0, sizeof(exp)); - cl_git_pass(git_diff_index_to_tree(g_repo, &opts, b, &diff)); + cl_git_pass(git_diff_index_to_tree(&diff, g_repo, b, &opts)); cl_git_pass(git_diff_foreach( diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn)); @@ -125,7 +125,7 @@ void test_diff_index__1(void) memset(&exp, 0, sizeof(exp)); - cl_git_pass(git_diff_index_to_tree(g_repo, &opts, a, &diff)); + cl_git_pass(git_diff_index_to_tree(&diff, g_repo, a, &opts)); cl_assert_equal_i( GIT_EUSER, diff --git a/tests-clar/diff/patch.c b/tests-clar/diff/patch.c index dce6d6da2..6aaf7651f 100644 --- a/tests-clar/diff/patch.c +++ b/tests-clar/diff/patch.c @@ -88,7 +88,7 @@ void test_diff_patch__can_properly_display_the_removal_of_a_file(void) one = resolve_commit_oid_to_tree(g_repo, one_sha); another = resolve_commit_oid_to_tree(g_repo, another_sha); - cl_git_pass(git_diff_tree_to_tree(g_repo, NULL, one, another, &diff)); + cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, one, another, NULL)); cl_git_pass(git_diff_print_patch(diff, NULL, check_removal_cb)); @@ -111,7 +111,7 @@ void test_diff_patch__to_string(void) one = resolve_commit_oid_to_tree(g_repo, one_sha); another = resolve_commit_oid_to_tree(g_repo, another_sha); - cl_git_pass(git_diff_tree_to_tree(g_repo, NULL, one, another, &diff)); + cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, one, another, NULL)); cl_assert_equal_i(1, git_diff_num_deltas(diff)); diff --git a/tests-clar/diff/rename.c b/tests-clar/diff/rename.c index 0ee1db842..1ea2e3fc9 100644 --- a/tests-clar/diff/rename.c +++ b/tests-clar/diff/rename.c @@ -47,7 +47,7 @@ void test_diff_rename__match_oid(void) diffopts.flags |= GIT_DIFF_INCLUDE_UNMODIFIED; cl_git_pass(git_diff_tree_to_tree( - g_repo, &diffopts, old_tree, new_tree, &diff)); + &diff, g_repo, old_tree, new_tree, &diffopts)); /* git diff --no-renames \ * 31e47d8c1fa36d7f8d537b96158e3f024de0a9f2 \ @@ -79,7 +79,7 @@ void test_diff_rename__match_oid(void) git_diff_list_free(diff); cl_git_pass(git_diff_tree_to_tree( - g_repo, &diffopts, old_tree, new_tree, &diff)); + &diff, g_repo, old_tree, new_tree, &diffopts)); /* git diff --find-copies-harder \ * 31e47d8c1fa36d7f8d537b96158e3f024de0a9f2 \ diff --git a/tests-clar/diff/tree.c b/tests-clar/diff/tree.c index f8b9a71a5..8e8939976 100644 --- a/tests-clar/diff/tree.c +++ b/tests-clar/diff/tree.c @@ -34,7 +34,7 @@ void test_diff_tree__0(void) memset(&exp, 0, sizeof(exp)); - cl_git_pass(git_diff_tree_to_tree(g_repo, &opts, a, b, &diff)); + cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, &opts)); cl_git_pass(git_diff_foreach( diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn)); @@ -56,7 +56,7 @@ void test_diff_tree__0(void) memset(&exp, 0, sizeof(exp)); - cl_git_pass(git_diff_tree_to_tree(g_repo, &opts, c, b, &diff)); + cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, c, b, &opts)); cl_git_pass(git_diff_foreach( diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn)); @@ -141,9 +141,9 @@ void test_diff_tree__options(void) opts = test_options[i]; if (test_ab_or_cd[i] == 0) - cl_git_pass(git_diff_tree_to_tree(g_repo, &opts, a, b, &diff)); + cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, &opts)); else - cl_git_pass(git_diff_tree_to_tree(g_repo, &opts, c, d, &diff)); + cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, c, d, &opts)); cl_git_pass(git_diff_foreach( diff, &actual, diff_file_fn, diff_hunk_fn, diff_line_fn)); @@ -187,7 +187,7 @@ void test_diff_tree__bare(void) memset(&exp, 0, sizeof(exp)); - cl_git_pass(git_diff_tree_to_tree(g_repo, &opts, a, b, &diff)); + cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, &opts)); cl_git_pass(git_diff_foreach( diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn)); @@ -225,9 +225,9 @@ void test_diff_tree__merge(void) cl_assert((b = resolve_commit_oid_to_tree(g_repo, b_commit)) != NULL); cl_assert((c = resolve_commit_oid_to_tree(g_repo, c_commit)) != NULL); - cl_git_pass(git_diff_tree_to_tree(g_repo, NULL, a, b, &diff1)); + cl_git_pass(git_diff_tree_to_tree(&diff1, g_repo, a, b, NULL)); - cl_git_pass(git_diff_tree_to_tree(g_repo, NULL, c, b, &diff2)); + cl_git_pass(git_diff_tree_to_tree(&diff2, g_repo, c, b, NULL)); git_tree_free(a); git_tree_free(b); @@ -279,7 +279,7 @@ void test_diff_tree__larger_hunks(void) opts.context_lines = 1; opts.interhunk_lines = 0; - cl_git_pass(git_diff_tree_to_tree(g_repo, &opts, a, b, &diff)); + cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, a, b, &opts)); num_d = git_diff_num_deltas(diff); for (d = 0; d < num_d; ++d) { diff --git a/tests-clar/diff/workdir.c b/tests-clar/diff/workdir.c index e617560f7..8de68e545 100644 --- a/tests-clar/diff/workdir.c +++ b/tests-clar/diff/workdir.c @@ -26,7 +26,7 @@ void test_diff_workdir__to_index(void) opts.interhunk_lines = 1; opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED; - cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff)); + cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, &opts)); for (use_iterator = 0; use_iterator <= 1; use_iterator++) { memset(&exp, 0, sizeof(exp)); @@ -94,7 +94,7 @@ void test_diff_workdir__to_tree(void) * The results are documented at the bottom of this file in the * long comment entitled "PREPARATION OF TEST DATA". */ - cl_git_pass(git_diff_workdir_to_tree(g_repo, &opts, a, &diff)); + cl_git_pass(git_diff_workdir_to_tree(&diff, g_repo, a, &opts)); for (use_iterator = 0; use_iterator <= 1; use_iterator++) { memset(&exp, 0, sizeof(exp)); @@ -127,8 +127,8 @@ void test_diff_workdir__to_tree(void) * a workdir to tree diff (even though it is not really). This is what * you would get from "git diff --name-status 26a125ee1bf" */ - cl_git_pass(git_diff_index_to_tree(g_repo, &opts, a, &diff)); - cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff2)); + cl_git_pass(git_diff_index_to_tree(&diff, g_repo, a, &opts)); + cl_git_pass(git_diff_workdir_to_index(&diff2, g_repo, &opts)); cl_git_pass(git_diff_merge(diff, diff2)); git_diff_list_free(diff2); @@ -164,8 +164,8 @@ void test_diff_workdir__to_tree(void) /* Again, emulating "git diff " for testing purposes using * "git diff --name-status 0017bd4ab1ec3" instead. */ - cl_git_pass(git_diff_index_to_tree(g_repo, &opts, b, &diff)); - cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff2)); + cl_git_pass(git_diff_index_to_tree(&diff, g_repo, b, &opts)); + cl_git_pass(git_diff_workdir_to_index(&diff2, g_repo, &opts)); cl_git_pass(git_diff_merge(diff, diff2)); git_diff_list_free(diff2); @@ -216,7 +216,7 @@ void test_diff_workdir__to_index_with_pathspec(void) opts.pathspec.strings = &pathspec; opts.pathspec.count = 1; - cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff)); + cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, &opts)); for (use_iterator = 0; use_iterator <= 1; use_iterator++) { memset(&exp, 0, sizeof(exp)); @@ -239,7 +239,7 @@ void test_diff_workdir__to_index_with_pathspec(void) pathspec = "modified_file"; - cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff)); + cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, &opts)); for (use_iterator = 0; use_iterator <= 1; use_iterator++) { memset(&exp, 0, sizeof(exp)); @@ -262,7 +262,7 @@ void test_diff_workdir__to_index_with_pathspec(void) pathspec = "subdir"; - cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff)); + cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, &opts)); for (use_iterator = 0; use_iterator <= 1; use_iterator++) { memset(&exp, 0, sizeof(exp)); @@ -285,7 +285,7 @@ void test_diff_workdir__to_index_with_pathspec(void) pathspec = "*_deleted"; - cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff)); + cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, &opts)); for (use_iterator = 0; use_iterator <= 1; use_iterator++) { memset(&exp, 0, sizeof(exp)); @@ -324,7 +324,7 @@ void test_diff_workdir__filemode_changes(void) /* test once with no mods */ - cl_git_pass(git_diff_workdir_to_index(g_repo, NULL, &diff)); + cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, NULL)); for (use_iterator = 0; use_iterator <= 1; use_iterator++) { memset(&exp, 0, sizeof(exp)); @@ -347,7 +347,7 @@ void test_diff_workdir__filemode_changes(void) cl_assert(cl_toggle_filemode("issue_592/a.txt")); - cl_git_pass(git_diff_workdir_to_index(g_repo, NULL, &diff)); + cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, NULL)); for (use_iterator = 0; use_iterator <= 1; use_iterator++) { memset(&exp, 0, sizeof(exp)); @@ -386,7 +386,7 @@ void test_diff_workdir__filemode_changes_with_filemode_false(void) /* test once with no mods */ - cl_git_pass(git_diff_workdir_to_index(g_repo, NULL, &diff)); + cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, NULL)); memset(&exp, 0, sizeof(exp)); cl_git_pass(git_diff_foreach( @@ -402,7 +402,7 @@ void test_diff_workdir__filemode_changes_with_filemode_false(void) cl_assert(cl_toggle_filemode("issue_592/a.txt")); - cl_git_pass(git_diff_workdir_to_index(g_repo, NULL, &diff)); + cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, NULL)); memset(&exp, 0, sizeof(exp)); cl_git_pass(git_diff_foreach( @@ -442,8 +442,8 @@ void test_diff_workdir__head_index_and_workdir_all_differ(void) opts.pathspec.strings = &pathspec; opts.pathspec.count = 1; - cl_git_pass(git_diff_index_to_tree(g_repo, &opts, tree, &diff_i2t)); - cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff_w2i)); + cl_git_pass(git_diff_index_to_tree(&diff_i2t, g_repo, tree, &opts)); + cl_git_pass(git_diff_workdir_to_index(&diff_w2i, g_repo, &opts)); for (use_iterator = 0; use_iterator <= 1; use_iterator++) { memset(&exp, 0, sizeof(exp)); @@ -529,7 +529,7 @@ void test_diff_workdir__eof_newline_changes(void) opts.pathspec.strings = &pathspec; opts.pathspec.count = 1; - cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff)); + cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, &opts)); for (use_iterator = 0; use_iterator <= 1; use_iterator++) { memset(&exp, 0, sizeof(exp)); @@ -556,7 +556,7 @@ void test_diff_workdir__eof_newline_changes(void) cl_git_append2file("status/current_file", "\n"); - cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff)); + cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, &opts)); for (use_iterator = 0; use_iterator <= 1; use_iterator++) { memset(&exp, 0, sizeof(exp)); @@ -583,7 +583,7 @@ void test_diff_workdir__eof_newline_changes(void) cl_git_rewritefile("status/current_file", "current_file"); - cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff)); + cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, &opts)); for (use_iterator = 0; use_iterator <= 1; use_iterator++) { memset(&exp, 0, sizeof(exp)); @@ -699,13 +699,13 @@ void test_diff_workdir__larger_hunks(void) /* okay, this is a bit silly, but oh well */ switch (i) { case 0: - cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff)); + cl_git_pass(git_diff_workdir_to_index(&diff, g_repo, &opts)); break; case 1: - cl_git_pass(git_diff_workdir_to_tree(g_repo, &opts, a, &diff)); + cl_git_pass(git_diff_workdir_to_tree(&diff, g_repo, a, &opts)); break; case 2: - cl_git_pass(git_diff_workdir_to_tree(g_repo, &opts, b, &diff)); + cl_git_pass(git_diff_workdir_to_tree(&diff, g_repo, b, &opts)); break; } @@ -784,7 +784,7 @@ void test_diff_workdir__submodules(void) GIT_DIFF_RECURSE_UNTRACKED_DIRS | GIT_DIFF_INCLUDE_UNTRACKED_CONTENT; - cl_git_pass(git_diff_workdir_to_tree(g_repo, &opts, a, &diff)); + cl_git_pass(git_diff_workdir_to_tree(&diff, g_repo, a, &opts)); /* diff_print(stderr, diff); */ @@ -828,10 +828,13 @@ void test_diff_workdir__cannot_diff_against_a_bare_repository(void) g_repo = cl_git_sandbox_init("testrepo.git"); - cl_assert_equal_i(GIT_EBAREREPO, git_diff_workdir_to_index(g_repo, &opts, &diff)); + cl_assert_equal_i( + GIT_EBAREREPO, git_diff_workdir_to_index(&diff, g_repo, &opts)); cl_git_pass(git_repository_head_tree(&tree, g_repo)); - cl_assert_equal_i(GIT_EBAREREPO, git_diff_workdir_to_tree(g_repo, &opts, tree, &diff)); + + cl_assert_equal_i( + GIT_EBAREREPO, git_diff_workdir_to_tree(&diff, g_repo, tree, &opts)); git_tree_free(tree); }