From ff369d23bd12f501b59726cbec77512e2f39fd13 Mon Sep 17 00:00:00 2001
From: James Moger <james.moger@gitblit.com>
Date: Mon, 18 Apr 2011 17:50:03 -0400
Subject: [PATCH] Fix Eclipse complaints about illegal tag location.
---
src/com/gitblit/utils/JGitUtils.java | 284 +++++++++++++++++++++++++++++++++++++++++++++++---------
1 files changed, 235 insertions(+), 49 deletions(-)
diff --git a/src/com/gitblit/utils/JGitUtils.java b/src/com/gitblit/utils/JGitUtils.java
index 1b418b0..3b69c22 100644
--- a/src/com/gitblit/utils/JGitUtils.java
+++ b/src/com/gitblit/utils/JGitUtils.java
@@ -16,11 +16,13 @@
import java.util.Map;
import java.util.Set;
-import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.diff.DiffEntry;
import org.eclipse.jgit.diff.DiffFormatter;
import org.eclipse.jgit.diff.RawTextComparator;
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;
@@ -35,7 +37,9 @@
import org.eclipse.jgit.revwalk.RevObject;
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;
import org.eclipse.jgit.treewalk.filter.PathFilterGroup;
import org.eclipse.jgit.treewalk.filter.TreeFilter;
@@ -43,10 +47,11 @@
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.gitblit.utils.TicGitTicket.Comment;
import com.gitblit.wicket.models.Metric;
import com.gitblit.wicket.models.PathModel;
import com.gitblit.wicket.models.RefModel;
+import com.gitblit.wicket.models.TicketModel;
+import com.gitblit.wicket.models.TicketModel.Comment;
public class JGitUtils {
@@ -99,12 +104,15 @@
return getCommitDate(commit);
}
- public static RevCommit getCommit(Repository r, String commitId) {
+ public static RevCommit getCommit(Repository r, String objectId) {
RevCommit commit = null;
try {
- ObjectId objectId = r.resolve(commitId);
+ if (objectId == null || objectId.trim().length() == 0) {
+ objectId = Constants.HEAD;
+ }
+ ObjectId object = r.resolve(objectId);
RevWalk walk = new RevWalk(r);
- RevCommit rev = walk.parseCommit(objectId);
+ RevCommit rev = walk.parseCommit(object);
commit = rev;
walk.dispose();
} catch (Throwable t) {
@@ -206,8 +214,8 @@
return new String(getRawContent(r, (RevBlob) obj));
}
- public static List<PathModel> getFilesInPath(Repository r, String basePath, String commitId) {
- RevCommit commit = getCommit(r, commitId);
+ public static List<PathModel> getFilesInPath(Repository r, String basePath, String objectId) {
+ RevCommit commit = getCommit(r, objectId);
return getFilesInPath(r, basePath, commit);
}
@@ -284,26 +292,37 @@
}
public static String getCommitDiff(Repository r, RevCommit commit, boolean outputHtml) {
- return getCommitDiff(r, commit, null, outputHtml);
+ return getCommitDiff(r, null, commit, null, outputHtml);
}
-
+
public static String getCommitDiff(Repository r, RevCommit commit, String path, boolean outputHtml) {
+ return getCommitDiff(r, null, commit, path, outputHtml);
+ }
+
+ public static String getCommitDiff(Repository r, RevCommit baseCommit, RevCommit commit, boolean outputHtml) {
+ return getCommitDiff(r, baseCommit, commit, null, outputHtml);
+ }
+
+ public static String getCommitDiff(Repository r, RevCommit baseCommit, RevCommit commit, String path, boolean outputHtml) {
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);
- if (path != null && path.trim().length() > 0) {
- walk.setFilter(PathFilter.create(path));
- } else {
- walk.setFilter(TreeFilter.ANY_DIFF);
- }
+ walk.setFilter(TreeFilter.ANY_DIFF);
final ByteArrayOutputStream os = new ByteArrayOutputStream();
RawTextComparator cmp = RawTextComparator.DEFAULT;
@@ -316,8 +335,17 @@
df.setRepository(r);
df.setDiffComparator(cmp);
df.setDetectRenames(true);
- List<DiffEntry> diffs = df.scan(parentTree, commitTree);
- df.format(diffs);
+ List<DiffEntry> diffs = df.scan(baseTree, commitTree);
+ if (path != null && path.length() > 0) {
+ for (DiffEntry diff : diffs) {
+ if (diff.getNewPath().equalsIgnoreCase(path)) {
+ df.format(diff);
+ break;
+ }
+ }
+ } else {
+ df.format(diffs);
+ }
String diff;
if (outputHtml) {
// workaround for complex private methods in DiffFormatter
@@ -325,6 +353,59 @@
} else {
diff = os.toString();
}
+ df.flush();
+ return diff;
+ } catch (Throwable t) {
+ LOGGER.error("failed to generate commit diff!", t);
+ }
+ return null;
+ }
+
+ public static String getCommitPatch(Repository r, RevCommit commit) {
+ return getCommitPatch(r, commit);
+ }
+
+ 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 {
+ 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(baseTree);
+ walk.addTree(commitTree);
+ walk.setFilter(TreeFilter.ANY_DIFF);
+
+ final ByteArrayOutputStream os = new ByteArrayOutputStream();
+ RawTextComparator cmp = RawTextComparator.DEFAULT;
+ PatchFormatter df = new PatchFormatter(os);
+ df.setRepository(r);
+ df.setDiffComparator(cmp);
+ df.setDetectRenames(true);
+ List<DiffEntry> diffs = df.scan(baseTree, commitTree);
+ if (path != null && path.length() > 0) {
+ for (DiffEntry diff : diffs) {
+ if (diff.getNewPath().equalsIgnoreCase(path)) {
+ df.format(diff);
+ break;
+ }
+ }
+ } else {
+ df.format(diffs);
+ }
+ String diff = df.getPatch(commit);
df.flush();
return diff;
} catch (Throwable t) {
@@ -380,16 +461,118 @@
}
public static List<RevCommit> getRevLog(Repository r, int maxCount) {
+ return getRevLog(r, Constants.HEAD, 0, maxCount);
+ }
+
+ 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 {
- Git git = new Git(r);
- Iterable<RevCommit> revlog = git.log().call();
- for (RevCommit rev : revlog) {
- list.add(rev);
- if (maxCount > 0 && list.size() == maxCount) {
- break;
+ if (objectId == null || objectId.trim().length() == 0) {
+ objectId = Constants.HEAD;
+ }
+ RevWalk walk = new RevWalk(r);
+ 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);
+ 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 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;
+ 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);
}
@@ -501,11 +684,14 @@
}
public static List<Metric> getDateMetrics(Repository r) {
+ final List<RefModel> tags = getTags(r, -1);
final Map<String, Metric> map = new HashMap<String, Metric>();
try {
DateFormat df = new SimpleDateFormat("yyyy-MM");
- Git git = new Git(r);
- Iterable<RevCommit> revlog = git.log().call();
+ RevWalk walk = new RevWalk(r);
+ ObjectId object = r.resolve(Constants.HEAD);
+ walk.markStart(walk.parseCommit(object));
+ Iterable<RevCommit> revlog = walk;
for (RevCommit rev : revlog) {
Date d = getCommitDate(rev);
String p = df.format(d);
@@ -525,12 +711,12 @@
return metrics;
}
- public static RefModel getTicGitBranch(Repository r) {
+ public static RefModel getTicketsBranch(Repository r) {
RefModel ticgitBranch = null;
try {
// search for ticgit branch in local heads
for (RefModel ref : getLocalBranches(r, -1)) {
- if (ref.getDisplayName().endsWith("ticgit") || ref.getDisplayName().endsWith("ticgit-ng")) {
+ if (ref.getDisplayName().endsWith("ticgit")) {
ticgitBranch = ref;
break;
}
@@ -539,7 +725,7 @@
// search for ticgit branch in remote heads
if (ticgitBranch == null) {
for (RefModel ref : getRemoteBranches(r, -1)) {
- if (ref.getDisplayName().endsWith("ticgit") || ref.getDisplayName().endsWith("ticgit-ng")) {
+ if (ref.getDisplayName().endsWith("ticgit")) {
ticgitBranch = ref;
break;
}
@@ -551,18 +737,18 @@
return ticgitBranch;
}
- public static List<TicGitTicket> getTicGitTickets(Repository r) {
- RefModel ticgitBranch = getTicGitBranch(r);
+ public static List<TicketModel> getTickets(Repository r) {
+ RefModel ticgitBranch = getTicketsBranch(r);
List<PathModel> paths = getFilesInPath(r, null, ticgitBranch.getCommit());
- List<TicGitTicket> tickets = new ArrayList<TicGitTicket>();
+ List<TicketModel> tickets = new ArrayList<TicketModel>();
for (PathModel ticketFolder : paths) {
if (ticketFolder.isTree()) {
try {
- TicGitTicket t = new TicGitTicket(ticketFolder.name);
+ TicketModel t = new TicketModel(ticketFolder.name);
readTicketContents(r, ticgitBranch, t);
tickets.add(t);
} catch (Throwable t) {
- LOGGER.error("Failed to get a ticgit ticket!", t);
+ LOGGER.error("Failed to get a ticket!", t);
}
}
}
@@ -571,24 +757,24 @@
return tickets;
}
- public static TicGitTicket getTicGitTicket(Repository r, String ticketFolder) {
- RefModel ticgitBranch = getTicGitBranch(r);
- if (ticgitBranch != null) {
+ public static TicketModel getTicket(Repository r, String ticketFolder) {
+ RefModel ticketsBranch = getTicketsBranch(r);
+ if (ticketsBranch != null) {
try {
- TicGitTicket ticket = new TicGitTicket(ticketFolder);
- readTicketContents(r, ticgitBranch, ticket);
+ TicketModel ticket = new TicketModel(ticketFolder);
+ readTicketContents(r, ticketsBranch, ticket);
return ticket;
} catch (Throwable t) {
- LOGGER.error("Failed to get ticgit ticket " + ticketFolder, t);
+ LOGGER.error("Failed to get ticket " + ticketFolder, t);
}
}
return null;
}
- private static void readTicketContents(Repository r, RefModel ticgitBranch, TicGitTicket ticket) {
- List<PathModel> ticketFiles = getFilesInPath(r, ticket.name, ticgitBranch.getCommit());
+ private static void readTicketContents(Repository r, RefModel ticketsBranch, TicketModel ticket) {
+ List<PathModel> ticketFiles = getFilesInPath(r, ticket.name, ticketsBranch.getCommit());
for (PathModel file : ticketFiles) {
- String content = getRawContentAsString(r, ticgitBranch.getCommit(), file.path).trim();
+ String content = getRawContentAsString(r, ticketsBranch.getCommit(), file.path).trim();
if (file.name.equals("TICKET_ID")) {
ticket.id = content;
} else if (file.name.equals("TITLE")) {
@@ -618,10 +804,10 @@
Collections.sort(ticket.comments);
}
- public static String getTicGitContent(Repository r, String filePath) {
- RefModel ticgitBranch = getTicGitBranch(r);
- if (ticgitBranch != null) {
- return getRawContentAsString(r, ticgitBranch.getCommit(), filePath);
+ public static String getTicketContent(Repository r, String filePath) {
+ RefModel ticketsBranch = getTicketsBranch(r);
+ if (ticketsBranch != null) {
+ return getRawContentAsString(r, ticketsBranch.getCommit(), filePath);
}
return "";
}
--
Gitblit v1.9.1