/// <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; }
public override TreeFilter Clone() { TreeFilter n = a.Clone(); return(n == a ? this : new NotTreeFilter(n)); }