Discrepancy in line change counts reported by your library

[omucci]

Version

7.5.0.202512021534-r

Operating System

Windows

Bug description

I'm using this library to extract numerical values related to added and deleted lines within commits of a Bitbucket repository. To calculate these values I'm using:
linesAdded += edit.getEndB() - edit.getBeginB(); linesDeleted += edit.getEndA() - edit.getBeginA();
However, I notice that for some commits—fortunately just a few—the numbers I obtain are incorrect compared to what I should be getting.

Actual behavior

I have reproduced one of the problematic commits in a public repository. For copyright reasons, I am unable to share the original commit; however, you can review the reproduced version at the following link:
omucci/IssueJgit@e106a4c...793db02.
As is evident, the commit shows 70 lines removed and 58 lines added. Nevertheless, the output produced by your library reports 50 lines inserted and 62 lines deleted.
This discrepancy suggests a potential issue in how line changes are computed or reported. I would appreciate your assistance in investigating this behavior.

For additional verification, I printed the edits of the hunk for that specific commit and obtained:
EditEditList[REPLACE(0-2,0-2), REPLACE(3-5,3-9), REPLACE(6-8,10-11), REPLACE(9-11,12-24), REPLACE(12-14,25-27), REPLACE(15-17,28-41), REPLACE(18-20,42-43), REPLACE(21-68,44-56), REPLACE(69-70,57-58)] Lines Added: 50 Lines Deleted: 62

My DiffFormatter is configured as follows:

try (DiffFormatter df = new DiffFormatter(DisabledOutputStream.INSTANCE)) {
    df.setRepository(repo);
    df.setDetectRenames(true); 
    df.getRenameDetector().setRenameScore(thresholdFileRename); 
    df.setDiffAlgorithm(DiffAlgorithm.getAlgorithm(DiffAlgorithm.SupportedAlgorithm.MYERS));
    df.setDiffComparator(RawTextComparator.DEFAULT);
}

Expected behavior

I would expect the result to clearly indicate 70 lines removed and 58 added, exactly as reported by both the Git comparator and the Bitbucket diff tool.

git diff --numstat 793db0271eb27394223ff338d2905fa3dd94e346 e106a4c2deb516d68d9647e7d8b1c0bf8fa66ef8
70      58      src/main/resources/test.sql

Relevant log output

Other information

Public repo: https://github.com/omucci/IssueJgit
Git compare:omucci/IssueJgit@e106a4c...793db02

[tomaswolf]

Different diff algorithms may produce different results. JGit considers the 8 empty lines in the new version to have come from the old version. The diff is nevertheless correct.

[tomaswolf]

Also see #232: is it possible that C git's slider logic merges individual diffs if separated only by a single new line in both version? If so, that would explain the different behavior.

[omucci]

Ok, I’ll provide another example where the empty lines don’t seem to be the issue. In this case, JGit reports 9 added lines and 10 deleted lines, whereas it should be 10 added and 11 deleted.

[tomaswolf]

Same case: JGit considers the empty line 57 in the new version to have come from empty line 61 in the old version. Github (based on C git?) somehow merges the chunks before and after, including that empty line in the chunks.

The chunks may be different; the end result when applied as a patch to the old version is identical.

[tomaswolf]

BTW: the difference doesn't seem to come from the slider heuristic nor from context lines: running git diff --no-indent-heuristic -U1 main~1: on your test repo gives exactly the same as github shows. (Also with -U0.) Looks like the Myers diff itself is slightly different...

[msohn]

Try HistogramDiff
https://github.com/eclipse-jgit/jgit/blob/master/org.eclipse.jgit/src/org/eclipse/jgit/diff/HistogramDiff.java#L17
which typically provides more readable diffs and is faster than MyersDiff.

See
https://eclipse.gerrithub.io/c/eclipse-jgit/jgit/+/1643
https://eclipse.gerrithub.io/c/eclipse-jgit/jgit/+/1662
https://eclipse.gerrithub.io/c/eclipse-jgit/jgit/+/30526

[omucci]

Try HistogramDiff https://github.com/eclipse-jgit/jgit/blob/master/org.eclipse.jgit/src/org/eclipse/jgit/diff/HistogramDiff.java#L17 which typically provides more readable diffs and is faster than MyersDiff.

See https://eclipse.gerrithub.io/c/eclipse-jgit/jgit/+/1643 https://eclipse.gerrithub.io/c/eclipse-jgit/jgit/+/1662 https://eclipse.gerrithub.io/c/eclipse-jgit/jgit/+/30526

The result I’m trying to achieve should get as close as possible to what I would obtain with git diff. Using the Histogram algorithm might improve the numbers for added and removed lines for this specific commit, but it will certainly make them worse for other commits