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

Change-Id: I8f26746a611e9ab955efe8b2597cc81db48fb085

4 files changed, 347 insertions, 53 deletions

diff --git a/src/main/java/com/gitblit/utils/DiffStatFormatter.java b/src/main/java/com/gitblit/utils/DiffStatFormatter.java
new file mode 100644
index 00000000..572046ee
--- /dev/null
+++ b/src/main/java/com/gitblit/utils/DiffStatFormatter.java
@@ -0,0 +1,60 @@
+/*

+ * Copyright 2013 gitblit.com.

+ *

+ * Licensed under the Apache License, Version 2.0 (the "License");

+ * you may not use this file except in compliance with the License.

+ * You may obtain a copy of the License at

+ *

+ *     http://www.apache.org/licenses/LICENSE-2.0

+ *

+ * Unless required by applicable law or agreed to in writing, software

+ * distributed under the License is distributed on an "AS IS" BASIS,

+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+ * See the License for the specific language governing permissions and

+ * limitations under the License.

+ */

+package com.gitblit.utils;

+

+import java.io.IOException;

+

+import org.eclipse.jgit.diff.DiffEntry;

+import org.eclipse.jgit.diff.DiffFormatter;

+import org.eclipse.jgit.diff.RawText;

+import org.eclipse.jgit.util.io.NullOutputStream;

+

+import com.gitblit.models.PathModel.PathChangeModel;

+import com.gitblit.utils.DiffUtils.DiffStat;

+

+/**

+ * Calculates a DiffStat.

+ *

+ * @author James Moger

+ *

+ */

+public class DiffStatFormatter extends DiffFormatter {

+

+	private final DiffStat diffStat;

+

+	private PathChangeModel path;

+

+	public DiffStatFormatter(String commitId) {

+		super(NullOutputStream.INSTANCE);

+		diffStat = new DiffStat(commitId);

+	}

+

+	@Override

+	public void format(DiffEntry entry) throws IOException {

+		path = diffStat.addPath(entry);

+		super.format(entry);

+	}

+

+	@Override

+	protected void writeLine(final char prefix, final RawText text, final int cur)

+			throws IOException {

+		path.update(prefix);

+	}

+

+	public DiffStat getDiffStat() {

+		return diffStat;

+	}

+}

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

+	}

 }

diff --git a/src/main/java/com/gitblit/utils/GitBlitDiffFormatter.java b/src/main/java/com/gitblit/utils/GitBlitDiffFormatter.java
index a00e1076..8ca42854 100644
--- a/src/main/java/com/gitblit/utils/GitBlitDiffFormatter.java
+++ b/src/main/java/com/gitblit/utils/GitBlitDiffFormatter.java
@@ -23,12 +23,17 @@ import java.io.IOException;
 import java.io.OutputStream;

 import java.text.MessageFormat;

 

+import org.eclipse.jgit.diff.DiffEntry;

 import org.eclipse.jgit.diff.DiffFormatter;

 import org.eclipse.jgit.diff.RawText;

 import org.eclipse.jgit.util.RawParseUtils;

 

+import com.gitblit.models.PathModel.PathChangeModel;

+import com.gitblit.utils.DiffUtils.DiffStat;

+

 /**

- * Generates an html snippet of a diff in Gitblit's style.

+ * Generates an html snippet of a diff in Gitblit's style, tracks changed paths,

+ * and calculates diff stats.

  * 

  * @author James Moger

  * 

@@ -37,13 +42,24 @@ public class GitBlitDiffFormatter extends DiffFormatter {
 

 	private final OutputStream os;

 

-	private int left, right;

+	private final DiffStat diffStat;

+

+	private PathChangeModel currentPath;

 

-	public GitBlitDiffFormatter(OutputStream os) {

+	private int left, right;

+	

+	public GitBlitDiffFormatter(OutputStream os, String commitId) {

 		super(os);

 		this.os = os;

+		this.diffStat = new DiffStat(commitId);

 	}

-

+	

+	@Override

+	public void format(DiffEntry ent) throws IOException {

+		currentPath = diffStat.addPath(ent);

+		super.format(ent);

+	}

+	

 	/**

 	 * Output a hunk header

 	 * 

@@ -109,6 +125,10 @@ public class GitBlitDiffFormatter extends DiffFormatter {
 	@Override

 	protected void writeLine(final char prefix, final RawText text, final int cur)

 			throws IOException {

+		// update entry diffstat

+		currentPath.update(prefix);

+		

+		// output diff

 		os.write("<tr>".getBytes());

 		switch (prefix) {

 		case '+':

@@ -209,4 +229,8 @@ public class GitBlitDiffFormatter extends DiffFormatter {
 		sb.append("</table></div>");

 		return sb.toString();

 	}

+	

+	public DiffStat getDiffStat() {

+		return diffStat;

+	}

 }

diff --git a/src/main/java/com/gitblit/utils/JGitUtils.java b/src/main/java/com/gitblit/utils/JGitUtils.java
index 3c1173ce..c494ccc3 100644
--- a/src/main/java/com/gitblit/utils/JGitUtils.java
+++ b/src/main/java/com/gitblit/utils/JGitUtils.java
@@ -81,7 +81,6 @@ import org.eclipse.jgit.treewalk.filter.PathFilterGroup;
 import org.eclipse.jgit.treewalk.filter.PathSuffixFilter;

 import org.eclipse.jgit.treewalk.filter.TreeFilter;

 import org.eclipse.jgit.util.FS;

-import org.eclipse.jgit.util.io.DisabledOutputStream;

 import org.slf4j.Logger;

 import org.slf4j.LoggerFactory;

 

@@ -901,7 +900,7 @@ public class JGitUtils {
 		Collections.sort(list);

 		return list;

 	}

-

+	

 	/**

 	 * Returns the list of files changed in a specified commit. If the

 	 * repository does not exist or is empty, an empty list is returned.

@@ -912,6 +911,21 @@ public class JGitUtils {
 	 * @return list of files changed in a commit

 	 */

 	public static List<PathChangeModel> getFilesInCommit(Repository repository, RevCommit commit) {

+		return getFilesInCommit(repository, commit, true);

+	}

+

+	/**

+	 * Returns the list of files changed in a specified commit. If the

+	 * repository does not exist or is empty, an empty list is returned.

+	 * 

+	 * @param repository

+	 * @param commit

+	 *            if null, HEAD is assumed.

+	 * @param calculateDiffStat

+	 *            if true, each PathChangeModel will have insertions/deletions

+	 * @return list of files changed in a commit

+	 */

+	public static List<PathChangeModel> getFilesInCommit(Repository repository, RevCommit commit, boolean calculateDiffStat) {

 		List<PathChangeModel> list = new ArrayList<PathChangeModel>();

 		if (!hasCommits(repository)) {

 			return list;

@@ -936,26 +950,25 @@ public class JGitUtils {
 				tw.release();

 			} else {

 				RevCommit parent = rw.parseCommit(commit.getParent(0).getId());

-				DiffFormatter df = new DiffFormatter(DisabledOutputStream.INSTANCE);

+				DiffStatFormatter df = new DiffStatFormatter(commit.getName());

 				df.setRepository(repository);

 				df.setDiffComparator(RawTextComparator.DEFAULT);

 				df.setDetectRenames(true);

 				List<DiffEntry> diffs = df.scan(parent.getTree(), commit.getTree());

 				for (DiffEntry diff : diffs) {

-					String objectId = diff.getNewId().name();

-					if (diff.getChangeType().equals(ChangeType.DELETE)) {

-						list.add(new PathChangeModel(diff.getOldPath(), diff.getOldPath(), 0, diff

-								.getNewMode().getBits(), objectId, commit.getId().getName(), diff

-								.getChangeType()));

-					} else if (diff.getChangeType().equals(ChangeType.RENAME)) {

-						list.add(new PathChangeModel(diff.getOldPath(), diff.getNewPath(), 0, diff

-								.getNewMode().getBits(), objectId, commit.getId().getName(), diff

-								.getChangeType()));

-					} else {

-						list.add(new PathChangeModel(diff.getNewPath(), diff.getNewPath(), 0, diff

-								.getNewMode().getBits(), objectId, commit.getId().getName(), diff

-								.getChangeType()));

+					// create the path change model

+					PathChangeModel pcm = PathChangeModel.from(diff, commit.getName());

+					

+					if (calculateDiffStat) {

+						// update file diffstats

+						df.format(diff);

+						PathChangeModel pathStat = df.getDiffStat().getPath(pcm.path);

+						if (pathStat != null) {

+							pcm.insertions = pathStat.insertions;

+							pcm.deletions = pathStat.deletions;

+						}

 					}

+					list.add(pcm);

 				}

 			}

 		} catch (Throwable t) {

@@ -990,20 +1003,8 @@ public class JGitUtils {
 

 			List<DiffEntry> diffEntries = df.scan(startCommit.getTree(), endCommit.getTree());

 			for (DiffEntry diff : diffEntries) {

-				

-				if (diff.getChangeType().equals(ChangeType.DELETE)) {

-					list.add(new PathChangeModel(diff.getOldPath(), diff.getOldPath(), 0, diff

-							.getNewMode().getBits(), diff.getOldId().name(), null, diff

-							.getChangeType()));

-				} else if (diff.getChangeType().equals(ChangeType.RENAME)) {

-					list.add(new PathChangeModel(diff.getOldPath(), diff.getNewPath(), 0, diff

-							.getNewMode().getBits(), diff.getNewId().name(), null, diff

-							.getChangeType()));

-				} else {

-					list.add(new PathChangeModel(diff.getNewPath(), diff.getNewPath(), 0, diff

-							.getNewMode().getBits(), diff.getNewId().name(), null, diff

-							.getChangeType()));

-				}

+				PathChangeModel pcm = PathChangeModel.from(diff,  null);

+				list.add(pcm);

 			}			

 			Collections.sort(list);

 		} catch (Throwable t) {