From 319342c09152c61af13930e79777e1396f9c397f Mon Sep 17 00:00:00 2001 From: James Moger Date: Fri, 27 Sep 2013 20:25:06 -0400 Subject: Add normalized diffstats to the commit, commitdiff, and compare pages Change-Id: I8f26746a611e9ab955efe8b2597cc81db48fb085 --- src/main/java/com/gitblit/utils/DiffUtils.java | 247 +++++++++++++++++++++++-- 1 file changed, 228 insertions(+), 19 deletions(-) (limited to 'src/main/java/com/gitblit/utils/DiffUtils.java') diff --git a/src/main/java/com/gitblit/utils/DiffUtils.java b/src/main/java/com/gitblit/utils/DiffUtils.java index 3844d103..3c52cb03 100644 --- a/src/main/java/com/gitblit/utils/DiffUtils.java +++ b/src/main/java/com/gitblit/utils/DiffUtils.java @@ -16,6 +16,7 @@ package com.gitblit.utils; import java.io.ByteArrayOutputStream; +import java.io.Serializable; import java.text.MessageFormat; import java.util.ArrayList; import java.util.List; @@ -35,15 +36,16 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.gitblit.models.AnnotatedLine; +import com.gitblit.models.PathModel.PathChangeModel; /** * DiffUtils is a class of utility methods related to diff, patch, and blame. - * + * * The diff methods support pluggable diff output types like Gitblit, Gitweb, * and Plain. - * + * * @author James Moger - * + * */ public class DiffUtils { @@ -64,17 +66,116 @@ public class DiffUtils { return null; } } + + /** + * Encapsulates the output of a diff. + */ + public static class DiffOutput implements Serializable { + private static final long serialVersionUID = 1L; + + public final DiffOutputType type; + public final String content; + public final DiffStat stat; + + DiffOutput(DiffOutputType type, String content, DiffStat stat) { + this.type = type; + this.content = content; + this.stat = stat; + } + + public PathChangeModel getPath(String path) { + if (stat == null) { + return null; + } + return stat.getPath(path); + } + } + + /** + * Class that represents the number of insertions and deletions from a + * chunk. + */ + public static class DiffStat implements Serializable { + + private static final long serialVersionUID = 1L; + + public final List paths = new ArrayList(); + + private final String commitId; + + public DiffStat(String commitId) { + this.commitId = commitId; + } + + public PathChangeModel addPath(DiffEntry entry) { + PathChangeModel pcm = PathChangeModel.from(entry, commitId); + paths.add(pcm); + return pcm; + } + + public int getInsertions() { + int val = 0; + for (PathChangeModel entry : paths) { + val += entry.insertions; + } + return val; + } + + public int getDeletions() { + int val = 0; + for (PathChangeModel entry : paths) { + val += entry.deletions; + } + return val; + } + + public PathChangeModel getPath(String path) { + PathChangeModel stat = null; + for (PathChangeModel p : paths) { + if (p.path.equals(path)) { + stat = p; + break; + } + } + return stat; + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + for (PathChangeModel entry : paths) { + sb.append(entry.toString()).append('\n'); + } + sb.setLength(sb.length() - 1); + return sb.toString(); + } + } + + public static class NormalizedDiffStat implements Serializable { + + private static final long serialVersionUID = 1L; + + public final int insertions; + public final int deletions; + public final int blanks; + + NormalizedDiffStat(int insertions, int deletions, int blanks) { + this.insertions = insertions; + this.deletions = deletions; + this.blanks = blanks; + } + } /** * Returns the complete diff of the specified commit compared to its primary * parent. - * + * * @param repository * @param commit * @param outputType - * @return the diff as a string + * @return the diff */ - public static String getCommitDiff(Repository repository, RevCommit commit, + public static DiffOutput getCommitDiff(Repository repository, RevCommit commit, DiffOutputType outputType) { return getDiff(repository, null, commit, null, outputType); } @@ -82,35 +183,35 @@ public class DiffUtils { /** * Returns the diff for the specified file or folder from the specified * commit compared to its primary parent. - * + * * @param repository * @param commit * @param path * @param outputType - * @return the diff as a string + * @return the diff */ - public static String getDiff(Repository repository, RevCommit commit, String path, + public static DiffOutput getDiff(Repository repository, RevCommit commit, String path, DiffOutputType outputType) { return getDiff(repository, null, commit, path, outputType); } /** * Returns the complete diff between the two specified commits. - * + * * @param repository * @param baseCommit * @param commit * @param outputType - * @return the diff as a string + * @return the diff */ - public static String getDiff(Repository repository, RevCommit baseCommit, RevCommit commit, + public static DiffOutput getDiff(Repository repository, RevCommit baseCommit, RevCommit commit, DiffOutputType outputType) { return getDiff(repository, baseCommit, commit, null, outputType); } /** * Returns the diff between two commits for the specified file. - * + * * @param repository * @param baseCommit * if base commit is null the diff is to the primary parent of @@ -120,10 +221,11 @@ public class DiffUtils { * if the path is specified, the diff is restricted to that file * or folder. if unspecified, the diff is for the entire commit. * @param outputType - * @return the diff as a string + * @return the diff */ - public static String getDiff(Repository repository, RevCommit baseCommit, RevCommit commit, + public static DiffOutput getDiff(Repository repository, RevCommit baseCommit, RevCommit commit, String path, DiffOutputType outputType) { + DiffStat stat = null; String diff = null; try { final ByteArrayOutputStream os = new ByteArrayOutputStream(); @@ -131,7 +233,7 @@ public class DiffUtils { DiffFormatter df; switch (outputType) { case HTML: - df = new GitBlitDiffFormatter(os); + df = new GitBlitDiffFormatter(os, commit.getName()); break; case PLAIN: default: @@ -172,6 +274,7 @@ public class DiffUtils { if (df instanceof GitBlitDiffFormatter) { // workaround for complex private methods in DiffFormatter diff = ((GitBlitDiffFormatter) df).getHtml(); + stat = ((GitBlitDiffFormatter) df).getDiffStat(); } else { diff = os.toString(); } @@ -179,13 +282,14 @@ public class DiffUtils { } catch (Throwable t) { LOGGER.error("failed to generate commit diff!", t); } - return diff; + + return new DiffOutput(outputType, diff, stat); } /** * Returns the diff between the two commits for the specified file or folder * formatted as a patch. - * + * * @param repository * @param baseCommit * if base commit is unspecified, the patch is generated against @@ -242,10 +346,72 @@ public class DiffUtils { return diff; } + public static DiffStat getDiffStat(Repository repository, RevCommit commit) { + return getDiffStat(repository, null, commit, null); + } + + /** + * Returns the diffstat between the two commits for the specified file or folder. + * + * @param repository + * @param baseCommit + * if base commit is unspecified, the diffstat is generated against + * the primary parent of the specified commit. + * @param commit + * @param path + * if path is specified, the diffstat is generated only for the + * specified file or folder. if unspecified, the diffstat is + * generated for the entire diff between the two commits. + * @return patch as a string + */ + public static DiffStat getDiffStat(Repository repository, RevCommit baseCommit, + RevCommit commit, String path) { + DiffStat stat = null; + try { + RawTextComparator cmp = RawTextComparator.DEFAULT; + DiffStatFormatter df = new DiffStatFormatter(commit.getName()); + df.setRepository(repository); + df.setDiffComparator(cmp); + df.setDetectRenames(true); + + RevTree commitTree = commit.getTree(); + RevTree baseTree; + if (baseCommit == null) { + if (commit.getParentCount() > 0) { + final RevWalk rw = new RevWalk(repository); + RevCommit parent = rw.parseCommit(commit.getParent(0).getId()); + baseTree = parent.getTree(); + } else { + // FIXME initial commit. no parent?! + baseTree = commitTree; + } + } else { + baseTree = baseCommit.getTree(); + } + + List diffEntries = df.scan(baseTree, commitTree); + if (path != null && path.length() > 0) { + for (DiffEntry diffEntry : diffEntries) { + if (diffEntry.getNewPath().equalsIgnoreCase(path)) { + df.format(diffEntry); + break; + } + } + } else { + df.format(diffEntries); + } + stat = df.getDiffStat(); + df.flush(); + } catch (Throwable t) { + LOGGER.error("failed to generate commit diff!", t); + } + return stat; + } + /** * Returns the list of lines in the specified source file annotated with the * source commit metadata. - * + * * @param repository * @param blobPath * @param objectId @@ -276,4 +442,47 @@ public class DiffUtils { } return lines; } + + /** + * Normalizes a diffstat to an N-segment display. + * + * @params segments + * @param insertions + * @param deletions + * @return a normalized diffstat + */ + public static NormalizedDiffStat normalizeDiffStat(final int segments, final int insertions, final int deletions) { + final int total = insertions + deletions; + final float fi = ((float) insertions) / total; + int si; + int sd; + int sb; + if (deletions == 0) { + // only addition + si = Math.min(insertions, segments); + sd = 0; + sb = si < segments ? (segments - si) : 0; + } else if (insertions == 0) { + // only deletion + si = 0; + sd = Math.min(deletions, segments); + sb = sd < segments ? (segments - sd) : 0; + } else if (total <= segments) { + // total churn fits in segment display + si = insertions; + sd = deletions; + sb = segments - total; + } else if ((segments % 2) > 0 && fi > 0.45f && fi < 0.55f) { + // odd segment display, fairly even +/-, use even number of segments + si = Math.round(((float) insertions)/total * (segments - 1)); + sd = segments - 1 - si; + sb = 1; + } else { + si = Math.round(((float) insertions)/total * segments); + sd = segments - si; + sb = 0; + } + + return new NormalizedDiffStat(si, sd, sb); + } } -- cgit v1.2.3