From c3f4f124f1b9e45d7696f3c16f958d1c81ff280a Mon Sep 17 00:00:00 2001
From: James Moger <james.moger@gitblit.com>
Date: Thu, 21 Apr 2011 21:46:47 -0400
Subject: [PATCH] Use markdown for welcome message. Simplify login page appearance.
---
src/com/gitblit/utils/JGitUtils.java | 264 ++++++++++++++++++++++++++++++++++++++++++++++------
1 files changed, 230 insertions(+), 34 deletions(-)
diff --git a/src/com/gitblit/utils/JGitUtils.java b/src/com/gitblit/utils/JGitUtils.java
index 075ad81..cd3e6ef 100644
--- a/src/com/gitblit/utils/JGitUtils.java
+++ b/src/com/gitblit/utils/JGitUtils.java
@@ -15,11 +15,16 @@
import java.util.List;
import java.util.Map;
import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
import org.eclipse.jgit.diff.DiffEntry;
import org.eclipse.jgit.diff.DiffFormatter;
import org.eclipse.jgit.diff.RawTextComparator;
+import org.eclipse.jgit.diff.DiffEntry.ChangeType;
import org.eclipse.jgit.errors.ConfigInvalidException;
+import org.eclipse.jgit.errors.IncorrectObjectTypeException;
+import org.eclipse.jgit.errors.MissingObjectException;
+import org.eclipse.jgit.errors.StopWalkException;
import org.eclipse.jgit.lib.AnyObjectId;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.FileMode;
@@ -32,8 +37,10 @@
import org.eclipse.jgit.revwalk.RevBlob;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevObject;
+import org.eclipse.jgit.revwalk.RevSort;
import org.eclipse.jgit.revwalk.RevTree;
import org.eclipse.jgit.revwalk.RevWalk;
+import org.eclipse.jgit.revwalk.filter.RevFilter;
import org.eclipse.jgit.treewalk.TreeWalk;
import org.eclipse.jgit.treewalk.filter.AndTreeFilter;
import org.eclipse.jgit.treewalk.filter.PathFilter;
@@ -45,6 +52,7 @@
import com.gitblit.wicket.models.Metric;
import com.gitblit.wicket.models.PathModel;
+import com.gitblit.wicket.models.PathModel.PathChangeModel;
import com.gitblit.wicket.models.RefModel;
import com.gitblit.wicket.models.TicketModel;
import com.gitblit.wicket.models.TicketModel.Comment;
@@ -93,6 +101,34 @@
}
}
return list;
+ }
+
+ public static RevCommit getFirstCommit(Repository r, String branch) {
+ if (StringUtils.isEmpty(branch)) {
+ branch = Constants.HEAD;
+ }
+ try {
+ RevWalk walk = new RevWalk(r);
+ walk.sort(RevSort.REVERSE);
+ RevCommit head = walk.parseCommit(r.resolve(branch));
+ walk.markStart(head);
+ RevCommit commit = walk.next();
+ walk.dispose();
+ return commit;
+ } catch (Throwable t) {
+ LOGGER.error("Failed to determine first commit", t);
+ }
+ return null;
+ }
+
+ public static Date getFirstChange(Repository r, String branch) {
+ try {
+ RevCommit commit = getFirstCommit(r, branch);
+ return getCommitDate(commit);
+ } catch (Throwable t) {
+ LOGGER.error("Failed to determine first change", t);
+ }
+ return null;
}
public static Date getLastChange(Repository r) {
@@ -252,13 +288,13 @@
return list;
}
- public static List<PathModel> getFilesInCommit(Repository r, String commitId) {
+ public static List<PathChangeModel> getFilesInCommit(Repository r, String commitId) {
RevCommit commit = getCommit(r, commitId);
return getFilesInCommit(r, commit);
}
- public static List<PathModel> getFilesInCommit(Repository r, RevCommit commit) {
- List<PathModel> list = new ArrayList<PathModel>();
+ public static List<PathChangeModel> getFilesInCommit(Repository r, RevCommit commit) {
+ List<PathChangeModel> list = new ArrayList<PathChangeModel>();
try {
final RevWalk rw = new RevWalk(r);
RevCommit parent = rw.parseCommit(commit.getParent(0).getId());
@@ -279,7 +315,11 @@
df.setDetectRenames(true);
List<DiffEntry> diffs = df.scan(parentTree, commitTree);
for (DiffEntry diff : diffs) {
- list.add(new PathModel(diff.getNewPath(), diff.getNewPath(), 0, diff.getNewMode().getBits(), commit.getId().getName()));
+ if (diff.getChangeType().equals(ChangeType.DELETE)) {
+ list.add(new PathChangeModel(diff.getOldPath(), diff.getOldPath(), 0, diff.getNewMode().getBits(), commit.getId().getName(), diff.getChangeType()));
+ } else {
+ list.add(new PathChangeModel(diff.getNewPath(), diff.getNewPath(), 0, diff.getNewMode().getBits(), commit.getId().getName(), diff.getChangeType()));
+ }
}
} catch (Throwable t) {
LOGGER.error("failed to determine files in commit!", t);
@@ -287,36 +327,82 @@
return list;
}
- public static String getCommitDiff(Repository r, RevCommit commit, boolean outputHtml) {
- return getCommitDiff(r, commit, null, outputHtml);
+ public static Map<ChangeType, AtomicInteger> getChangedPathsStats(List<PathChangeModel> paths) {
+ Map<ChangeType, AtomicInteger> stats = new HashMap<ChangeType, AtomicInteger>();
+ for (PathChangeModel path : paths) {
+ if (!stats.containsKey(path.changeType)) {
+ stats.put(path.changeType, new AtomicInteger(0));
+ }
+ stats.get(path.changeType).incrementAndGet();
+ }
+ return stats;
}
- public static String getCommitDiff(Repository r, RevCommit commit, String path, boolean outputHtml) {
+ public static enum DiffOutputType {
+ PLAIN, GITWEB, GITBLIT;
+
+ public static DiffOutputType forName(String name) {
+ for (DiffOutputType type : values()) {
+ if (type.name().equalsIgnoreCase(name)) {
+ return type;
+ }
+ }
+ return null;
+ }
+ }
+
+ public static String getCommitDiff(Repository r, RevCommit commit, DiffOutputType outputType) {
+ return getCommitDiff(r, null, commit, null, outputType);
+ }
+
+ public static String getCommitDiff(Repository r, RevCommit commit, String path, DiffOutputType outputType) {
+ return getCommitDiff(r, null, commit, path, outputType);
+ }
+
+ public static String getCommitDiff(Repository r, RevCommit baseCommit, RevCommit commit, DiffOutputType outputType) {
+ return getCommitDiff(r, baseCommit, commit, null, outputType);
+ }
+
+ public static String getCommitDiff(Repository r, RevCommit baseCommit, RevCommit commit, String path, DiffOutputType outputType) {
try {
- final RevWalk rw = new RevWalk(r);
- RevCommit parent = rw.parseCommit(commit.getParent(0).getId());
- RevTree parentTree = parent.getTree();
+ RevTree baseTree;
+ if (baseCommit == null) {
+ final RevWalk rw = new RevWalk(r);
+ RevCommit parent = rw.parseCommit(commit.getParent(0).getId());
+ rw.dispose();
+ baseTree = parent.getTree();
+ } else {
+ baseTree = baseCommit.getTree();
+ }
+
RevTree commitTree = commit.getTree();
final TreeWalk walk = new TreeWalk(r);
walk.reset();
walk.setRecursive(true);
- walk.addTree(parentTree);
+ walk.addTree(baseTree);
walk.addTree(commitTree);
walk.setFilter(TreeFilter.ANY_DIFF);
final ByteArrayOutputStream os = new ByteArrayOutputStream();
RawTextComparator cmp = RawTextComparator.DEFAULT;
DiffFormatter df;
- if (outputHtml) {
- df = new HtmlDiffFormatter(os);
- } else {
+ switch (outputType) {
+ case GITWEB:
+ df = new GitWebDiffFormatter(os);
+ break;
+ case GITBLIT:
+ df = new GitBlitDiffFormatter(os);
+ break;
+ case PLAIN:
+ default:
df = new DiffFormatter(os);
+ break;
}
df.setRepository(r);
df.setDiffComparator(cmp);
df.setDetectRenames(true);
- List<DiffEntry> diffs = df.scan(parentTree, commitTree);
+ List<DiffEntry> diffs = df.scan(baseTree, commitTree);
if (path != null && path.length() > 0) {
for (DiffEntry diff : diffs) {
if (diff.getNewPath().equalsIgnoreCase(path)) {
@@ -328,9 +414,9 @@
df.format(diffs);
}
String diff;
- if (outputHtml) {
+ if (df instanceof GitWebDiffFormatter) {
// workaround for complex private methods in DiffFormatter
- diff = ((HtmlDiffFormatter) df).getHtml();
+ diff = ((GitWebDiffFormatter) df).getHtml();
} else {
diff = os.toString();
}
@@ -347,16 +433,25 @@
}
public static String getCommitPatch(Repository r, RevCommit commit, String path) {
+ return getCommitPatch(r, null, commit, path);
+ }
+
+ public static String getCommitPatch(Repository r, RevCommit baseCommit, RevCommit commit, String path) {
try {
- final RevWalk rw = new RevWalk(r);
- RevCommit parent = rw.parseCommit(commit.getParent(0).getId());
- RevTree parentTree = parent.getTree();
+ RevTree baseTree;
+ if (baseCommit == null) {
+ final RevWalk rw = new RevWalk(r);
+ RevCommit parent = rw.parseCommit(commit.getParent(0).getId());
+ baseTree = parent.getTree();
+ } else {
+ baseTree = baseCommit.getTree();
+ }
RevTree commitTree = commit.getTree();
final TreeWalk walk = new TreeWalk(r);
walk.reset();
walk.setRecursive(true);
- walk.addTree(parentTree);
+ walk.addTree(baseTree);
walk.addTree(commitTree);
walk.setFilter(TreeFilter.ANY_DIFF);
@@ -366,7 +461,7 @@
df.setRepository(r);
df.setDiffComparator(cmp);
df.setDetectRenames(true);
- List<DiffEntry> diffs = df.scan(parentTree, commitTree);
+ List<DiffEntry> diffs = df.scan(baseTree, commitTree);
if (path != null && path.length() > 0) {
for (DiffEntry diff : diffs) {
if (diff.getNewPath().equalsIgnoreCase(path)) {
@@ -439,7 +534,7 @@
public static List<RevCommit> getRevLog(Repository r, String objectId, int offset, int maxCount) {
return getRevLog(r, objectId, null, offset, maxCount);
}
-
+
public static List<RevCommit> getRevLog(Repository r, String objectId, String path, int offset, int maxCount) {
List<RevCommit> list = new ArrayList<RevCommit>();
try {
@@ -450,11 +545,84 @@
ObjectId object = r.resolve(objectId);
walk.markStart(walk.parseCommit(object));
if (!StringUtils.isEmpty(path)) {
- TreeFilter filter = AndTreeFilter.create(PathFilterGroup
- .createFromStrings(Collections.singleton(path)),
- TreeFilter.ANY_DIFF);
+ TreeFilter filter = AndTreeFilter.create(PathFilterGroup.createFromStrings(Collections.singleton(path)), TreeFilter.ANY_DIFF);
walk.setTreeFilter(filter);
}
+ Iterable<RevCommit> revlog = walk;
+ if (offset > 0) {
+ int count = 0;
+ for (RevCommit rev : revlog) {
+ count++;
+ if (count > offset) {
+ list.add(rev);
+ if (maxCount > 0 && list.size() == maxCount) {
+ break;
+ }
+ }
+ }
+ } else {
+ for (RevCommit rev : revlog) {
+ list.add(rev);
+ if (maxCount > 0 && list.size() == maxCount) {
+ break;
+ }
+ }
+ }
+ walk.dispose();
+ } catch (Throwable t) {
+ LOGGER.error("Failed to determine last change", t);
+ }
+ return list;
+ }
+
+ public static enum SearchType {
+ AUTHOR, COMMITTER, COMMIT;
+
+ public static SearchType forName(String name) {
+ for (SearchType type : values()) {
+ if (type.name().equalsIgnoreCase(name)) {
+ return type;
+ }
+ }
+ return null;
+ }
+
+ public String toString() {
+ return name().toLowerCase();
+ }
+ }
+
+ public static List<RevCommit> searchRevlogs(Repository r, String objectId, String value, final SearchType type, int offset, int maxCount) {
+ final String lcValue = value.toLowerCase();
+ List<RevCommit> list = new ArrayList<RevCommit>();
+ try {
+ if (objectId == null || objectId.trim().length() == 0) {
+ objectId = Constants.HEAD;
+ }
+ RevWalk walk = new RevWalk(r);
+ walk.setRevFilter(new RevFilter() {
+
+ @Override
+ public RevFilter clone() {
+ return this;
+ }
+
+ @Override
+ public boolean include(RevWalk walker, RevCommit commit) throws StopWalkException, MissingObjectException, IncorrectObjectTypeException, IOException {
+ switch (type) {
+ case AUTHOR:
+ return (commit.getAuthorIdent().getName().toLowerCase().indexOf(lcValue) > -1) || (commit.getAuthorIdent().getEmailAddress().toLowerCase().indexOf(lcValue) > -1);
+ case COMMITTER:
+ return (commit.getCommitterIdent().getName().toLowerCase().indexOf(lcValue) > -1) || (commit.getCommitterIdent().getEmailAddress().toLowerCase().indexOf(lcValue) > -1);
+ case COMMIT:
+ return commit.getFullMessage().toLowerCase().indexOf(lcValue) > -1;
+ }
+ return false;
+ }
+
+ });
+ ObjectId object = r.resolve(objectId);
+ walk.markStart(walk.parseCommit(object));
Iterable<RevCommit> revlog = walk;
if (offset > 0) {
int count = 0;
@@ -588,29 +756,57 @@
public static List<Metric> getDateMetrics(Repository r) {
final List<RefModel> tags = getTags(r, -1);
- final Map<String, Metric> map = new HashMap<String, Metric>();
+ final Map<ObjectId, RefModel> tagMap = new HashMap<ObjectId, RefModel>();
+ for (RefModel tag : tags) {
+ tagMap.put(tag.getCommitId(), tag);
+ }
+ Metric total = new Metric("TOTAL");
+ final Map<String, Metric> metricMap = new HashMap<String, Metric>();
try {
- DateFormat df = new SimpleDateFormat("yyyy-MM");
RevWalk walk = new RevWalk(r);
ObjectId object = r.resolve(Constants.HEAD);
- walk.markStart(walk.parseCommit(object));
+
+ RevCommit firstCommit = getFirstCommit(r, Constants.HEAD);
+ RevCommit lastCommit = walk.parseCommit(object);
+ int diffDays = (lastCommit.getCommitTime() - firstCommit.getCommitTime()) / (60 * 60 * 24);
+ total.duration = diffDays;
+ DateFormat df;
+ if (diffDays <= 90) {
+ // Days
+ df = new SimpleDateFormat("yyyy-MM-dd");
+ } else if (diffDays > 90 && diffDays < 365) {
+ // Weeks
+ df = new SimpleDateFormat("yyyy-MM (w)");
+ } else {
+ // Months
+ df = new SimpleDateFormat("yyyy-MM");
+ }
+ walk.markStart(lastCommit);
+
Iterable<RevCommit> revlog = walk;
for (RevCommit rev : revlog) {
Date d = getCommitDate(rev);
String p = df.format(d);
- if (!map.containsKey(p))
- map.put(p, new Metric(p));
- map.get(p).count++;
+ if (!metricMap.containsKey(p))
+ metricMap.put(p, new Metric(p));
+ Metric m = metricMap.get(p);
+ m.count++;
+ total.count++;
+ if (tagMap.containsKey(rev.getId())) {
+ m.tag++;
+ total.tag++;
+ }
}
} catch (Throwable t) {
LOGGER.error("Failed to mine log history for metrics", t);
}
- List<String> keys = new ArrayList<String>(map.keySet());
+ List<String> keys = new ArrayList<String>(metricMap.keySet());
Collections.sort(keys);
List<Metric> metrics = new ArrayList<Metric>();
for (String key : keys) {
- metrics.add(map.get(key));
+ metrics.add(metricMap.get(key));
}
+ metrics.add(0, total);
return metrics;
}
--
Gitblit v1.9.1