Add normalized diffstats to the commit, commitdiff, and compare pages

Change-Id: I8f26746a611e9ab955efe8b2597cc81db48fb085

1 files changed, 228 insertions, 19 deletions

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<PathChangeModel> paths = new ArrayList<PathChangeModel>();

+		

+		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<DiffEntry> 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);

+	}

 }