/* | |
* Copyright 2011 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.ByteArrayOutputStream; | |
import java.io.Serializable; | |
import java.text.MessageFormat; | |
import java.util.ArrayList; | |
import java.util.List; | |
import org.eclipse.jgit.api.BlameCommand; | |
import org.eclipse.jgit.blame.BlameResult; | |
import org.eclipse.jgit.diff.DiffEntry; | |
import org.eclipse.jgit.diff.DiffFormatter; | |
import org.eclipse.jgit.diff.RawText; | |
import org.eclipse.jgit.diff.RawTextComparator; | |
import org.eclipse.jgit.lib.ObjectId; | |
import org.eclipse.jgit.lib.Repository; | |
import org.eclipse.jgit.revwalk.RevCommit; | |
import org.eclipse.jgit.revwalk.RevTree; | |
import org.eclipse.jgit.revwalk.RevWalk; | |
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 { | |
private static final Logger LOGGER = LoggerFactory.getLogger(DiffUtils.class); | |
/** | |
* Enumeration for the diff output types. | |
*/ | |
public static enum DiffOutputType { | |
PLAIN, HTML; | |
public static DiffOutputType forName(String name) { | |
for (DiffOutputType type : values()) { | |
if (type.name().equalsIgnoreCase(name)) { | |
return type; | |
} | |
} | |
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 | |
*/ | |
public static DiffOutput getCommitDiff(Repository repository, RevCommit commit, | |
DiffOutputType outputType) { | |
return getDiff(repository, null, commit, null, outputType); | |
} | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
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 | |
* the commit. | |
* @param commit | |
* @param path | |
* 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 | |
*/ | |
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(); | |
RawTextComparator cmp = RawTextComparator.DEFAULT; | |
DiffFormatter df; | |
switch (outputType) { | |
case HTML: | |
df = new GitBlitDiffFormatter(os, commit.getName()); | |
break; | |
case PLAIN: | |
default: | |
df = new DiffFormatter(os); | |
break; | |
} | |
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()); | |
rw.dispose(); | |
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); | |
} | |
if (df instanceof GitBlitDiffFormatter) { | |
// workaround for complex private methods in DiffFormatter | |
diff = ((GitBlitDiffFormatter) df).getHtml(); | |
stat = ((GitBlitDiffFormatter) df).getDiffStat(); | |
} else { | |
diff = os.toString(); | |
} | |
df.flush(); | |
} catch (Throwable t) { | |
LOGGER.error("failed to generate commit diff!", t); | |
} | |
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 | |
* the primary parent of the specified commit. | |
* @param commit | |
* @param path | |
* if path is specified, the patch is generated only for the | |
* specified file or folder. if unspecified, the patch is | |
* generated for the entire diff between the two commits. | |
* @return patch as a string | |
*/ | |
public static String getCommitPatch(Repository repository, RevCommit baseCommit, | |
RevCommit commit, String path) { | |
String diff = null; | |
try { | |
final ByteArrayOutputStream os = new ByteArrayOutputStream(); | |
RawTextComparator cmp = RawTextComparator.DEFAULT; | |
PatchFormatter df = new PatchFormatter(os); | |
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); | |
} | |
diff = df.getPatch(commit); | |
df.flush(); | |
} catch (Throwable t) { | |
LOGGER.error("failed to generate commit diff!", t); | |
} | |
return diff; | |
} | |
/** | |
* Returns the diffstat between the two commits for the specified file or folder. | |
* | |
* @param repository | |
* @param base | |
* if base commit is unspecified, the diffstat is generated against | |
* the primary parent of the specified tip. | |
* @param tip | |
* @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, String base, String tip) { | |
RevCommit baseCommit = null; | |
RevCommit tipCommit = null; | |
RevWalk revWalk = new RevWalk(repository); | |
try { | |
tipCommit = revWalk.parseCommit(repository.resolve(tip)); | |
if (!StringUtils.isEmpty(base)) { | |
baseCommit = revWalk.parseCommit(repository.resolve(base)); | |
} | |
return getDiffStat(repository, baseCommit, tipCommit, null); | |
} catch (Exception e) { | |
LOGGER.error("failed to generate diffstat!", e); | |
} finally { | |
revWalk.dispose(); | |
} | |
return null; | |
} | |
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 | |
* @return list of annotated lines | |
*/ | |
public static List<AnnotatedLine> blame(Repository repository, String blobPath, String objectId) { | |
List<AnnotatedLine> lines = new ArrayList<AnnotatedLine>(); | |
try { | |
ObjectId object; | |
if (StringUtils.isEmpty(objectId)) { | |
object = JGitUtils.getDefaultBranch(repository); | |
} else { | |
object = repository.resolve(objectId); | |
} | |
BlameCommand blameCommand = new BlameCommand(repository); | |
blameCommand.setFilePath(blobPath); | |
blameCommand.setStartCommit(object); | |
BlameResult blameResult = blameCommand.call(); | |
RawText rawText = blameResult.getResultContents(); | |
int length = rawText.size(); | |
for (int i = 0; i < length; i++) { | |
RevCommit commit = blameResult.getSourceCommit(i); | |
AnnotatedLine line = new AnnotatedLine(commit, i + 1, rawText.getString(i)); | |
lines.add(line); | |
} | |
} catch (Throwable t) { | |
LOGGER.error(MessageFormat.format("failed to generate blame for {0} {1}!", blobPath, objectId), t); | |
} | |
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); | |
} | |
} |