/** @param repository */
public IndexDiffCacheEntry(Repository repository) {
this.repository = repository;
indexChangedListenerHandle =
repository
.getListenerList()
.addIndexChangedListener(
new IndexChangedListener() {
public void onIndexChanged(IndexChangedEvent event) {
refreshIndexDelta();
}
});
refsChangedListenerHandle =
repository
.getListenerList()
.addRefsChangedListener(
new RefsChangedListener() {
public void onRefsChanged(RefsChangedEvent event) {
scheduleReloadJob("RefsChanged"); // $NON-NLS-1$
}
});
scheduleReloadJob("IndexDiffCacheEntry construction"); // $NON-NLS-1$
createResourceChangeListener();
if (!repository.isBare()) {
try {
lastIndex = repository.readDirCache();
} catch (IOException ex) {
Activator.error(
MessageFormat.format(
CoreText.IndexDiffCacheEntry_errorCalculatingIndexDelta, repository),
ex);
}
}
}
/**
* Refreshes all resources that changed in the index since the last call to this method. This is
* suitable for incremental updates on index changed events
*
* <p>For bare repositories this does nothing.
*/
private void refreshIndexDelta() {
if (repository.isBare()) return;
try {
DirCache currentIndex = repository.readDirCache();
DirCache oldIndex = lastIndex;
lastIndex = currentIndex;
if (oldIndex == null) {
refresh(); // full refresh in case we have no data to compare.
return;
}
Set<String> paths = new TreeSet<String>();
TreeWalk walk = new TreeWalk(repository);
try {
walk.addTree(new DirCacheIterator(oldIndex));
walk.addTree(new DirCacheIterator(currentIndex));
walk.setFilter(new InterIndexDiffFilter());
while (walk.next()) {
if (walk.isSubtree()) walk.enterSubtree();
else paths.add(walk.getPathString());
}
} finally {
walk.release();
}
if (!paths.isEmpty()) refreshFiles(paths);
} catch (IOException ex) {
Activator.error(
MessageFormat.format(CoreText.IndexDiffCacheEntry_errorCalculatingIndexDelta, repository),
ex);
scheduleReloadJob(
"Exception while calculating index delta, doing full reload instead"); //$NON-NLS-1$
}
}
private boolean handleGetDiff(
HttpServletRequest request,
HttpServletResponse response,
Repository db,
String scope,
String pattern,
OutputStream out)
throws Exception {
Git git = new Git(db);
DiffCommand diff = git.diff();
diff.setOutputStream(new BufferedOutputStream(out));
AbstractTreeIterator oldTree;
AbstractTreeIterator newTree = new FileTreeIterator(db);
if (scope.contains("..")) { // $NON-NLS-1$
String[] commits = scope.split("\\.\\."); // $NON-NLS-1$
if (commits.length != 2) {
String msg = NLS.bind("Failed to generate diff for {0}", scope);
return statusHandler.handleRequest(
request,
response,
new ServerStatus(IStatus.ERROR, HttpServletResponse.SC_BAD_REQUEST, msg, null));
}
oldTree = getTreeIterator(db, commits[0]);
newTree = getTreeIterator(db, commits[1]);
} else if (scope.equals(GitConstants.KEY_DIFF_CACHED)) {
ObjectId head = db.resolve(Constants.HEAD + "^{tree}"); // $NON-NLS-1$
if (head == null) {
String msg = NLS.bind("Failed to generate diff for {0}, no HEAD", scope);
return statusHandler.handleRequest(
request,
response,
new ServerStatus(IStatus.ERROR, HttpServletResponse.SC_BAD_REQUEST, msg, null));
}
CanonicalTreeParser p = new CanonicalTreeParser();
ObjectReader reader = db.newObjectReader();
try {
p.reset(reader, head);
} finally {
reader.release();
}
oldTree = p;
newTree = new DirCacheIterator(db.readDirCache());
} else if (scope.equals(GitConstants.KEY_DIFF_DEFAULT)) {
oldTree = new DirCacheIterator(db.readDirCache());
} else {
oldTree = getTreeIterator(db, scope);
}
String[] paths = request.getParameterValues(ProtocolConstants.KEY_PATH);
TreeFilter filter = null;
TreeFilter pathFilter = null;
if (paths != null) {
if (paths.length > 1) {
Set<TreeFilter> pathFilters = new HashSet<TreeFilter>(paths.length);
for (String path : paths) {
pathFilters.add(PathFilter.create(path));
}
pathFilter = OrTreeFilter.create(pathFilters);
} else if (paths.length == 1) {
pathFilter = PathFilter.create(paths[0]);
}
}
if (pattern != null) {
PathFilter patternFilter = PathFilter.create(pattern);
if (pathFilter != null) filter = AndTreeFilter.create(patternFilter, pathFilter);
else filter = patternFilter;
} else {
filter = pathFilter;
}
if (filter != null) diff.setPathFilter(filter);
diff.setOldTree(oldTree);
diff.setNewTree(newTree);
diff.call();
return true;
}
private void buildMaps(
Repository repository,
RevCommit baseCommit,
RevCommit compareCommit,
IProgressMonitor monitor)
throws InterruptedException, IOException {
monitor.beginTask(UIText.CompareTreeView_AnalyzingRepositoryTaskText, IProgressMonitor.UNKNOWN);
boolean useIndex = compareVersion.equals(INDEX_VERSION);
deletedPaths.clear();
equalContentPaths.clear();
baseVersionMap.clear();
compareVersionMap.clear();
compareVersionPathsWithChildren.clear();
addedPaths.clear();
baseVersionPathsWithChildren.clear();
boolean checkIgnored = false;
TreeWalk tw = new TreeWalk(repository);
try {
int baseTreeIndex;
if (baseCommit == null) {
checkIgnored = true;
baseTreeIndex =
tw.addTree(
new AdaptableFileTreeIterator(
repository, ResourcesPlugin.getWorkspace().getRoot()));
} else
baseTreeIndex =
tw.addTree(
new CanonicalTreeParser(null, repository.newObjectReader(), baseCommit.getTree()));
int compareTreeIndex;
if (!useIndex)
compareTreeIndex =
tw.addTree(
new CanonicalTreeParser(
null, repository.newObjectReader(), compareCommit.getTree()));
else compareTreeIndex = tw.addTree(new DirCacheIterator(repository.readDirCache()));
if (input instanceof IResource[]) {
IResource[] resources = (IResource[]) input;
List<TreeFilter> orFilters = new ArrayList<TreeFilter>(resources.length);
for (IResource resource : resources) {
String relPath = repositoryMapping.getRepoRelativePath(resource);
if (relPath.length() > 0) orFilters.add(PathFilter.create(relPath));
}
if (orFilters.size() > 1) tw.setFilter(OrTreeFilter.create(orFilters));
else if (orFilters.size() == 1) tw.setFilter(orFilters.get(0));
}
tw.setRecursive(true);
if (monitor.isCanceled()) throw new InterruptedException();
while (tw.next()) {
if (monitor.isCanceled()) throw new InterruptedException();
AbstractTreeIterator compareVersionIterator =
tw.getTree(compareTreeIndex, AbstractTreeIterator.class);
AbstractTreeIterator baseVersionIterator =
tw.getTree(baseTreeIndex, AbstractTreeIterator.class);
if (checkIgnored
&& baseVersionIterator != null
&& ((WorkingTreeIterator) baseVersionIterator).isEntryIgnored()) continue;
if (compareVersionIterator != null && baseVersionIterator != null) {
monitor.setTaskName(baseVersionIterator.getEntryPathString());
IPath currentPath = new Path(baseVersionIterator.getEntryPathString());
if (!useIndex)
compareVersionMap.put(
currentPath,
GitFileRevision.inCommit(
repository,
compareCommit,
baseVersionIterator.getEntryPathString(),
tw.getObjectId(compareTreeIndex)));
else
compareVersionMap.put(
currentPath,
GitFileRevision.inIndex(repository, baseVersionIterator.getEntryPathString()));
if (baseCommit != null)
baseVersionMap.put(
currentPath,
GitFileRevision.inCommit(
repository,
baseCommit,
baseVersionIterator.getEntryPathString(),
tw.getObjectId(baseTreeIndex)));
boolean equalContent =
compareVersionIterator
.getEntryObjectId()
.equals(baseVersionIterator.getEntryObjectId());
if (equalContent) equalContentPaths.add(currentPath);
if (equalContent && !showEquals) continue;
while (currentPath.segmentCount() > 0) {
currentPath = currentPath.removeLastSegments(1);
if (!baseVersionPathsWithChildren.add(currentPath)) break;
}
} else if (baseVersionIterator != null && compareVersionIterator == null) {
monitor.setTaskName(baseVersionIterator.getEntryPathString());
// only on base side
IPath currentPath = new Path(baseVersionIterator.getEntryPathString());
addedPaths.add(currentPath);
if (baseCommit != null)
baseVersionMap.put(
currentPath,
GitFileRevision.inCommit(
repository,
baseCommit,
baseVersionIterator.getEntryPathString(),
tw.getObjectId(baseTreeIndex)));
while (currentPath.segmentCount() > 0) {
currentPath = currentPath.removeLastSegments(1);
if (!baseVersionPathsWithChildren.add(currentPath)) break;
}
} else if (compareVersionIterator != null && baseVersionIterator == null) {
monitor.setTaskName(compareVersionIterator.getEntryPathString());
// only on compare side
IPath currentPath = new Path(compareVersionIterator.getEntryPathString());
deletedPaths.add(currentPath);
List<PathNodeAdapter> children =
compareVersionPathsWithChildren.get(currentPath.removeLastSegments(1));
if (children == null) {
children = new ArrayList<PathNodeAdapter>(1);
compareVersionPathsWithChildren.put(currentPath.removeLastSegments(1), children);
}
children.add(new PathNodeAdapter(new PathNode(currentPath, Type.FILE_DELETED)));
if (!useIndex)
compareVersionMap.put(
currentPath,
GitFileRevision.inCommit(
repository,
compareCommit,
compareVersionIterator.getEntryPathString(),
tw.getObjectId(compareTreeIndex)));
else
compareVersionMap.put(
currentPath,
GitFileRevision.inIndex(repository, compareVersionIterator.getEntryPathString()));
}
}
} finally {
tw.release();
monitor.done();
}
}
private IDiffContainer buildDiffContainer(
RevCommit baseCommit, RevCommit compareCommit, IProgressMonitor monitor)
throws IOException, InterruptedException {
boolean useIndex = compareVersion.equals(CompareTreeView.INDEX_VERSION);
boolean checkIgnored = false;
IDiffContainer result = new DiffNode(Differencer.CONFLICTING);
try (TreeWalk tw = new TreeWalk(repository)) {
// filter by selected resources
if (filterPathStrings.size() > 1) {
List<TreeFilter> suffixFilters = new ArrayList<TreeFilter>();
for (String filterPath : filterPathStrings)
suffixFilters.add(PathFilter.create(filterPath));
TreeFilter otf = OrTreeFilter.create(suffixFilters);
tw.setFilter(otf);
} else if (filterPathStrings.size() > 0) {
String path = filterPathStrings.get(0);
if (path.length() != 0) tw.setFilter(PathFilter.create(path));
}
tw.setRecursive(true);
int baseTreeIndex;
if (baseCommit == null) {
// compare workspace with something
checkIgnored = true;
baseTreeIndex = tw.addTree(new FileTreeIterator(repository));
} else
baseTreeIndex =
tw.addTree(
new CanonicalTreeParser(null, repository.newObjectReader(), baseCommit.getTree()));
int compareTreeIndex;
if (!useIndex)
compareTreeIndex =
tw.addTree(
new CanonicalTreeParser(
null, repository.newObjectReader(), compareCommit.getTree()));
else
// compare something with the index
compareTreeIndex = tw.addTree(new DirCacheIterator(repository.readDirCache()));
while (tw.next()) {
if (monitor.isCanceled()) throw new InterruptedException();
AbstractTreeIterator compareVersionIterator =
tw.getTree(compareTreeIndex, AbstractTreeIterator.class);
AbstractTreeIterator baseVersionIterator =
tw.getTree(baseTreeIndex, AbstractTreeIterator.class);
if (checkIgnored
&& baseVersionIterator != null
&& ((WorkingTreeIterator) baseVersionIterator).isEntryIgnored()) continue;
if (compareVersionIterator != null && baseVersionIterator != null) {
boolean equalContent =
compareVersionIterator
.getEntryObjectId()
.equals(baseVersionIterator.getEntryObjectId());
if (equalContent) continue;
}
String encoding = null;
GitFileRevision compareRev = null;
if (compareVersionIterator != null) {
String entryPath = compareVersionIterator.getEntryPathString();
encoding = CompareCoreUtils.getResourceEncoding(repository, entryPath);
if (!useIndex)
compareRev =
GitFileRevision.inCommit(
repository, compareCommit, entryPath, tw.getObjectId(compareTreeIndex));
else compareRev = GitFileRevision.inIndex(repository, entryPath);
}
GitFileRevision baseRev = null;
if (baseVersionIterator != null) {
String entryPath = baseVersionIterator.getEntryPathString();
if (encoding == null) {
encoding = CompareCoreUtils.getResourceEncoding(repository, entryPath);
}
baseRev =
GitFileRevision.inCommit(
repository, baseCommit, entryPath, tw.getObjectId(baseTreeIndex));
}
if (compareVersionIterator != null && baseVersionIterator != null) {
monitor.setTaskName(baseVersionIterator.getEntryPathString());
// content exists on both sides
add(
result,
baseVersionIterator.getEntryPathString(),
new DiffNode(
new FileRevisionTypedElement(compareRev, encoding),
new FileRevisionTypedElement(baseRev, encoding)));
} else if (baseVersionIterator != null && compareVersionIterator == null) {
monitor.setTaskName(baseVersionIterator.getEntryPathString());
// only on base side
add(
result,
baseVersionIterator.getEntryPathString(),
new DiffNode(
Differencer.DELETION | Differencer.RIGHT,
null,
null,
new FileRevisionTypedElement(baseRev, encoding)));
} else if (compareVersionIterator != null && baseVersionIterator == null) {
monitor.setTaskName(compareVersionIterator.getEntryPathString());
// only on compare side
add(
result,
compareVersionIterator.getEntryPathString(),
new DiffNode(
Differencer.ADDITION | Differencer.RIGHT,
null,
new FileRevisionTypedElement(compareRev, encoding),
null));
}
if (monitor.isCanceled()) throw new InterruptedException();
}
return result;
}
}