/// <exception cref="NGit.Errors.MissingObjectException"></exception>
/// <exception cref="NGit.Errors.IncorrectObjectTypeException"></exception>
/// <exception cref="NGit.Errors.CorruptObjectException"></exception>
/// <exception cref="System.IO.IOException"></exception>
private void UpdateFollowFilter(ObjectId[] trees)
{
TreeWalk tw = pathFilter;
FollowFilter oldFilter = (FollowFilter)tw.Filter;
tw.Filter = TreeFilter.ANY_DIFF;
tw.Reset(trees);
IList <DiffEntry> files = DiffEntry.Scan(tw);
RenameDetector rd = new RenameDetector(repository);
rd.AddAll(files);
files = rd.Compute();
TreeFilter newFilter = oldFilter;
foreach (DiffEntry ent in files)
{
if (IsRename(ent) && ent.GetNewPath().Equals(oldFilter.GetPath()))
{
newFilter = FollowFilter.Create(ent.GetOldPath());
RenameCallback callback = oldFilter.GetRenameCallback();
if (callback != null)
{
callback.Renamed(ent);
// forward the callback to the new follow filter
((FollowFilter)newFilter).SetRenameCallback(callback);
}
break;
}
}
tw.Filter = newFilter;
}
internal RewriteTreeFilter(RevWalk walker, TreeFilter t)
{
repository = walker.repository;
pathFilter = new TreeWalk(walker.reader);
pathFilter.Filter = t;
pathFilter.Recursive = t.ShouldBeRecursive();
}
public void Allow_Works_WithBeforeAndAfter()
{
var target = new TreeFilter()
{
ColumnName = "Date",
FilterText = "2018/10/11"
};
var columnLookup = new Dictionary<string, int>() { { "Date", 0 }, { "NonDate", 1 }, };
var data = new string[] { "2018/10/10", "2ssf3322.4" };
var treeItem = new ColumnarItemData(null, columnLookup, data);
target.Operator = "BeforeDate"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
target.Operator = "AfterDate"; Assert.AreEqual(false, target.ShouldAllow(treeItem));
// Non-date
target.ColumnName = "NonDate";
target.Operator = "BeforeDate"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
target.Operator = "AfterDate"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
// NonExisting value
target.ColumnName = "bbbbbbbbbb";
target.Operator = "BeforeDate"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
target.Operator = "AfterDate"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
// Bad filter value
target.FilterText = "dfdfdf";
target.Operator = "BeforeDate"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
target.Operator = "AfterDate"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
}
public void testNegateIsUnwrap()
{
TreeFilter a = PathFilter.create("a/b");
TreeFilter n = NotTreeFilter.create(a);
Assert.AreSame(a, n.negate());
}
/// <summary>
/// Construct expressions chain for tree filter.
/// </summary>
/// <param name="e">Parameter expression.</param>
/// <param name="filter">Tree filter for query.</param>
/// <param name="suffix">Suffix vor variable.</param>
/// <returns>Expression chain.</returns>
private static Expression GetExpressionForTreeField(Expression e, TreeFilter filter, string suffix)
{
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
if (filter.OperatorType == TreeFilterType.None)
{
return(GetExpressionForField(e, filter, suffix + "0"));
}
if (!(filter.Operands?.Any() ?? false))
{
throw new ArgumentException("Filter operands with operator type different from TreeFilterType.None cannot be empty.");
}
var i = 0;
var exp = GetExpressionForTreeField(e, filter.Operands[i], suffix + i);
var mi = filter.OperatorType == TreeFilterType.And ? AndExpMethod : OrExpMethod;
for (i = 1; i < filter.Operands.Count; i++)
{
var args = new object[] { exp, GetExpressionForTreeField(e, filter.Operands[i], suffix + i) };
exp = (BinaryExpression)mi.Invoke(null, args);
}
return(exp);
}
public void testShouldBeRecursive_ALL()
{
TreeFilter a = TreeFilter.ALL;
TreeFilter n = NotTreeFilter.create(a);
Assert.AreEqual(a.shouldBeRecursive(), n.shouldBeRecursive());
}
private TreeValue <TypeValueInfo> GetTreeValue(TreeOpe treeOpe)
{
TreeValue <TypeValueInfo> treeValue = new TreeValue <TypeValueInfo> {
Index = _index, Value = _typeValueInfo, Level = _level, TreeOpe = treeOpe, Selected = false, Skip = false, Stop = false
};
TreeFilter treeFilter = TreeFilter.Select;
if (_filter != null)
{
treeFilter = _filter(_typeValueInfo);
}
if ((treeFilter & TreeFilter.Stop) == TreeFilter.Stop)
{
treeValue.Stop = true;
}
else if ((treeFilter & TreeFilter.Skip) == TreeFilter.Skip)
{
treeValue.Skip = true;
}
else if ((treeFilter & TreeFilter.DontSelect) == 0)
{
treeValue.Selected = true;
}
return(treeValue);
}
internal IList <GitFile> GetChangedFiles()
{
if (!HasGitRepository)
{
return(new List <GitFile>());
}
if (GitBash.Exists)
{
var output = GitBash.Run("status --porcelain -z --untracked-files", this.GitWorkingDirectory);
return(ParseGitStatus(output));
}
else
{
var list = new List <GitFile>();
var treeWalk = new TreeWalk(this.repository);
treeWalk.Recursive = true;
treeWalk.Filter = TreeFilter.ANY_DIFF;
var id = repository.Resolve(Constants.HEAD);
if (id != null)
{
treeWalk.AddTree(new RevWalk(repository).ParseTree(id));
}
else
{
treeWalk.AddTree(new EmptyTreeIterator());
}
treeWalk.AddTree(new DirCacheIterator(this.repository.ReadDirCache()));
treeWalk.AddTree(new FileTreeIterator(this.repository));
var filters = new TreeFilter[] { new SkipWorkTreeFilter(INDEX), new IndexDiffFilter(INDEX, WORKDIR) };
treeWalk.Filter = AndTreeFilter.Create(filters);
while (treeWalk.Next())
{
WorkingTreeIterator workingTreeIterator = treeWalk.GetTree <WorkingTreeIterator>(WORKDIR);
if (workingTreeIterator != null && workingTreeIterator.IsEntryIgnored())
{
continue;
}
var fileName = GetFullPath(treeWalk.PathString);
if (Directory.Exists(fileName))
{
continue; // this excludes sub modules
}
var status = GetFileStatus(treeWalk);
list.Add(new GitFile
{
FileName = GetRelativeFileName(fileName),
Status = status
});
this.cache[GetCacheKey(fileName)] = status;
}
return(list);
}
}
public void testCloneIsDeepClone()
{
TreeFilter a = new AlwaysCloneTreeFilter();
Assert.AreNotSame(a, a.Clone());
TreeFilter n = NotTreeFilter.create(a);
Assert.AreNotSame(n, n.Clone());
}
public void testShouldBeRecursive_PathFilter()
{
TreeFilter a = PathFilter.create("a/b");
Assert.IsTrue(a.shouldBeRecursive());
TreeFilter n = NotTreeFilter.create(a);
Assert.IsTrue(n.shouldBeRecursive());
}
public void testCloneIsSparseWhenPossible()
{
TreeFilter a = TreeFilter.ALL;
Assert.AreSame(a, a.Clone());
TreeFilter n = NotTreeFilter.create(a);
Assert.AreSame(n, n.Clone());
}
/// <summary>
/// Create a new tree walker for a given repository.
/// </summary>
/// <param name="repo">
/// The repository the walker will obtain data from.
/// </param>
public TreeWalk(Repository repo)
{
_idBuffer = new MutableObjectId();
_cursor = new WindowCursor();
_db = repo;
_filter = TreeFilter.ALL;
_trees = new AbstractTreeIterator[] { new EmptyTreeIterator() };
}
public void testWrap()
{
GitSharp.Core.TreeWalk.TreeWalk tw = new GitSharp.Core.TreeWalk.TreeWalk(db);
TreeFilter a = TreeFilter.ALL;
TreeFilter n = NotTreeFilter.create(a);
Assert.IsNotNull(n);
Assert.IsTrue(a.include(tw));
Assert.IsFalse(n.include(tw));
}
public void Allow_Works_WithContains()
{
var target = new TreeFilter()
{
ColumnName = "Text",
Operator = "Contains",
FilterText = "OW"
};
var columnLookup = new Dictionary<string, int>() { { "Text", 0 }, { "Numeric", 1 }, };
var data = new string[] { "Wow!", "222.4" };
var treeItem = new ColumnarItemData(null, columnLookup, data);
// Text matches
target.Operator = "Contains"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
target.Operator = "DoesNotContain"; Assert.AreEqual(false, target.ShouldAllow(treeItem));
target.IsCaseSensitive = true;
target.Operator = "Contains"; Assert.AreEqual(false, target.ShouldAllow(treeItem));
target.Operator = "DoesNotContain"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
target.FilterText = "ZZ";
target.Operator = "Contains"; Assert.AreEqual(false, target.ShouldAllow(treeItem));
target.Operator = "DoesNotContain"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
target.IsCaseSensitive = false;
target.Operator = "Contains"; Assert.AreEqual(false, target.ShouldAllow(treeItem));
target.Operator = "DoesNotContain"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
target.FilterText = "!";
target.Operator = "Contains"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
target.Operator = "DoesNotContain"; Assert.AreEqual(false, target.ShouldAllow(treeItem));
target.FilterText = "W";
target.Operator = "Contains"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
target.Operator = "DoesNotContain"; Assert.AreEqual(false, target.ShouldAllow(treeItem));
target.FilterText = "Wow!";
target.Operator = "Contains"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
target.Operator = "DoesNotContain"; Assert.AreEqual(false, target.ShouldAllow(treeItem));
target.ColumnName = "NonExistent";
target.Operator = "Contains"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
target.Operator = "DoesNotContain"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
// Numeric matches
target.ColumnName = "Numeric";
target.FilterText = "2.";
target.IsValueColumn = true;
target.Operator = "Contains"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
target.Operator = "DoesNotContain"; Assert.AreEqual(false, target.ShouldAllow(treeItem));
// Non numeric filter values should still work (because we sometimes mistcategorize columns)
target.FilterText = "a";
target.Operator = "Contains"; Assert.AreEqual(false, target.ShouldAllow(treeItem));
target.Operator = "DoesNotContain"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
}
public GitFileStatus GetFileStatusNoCache(string fileName)
{
if (Directory.Exists(fileName))
{
return(GitFileStatus.Ignored);
}
var fileNameRel = GetRelativeFileNameForGit(fileName);
TreeWalk treeWalk = new TreeWalk(this.repository)
{
Recursive = true
};
RevTree revTree = head == null ? null : new RevWalk(repository).ParseTree(head);
if (revTree != null)
{
treeWalk.AddTree(revTree);
}
else
{
treeWalk.AddTree(new EmptyTreeIterator());
}
treeWalk.AddTree(new DirCacheIterator(dirCache));
treeWalk.AddTree(new FileTreeIterator(this.repository));
var filters = new TreeFilter[] {
PathFilter.Create(fileNameRel),
new SkipWorkTreeFilter(INDEX),
new IndexDiffFilter(INDEX, WORKDIR)
};
treeWalk.Filter = AndTreeFilter.Create(filters);
var status = GitFileStatus.NotControlled;
if (treeWalk.Next())
{
status = GetFileStatus(treeWalk);
}
if (status == GitFileStatus.NotControlled)
{
var dirCacheEntry2 = dirCache.GetEntry(fileNameRel);
if (dirCacheEntry2 != null)
{
var treeEntry2 = TreeWalk.ForPath(repository, fileNameRel, revTree);
if (treeEntry2 != null && treeEntry2.GetObjectId(0).Equals(dirCacheEntry2.GetObjectId()))
{
return(GitFileStatus.Tracked);
}
}
}
return(GitFileStatus.NotControlled);
}
public void Allow_Works_WithInequalities()
{
var target = new TreeFilter()
{
ColumnName = "Text",
Operator = ">",
FilterText = "wzzz"
};
var columnLookup = new Dictionary<string, int>() { { "Text", 0 }, { "Numeric", 1 }, };
var data = new string[] { "Wow!", "222.4" };
var treeItem = new ColumnarItemData(null, columnLookup, data);
// Text matches
target.Operator = ">"; Assert.AreEqual(false, target.ShouldAllow(treeItem));
target.Operator = "<"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
target.IsCaseSensitive = true;
target.Operator = ">"; Assert.AreEqual(false, target.ShouldAllow(treeItem));
target.Operator = "<"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
target.FilterText = "Wow!";
target.Operator = ">"; Assert.AreEqual(false, target.ShouldAllow(treeItem));
target.Operator = "<"; Assert.AreEqual(false, target.ShouldAllow(treeItem));
target.ColumnName = "NonExistent";
target.Operator = ">"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
target.Operator = "<"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
// Numeric matches
target.ColumnName = "Numeric";
target.FilterText = "11111";
target.Operator = ">"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
target.Operator = "<"; Assert.AreEqual(false, target.ShouldAllow(treeItem));
target.IsValueColumn = true;
target.Operator = ">"; Assert.AreEqual(false, target.ShouldAllow(treeItem));
target.Operator = "<"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
target.FilterText = "222.401";
target.Operator = ">"; Assert.AreEqual(false, target.ShouldAllow(treeItem));
target.Operator = "<"; Assert.AreEqual(true, target.ShouldAllow(treeItem));
target.FilterText = "222.40";
target.Operator = ">"; Assert.AreEqual(false, target.ShouldAllow(treeItem));
target.Operator = "<"; Assert.AreEqual(false, target.ShouldAllow(treeItem));
// Bad filter value
target.FilterText = "a";
Assert.AreEqual(true, target.ShouldAllow(treeItem));
}
private IList <DiffEntry> UpdateFollowFilter(IList <DiffEntry> files)
{
string oldPath = ((FollowFilter)pathFilter).GetPath();
foreach (DiffEntry ent in files)
{
if (IsRename(ent) && ent.GetNewPath().Equals(oldPath))
{
pathFilter = FollowFilter.Create(ent.GetOldPath());
return(Sharpen.Collections.SingletonList(ent));
}
}
return(Sharpen.Collections.EmptyList <DiffEntry>());
}
/// <summary>Determine the differences between two trees.</summary>
/// <remarks>
/// Determine the differences between two trees.
/// No output is created, instead only the file paths that are different are
/// returned. Callers may choose to format these paths themselves, or convert
/// them into
/// <see cref="NGit.Patch.FileHeader">NGit.Patch.FileHeader</see>
/// instances with a complete edit list by
/// calling
/// <see cref="ToFileHeader(DiffEntry)">ToFileHeader(DiffEntry)</see>
/// .
/// </remarks>
/// <param name="a">the old (or previous) side.</param>
/// <param name="b">the new (or updated) side.</param>
/// <returns>the paths that are different.</returns>
/// <exception cref="System.IO.IOException">trees cannot be read or file contents cannot be read.
/// </exception>
public virtual IList <DiffEntry> Scan(AbstractTreeIterator a, AbstractTreeIterator
b)
{
AssertHaveRepository();
TreeWalk walk = new TreeWalk(reader);
walk.AddTree(a);
walk.AddTree(b);
walk.Recursive = true;
TreeFilter filter = GetDiffTreeFilterFor(a, b);
if (pathFilter is FollowFilter)
{
walk.Filter = AndTreeFilter.Create(PathFilter.Create(((FollowFilter)pathFilter).GetPath
()), filter);
}
else
{
walk.Filter = AndTreeFilter.Create(pathFilter, filter);
}
source = new ContentSource.Pair(Source(a), Source(b));
IList <DiffEntry> files = DiffEntry.Scan(walk);
if (pathFilter is FollowFilter && IsAdd(files))
{
// The file we are following was added here, find where it
// came from so we can properly show the rename or copy,
// then continue digging backwards.
//
a.Reset();
b.Reset();
walk.Reset();
walk.AddTree(a);
walk.AddTree(b);
walk.Filter = filter;
if (renameDetector == null)
{
SetDetectRenames(true);
}
files = UpdateFollowFilter(DetectRenames(DiffEntry.Scan(walk)));
}
else
{
if (renameDetector != null)
{
files = DetectRenames(files);
}
}
return(files);
}
private static async Task <TreeNode> CreateTreeFiltered(string path)
{
var fileSystem = new FileSystem();
var treeCreator = new TreeCreator(fileSystem);
var treeFilter = new TreeFilter(fileSystem);
treeFilter.PredefinedIgnores = new List <string>
{
KvdSystemDirectoryPath
};
var tree = await treeCreator.Create(path);
var treeFiltered = await treeFilter.Filter(tree, path);
return(treeFiltered);
}
private static TreeFilter GetDiffTreeFilterFor(AbstractTreeIterator a, AbstractTreeIterator
b)
{
if (a is DirCacheIterator && b is WorkingTreeIterator)
{
return(new IndexDiffFilter(0, 1));
}
if (a is WorkingTreeIterator && b is DirCacheIterator)
{
return(new IndexDiffFilter(1, 0));
}
TreeFilter filter = TreeFilter.ANY_DIFF;
if (a is WorkingTreeIterator)
{
filter = AndTreeFilter.Create(new NotIgnoredFilter(0), filter);
}
if (b is WorkingTreeIterator)
{
filter = AndTreeFilter.Create(new NotIgnoredFilter(1), filter);
}
return(filter);
}
public void Allow_Works_WithRegex()
{
var target = new TreeFilter()
{
ColumnName = "Text",
Operator = "Regex",
FilterText = "[bu]+LES"
};
var columnLookup = new Dictionary<string, int>() { { "Text", 0 }, { "Numeric", 1 }, };
var data = new string[] { "BUBBLES!", "222.4" };
var treeItem = new ColumnarItemData(null, columnLookup, data);
// Text matches
Assert.AreEqual(true, target.ShouldAllow(treeItem));
target.IsCaseSensitive = true;
Assert.AreEqual(false, target.ShouldAllow(treeItem));
target.FilterText = "blah";
Assert.AreEqual(false, target.ShouldAllow(treeItem));
target.ColumnName = "NonExistent";
target.FilterText = "Wow!";
Assert.AreEqual(true, target.ShouldAllow(treeItem));
// Numeric matches
target.ColumnName = "Numeric";
target.FilterText = "2+\\.4";
target.IsValueColumn = true;
Assert.AreEqual(true, target.ShouldAllow(treeItem));
// Bad filter value
target.FilterText = "2(";
Assert.AreEqual(true, target.ShouldAllow(treeItem));
}
/// <exception cref="NGit.Errors.MissingObjectException"></exception>
/// <exception cref="NGit.Errors.IncorrectObjectTypeException"></exception>
/// <exception cref="NGit.Errors.CorruptObjectException"></exception>
/// <exception cref="System.IO.IOException"></exception>
private void UpdateFollowFilter(ObjectId[] trees)
{
TreeWalk tw = pathFilter;
FollowFilter oldFilter = (FollowFilter)tw.Filter;
tw.Filter = TreeFilter.ANY_DIFF;
tw.Reset(trees);
IList <DiffEntry> files = DiffEntry.Scan(tw);
RenameDetector rd = new RenameDetector(repository);
rd.AddAll(files);
files = rd.Compute();
TreeFilter newFilter = oldFilter;
foreach (DiffEntry ent in files)
{
if (IsRename(ent) && ent.GetNewPath().Equals(oldFilter.GetPath()))
{
newFilter = FollowFilter.Create(ent.GetOldPath());
break;
}
}
tw.Filter = newFilter;
}
public async Task <ActionResult> GetTrees(TreeFilter model)
{
var pages = await _itemService.FindByParentIdAsync(model.id);
return(Json(pages));
}
public async Task <ActionResult> GetTrees(TreeFilter model)
{
var pages = await _departmentService.FindByParentId(model.id);
return(JsonOk(pages));
}
public RewriteTreeFilter(RevWalk walker, TreeFilter t)
{
_pathFilter = new TreeWalk.TreeWalk(walker.Repository);
_pathFilter.setFilter(t);
_pathFilter.Recursive = t.shouldBeRecursive();
}
/**
* Create a filter that negates the result of another filter.
*
* @param a
* filter to negate.
* @return a filter that does the reverse of <code>a</code>.
*/
public static TreeFilter create(TreeFilter a)
{
return(new NotTreeFilter(a));
}
/// <summary>
/// Get final expression for tree filter.
/// </summary>
/// <typeparam name="T">Return type.</typeparam>
/// <param name="filter">Tree filter for query.</param>
/// <param name="suffix">Suffix vor variable.</param>
/// <returns>Final expression.</returns>
public static Expression <Func <T, bool> > GetTreeExpression <T>(this TreeFilter filter, string suffix = "")
{
var e = Expression.Parameter(typeof(T), "e" + suffix);
return(Expression.Lambda <Func <T, bool> >(GetExpressionForTreeField(e, filter, suffix), e));
}
/// <summary>Set the filter to produce only specific paths.</summary>
/// <remarks>
/// Set the filter to produce only specific paths.
/// If the filter is an instance of
/// <see cref="NGit.Revwalk.FollowFilter">NGit.Revwalk.FollowFilter</see>
/// , the filter path
/// will be updated during successive scan or format invocations. The updated
/// path can be obtained from
/// <see cref="GetPathFilter()">GetPathFilter()</see>
/// .
/// </remarks>
/// <param name="filter">the tree filter to apply.</param>
public virtual void SetPathFilter(TreeFilter filter)
{
pathFilter = filter != null ? filter : TreeFilter.ALL;
}
/**
* Create a filter that negates the result of another filter.
*
* @param a
* filter to negate.
* @return a filter that does the reverse of <code>a</code>.
*/
public static TreeFilter create(TreeFilter a)
{
return new NotTreeFilter(a);
}
private NotTreeFilter(TreeFilter one)
{
a = one;
}
private NotTreeFilter(TreeFilter one)
{
a = one;
}
public override TreeFilter Clone()
{
TreeFilter n = a.Clone();
return(n == a ? this : new NotTreeFilter(n));
}
