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);
}
public virtual void TestSingleSubtree_NoRecursion()
{
DirCache dc = DirCache.NewInCore();
string[] paths = new string[] { "a.", "a/b", "a/c", "a/d", "a0b" };
DirCacheEntry[] ents = new DirCacheEntry[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
ents[i] = new DirCacheEntry(paths[i]);
ents[i].FileMode = FileMode.REGULAR_FILE;
}
DirCacheBuilder b = dc.Builder();
for (int i_1 = 0; i_1 < ents.Length; i_1++)
{
b.Add(ents[i_1]);
}
b.Finish();
string[] expPaths = new string[] { "a.", "a", "a0b" };
FileMode[] expModes = new FileMode[] { FileMode.REGULAR_FILE, FileMode.TREE, FileMode
.REGULAR_FILE };
int[] expPos = new int[] { 0, -1, 4 };
DirCacheIterator i_2 = new DirCacheIterator(dc);
TreeWalk tw = new TreeWalk(db);
tw.AddTree(i_2);
tw.Recursive = false;
int pathIdx = 0;
while (tw.Next())
{
NUnit.Framework.Assert.AreSame(i_2, tw.GetTree <DirCacheIterator>(0));
NUnit.Framework.Assert.AreEqual(expModes[pathIdx].GetBits(), tw.GetRawMode(0));
NUnit.Framework.Assert.AreSame(expModes[pathIdx], tw.GetFileMode(0));
NUnit.Framework.Assert.AreEqual(expPaths[pathIdx], tw.PathString);
if (expPos[pathIdx] >= 0)
{
NUnit.Framework.Assert.AreEqual(expPos[pathIdx], i_2.ptr);
NUnit.Framework.Assert.AreSame(ents[expPos[pathIdx]], i_2.GetDirCacheEntry());
}
else
{
NUnit.Framework.Assert.AreSame(FileMode.TREE, tw.GetFileMode(0));
}
pathIdx++;
}
NUnit.Framework.Assert.AreEqual(expPaths.Length, pathIdx);
}
public virtual void TestPathFilterGroup_DoesNotSkipTail()
{
DirCache dc = db.ReadDirCache();
FileMode mode = FileMode.REGULAR_FILE;
string[] paths = new string[] { "a.", "a/b", "a/c", "a/d", "a0b" };
DirCacheEntry[] ents = new DirCacheEntry[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
ents[i] = new DirCacheEntry(paths[i]);
ents[i].FileMode = mode;
}
{
DirCacheBuilder b = dc.Builder();
for (int i_1 = 0; i_1 < ents.Length; i_1++)
{
b.Add(ents[i_1]);
}
b.Finish();
}
int expIdx = 2;
DirCacheBuilder b_1 = dc.Builder();
TreeWalk tw = new TreeWalk(db);
tw.AddTree(new DirCacheBuildIterator(b_1));
tw.Recursive = true;
tw.Filter = PathFilterGroup.CreateFromStrings(Collections.Singleton(paths[expIdx]
));
NUnit.Framework.Assert.IsTrue(tw.Next(), "found " + paths[expIdx]);
DirCacheIterator c = tw.GetTree <DirCacheIterator>(0);
NUnit.Framework.Assert.IsNotNull(c);
NUnit.Framework.Assert.AreEqual(expIdx, c.ptr);
NUnit.Framework.Assert.AreSame(ents[expIdx], c.GetDirCacheEntry());
NUnit.Framework.Assert.AreEqual(paths[expIdx], tw.PathString);
NUnit.Framework.Assert.AreEqual(mode.GetBits(), tw.GetRawMode(0));
NUnit.Framework.Assert.AreSame(mode, tw.GetFileMode(0));
b_1.Add(c.GetDirCacheEntry());
NUnit.Framework.Assert.IsFalse(tw.Next(), "no more entries");
b_1.Finish();
NUnit.Framework.Assert.AreEqual(ents.Length, dc.GetEntryCount());
for (int i_2 = 0; i_2 < ents.Length; i_2++)
{
NUnit.Framework.Assert.AreSame(ents[i_2], dc.GetEntry(i_2));
}
}
public virtual void TestTwoLevelSubtree_FilterPath()
{
DirCache dc = DirCache.NewInCore();
FileMode mode = FileMode.REGULAR_FILE;
string[] paths = new string[] { "a.", "a/b", "a/c/e", "a/c/f", "a/d", "a0b" };
DirCacheEntry[] ents = new DirCacheEntry[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
ents[i] = new DirCacheEntry(paths[i]);
ents[i].FileMode = mode;
}
DirCacheBuilder b = dc.Builder();
for (int i_1 = 0; i_1 < ents.Length; i_1++)
{
b.Add(ents[i_1]);
}
b.Finish();
TreeWalk tw = new TreeWalk(db);
for (int victimIdx = 0; victimIdx < paths.Length; victimIdx++)
{
tw.Reset();
tw.AddTree(new DirCacheIterator(dc));
tw.Filter = PathFilterGroup.CreateFromStrings(Collections.Singleton(paths[victimIdx
]));
tw.Recursive = tw.Filter.ShouldBeRecursive();
NUnit.Framework.Assert.IsTrue(tw.Next());
DirCacheIterator c = tw.GetTree <DirCacheIterator>(0);
NUnit.Framework.Assert.IsNotNull(c);
NUnit.Framework.Assert.AreEqual(victimIdx, c.ptr);
NUnit.Framework.Assert.AreSame(ents[victimIdx], c.GetDirCacheEntry());
NUnit.Framework.Assert.AreEqual(paths[victimIdx], tw.PathString);
NUnit.Framework.Assert.AreEqual(mode.GetBits(), tw.GetRawMode(0));
NUnit.Framework.Assert.AreSame(mode, tw.GetFileMode(0));
NUnit.Framework.Assert.IsFalse(tw.Next());
}
}
public virtual void TestSingleSubtree_Recursive()
{
DirCache dc = DirCache.NewInCore();
FileMode mode = FileMode.REGULAR_FILE;
string[] paths = new string[] { "a.", "a/b", "a/c", "a/d", "a0b" };
DirCacheEntry[] ents = new DirCacheEntry[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
ents[i] = new DirCacheEntry(paths[i]);
ents[i].FileMode = mode;
}
DirCacheBuilder b = dc.Builder();
for (int i_1 = 0; i_1 < ents.Length; i_1++)
{
b.Add(ents[i_1]);
}
b.Finish();
DirCacheIterator i_2 = new DirCacheIterator(dc);
TreeWalk tw = new TreeWalk(db);
tw.AddTree(i_2);
tw.Recursive = true;
int pathIdx = 0;
while (tw.Next())
{
DirCacheIterator c = tw.GetTree <DirCacheIterator>(0);
NUnit.Framework.Assert.IsNotNull(c);
NUnit.Framework.Assert.AreEqual(pathIdx, c.ptr);
NUnit.Framework.Assert.AreSame(ents[pathIdx], c.GetDirCacheEntry());
NUnit.Framework.Assert.AreEqual(paths[pathIdx], tw.PathString);
NUnit.Framework.Assert.AreEqual(mode.GetBits(), tw.GetRawMode(0));
NUnit.Framework.Assert.AreSame(mode, tw.GetFileMode(0));
pathIdx++;
}
NUnit.Framework.Assert.AreEqual(paths.Length, pathIdx);
}
public virtual void TestNoSubtree_WithTreeWalk()
{
DirCache dc = DirCache.NewInCore();
string[] paths = new string[] { "a.", "a0b" };
FileMode[] modes = new FileMode[] { FileMode.EXECUTABLE_FILE, FileMode.GITLINK };
DirCacheEntry[] ents = new DirCacheEntry[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
ents[i] = new DirCacheEntry(paths[i]);
ents[i].FileMode = modes[i];
}
DirCacheBuilder b = dc.Builder();
for (int i_1 = 0; i_1 < ents.Length; i_1++)
{
b.Add(ents[i_1]);
}
b.Finish();
DirCacheIterator i_2 = new DirCacheIterator(dc);
TreeWalk tw = new TreeWalk(db);
tw.AddTree(i_2);
int pathIdx = 0;
while (tw.Next())
{
NUnit.Framework.Assert.AreSame(i_2, tw.GetTree <DirCacheIterator>(0));
NUnit.Framework.Assert.AreEqual(pathIdx, i_2.ptr);
NUnit.Framework.Assert.AreSame(ents[pathIdx], i_2.GetDirCacheEntry());
NUnit.Framework.Assert.AreEqual(paths[pathIdx], tw.PathString);
NUnit.Framework.Assert.AreEqual(modes[pathIdx].GetBits(), tw.GetRawMode(0));
NUnit.Framework.Assert.AreSame(modes[pathIdx], tw.GetFileMode(0));
pathIdx++;
}
NUnit.Framework.Assert.AreEqual(paths.Length, pathIdx);
}
/// <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);
}
/// <summary>
/// Return a list of those objects in the index which differ from whats in
/// HEAD
/// </summary>
/// <returns>a set of ObjectIds of changed objects in the index</returns>
/// <exception cref="System.IO.IOException">System.IO.IOException</exception>
/// <exception cref="NGit.Errors.CorruptObjectException">NGit.Errors.CorruptObjectException
/// </exception>
/// <exception cref="NGit.Errors.NoWorkTreeException">NGit.Errors.NoWorkTreeException
/// </exception>
private ICollection <ObjectId> ListNonHEADIndexObjects()
{
RevWalk revWalk = null;
try
{
if (repo.GetIndexFile() == null)
{
return(Sharpen.Collections.EmptySet <ObjectId>());
}
}
catch (NoWorkTreeException)
{
return(Sharpen.Collections.EmptySet <ObjectId>());
}
TreeWalk treeWalk = new TreeWalk(repo);
try
{
treeWalk.AddTree(new DirCacheIterator(repo.ReadDirCache()));
ObjectId headID = repo.Resolve(Constants.HEAD);
if (headID != null)
{
revWalk = new RevWalk(repo);
treeWalk.AddTree(revWalk.ParseTree(headID));
revWalk.Dispose();
revWalk = null;
}
treeWalk.Filter = TreeFilter.ANY_DIFF;
treeWalk.Recursive = true;
ICollection <ObjectId> ret = new HashSet <ObjectId>();
while (treeWalk.Next())
{
ObjectId objectId = treeWalk.GetObjectId(0);
switch (treeWalk.GetRawMode(0) & FileMode.TYPE_MASK)
{
case FileMode.TYPE_MISSING:
case FileMode.TYPE_GITLINK:
{
continue;
goto case FileMode.TYPE_TREE;
}
case FileMode.TYPE_TREE:
case FileMode.TYPE_FILE:
case FileMode.TYPE_SYMLINK:
{
ret.AddItem(objectId);
continue;
goto default;
}
default:
{
throw new IOException(MessageFormat.Format(JGitText.Get().corruptObjectInvalidMode3
, string.Format("%o", Sharpen.Extensions.ValueOf(treeWalk.GetRawMode(0)), (objectId
== null) ? "null" : objectId.Name, treeWalk.PathString, repo.GetIndexFile())));
}
}
}
return(ret);
}
finally
{
if (revWalk != null)
{
revWalk.Dispose();
}
treeWalk.Release();
}
}
public virtual void TestTwoLevelSubtree_FilterPath()
{
DirCache dc = DirCache.NewInCore();
FileMode mode = FileMode.REGULAR_FILE;
string[] paths = new string[] { "a.", "a/b", "a/c/e", "a/c/f", "a/d", "a0b" };
DirCacheEntry[] ents = new DirCacheEntry[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
ents[i] = new DirCacheEntry(paths[i]);
ents[i].FileMode = mode;
}
DirCacheBuilder b = dc.Builder();
for (int i_1 = 0; i_1 < ents.Length; i_1++)
{
b.Add(ents[i_1]);
}
b.Finish();
TreeWalk tw = new TreeWalk(db);
for (int victimIdx = 0; victimIdx < paths.Length; victimIdx++)
{
tw.Reset();
tw.AddTree(new DirCacheIterator(dc));
tw.Filter = PathFilterGroup.CreateFromStrings(Collections.Singleton(paths[victimIdx
]));
tw.Recursive = tw.Filter.ShouldBeRecursive();
NUnit.Framework.Assert.IsTrue(tw.Next());
DirCacheIterator c = tw.GetTree<DirCacheIterator>(0);
NUnit.Framework.Assert.IsNotNull(c);
NUnit.Framework.Assert.AreEqual(victimIdx, c.ptr);
NUnit.Framework.Assert.AreSame(ents[victimIdx], c.GetDirCacheEntry());
NUnit.Framework.Assert.AreEqual(paths[victimIdx], tw.PathString);
NUnit.Framework.Assert.AreEqual(mode.GetBits(), tw.GetRawMode(0));
NUnit.Framework.Assert.AreSame(mode, tw.GetFileMode(0));
NUnit.Framework.Assert.IsFalse(tw.Next());
}
}
public virtual void TestSingleSubtree_NoRecursion()
{
DirCache dc = DirCache.NewInCore();
string[] paths = new string[] { "a.", "a/b", "a/c", "a/d", "a0b" };
DirCacheEntry[] ents = new DirCacheEntry[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
ents[i] = new DirCacheEntry(paths[i]);
ents[i].FileMode = FileMode.REGULAR_FILE;
}
DirCacheBuilder b = dc.Builder();
for (int i_1 = 0; i_1 < ents.Length; i_1++)
{
b.Add(ents[i_1]);
}
b.Finish();
string[] expPaths = new string[] { "a.", "a", "a0b" };
FileMode[] expModes = new FileMode[] { FileMode.REGULAR_FILE, FileMode.TREE, FileMode
.REGULAR_FILE };
int[] expPos = new int[] { 0, -1, 4 };
DirCacheIterator i_2 = new DirCacheIterator(dc);
TreeWalk tw = new TreeWalk(db);
tw.AddTree(i_2);
tw.Recursive = false;
int pathIdx = 0;
while (tw.Next())
{
NUnit.Framework.Assert.AreSame(i_2, tw.GetTree<DirCacheIterator>(0));
NUnit.Framework.Assert.AreEqual(expModes[pathIdx].GetBits(), tw.GetRawMode(0));
NUnit.Framework.Assert.AreSame(expModes[pathIdx], tw.GetFileMode(0));
NUnit.Framework.Assert.AreEqual(expPaths[pathIdx], tw.PathString);
if (expPos[pathIdx] >= 0)
{
NUnit.Framework.Assert.AreEqual(expPos[pathIdx], i_2.ptr);
NUnit.Framework.Assert.AreSame(ents[expPos[pathIdx]], i_2.GetDirCacheEntry());
}
else
{
NUnit.Framework.Assert.AreSame(FileMode.TREE, tw.GetFileMode(0));
}
pathIdx++;
}
NUnit.Framework.Assert.AreEqual(expPaths.Length, pathIdx);
}
/// <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 virtual void TestPathFilterGroup_DoesNotSkipTail()
{
DirCache dc = db.ReadDirCache();
FileMode mode = FileMode.REGULAR_FILE;
string[] paths = new string[] { "a.", "a/b", "a/c", "a/d", "a0b" };
DirCacheEntry[] ents = new DirCacheEntry[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
ents[i] = new DirCacheEntry(paths[i]);
ents[i].FileMode = mode;
}
{
DirCacheBuilder b = dc.Builder();
for (int i_1 = 0; i_1 < ents.Length; i_1++)
{
b.Add(ents[i_1]);
}
b.Finish();
}
int expIdx = 2;
DirCacheBuilder b_1 = dc.Builder();
TreeWalk tw = new TreeWalk(db);
tw.AddTree(new DirCacheBuildIterator(b_1));
tw.Recursive = true;
tw.Filter = PathFilterGroup.CreateFromStrings(Collections.Singleton(paths[expIdx]
));
NUnit.Framework.Assert.IsTrue(tw.Next(), "found " + paths[expIdx]);
DirCacheIterator c = tw.GetTree<DirCacheIterator>(0);
NUnit.Framework.Assert.IsNotNull(c);
NUnit.Framework.Assert.AreEqual(expIdx, c.ptr);
NUnit.Framework.Assert.AreSame(ents[expIdx], c.GetDirCacheEntry());
NUnit.Framework.Assert.AreEqual(paths[expIdx], tw.PathString);
NUnit.Framework.Assert.AreEqual(mode.GetBits(), tw.GetRawMode(0));
NUnit.Framework.Assert.AreSame(mode, tw.GetFileMode(0));
b_1.Add(c.GetDirCacheEntry());
NUnit.Framework.Assert.IsFalse(tw.Next(), "no more entries");
b_1.Finish();
NUnit.Framework.Assert.AreEqual(ents.Length, dc.GetEntryCount());
for (int i_2 = 0; i_2 < ents.Length; i_2++)
{
NUnit.Framework.Assert.AreSame(ents[i_2], dc.GetEntry(i_2));
}
}
/// <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);
}
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);
}
}
}
}
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;
}
public virtual void TestNoSubtree_WithTreeWalk()
{
DirCache dc = DirCache.NewInCore();
string[] paths = new string[] { "a.", "a0b" };
FileMode[] modes = new FileMode[] { FileMode.EXECUTABLE_FILE, FileMode.GITLINK };
DirCacheEntry[] ents = new DirCacheEntry[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
ents[i] = new DirCacheEntry(paths[i]);
ents[i].FileMode = modes[i];
}
DirCacheBuilder b = dc.Builder();
for (int i_1 = 0; i_1 < ents.Length; i_1++)
{
b.Add(ents[i_1]);
}
b.Finish();
DirCacheIterator i_2 = new DirCacheIterator(dc);
TreeWalk tw = new TreeWalk(db);
tw.AddTree(i_2);
int pathIdx = 0;
while (tw.Next())
{
NUnit.Framework.Assert.AreSame(i_2, tw.GetTree<DirCacheIterator>(0));
NUnit.Framework.Assert.AreEqual(pathIdx, i_2.ptr);
NUnit.Framework.Assert.AreSame(ents[pathIdx], i_2.GetDirCacheEntry());
NUnit.Framework.Assert.AreEqual(paths[pathIdx], tw.PathString);
NUnit.Framework.Assert.AreEqual(modes[pathIdx].GetBits(), tw.GetRawMode(0));
NUnit.Framework.Assert.AreSame(modes[pathIdx], tw.GetFileMode(0));
pathIdx++;
}
NUnit.Framework.Assert.AreEqual(paths.Length, pathIdx);
}
// 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 virtual void TestTwoLevelSubtree_Recursive()
{
DirCache dc = DirCache.NewInCore();
FileMode mode = FileMode.REGULAR_FILE;
string[] paths = new string[] { "a.", "a/b", "a/c/e", "a/c/f", "a/d", "a0b" };
DirCacheEntry[] ents = new DirCacheEntry[paths.Length];
for (int i = 0; i < paths.Length; i++)
{
ents[i] = new DirCacheEntry(paths[i]);
ents[i].FileMode = mode;
}
DirCacheBuilder b = dc.Builder();
for (int i_1 = 0; i_1 < ents.Length; i_1++)
{
b.Add(ents[i_1]);
}
b.Finish();
TreeWalk tw = new TreeWalk(db);
tw.AddTree(new DirCacheIterator(dc));
tw.Recursive = true;
int pathIdx = 0;
while (tw.Next())
{
DirCacheIterator c = tw.GetTree<DirCacheIterator>(0);
NUnit.Framework.Assert.IsNotNull(c);
NUnit.Framework.Assert.AreEqual(pathIdx, c.ptr);
NUnit.Framework.Assert.AreSame(ents[pathIdx], c.GetDirCacheEntry());
NUnit.Framework.Assert.AreEqual(paths[pathIdx], tw.PathString);
NUnit.Framework.Assert.AreEqual(mode.GetBits(), tw.GetRawMode(0));
NUnit.Framework.Assert.AreSame(mode, tw.GetFileMode(0));
pathIdx++;
}
NUnit.Framework.Assert.AreEqual(paths.Length, pathIdx);
}
/// <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));
}
