in org.eclipse.jgit/src/org/eclipse/jgit/lib/IndexDiff.java [441:652]
public boolean diff(ProgressMonitor monitor, int estWorkTreeSize,
int estIndexSize, String title, RepositoryBuilderFactory factory)
throws IOException {
dirCache = repository.readDirCache();
try (TreeWalk treeWalk = new TreeWalk(repository)) {
treeWalk.setOperationType(OperationType.CHECKIN_OP);
treeWalk.setRecursive(true);
// add the trees (tree, dirchache, workdir)
if (tree != null)
treeWalk.addTree(tree);
else
treeWalk.addTree(new EmptyTreeIterator());
treeWalk.addTree(new DirCacheIterator(dirCache));
treeWalk.addTree(initialWorkingTreeIterator);
initialWorkingTreeIterator.setDirCacheIterator(treeWalk, 1);
Collection<TreeFilter> filters = new ArrayList<>(4);
if (monitor != null) {
// Get the maximum size of the work tree and index
// and add some (quite arbitrary)
if (estIndexSize == 0)
estIndexSize = dirCache.getEntryCount();
int total = Math.max(estIndexSize * 10 / 9,
estWorkTreeSize * 10 / 9);
monitor.beginTask(title, total);
filters.add(new ProgressReportingFilter(monitor, total));
}
if (filter != null)
filters.add(filter);
filters.add(new SkipWorkTreeFilter(INDEX));
indexDiffFilter = new IndexDiffFilter(INDEX, WORKDIR);
filters.add(indexDiffFilter);
treeWalk.setFilter(AndTreeFilter.create(filters));
fileModes.clear();
while (treeWalk.next()) {
AbstractTreeIterator treeIterator = treeWalk.getTree(TREE,
AbstractTreeIterator.class);
DirCacheIterator dirCacheIterator = treeWalk.getTree(INDEX,
DirCacheIterator.class);
WorkingTreeIterator workingTreeIterator = treeWalk
.getTree(WORKDIR, WorkingTreeIterator.class);
if (dirCacheIterator != null) {
final DirCacheEntry dirCacheEntry = dirCacheIterator
.getDirCacheEntry();
if (dirCacheEntry != null) {
int stage = dirCacheEntry.getStage();
if (stage > 0) {
String path = treeWalk.getPathString();
addConflict(path, stage);
continue;
}
}
}
if (treeIterator != null) {
if (dirCacheIterator != null) {
if (!treeIterator.idEqual(dirCacheIterator)
|| treeIterator
.getEntryRawMode() != dirCacheIterator
.getEntryRawMode()) {
// in repo, in index, content diff => changed
if (!isEntryGitLink(treeIterator)
|| !isEntryGitLink(dirCacheIterator)
|| ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
changed.add(treeWalk.getPathString());
}
} else {
// in repo, not in index => removed
if (!isEntryGitLink(treeIterator)
|| ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
removed.add(treeWalk.getPathString());
if (workingTreeIterator != null)
untracked.add(treeWalk.getPathString());
}
} else {
if (dirCacheIterator != null) {
// not in repo, in index => added
if (!isEntryGitLink(dirCacheIterator)
|| ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
added.add(treeWalk.getPathString());
} else {
// not in repo, not in index => untracked
if (workingTreeIterator != null
&& !workingTreeIterator.isEntryIgnored()) {
untracked.add(treeWalk.getPathString());
}
}
}
if (dirCacheIterator != null) {
if (workingTreeIterator == null) {
// in index, not in workdir => missing
boolean isGitLink = isEntryGitLink(dirCacheIterator);
if (!isGitLink
|| ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL) {
String path = treeWalk.getPathString();
missing.add(path);
if (isGitLink) {
missingSubmodules.add(path);
}
}
} else {
if (workingTreeIterator.isModified(
dirCacheIterator.getDirCacheEntry(), true,
treeWalk.getObjectReader())) {
// in index, in workdir, content differs => modified
if (!isEntryGitLink(dirCacheIterator)
|| !isEntryGitLink(workingTreeIterator)
|| (ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL
&& ignoreSubmoduleMode != IgnoreSubmoduleMode.DIRTY))
modified.add(treeWalk.getPathString());
}
}
}
String path = treeWalk.getPathString();
if (path != null) {
for (int i = 0; i < treeWalk.getTreeCount(); i++) {
recordFileMode(path, treeWalk.getFileMode(i));
}
}
}
}
if (ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL) {
try (SubmoduleWalk smw = new SubmoduleWalk(repository)) {
smw.setTree(new DirCacheIterator(dirCache));
smw.setBuilderFactory(factory);
while (smw.next()) {
IgnoreSubmoduleMode localIgnoreSubmoduleMode = ignoreSubmoduleMode;
try {
if (localIgnoreSubmoduleMode == null)
localIgnoreSubmoduleMode = smw.getModulesIgnore();
if (IgnoreSubmoduleMode.ALL
.equals(localIgnoreSubmoduleMode))
continue;
} catch (ConfigInvalidException e) {
throw new IOException(MessageFormat.format(
JGitText.get().invalidIgnoreParamSubmodule,
smw.getPath()), e);
}
try (Repository subRepo = smw.getRepository()) {
String subRepoPath = smw.getPath();
if (subRepo != null) {
ObjectId subHead = subRepo.resolve("HEAD"); //$NON-NLS-1$
if (subHead != null
&& !subHead.equals(smw.getObjectId())) {
modified.add(subRepoPath);
recordFileMode(subRepoPath, FileMode.GITLINK);
} else if (localIgnoreSubmoduleMode != IgnoreSubmoduleMode.DIRTY) {
IndexDiff smid = submoduleIndexDiffs
.get(smw.getPath());
if (smid == null) {
smid = new IndexDiff(subRepo,
smw.getObjectId(),
wTreeIt.getWorkingTreeIterator(
subRepo));
submoduleIndexDiffs.put(subRepoPath, smid);
}
if (smid.diff(factory)) {
if (localIgnoreSubmoduleMode == IgnoreSubmoduleMode.UNTRACKED
&& smid.getAdded().isEmpty()
&& smid.getChanged().isEmpty()
&& smid.getConflicting().isEmpty()
&& smid.getMissing().isEmpty()
&& smid.getModified().isEmpty()
&& smid.getRemoved().isEmpty()) {
continue;
}
modified.add(subRepoPath);
recordFileMode(subRepoPath,
FileMode.GITLINK);
}
}
} else if (missingSubmodules.remove(subRepoPath)) {
// If the directory is there and empty but the
// submodule repository in .git/modules doesn't
// exist yet it isn't "missing".
File gitDir = new File(
new File(repository.getDirectory(),
Constants.MODULES),
subRepoPath);
if (!gitDir.isDirectory()) {
File dir = SubmoduleWalk.getSubmoduleDirectory(
repository, subRepoPath);
if (dir.isDirectory() && !hasFiles(dir)) {
missing.remove(subRepoPath);
}
}
}
}
}
}
}
// consume the remaining work
if (monitor != null) {
monitor.endTask();
}
ignored = indexDiffFilter.getIgnoredPaths();
if (added.isEmpty() && changed.isEmpty() && removed.isEmpty()
&& missing.isEmpty() && modified.isEmpty()
&& untracked.isEmpty()) {
return false;
}
return true;
}