public override bool Include(TreeWalk walker)
{
int m = walker.GetRawMode(0);
if (walker.GetRawMode(1) != m || !walker.IdEqual(1, 0))
{
return(true);
}
if (walker.GetRawMode(2) != m || !walker.IdEqual(2, 0))
{
return(true);
}
return(false);
}
public override bool Include(TreeWalk walker)
{
int n = walker.TreeCount;
if (n == 1)
{
// Assume they meant difference to empty tree.
return(true);
}
int m = walker.GetRawMode(0);
for (int i = 1; i < n; i++)
{
if (walker.GetRawMode(i) != m || !walker.IdEqual(i, 0))
{
return(true);
}
}
return(false);
}
static IEnumerable<Change> CalculateCommitDiff (NGit.Repository repo, TreeWalk walk, RevCommit[] commits)
{
while (walk.Next ()) {
int m0 = walk.GetRawMode (0);
if (walk.TreeCount == 2) {
int m1 = walk.GetRawMode (1);
var change = new Change { ReferenceCommit = commits[0], ComparedCommit = commits[1], ReferencePermissions = walk.GetFileMode (0).GetBits (), ComparedPermissions = walk.GetFileMode (1).GetBits (), Name = walk.NameString, Path = walk.PathString };
if (m0 != 0 && m1 == 0) {
change.ChangeType = ChangeType.Added;
change.ComparedObject = walk.GetObjectId (0);
} else if (m0 == 0 && m1 != 0) {
change.ChangeType = ChangeType.Deleted;
change.ReferenceObject = walk.GetObjectId (0);
} else if (m0 != m1 && walk.IdEqual (0, 1)) {
change.ChangeType = ChangeType.TypeChanged;
change.ReferenceObject = walk.GetObjectId (0);
change.ComparedObject = walk.GetObjectId (1);
} else {
change.ChangeType = ChangeType.Modified;
change.ReferenceObject = walk.GetObjectId (0);
change.ComparedObject = walk.GetObjectId (1);
}
yield return change;
} else {
var raw_modes = new int[walk.TreeCount - 1];
for (int i = 0; i < walk.TreeCount - 1; i++)
raw_modes[i] = walk.GetRawMode (i + 1);
//ComparedCommit = compared,
var change = new Change { ReferenceCommit = commits[0], Name = walk.NameString, Path = walk.PathString };
if (m0 != 0 && raw_modes.All (m1 => m1 == 0)) {
change.ChangeType = ChangeType.Added;
change.ComparedObject = walk.GetObjectId (0);
yield return change;
} else if (m0 == 0 && raw_modes.Any (m1 => m1 != 0)) {
change.ChangeType = ChangeType.Deleted;
yield return change;
// TODO: not sure if this condition suffices in some special cases.
} else if (raw_modes.Select ((m1, i) => new { Mode = m1, Index = i + 1 }).All (x => !walk.IdEqual (0, x.Index))) {
change.ChangeType = ChangeType.Modified;
change.ReferenceObject = walk.GetObjectId (0);
yield return change;
} else if (raw_modes.Select ((m1, i) => new { Mode = m1, Index = i + 1 }).Any (x => m0 != x.Mode && walk.IdEqual (0, x.Index))) {
change.ChangeType = ChangeType.TypeChanged;
change.ReferenceObject = walk.GetObjectId (0);
yield return change;
}
}
}
}
/// <exception cref="NGit.Errors.MissingObjectException"></exception>
/// <exception cref="NGit.Errors.IncorrectObjectTypeException"></exception>
/// <exception cref="System.IO.IOException"></exception>
public override bool Include(TreeWalk tw)
{
int cnt = tw.TreeCount;
int wm = tw.GetRawMode(workingTree);
string path = tw.PathString;
if (!tw.PostOrderTraversal)
{
// detect untracked Folders
// Whenever we enter a folder in the workingtree assume it will
// contain only untracked files and add it to
// untrackedParentFolders. If we later find tracked files we will
// remove it from this list
if (FileMode.TREE.Equals(wm))
{
// Clean untrackedParentFolders. This potentially moves entries
// from untrackedParentFolders to untrackedFolders
CopyUntrackedFolders(path);
// add the folder we just entered to untrackedParentFolders
untrackedParentFolders.AddFirst(path);
}
// detect untracked Folders
// Whenever we see a tracked file we know that all of its parent
// folders do not belong into untrackedParentFolders anymore. Clean
// it.
for (int i = 0; i < cnt; i++)
{
int rmode = tw.GetRawMode(i);
if (i != workingTree && rmode != 0 && FileMode.TREE.Equals(rmode))
{
untrackedParentFolders.Clear();
break;
}
}
}
// If the working tree file doesn't exist, it does exist for at least
// one other so include this difference.
if (wm == 0)
{
return(true);
}
// If the path does not appear in the DirCache and its ignored
// we can avoid returning a result here, but only if its not in any
// other tree.
int dm = tw.GetRawMode(dirCache);
WorkingTreeIterator wi = WorkingTree(tw);
if (dm == 0)
{
if (honorIgnores && wi.IsEntryIgnored())
{
ignoredPaths.AddItem(wi.EntryPathString);
int i = 0;
for (; i < cnt; i++)
{
if (i == dirCache || i == workingTree)
{
continue;
}
if (tw.GetRawMode(i) != 0)
{
break;
}
}
// If i is cnt then the path does not appear in any other tree,
// and this working tree entry can be safely ignored.
return(i == cnt ? false : true);
}
else
{
// In working tree and not ignored, and not in DirCache.
return(true);
}
}
// Always include subtrees as WorkingTreeIterator cannot provide
// efficient elimination of unmodified subtrees.
if (tw.IsSubtree)
{
return(true);
}
// Try the inexpensive comparisons between index and all real trees
// first. Only if we don't find a diff here we have to bother with
// the working tree
for (int i_1 = 0; i_1 < cnt; i_1++)
{
if (i_1 == dirCache || i_1 == workingTree)
{
continue;
}
if (tw.GetRawMode(i_1) != dm || !tw.IdEqual(i_1, dirCache))
{
return(true);
}
}
// Only one chance left to detect a diff: between index and working
// tree. Make use of the WorkingTreeIterator#isModified() method to
// avoid computing SHA1 on filesystem content if not really needed.
DirCacheIterator di = tw.GetTree <DirCacheIterator>(dirCache);
return(wi.IsModified(di.GetDirCacheEntry(), true));
}
static IEnumerable <Change> CalculateCommitDiff(NGit.Repository repo, TreeWalk walk, RevCommit[] commits)
{
while (walk.Next())
{
int m0 = walk.GetRawMode(0);
if (walk.TreeCount == 2)
{
int m1 = walk.GetRawMode(1);
var change = new Change {
ReferenceCommit = commits[0], ComparedCommit = commits[1], ReferencePermissions = walk.GetFileMode(0).GetBits(), ComparedPermissions = walk.GetFileMode(1).GetBits(), Name = walk.NameString, Path = walk.PathString
};
if (m0 != 0 && m1 == 0)
{
change.ChangeType = ChangeType.Added;
change.ComparedObject = walk.GetObjectId(0);
}
else if (m0 == 0 && m1 != 0)
{
change.ChangeType = ChangeType.Deleted;
change.ReferenceObject = walk.GetObjectId(0);
}
else if (m0 != m1 && walk.IdEqual(0, 1))
{
change.ChangeType = ChangeType.TypeChanged;
change.ReferenceObject = walk.GetObjectId(0);
change.ComparedObject = walk.GetObjectId(1);
}
else
{
change.ChangeType = ChangeType.Modified;
change.ReferenceObject = walk.GetObjectId(0);
change.ComparedObject = walk.GetObjectId(1);
}
yield return(change);
}
else
{
var raw_modes = new int[walk.TreeCount - 1];
for (int i = 0; i < walk.TreeCount - 1; i++)
{
raw_modes[i] = walk.GetRawMode(i + 1);
}
//ComparedCommit = compared,
var change = new Change {
ReferenceCommit = commits[0], Name = walk.NameString, Path = walk.PathString
};
if (m0 != 0 && raw_modes.All(m1 => m1 == 0))
{
change.ChangeType = ChangeType.Added;
change.ComparedObject = walk.GetObjectId(0);
yield return(change);
}
else if (m0 == 0 && raw_modes.Any(m1 => m1 != 0))
{
change.ChangeType = ChangeType.Deleted;
yield return(change);
// TODO: not sure if this condition suffices in some special cases.
}
else if (raw_modes.Select((m1, i) => new { Mode = m1, Index = i + 1 }).All(x => !walk.IdEqual(0, x.Index)))
{
change.ChangeType = ChangeType.Modified;
change.ReferenceObject = walk.GetObjectId(0);
yield return(change);
}
else if (raw_modes.Select((m1, i) => new { Mode = m1, Index = i + 1 }).Any(x => m0 != x.Mode && walk.IdEqual(0, x.Index)))
{
change.ChangeType = ChangeType.TypeChanged;
change.ReferenceObject = walk.GetObjectId(0);
yield return(change);
}
}
}
}
/// <exception cref="NGit.Errors.MissingObjectException"></exception>
/// <exception cref="NGit.Errors.IncorrectObjectTypeException"></exception>
/// <exception cref="System.IO.IOException"></exception>
public override bool Include(TreeWalk tw)
{
// If the working tree file doesn't exist, it does exist for at least
// one other so include this difference.
int wm = tw.GetRawMode(workingTree);
if (wm == 0)
{
return true;
}
// If the path does not appear in the DirCache and its ignored
// we can avoid returning a result here, but only if its not in any
// other tree.
int cnt = tw.TreeCount;
int dm = tw.GetRawMode(dirCache);
if (dm == 0)
{
if (honorIgnores && WorkingTree(tw).IsEntryIgnored())
{
int i = 0;
for (; i < cnt; i++)
{
if (i == dirCache || i == workingTree)
{
continue;
}
if (tw.GetRawMode(i) != 0)
{
break;
}
}
// If i is cnt then the path does not appear in any other tree,
// and this working tree entry can be safely ignored.
return i == cnt ? false : true;
}
else
{
// In working tree and not ignored, and not in DirCache.
return true;
}
}
// Always include subtrees as WorkingTreeIterator cannot provide
// efficient elimination of unmodified subtrees.
if (tw.IsSubtree)
{
return true;
}
// Try the inexpensive comparisons between index and all real trees
// first. Only if we don't find a diff here we have to bother with
// the working tree
for (int i_1 = 0; i_1 < cnt; i_1++)
{
if (i_1 == dirCache || i_1 == workingTree)
{
continue;
}
if (tw.GetRawMode(i_1) != dm || !tw.IdEqual(i_1, dirCache))
{
return true;
}
}
// Only one chance left to detect a diff: between index and working
// tree. Make use of the WorkingTreeIterator#isModified() method to
// avoid computing SHA1 on filesystem content if not really needed.
WorkingTreeIterator wi = WorkingTree(tw);
DirCacheIterator di = tw.GetTree<DirCacheIterator>(dirCache);
return wi.IsModified(di.GetDirCacheEntry(), true);
}
/// <exception cref="NGit.Errors.StopWalkException"></exception>
/// <exception cref="NGit.Errors.MissingObjectException"></exception>
/// <exception cref="NGit.Errors.IncorrectObjectTypeException"></exception>
/// <exception cref="System.IO.IOException"></exception>
public override bool Include(RevWalk walker, RevCommit c)
{
// Reset the tree filter to scan this commit and parents.
//
RevCommit[] pList = c.parents;
int nParents = pList.Length;
TreeWalk tw = pathFilter;
ObjectId[] trees = new ObjectId[nParents + 1];
for (int i = 0; i < nParents; i++)
{
RevCommit p = c.parents[i];
if ((p.flags & PARSED) == 0)
{
p.ParseHeaders(walker);
}
trees[i] = p.Tree;
}
trees[nParents] = c.Tree;
tw.Reset(trees);
if (nParents == 1)
{
// We have exactly one parent. This is a very common case.
//
int chgs = 0;
int adds = 0;
while (tw.Next())
{
chgs++;
if (tw.GetRawMode(0) == 0 && tw.GetRawMode(1) != 0)
{
adds++;
}
else
{
break;
}
}
// no point in looking at this further.
if (chgs == 0)
{
// No changes, so our tree is effectively the same as
// our parent tree. We pass the buck to our parent.
//
c.flags |= REWRITE;
return(false);
}
else
{
// We have interesting items, but neither of the special
// cases denoted above.
//
if (adds > 0 && tw.Filter is FollowFilter)
{
// One of the paths we care about was added in this
// commit. We need to update our filter to its older
// name, if we can discover it. Find out what that is.
//
UpdateFollowFilter(trees);
}
return(true);
}
}
else
{
if (nParents == 0)
{
// We have no parents to compare against. Consider us to be
// REWRITE only if we have no paths matching our filter.
//
if (tw.Next())
{
return(true);
}
c.flags |= REWRITE;
return(false);
}
}
// We are a merge commit. We can only be REWRITE if we are same
// to _all_ parents. We may also be able to eliminate a parent if
// it does not contribute changes to us. Such a parent may be an
// uninteresting side branch.
//
int[] chgs_1 = new int[nParents];
int[] adds_1 = new int[nParents];
while (tw.Next())
{
int myMode = tw.GetRawMode(nParents);
for (int i_1 = 0; i_1 < nParents; i_1++)
{
int pMode = tw.GetRawMode(i_1);
if (myMode == pMode && tw.IdEqual(i_1, nParents))
{
continue;
}
chgs_1[i_1]++;
if (pMode == 0 && myMode != 0)
{
adds_1[i_1]++;
}
}
}
bool same = false;
bool diff = false;
for (int i_2 = 0; i_2 < nParents; i_2++)
{
if (chgs_1[i_2] == 0)
{
// No changes, so our tree is effectively the same as
// this parent tree. We pass the buck to only this one
// parent commit.
//
RevCommit p = pList[i_2];
if ((p.flags & UNINTERESTING) != 0)
{
// This parent was marked as not interesting by the
// application. We should look for another parent
// that is interesting.
//
same = true;
continue;
}
c.flags |= REWRITE;
c.parents = new RevCommit[] { p };
return(false);
}
if (chgs_1[i_2] == adds_1[i_2])
{
// All of the differences from this parent were because we
// added files that they did not have. This parent is our
// "empty tree root" and thus their history is not relevant.
// Cut our grandparents to be an empty list.
//
pList[i_2].parents = RevCommit.NO_PARENTS;
}
// We have an interesting difference relative to this parent.
//
diff = true;
}
if (diff && !same)
{
// We did not abort above, so we are different in at least one
// way from all of our parents. We have to take the blame for
// that difference.
//
return(true);
}
// We are the same as all of our parents. We must keep them
// as they are and allow those parents to flow into pending
// for further scanning.
//
c.flags |= REWRITE;
return(false);
}
/// <exception cref="NGit.Errors.MissingObjectException"></exception>
/// <exception cref="NGit.Errors.IncorrectObjectTypeException"></exception>
/// <exception cref="System.IO.IOException"></exception>
public override bool Include(TreeWalk tw)
{
// If the working tree file doesn't exist, it does exist for at least
// one other so include this difference.
int wm = tw.GetRawMode(workingTree);
if (wm == 0)
{
return(true);
}
// If the path does not appear in the DirCache and its ignored
// we can avoid returning a result here, but only if its not in any
// other tree.
int cnt = tw.TreeCount;
int dm = tw.GetRawMode(dirCache);
if (dm == 0)
{
if (honorIgnores && WorkingTree(tw).IsEntryIgnored())
{
int i = 0;
for (; i < cnt; i++)
{
if (i == dirCache || i == workingTree)
{
continue;
}
if (tw.GetRawMode(i) != 0)
{
break;
}
}
// If i is cnt then the path does not appear in any other tree,
// and this working tree entry can be safely ignored.
return(i == cnt ? false : true);
}
else
{
// In working tree and not ignored, and not in DirCache.
return(true);
}
}
// Always include subtrees as WorkingTreeIterator cannot provide
// efficient elimination of unmodified subtrees.
if (tw.IsSubtree)
{
return(true);
}
// Try the inexpensive comparisons between index and all real trees
// first. Only if we don't find a diff here we have to bother with
// the working tree
for (int i_1 = 0; i_1 < cnt; i_1++)
{
if (i_1 == dirCache || i_1 == workingTree)
{
continue;
}
if (tw.GetRawMode(i_1) != dm || !tw.IdEqual(i_1, dirCache))
{
return(true);
}
}
// Only one chance left to detect a diff: between index and working
// tree. Make use of the WorkingTreeIterator#isModified() method to
// avoid computing SHA1 on filesystem content if not really needed.
WorkingTreeIterator wi = WorkingTree(tw);
DirCacheIterator di = tw.GetTree <DirCacheIterator>(dirCache);
return(wi.IsModified(di.GetDirCacheEntry(), true));
}
/// <exception cref="NGit.Errors.MissingObjectException"></exception>
/// <exception cref="NGit.Errors.IncorrectObjectTypeException"></exception>
/// <exception cref="System.IO.IOException"></exception>
public override bool Include(TreeWalk tw)
{
int cnt = tw.TreeCount;
int wm = tw.GetRawMode(workingTree);
string path = tw.PathString;
if (!tw.PostOrderTraversal)
{
// detect untracked Folders
// Whenever we enter a folder in the workingtree assume it will
// contain only untracked files and add it to
// untrackedParentFolders. If we later find tracked files we will
// remove it from this list
if (FileMode.TREE.Equals(wm))
{
// Clean untrackedParentFolders. This potentially moves entries
// from untrackedParentFolders to untrackedFolders
CopyUntrackedFolders(path);
// add the folder we just entered to untrackedParentFolders
untrackedParentFolders.AddFirst(path);
}
// detect untracked Folders
// Whenever we see a tracked file we know that all of its parent
// folders do not belong into untrackedParentFolders anymore. Clean
// it.
for (int i = 0; i < cnt; i++)
{
int rmode = tw.GetRawMode(i);
if (i != workingTree && rmode != 0 && FileMode.TREE.Equals(rmode))
{
untrackedParentFolders.Clear();
break;
}
}
}
// If the working tree file doesn't exist, it does exist for at least
// one other so include this difference.
if (wm == 0)
{
return true;
}
// If the path does not appear in the DirCache and its ignored
// we can avoid returning a result here, but only if its not in any
// other tree.
int dm = tw.GetRawMode(dirCache);
WorkingTreeIterator wi = WorkingTree(tw);
if (dm == 0)
{
if (honorIgnores && wi.IsEntryIgnored())
{
ignoredPaths.AddItem(wi.EntryPathString);
int i = 0;
for (; i < cnt; i++)
{
if (i == dirCache || i == workingTree)
{
continue;
}
if (tw.GetRawMode(i) != 0)
{
break;
}
}
// If i is cnt then the path does not appear in any other tree,
// and this working tree entry can be safely ignored.
return i == cnt ? false : true;
}
else
{
// In working tree and not ignored, and not in DirCache.
return true;
}
}
// Always include subtrees as WorkingTreeIterator cannot provide
// efficient elimination of unmodified subtrees.
if (tw.IsSubtree)
{
return true;
}
// Try the inexpensive comparisons between index and all real trees
// first. Only if we don't find a diff here we have to bother with
// the working tree
for (int i_1 = 0; i_1 < cnt; i_1++)
{
if (i_1 == dirCache || i_1 == workingTree)
{
continue;
}
if (tw.GetRawMode(i_1) != dm || !tw.IdEqual(i_1, dirCache))
{
return true;
}
}
// Only one chance left to detect a diff: between index and working
// tree. Make use of the WorkingTreeIterator#isModified() method to
// avoid computing SHA1 on filesystem content if not really needed.
DirCacheIterator di = tw.GetTree<DirCacheIterator>(dirCache);
return wi.IsModified(di.GetDirCacheEntry(), true);
}
// Modified version of GitSharp's Commit class
private Change[] GetChanges(Repository repository, ObjectId id1, ObjectId id2)
{
var list = new List<Change>();
TreeWalk walk = new TreeWalk(repository);
walk.Reset(id1, id2);
walk.Recursive = true;
walk.Filter = TreeFilter.ANY_DIFF;
while (walk.Next())
{
int m0 = walk.GetRawMode(0);
if (walk.TreeCount == 2)
{
int m1 = walk.GetRawMode(1);
var change = new Change
{
Name = walk.PathString,
};
if (m0 != 0 && m1 == 0)
{
change.ChangeType = ChangeType.Added;
}
else if (m0 == 0 && m1 != 0)
{
change.ChangeType = ChangeType.Deleted;
}
else if (m0 != m1 && walk.IdEqual(0, 1))
{
change.ChangeType = ChangeType.TypeChanged;
}
else
{
change.ChangeType = ChangeType.Modified;
}
list.Add(change);
}
else
{
var raw_modes = new int[walk.TreeCount - 1];
for (int i = 0; i < walk.TreeCount - 1; i++)
raw_modes[i] = walk.GetRawMode(i + 1);
var change = new Change
{
Name = walk.PathString,
};
if (m0 != 0 && raw_modes.All(m1 => m1 == 0))
{
change.ChangeType = ChangeType.Added;
list.Add(change);
}
else if (m0 == 0 && raw_modes.Any(m1 => m1 != 0))
{
change.ChangeType = ChangeType.Deleted;
list.Add(change);
}
else if (raw_modes.Select((m1, i) => new { Mode = m1, Index = i + 1 }).All(x => !walk.IdEqual(0, x.Index))) // TODO: not sure if this condition suffices in some special cases.
{
change.ChangeType = ChangeType.Modified;
list.Add(change);
}
else if (raw_modes.Select((m1, i) => new { Mode = m1, Index = i + 1 }).Any(x => m0 != x.Mode && walk.IdEqual(0, x.Index)))
{
change.ChangeType = ChangeType.TypeChanged;
list.Add(change);
}
}
}
return list.ToArray();
}
public override bool Include(TreeWalk walker)
{
int n = walker.TreeCount;
if (n == 1)
{
// Assume they meant difference to empty tree.
return true;
}
int m = walker.GetRawMode(0);
for (int i = 1; i < n; i++)
{
if (walker.GetRawMode(i) != m || !walker.IdEqual(i, 0))
{
return true;
}
}
return false;
}
// Modified version of GitSharp's Commit class
private Change[] GetChanges(Repository repository, ObjectId id1, ObjectId id2)
{
var list = new List <Change>();
TreeWalk walk = new TreeWalk(repository);
walk.Reset(id1, id2);
walk.Recursive = true;
walk.Filter = TreeFilter.ANY_DIFF;
while (walk.Next())
{
int m0 = walk.GetRawMode(0);
if (walk.TreeCount == 2)
{
int m1 = walk.GetRawMode(1);
var change = new Change
{
Name = walk.PathString,
};
if (m0 != 0 && m1 == 0)
{
change.ChangeType = ChangeType.Added;
}
else if (m0 == 0 && m1 != 0)
{
change.ChangeType = ChangeType.Deleted;
}
else if (m0 != m1 && walk.IdEqual(0, 1))
{
change.ChangeType = ChangeType.TypeChanged;
}
else
{
change.ChangeType = ChangeType.Modified;
}
list.Add(change);
}
else
{
var raw_modes = new int[walk.TreeCount - 1];
for (int i = 0; i < walk.TreeCount - 1; i++)
{
raw_modes[i] = walk.GetRawMode(i + 1);
}
var change = new Change
{
Name = walk.PathString,
};
if (m0 != 0 && raw_modes.All(m1 => m1 == 0))
{
change.ChangeType = ChangeType.Added;
list.Add(change);
}
else if (m0 == 0 && raw_modes.Any(m1 => m1 != 0))
{
change.ChangeType = ChangeType.Deleted;
list.Add(change);
}
else if (raw_modes.Select((m1, i) => new { Mode = m1, Index = i + 1 }).All(x => !walk.IdEqual(0, x.Index))) // TODO: not sure if this condition suffices in some special cases.
{
change.ChangeType = ChangeType.Modified;
list.Add(change);
}
else if (raw_modes.Select((m1, i) => new { Mode = m1, Index = i + 1 }).Any(x => m0 != x.Mode && walk.IdEqual(0, x.Index)))
{
change.ChangeType = ChangeType.TypeChanged;
list.Add(change);
}
}
}
return(list.ToArray());
}
