From e35e2684f693f28afb7a8f28028b4cb8bdd19f49 Mon Sep 17 00:00:00 2001 From: Russell Belfer Date: Tue, 7 May 2013 04:32:17 -0700 Subject: [PATCH 1/4] Add GIT_DIFF_LINE_CONTEXT_EOFNL This adds a new line origin constant for the special line that is used when both files end without a newline. In the course of writing the tests for this, I was having problems with modifying a file but not having diff notice because it was the same size and modified less than one second from the start of the test, so I decided to start working on nanosecond timestamp support. This commit doesn't contain the nanosecond support, but it contains the reorganization of maybe_modified and the hooks so that if the nanosecond data were being read by stat() (or rather being copied by git_index_entry__init_from_stat), then the nsec would be taken into account. This new stuff could probably use some more tests, although there is some amount of it here. --- include/git2/diff.h | 6 +- src/diff.c | 129 ++++++++++++++++++++------------- src/diff.h | 1 + src/diff_output.c | 2 +- tests-clar/diff/diff_helpers.c | 11 +-- tests-clar/diff/patch.c | 37 ++++++++-- 6 files changed, 117 insertions(+), 69 deletions(-) diff --git a/include/git2/diff.h b/include/git2/diff.h index 0ef47c018..e10b65f7b 100644 --- a/include/git2/diff.h +++ b/include/git2/diff.h @@ -356,8 +356,10 @@ typedef enum { GIT_DIFF_LINE_CONTEXT = ' ', GIT_DIFF_LINE_ADDITION = '+', GIT_DIFF_LINE_DELETION = '-', - GIT_DIFF_LINE_ADD_EOFNL = '\n', /**< Removed line w/o LF & added one with */ - GIT_DIFF_LINE_DEL_EOFNL = '\0', /**< LF was removed at end of file */ + + GIT_DIFF_LINE_CONTEXT_EOFNL = '=', /**< Both files have no LF at end */ + GIT_DIFF_LINE_ADD_EOFNL = '>', /**< Old has no LF at end, new does */ + GIT_DIFF_LINE_DEL_EOFNL = '<', /**< Old has LF at end, new does not */ /* The following values will only be sent to a `git_diff_data_cb` when * the content of a diff is being formatted (eg. through diff --git a/src/diff.c b/src/diff.c index fbff1a6fb..e0dff9c95 100644 --- a/src/diff.c +++ b/src/diff.c @@ -389,6 +389,9 @@ static int diff_list_apply_options( /* Don't set GIT_DIFFCAPS_USE_DEV - compile time option in core git */ + /* Set GIT_DIFFCAPS_TRUST_NANOSECS on a platform basis */ + diff->diffcaps = diff->diffcaps | GIT_DIFFCAPS_TRUST_NANOSECS; + /* If not given explicit `opts`, check `diff.xyz` configs */ if (!opts) { diff->opts.context_lines = config_int(cfg, "diff.context", 3); @@ -529,6 +532,13 @@ cleanup: return result; } +static bool diff_time_eq( + const git_index_time *a, const git_index_time *b, bool use_nanos) +{ + return a->seconds == a->seconds && + (!use_nanos || a->nanoseconds == b->nanoseconds); +} + typedef struct { git_repository *repo; git_iterator *old_iter; @@ -540,11 +550,51 @@ typedef struct { #define MODE_BITS_MASK 0000777 +static int maybe_modified_submodule( + git_delta_t *status, + git_oid *found_oid, + git_diff_list *diff, + diff_in_progress *info) +{ + int error = 0; + git_submodule *sub; + unsigned int sm_status = 0; + const git_oid *sm_oid; + + *status = GIT_DELTA_UNMODIFIED; + + if (!DIFF_FLAG_IS_SET(diff, GIT_DIFF_IGNORE_SUBMODULES) && + !(error = git_submodule_lookup( + &sub, diff->repo, info->nitem->path)) && + git_submodule_ignore(sub) != GIT_SUBMODULE_IGNORE_ALL && + !(error = git_submodule_status(&sm_status, sub))) + { + /* check IS_WD_UNMODIFIED because this case is only used + * when the new side of the diff is the working directory + */ + if (!GIT_SUBMODULE_STATUS_IS_WD_UNMODIFIED(sm_status)) + *status = GIT_DELTA_MODIFIED; + + /* grab OID while we are here */ + if (git_oid_iszero(&info->nitem->oid) && + (sm_oid = git_submodule_wd_id(sub)) != NULL) + git_oid_cpy(found_oid, sm_oid); + } + + /* GIT_EEXISTS means a dir with .git in it was found - ignore it */ + if (error == GIT_EEXISTS) { + giterr_clear(); + error = 0; + } + + return error; +} + static int maybe_modified( git_diff_list *diff, diff_in_progress *info) { - git_oid noid, *use_noid = NULL; + git_oid noid; git_delta_t status = GIT_DELTA_MODIFIED; const git_index_entry *oitem = info->oitem; const git_index_entry *nitem = info->nitem; @@ -560,6 +610,8 @@ static int maybe_modified( &matched_pathspec)) return 0; + memset(&noid, 0, sizeof(noid)); + /* on platforms with no symlinks, preserve mode of existing symlinks */ if (S_ISLNK(omode) && S_ISREG(nmode) && new_is_workdir && !(diff->diffcaps & GIT_DIFFCAPS_HAS_SYMLINKS)) @@ -600,55 +652,30 @@ static int maybe_modified( * circumstances that can accelerate things or need special handling */ else if (git_oid_iszero(&nitem->oid) && new_is_workdir) { + bool use_ctime = ((diff->diffcaps & GIT_DIFFCAPS_TRUST_CTIME) != 0); + bool use_nanos = ((diff->diffcaps & GIT_DIFFCAPS_TRUST_NANOSECS) != 0); + + status = GIT_DELTA_UNMODIFIED; + /* TODO: add check against index file st_mtime to avoid racy-git */ - /* if the stat data looks exactly alike, then assume the same */ - if (omode == nmode && - oitem->file_size == nitem->file_size && - (!(diff->diffcaps & GIT_DIFFCAPS_TRUST_CTIME) || - (oitem->ctime.seconds == nitem->ctime.seconds)) && - oitem->mtime.seconds == nitem->mtime.seconds && - (!(diff->diffcaps & GIT_DIFFCAPS_USE_DEV) || - (oitem->dev == nitem->dev)) && - oitem->ino == nitem->ino && - oitem->uid == nitem->uid && - oitem->gid == nitem->gid) - status = GIT_DELTA_UNMODIFIED; - - else if (S_ISGITLINK(nmode)) { - int err; - git_submodule *sub; - - if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_IGNORE_SUBMODULES)) - status = GIT_DELTA_UNMODIFIED; - else if ((err = git_submodule_lookup(&sub, diff->repo, nitem->path)) < 0) { - if (err == GIT_EEXISTS) - status = GIT_DELTA_UNMODIFIED; - else - return err; - } else if (git_submodule_ignore(sub) == GIT_SUBMODULE_IGNORE_ALL) - status = GIT_DELTA_UNMODIFIED; - else { - unsigned int sm_status = 0; - if (git_submodule_status(&sm_status, sub) < 0) - return -1; - - /* check IS_WD_UNMODIFIED because this case is only used - * when the new side of the diff is the working directory - */ - status = GIT_SUBMODULE_STATUS_IS_WD_UNMODIFIED(sm_status) - ? GIT_DELTA_UNMODIFIED : GIT_DELTA_MODIFIED; - - /* grab OID while we are here */ - if (git_oid_iszero(&nitem->oid)) { - const git_oid *sm_oid = git_submodule_wd_id(sub); - if (sm_oid != NULL) { - git_oid_cpy(&noid, sm_oid); - use_noid = &noid; - } - } - } + if (S_ISGITLINK(nmode)) { + if (maybe_modified_submodule(&status, &noid, diff, info) < 0) + return -1; } + + /* if the stat data looks different, then mark modified - this just + * means that the OID will be recalculated below to confirm change + */ + else if (omode != nmode || + oitem->file_size != nitem->file_size || + !diff_time_eq(&oitem->mtime, &nitem->mtime, use_nanos) || + (use_ctime && + !diff_time_eq(&oitem->ctime, &nitem->ctime, use_nanos)) || + oitem->ino != nitem->ino || + oitem->uid != nitem->uid || + oitem->gid != nitem->gid) + status = GIT_DELTA_MODIFIED; } /* if mode is GITLINK and submodules are ignored, then skip */ @@ -660,11 +687,10 @@ static int maybe_modified( * haven't calculated the OID of the new item, then calculate it now */ if (status != GIT_DELTA_UNMODIFIED && git_oid_iszero(&nitem->oid)) { - if (!use_noid) { + if (git_oid_iszero(&noid)) { if (git_diff__oid_for_file(diff->repo, nitem->path, nitem->mode, nitem->file_size, &noid) < 0) return -1; - use_noid = &noid; } /* if oid matches, then mark unmodified (except submodules, where @@ -672,12 +698,13 @@ static int maybe_modified( * matches between the index and the workdir HEAD) */ if (omode == nmode && !S_ISGITLINK(omode) && - git_oid_equal(&oitem->oid, use_noid)) + git_oid_equal(&oitem->oid, &noid)) status = GIT_DELTA_UNMODIFIED; } return diff_delta__from_two( - diff, status, oitem, omode, nitem, nmode, use_noid, matched_pathspec); + diff, status, oitem, omode, nitem, nmode, + git_oid_iszero(&noid) ? NULL : &noid, matched_pathspec); } static bool entry_is_prefixed( diff --git a/src/diff.h b/src/diff.h index 48e20d1e3..16df431ed 100644 --- a/src/diff.h +++ b/src/diff.h @@ -26,6 +26,7 @@ enum { GIT_DIFFCAPS_TRUST_MODE_BITS = (1 << 2), /* use st_mode? */ GIT_DIFFCAPS_TRUST_CTIME = (1 << 3), /* use st_ctime? */ GIT_DIFFCAPS_USE_DEV = (1 << 4), /* use st_dev? */ + GIT_DIFFCAPS_TRUST_NANOSECS = (1 << 5), /* use stat time nanoseconds */ }; enum { diff --git a/src/diff_output.c b/src/diff_output.c index bac8622c8..dda0f534d 100644 --- a/src/diff_output.c +++ b/src/diff_output.c @@ -726,7 +726,7 @@ static int diff_patch_cb(void *priv, mmbuffer_t *bufs, int len) char origin = (*bufs[0].ptr == '+') ? GIT_DIFF_LINE_DEL_EOFNL : (*bufs[0].ptr == '-') ? GIT_DIFF_LINE_ADD_EOFNL : - GIT_DIFF_LINE_CONTEXT; + GIT_DIFF_LINE_CONTEXT_EOFNL; if (ctxt->data_cb != NULL && ctxt->data_cb(patch->delta, &ctxt->range, diff --git a/tests-clar/diff/diff_helpers.c b/tests-clar/diff/diff_helpers.c index e7f97c034..75eda0520 100644 --- a/tests-clar/diff/diff_helpers.c +++ b/tests-clar/diff/diff_helpers.c @@ -97,20 +97,15 @@ int diff_line_cb( e->lines++; switch (line_origin) { case GIT_DIFF_LINE_CONTEXT: + case GIT_DIFF_LINE_CONTEXT_EOFNL: /* techically not a line */ e->line_ctxt++; break; case GIT_DIFF_LINE_ADDITION: - e->line_adds++; - break; - case GIT_DIFF_LINE_ADD_EOFNL: - /* technically not a line add, but we'll count it as such */ + case GIT_DIFF_LINE_ADD_EOFNL: /* technically not a line add */ e->line_adds++; break; case GIT_DIFF_LINE_DELETION: - e->line_dels++; - break; - case GIT_DIFF_LINE_DEL_EOFNL: - /* technically not a line delete, but we'll count it as such */ + case GIT_DIFF_LINE_DEL_EOFNL: /* technically not a line delete */ e->line_dels++; break; default: diff --git a/tests-clar/diff/patch.c b/tests-clar/diff/patch.c index 40b191dd5..c9a13f7fb 100644 --- a/tests-clar/diff/patch.c +++ b/tests-clar/diff/patch.c @@ -323,12 +323,12 @@ void test_diff_patch__hunks_have_correct_line_numbers(void) } static void check_single_patch_stats( - git_repository *repo, size_t hunks, size_t adds, size_t dels) + git_repository *repo, size_t hunks, size_t adds, size_t dels, size_t ctxt) { git_diff_list *diff; git_diff_patch *patch; const git_diff_delta *delta; - size_t actual_adds, actual_dels; + size_t actual_ctxt, actual_adds, actual_dels; cl_git_pass(git_diff_index_to_workdir(&diff, repo, NULL, NULL)); @@ -339,9 +339,10 @@ static void check_single_patch_stats( cl_assert_equal_i((int)hunks, (int)git_diff_patch_num_hunks(patch)); - cl_git_pass( - git_diff_patch_line_stats(NULL, &actual_adds, &actual_dels, patch)); + cl_git_pass( git_diff_patch_line_stats( + &actual_ctxt, &actual_adds, &actual_dels, patch) ); + cl_assert_equal_sz(ctxt, actual_ctxt); cl_assert_equal_sz(adds, actual_adds); cl_assert_equal_sz(dels, actual_dels); @@ -369,14 +370,14 @@ void test_diff_patch__line_counts_with_eofnl(void) git_buf_consume(&content, end); cl_git_rewritefile("renames/songof7cities.txt", content.ptr); - check_single_patch_stats(g_repo, 1, 0, 1); + check_single_patch_stats(g_repo, 1, 0, 1, 3); /* remove trailing whitespace */ git_buf_rtrim(&content); cl_git_rewritefile("renames/songof7cities.txt", content.ptr); - check_single_patch_stats(g_repo, 2, 1, 2); + check_single_patch_stats(g_repo, 2, 1, 2, 6); /* add trailing whitespace */ @@ -388,7 +389,29 @@ void test_diff_patch__line_counts_with_eofnl(void) cl_git_pass(git_buf_putc(&content, '\n')); cl_git_rewritefile("renames/songof7cities.txt", content.ptr); - check_single_patch_stats(g_repo, 1, 1, 1); + check_single_patch_stats(g_repo, 1, 1, 1, 3); + + /* no trailing whitespace as context line */ + + { + /* walk back a couple lines, make space and insert char */ + char *scan = content.ptr + content.size; + int i; + + for (i = 0; i < 5; ++i) { + for (--scan; scan > content.ptr && *scan != '\n'; --scan) + /* seek to prev \n */; + } + cl_assert(scan > content.ptr); + + /* overwrite trailing \n with right-shifted content */ + memmove(scan + 1, scan, content.size - (scan - content.ptr) - 1); + /* insert '#' char into space we created */ + scan[1] = '#'; + } + cl_git_rewritefile("renames/songof7cities.txt", content.ptr); + + check_single_patch_stats(g_repo, 1, 1, 1, 6); git_buf_free(&content); git_config_free(cfg); From fd96f98e142cdb129f447ace189b2086951be313 Mon Sep 17 00:00:00 2001 From: Russell Belfer Date: Tue, 7 May 2013 04:36:42 -0700 Subject: [PATCH 2/4] More tests for files with no newline at end --- tests-clar/diff/patch.c | 35 ++++++++++++++++++++++++++++++----- 1 file changed, 30 insertions(+), 5 deletions(-) diff --git a/tests-clar/diff/patch.c b/tests-clar/diff/patch.c index c9a13f7fb..6181ffbaf 100644 --- a/tests-clar/diff/patch.c +++ b/tests-clar/diff/patch.c @@ -323,7 +323,9 @@ void test_diff_patch__hunks_have_correct_line_numbers(void) } static void check_single_patch_stats( - git_repository *repo, size_t hunks, size_t adds, size_t dels, size_t ctxt) + git_repository *repo, size_t hunks, + size_t adds, size_t dels, size_t ctxt, + const char *expected) { git_diff_list *diff; git_diff_patch *patch; @@ -346,6 +348,13 @@ static void check_single_patch_stats( cl_assert_equal_sz(adds, actual_adds); cl_assert_equal_sz(dels, actual_dels); + if (expected != NULL) { + char *text; + cl_git_pass(git_diff_patch_to_str(&text, patch)); + cl_assert_equal_s(expected, text); + git__free(text); + } + git_diff_patch_free(patch); git_diff_list_free(diff); } @@ -370,14 +379,14 @@ void test_diff_patch__line_counts_with_eofnl(void) git_buf_consume(&content, end); cl_git_rewritefile("renames/songof7cities.txt", content.ptr); - check_single_patch_stats(g_repo, 1, 0, 1, 3); + check_single_patch_stats(g_repo, 1, 0, 1, 3, NULL); /* remove trailing whitespace */ git_buf_rtrim(&content); cl_git_rewritefile("renames/songof7cities.txt", content.ptr); - check_single_patch_stats(g_repo, 2, 1, 2, 6); + check_single_patch_stats(g_repo, 2, 1, 2, 6, NULL); /* add trailing whitespace */ @@ -389,7 +398,7 @@ void test_diff_patch__line_counts_with_eofnl(void) cl_git_pass(git_buf_putc(&content, '\n')); cl_git_rewritefile("renames/songof7cities.txt", content.ptr); - check_single_patch_stats(g_repo, 1, 1, 1, 3); + check_single_patch_stats(g_repo, 1, 1, 1, 3, NULL); /* no trailing whitespace as context line */ @@ -411,7 +420,23 @@ void test_diff_patch__line_counts_with_eofnl(void) } cl_git_rewritefile("renames/songof7cities.txt", content.ptr); - check_single_patch_stats(g_repo, 1, 1, 1, 6); + check_single_patch_stats( + g_repo, 1, 1, 1, 6, + /* below is pasted output of 'git diff' with fn context removed */ + "diff --git a/songof7cities.txt b/songof7cities.txt\n" + "index 378a7d9..3d0154e 100644\n" + "--- a/songof7cities.txt\n" + "+++ b/songof7cities.txt\n" + "@@ -42,7 +42,7 @@\n" + " \n" + " To the sound of trumpets shall their seed restore my Cities\n" + " Wealthy and well-weaponed, that once more may I behold\n" + "-All the world go softly when it walks before my Cities,\n" + "+#All the world go softly when it walks before my Cities,\n" + " And the horses and the chariots fleeing from them as of old!\n" + " \n" + " -- Rudyard Kipling\n" + "\\ No newline at end of file\n"); git_buf_free(&content); git_config_free(cfg); From d63eec6946341e5efa0514bbf2904db2ded2a294 Mon Sep 17 00:00:00 2001 From: Russell Belfer Date: Tue, 7 May 2013 04:44:08 -0700 Subject: [PATCH 3/4] Improve diff function docs --- include/git2/diff.h | 33 ++++++++++++++++++++++++++------- 1 file changed, 26 insertions(+), 7 deletions(-) diff --git a/include/git2/diff.h b/include/git2/diff.h index e10b65f7b..1feddd7a2 100644 --- a/include/git2/diff.h +++ b/include/git2/diff.h @@ -490,6 +490,8 @@ typedef struct { /** * Deallocate a diff list. + * + * @param diff The previously created diff list; cannot be used after free. */ GIT_EXTERN(void) git_diff_list_free(git_diff_list *diff); @@ -499,12 +501,14 @@ GIT_EXTERN(void) git_diff_list_free(git_diff_list *diff); * This is equivalent to `git diff ` * * The first tree will be used for the "old_file" side of the delta and the - * second tree will be used for the "new_file" side of the delta. + * second tree will be used for the "new_file" side of the delta. You can + * pass NULL to indicate an empty tree, although it is an error to pass + * NULL for both the `old_tree` and `new_tree`. * * @param diff Output pointer to a git_diff_list pointer to be allocated. * @param repo The repository containing the trees. - * @param old_tree A git_tree object to diff from. - * @param new_tree A git_tree object to diff to. + * @param old_tree A git_tree object to diff from, or NULL for empty tree. + * @param new_tree A git_tree object to diff to, or NULL for empty tree. * @param opts Structure with options to influence diff or NULL for defaults. */ GIT_EXTERN(int) git_diff_tree_to_tree( @@ -525,7 +529,7 @@ GIT_EXTERN(int) git_diff_tree_to_tree( * * @param diff Output pointer to a git_diff_list pointer to be allocated. * @param repo The repository containing the tree and index. - * @param old_tree A git_tree object to diff from. + * @param old_tree A git_tree object to diff from, or NULL for empty tree. * @param index The index to diff with; repo index used if NULL. * @param opts Structure with options to influence diff or NULL for defaults. */ @@ -584,7 +588,7 @@ GIT_EXTERN(int) git_diff_index_to_workdir( * * @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 old_tree A git_tree object to diff from, or NULL for empty tree. * @param opts Structure with options to influence diff or NULL for defaults. */ GIT_EXTERN(int) git_diff_tree_to_workdir( @@ -928,7 +932,14 @@ GIT_EXTERN(int) git_diff_patch_to_str( * to 1 and no call to the hunk_cb nor line_cb will be made (unless you pass * `GIT_DIFF_FORCE_TEXT` of course). * - * @return 0 on success, GIT_EUSER on non-zero callback, or error code + * @param old_blob Blob for old side of diff, or NULL for empty blob + * @param new_blob Blob for new side of diff, or NULL for empty blob + * @param options Options for diff, or NULL for default options + * @param file_cb Callback for "file"; made once if there is a diff; can be NULL + * @param hunk_cb Callback for each hunk in diff; can be NULL + * @param line_cb Callback for each line in diff; can be NULL + * @param payload Payload passed to each callback function + * @return 0 on success, GIT_EUSER on non-zero callback return, or error code */ GIT_EXTERN(int) git_diff_blobs( const git_blob *old_blob, @@ -951,7 +962,15 @@ GIT_EXTERN(int) git_diff_blobs( * entire content of the buffer added). Passing NULL to the buffer will do * the reverse, with GIT_DELTA_REMOVED and blob content removed. * - * @return 0 on success, GIT_EUSER on non-zero callback, or error code + * @param old_blob Blob for old side of diff, or NULL for empty blob + * @param buffer Raw data for new side of diff + * @param buffer_len Length of raw data for new side of diff + * @param options Options for diff, or NULL for default options + * @param file_cb Callback for "file"; made once if there is a diff; can be NULL + * @param hunk_cb Callback for each hunk in diff; can be NULL + * @param line_cb Callback for each line in diff; can be NULL + * @param payload Payload passed to each callback function + * @return 0 on success, GIT_EUSER on non-zero callback return, or error code */ GIT_EXTERN(int) git_diff_blob_to_buffer( const git_blob *old_blob, From c2f602f8a5265a4be6383127435a18a8be98c9fe Mon Sep 17 00:00:00 2001 From: Russell Belfer Date: Tue, 7 May 2013 07:15:39 -0700 Subject: [PATCH 4/4] Fix line numbering for patches with eofnl When a patch contained an eofnl change (i.e. the last line either gained or lost a newline), the oldno and newno line number values for the lines in the last hunk of the patch were not useful. This makes them behave in a more expected manner. --- src/diff_output.c | 2 + tests-clar/diff/patch.c | 128 ++++++++++++++++++++++++++++++++++++++-- 2 files changed, 124 insertions(+), 6 deletions(-) diff --git a/src/diff_output.c b/src/diff_output.c index dda0f534d..2214ae1b5 100644 --- a/src/diff_output.c +++ b/src/diff_output.c @@ -930,11 +930,13 @@ static int diff_patch_line_cb( switch (line_origin) { case GIT_DIFF_LINE_ADDITION: + case GIT_DIFF_LINE_DEL_EOFNL: line->oldno = -1; line->newno = patch->newno; patch->newno += line->lines; break; case GIT_DIFF_LINE_DELETION: + case GIT_DIFF_LINE_ADD_EOFNL: line->oldno = patch->oldno; line->newno = -1; patch->oldno += line->lines; diff --git a/tests-clar/diff/patch.c b/tests-clar/diff/patch.c index 6181ffbaf..f9e913a74 100644 --- a/tests-clar/diff/patch.c +++ b/tests-clar/diff/patch.c @@ -226,6 +226,7 @@ void test_diff_patch__hunks_have_correct_line_numbers(void) size_t hdrlen, hunklen, textlen; char origin; int oldno, newno; + git_buf old_content = GIT_BUF_INIT, actual = GIT_BUF_INIT; const char *new_content = "The Song of Seven Cities\n------------------------\n\nI WAS Lord of Cities very sumptuously builded.\nSeven roaring Cities paid me tribute from afar.\nIvory their outposts were--the guardrooms of them gilded,\nAnd garrisoned with Amazons invincible in war.\n\nThis is some new text;\nNot as good as the old text;\nBut here it is.\n\nSo they warred and trafficked only yesterday, my Cities.\nTo-day there is no mark or mound of where my Cities stood.\nFor the River rose at midnight and it washed away my Cities.\nThey are evened with Atlantis and the towns before the Flood.\n\nRain on rain-gorged channels raised the water-levels round them,\nFreshet backed on freshet swelled and swept their world from sight,\nTill the emboldened floods linked arms and, flashing forward, drowned them--\nDrowned my Seven Cities and their peoples in one night!\n\nLow among the alders lie their derelict foundations,\nThe beams wherein they trusted and the plinths whereon they built--\nMy rulers and their treasure and their unborn populations,\nDead, destroyed, aborted, and defiled with mud and silt!\n\nAnother replacement;\nBreaking up the poem;\nGenerating some hunks.\n\nTo the sound of trumpets shall their seed restore my Cities\nWealthy and well-weaponed, that once more may I behold\nAll the world go softly when it walks before my Cities,\nAnd the horses and the chariots fleeing from them as of old!\n\n -- Rudyard Kipling\n"; g_repo = cl_git_sandbox_init("renames"); @@ -233,6 +234,9 @@ void test_diff_patch__hunks_have_correct_line_numbers(void) cl_git_pass(git_config_new(&cfg)); git_repository_set_config(g_repo, cfg); + cl_git_pass( + git_futils_readbuffer(&old_content, "renames/songof7cities.txt")); + cl_git_rewritefile("renames/songof7cities.txt", new_content); cl_git_pass(git_repository_head_tree(&head, g_repo)); @@ -263,21 +267,24 @@ void test_diff_patch__hunks_have_correct_line_numbers(void) cl_git_pass(git_diff_patch_get_line_in_hunk( &origin, &text, &textlen, &oldno, &newno, patch, 0, 0)); cl_assert_equal_i(GIT_DIFF_LINE_CONTEXT, (int)origin); - cl_assert(strncmp("Ivory their outposts were--the guardrooms of them gilded,\n", text, textlen) == 0); + cl_git_pass(git_buf_set(&actual, text, textlen)); + cl_assert_equal_s("Ivory their outposts were--the guardrooms of them gilded,\n", actual.ptr); cl_assert_equal_i(6, oldno); cl_assert_equal_i(6, newno); cl_git_pass(git_diff_patch_get_line_in_hunk( &origin, &text, &textlen, &oldno, &newno, patch, 0, 3)); cl_assert_equal_i(GIT_DIFF_LINE_DELETION, (int)origin); - cl_assert(strncmp("All the world went softly when it walked before my Cities--\n", text, textlen) == 0); + cl_git_pass(git_buf_set(&actual, text, textlen)); + cl_assert_equal_s("All the world went softly when it walked before my Cities--\n", actual.ptr); cl_assert_equal_i(9, oldno); cl_assert_equal_i(-1, newno); cl_git_pass(git_diff_patch_get_line_in_hunk( &origin, &text, &textlen, &oldno, &newno, patch, 0, 12)); cl_assert_equal_i(GIT_DIFF_LINE_ADDITION, (int)origin); - cl_assert(strncmp("This is some new text;\n", text, textlen) == 0); + cl_git_pass(git_buf_set(&actual, text, textlen)); + cl_assert_equal_s("This is some new text;\n", actual.ptr); cl_assert_equal_i(-1, oldno); cl_assert_equal_i(9, newno); @@ -298,26 +305,103 @@ void test_diff_patch__hunks_have_correct_line_numbers(void) cl_git_pass(git_diff_patch_get_line_in_hunk( &origin, &text, &textlen, &oldno, &newno, patch, 1, 0)); cl_assert_equal_i(GIT_DIFF_LINE_CONTEXT, (int)origin); - cl_assert(strncmp("My rulers and their treasure and their unborn populations,\n", text, textlen) == 0); + cl_git_pass(git_buf_set(&actual, text, textlen)); + cl_assert_equal_s("My rulers and their treasure and their unborn populations,\n", actual.ptr); cl_assert_equal_i(31, oldno); cl_assert_equal_i(25, newno); cl_git_pass(git_diff_patch_get_line_in_hunk( &origin, &text, &textlen, &oldno, &newno, patch, 1, 3)); cl_assert_equal_i(GIT_DIFF_LINE_DELETION, (int)origin); - cl_assert(strncmp("The Daughters of the Palace whom they cherished in my Cities,\n", text, textlen) == 0); + cl_git_pass(git_buf_set(&actual, text, textlen)); + cl_assert_equal_s("The Daughters of the Palace whom they cherished in my Cities,\n", actual.ptr); cl_assert_equal_i(34, oldno); cl_assert_equal_i(-1, newno); cl_git_pass(git_diff_patch_get_line_in_hunk( &origin, &text, &textlen, &oldno, &newno, patch, 1, 12)); cl_assert_equal_i(GIT_DIFF_LINE_ADDITION, (int)origin); - cl_assert(strncmp("Another replacement;\n", text, textlen) == 0); + cl_git_pass(git_buf_set(&actual, text, textlen)); + cl_assert_equal_s("Another replacement;\n", actual.ptr); cl_assert_equal_i(-1, oldno); cl_assert_equal_i(28, newno); git_diff_patch_free(patch); git_diff_list_free(diff); + + /* Let's check line numbers when there is no newline */ + + git_buf_rtrim(&old_content); + cl_git_rewritefile("renames/songof7cities.txt", old_content.ptr); + + cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, head, &opt)); + + cl_assert_equal_i(1, (int)git_diff_num_deltas(diff)); + + cl_git_pass(git_diff_get_patch(&patch, &delta, diff, 0)); + + cl_assert_equal_i(GIT_DELTA_MODIFIED, (int)delta->status); + cl_assert_equal_i(1, (int)git_diff_patch_num_hunks(patch)); + + /* check hunk 0 */ + + cl_git_pass( + git_diff_patch_get_hunk(&range, &hdr, &hdrlen, &hunklen, patch, 0)); + + cl_assert_equal_i(6, (int)hunklen); + + cl_assert_equal_i(46, (int)range->old_start); + cl_assert_equal_i(4, (int)range->old_lines); + cl_assert_equal_i(46, (int)range->new_start); + cl_assert_equal_i(4, (int)range->new_lines); + + cl_assert_equal_i(6, (int)git_diff_patch_num_lines_in_hunk(patch, 0)); + + cl_git_pass(git_diff_patch_get_line_in_hunk( + &origin, &text, &textlen, &oldno, &newno, patch, 0, 1)); + cl_assert_equal_i(GIT_DIFF_LINE_CONTEXT, (int)origin); + cl_git_pass(git_buf_set(&actual, text, textlen)); + cl_assert_equal_s("And the horses and the chariots fleeing from them as of old!\n", actual.ptr); + cl_assert_equal_i(47, oldno); + cl_assert_equal_i(47, newno); + + cl_git_pass(git_diff_patch_get_line_in_hunk( + &origin, &text, &textlen, &oldno, &newno, patch, 0, 2)); + cl_assert_equal_i(GIT_DIFF_LINE_CONTEXT, (int)origin); + cl_git_pass(git_buf_set(&actual, text, textlen)); + cl_assert_equal_s("\n", actual.ptr); + cl_assert_equal_i(48, oldno); + cl_assert_equal_i(48, newno); + + cl_git_pass(git_diff_patch_get_line_in_hunk( + &origin, &text, &textlen, &oldno, &newno, patch, 0, 3)); + cl_assert_equal_i(GIT_DIFF_LINE_DELETION, (int)origin); + cl_git_pass(git_buf_set(&actual, text, textlen)); + cl_assert_equal_s(" -- Rudyard Kipling\n", actual.ptr); + cl_assert_equal_i(49, oldno); + cl_assert_equal_i(-1, newno); + + cl_git_pass(git_diff_patch_get_line_in_hunk( + &origin, &text, &textlen, &oldno, &newno, patch, 0, 4)); + cl_assert_equal_i(GIT_DIFF_LINE_ADDITION, (int)origin); + cl_git_pass(git_buf_set(&actual, text, textlen)); + cl_assert_equal_s(" -- Rudyard Kipling", actual.ptr); + cl_assert_equal_i(-1, oldno); + cl_assert_equal_i(49, newno); + + cl_git_pass(git_diff_patch_get_line_in_hunk( + &origin, &text, &textlen, &oldno, &newno, patch, 0, 5)); + cl_assert_equal_i(GIT_DIFF_LINE_DEL_EOFNL, (int)origin); + cl_git_pass(git_buf_set(&actual, text, textlen)); + cl_assert_equal_s("\n\\ No newline at end of file\n", actual.ptr); + cl_assert_equal_i(-1, oldno); + cl_assert_equal_i(49, newno); + + git_diff_patch_free(patch); + git_diff_list_free(diff); + + git_buf_free(&actual); + git_buf_free(&old_content); git_tree_free(head); git_config_free(cfg); } @@ -355,6 +439,38 @@ static void check_single_patch_stats( git__free(text); } + /* walk lines in hunk with basic sanity checks */ + for (; hunks > 0; --hunks) { + size_t i, max_i; + int lastoldno = -1, oldno, lastnewno = -1, newno; + char origin; + + max_i = git_diff_patch_num_lines_in_hunk(patch, hunks - 1); + + for (i = 0; i < max_i; ++i) { + int expected = 1; + + cl_git_pass(git_diff_patch_get_line_in_hunk( + &origin, NULL, NULL, &oldno, &newno, patch, hunks - 1, i)); + + if (origin == GIT_DIFF_LINE_ADD_EOFNL || + origin == GIT_DIFF_LINE_DEL_EOFNL || + origin == GIT_DIFF_LINE_CONTEXT_EOFNL) + expected = 0; + + if (oldno >= 0) { + if (lastoldno >= 0) + cl_assert_equal_i(expected, oldno - lastoldno); + lastoldno = oldno; + } + if (newno >= 0) { + if (lastnewno >= 0) + cl_assert_equal_i(expected, newno - lastnewno); + lastnewno = newno; + } + } + } + git_diff_patch_free(patch); git_diff_list_free(diff); }