public virtual void TestShouldBeRecursive_ALL() { TreeFilter a = TreeFilter.ALL; TreeFilter n = NotTreeFilter.Create(a); NUnit.Framework.Assert.AreEqual(a.ShouldBeRecursive(), n.ShouldBeRecursive()); }
public virtual void TestNegateIsUnwrap() { TreeFilter a = PathFilter.Create("a/b"); TreeFilter n = NotTreeFilter.Create(a); NUnit.Framework.Assert.AreSame(a, n.Negate()); }
/// <summary>Create a filter with two filters, one of which must match.</summary> /// <remarks>Create a filter with two filters, one of which must match.</remarks> /// <param name="a">first filter to test.</param> /// <param name="b">second filter to test.</param> /// <returns>a filter that must match at least one input filter.</returns> public static TreeFilter Create(TreeFilter a, TreeFilter b) { if (a == ALL || b == ALL) { return(ALL); } return(new OrTreeFilter.Binary(a, b)); }
/// <summary>Create a filter with two filters, one of which must match.</summary> /// <remarks>Create a filter with two filters, one of which must match.</remarks> /// <param name="a">first filter to test.</param> /// <param name="b">second filter to test.</param> /// <returns>a filter that must match at least one input filter.</returns> public static TreeFilter Create(TreeFilter a, TreeFilter b) { if (a == ALL || b == ALL) { return ALL; } return new OrTreeFilter.Binary(a, b); }
public virtual void TestCloneIsSparseWhenPossible() { TreeFilter a = TreeFilter.ALL; NUnit.Framework.Assert.AreSame(a, a.Clone()); TreeFilter n = NotTreeFilter.Create(a); NUnit.Framework.Assert.AreSame(n, n.Clone()); }
public virtual void TestCloneIsDeepClone() { TreeFilter a = new AlwaysCloneTreeFilter(); NUnit.Framework.Assert.AreNotSame(a, a.Clone()); TreeFilter n = NotTreeFilter.Create(a); NUnit.Framework.Assert.AreNotSame(n, n.Clone()); }
public virtual void TestShouldBeRecursive_PathFilter() { TreeFilter a = PathFilter.Create("a/b"); NUnit.Framework.Assert.IsTrue(a.ShouldBeRecursive()); TreeFilter n = NotTreeFilter.Create(a); NUnit.Framework.Assert.IsTrue(n.ShouldBeRecursive()); }
public override TreeFilter Clone() { TreeFilter[] s = new TreeFilter[subfilters.Length]; for (int i = 0; i < s.Length; i++) { s[i] = subfilters[i].Clone(); } return(new OrTreeFilter.List(s)); }
public virtual void TestWrap() { TreeWalk tw = new TreeWalk(db); TreeFilter a = TreeFilter.ALL; TreeFilter n = NotTreeFilter.Create(a); NUnit.Framework.Assert.IsNotNull(n); NUnit.Framework.Assert.IsTrue(a.Include(tw)); NUnit.Framework.Assert.IsFalse(n.Include(tw)); }
/// <summary>Create a filter with two filters, both of which must match.</summary> /// <remarks>Create a filter with two filters, both of which must match.</remarks> /// <param name="a">first filter to test.</param> /// <param name="b">second filter to test.</param> /// <returns>a filter that must match both input filters.</returns> public static TreeFilter Create(TreeFilter a, TreeFilter b) { if (a == ALL) { return(b); } if (b == ALL) { return(a); } return(new AndTreeFilter.Binary(a, b)); }
/// <summary>Create a filter with two filters, both of which must match.</summary> /// <remarks>Create a filter with two filters, both of which must match.</remarks> /// <param name="a">first filter to test.</param> /// <param name="b">second filter to test.</param> /// <returns>a filter that must match both input filters.</returns> public static TreeFilter Create(TreeFilter a, TreeFilter b) { if (a == ALL) { return b; } if (b == ALL) { return a; } return new AndTreeFilter.Binary(a, b); }
/// <summary>Create a filter around many filters, one of which must match.</summary> /// <remarks>Create a filter around many filters, one of which must match.</remarks> /// <param name="list"> /// list of filters to match against. Must contain at least 2 /// filters. /// </param> /// <returns>a filter that must match at least one input filter.</returns> public static TreeFilter Create(TreeFilter[] list) { if (list.Length == 2) { return(Create(list[0], list[1])); } if (list.Length < 2) { throw new ArgumentException(JGitText.Get().atLeastTwoFiltersNeeded); } TreeFilter[] subfilters = new TreeFilter[list.Length]; System.Array.Copy(list, 0, subfilters, 0, list.Length); return(new OrTreeFilter.List(subfilters)); }
/// <summary>Create a filter around many filters, one of which must match.</summary> /// <remarks>Create a filter around many filters, one of which must match.</remarks> /// <param name="list"> /// list of filters to match against. Must contain at least 2 /// filters. /// </param> /// <returns>a filter that must match at least one input filter.</returns> public static TreeFilter Create(ICollection <TreeFilter> list) { if (list.Count < 2) { throw new ArgumentException(JGitText.Get().atLeastTwoFiltersNeeded); } TreeFilter[] subfilters = new TreeFilter[list.Count]; Sharpen.Collections.ToArray(list, subfilters); if (subfilters.Length == 2) { return(Create(subfilters[0], subfilters[1])); } return(new OrTreeFilter.List(subfilters)); }
/// <summary>Set tree filter</summary> /// <param name="filter"></param> /// <returns>this generator</returns> public virtual NGit.Submodule.SubmoduleWalk SetFilter(TreeFilter filter) { walk.Filter = filter; return this; }
internal Binary(TreeFilter one, TreeFilter two) { a = one; b = two; }
private IList<GitFile> GetChangedFilesImpl(bool initializeCache) { if (!HasGitRepository) return new List<GitFile>(); var list = new List<GitFile>(); // initialize the cache if (initializeCache) { var treeWalk = new TreeWalk(this.repository); treeWalk.Recursive = true; treeWalk.Filter = TreeFilter.ALL; var id = repository.Resolve(Constants.HEAD); if (id != null) treeWalk.AddTree(new RevWalk(repository).ParseTree(id)); else treeWalk.AddTree(new EmptyTreeIterator()); while (treeWalk.Next()) { string pathString = treeWalk.PathString; var fileName = GetFullPath(pathString); if (Directory.Exists(fileName)) continue; // this excludes sub modules cache[pathString] = GitFileStatus.Tracked; } } if (GitBash.Exists) { var result = GitBash.Run("status --porcelain -z --untracked-files", this.GitWorkingDirectory); if (!result.HasError) return ParseGitStatus(result.Output); return list; } else { 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 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; }
/// <summary>Create a filter around many filters, all of which must match.</summary> /// <remarks>Create a filter around many filters, all of which must match.</remarks> /// <param name="list"> /// list of filters to match against. Must contain at least 2 /// filters. /// </param> /// <returns>a filter that must match all input filters.</returns> public static TreeFilter Create(TreeFilter[] list) { if (list.Length == 2) { return Create(list[0], list[1]); } if (list.Length < 2) { throw new ArgumentException(JGitText.Get().atLeastTwoFiltersNeeded); } TreeFilter[] subfilters = new TreeFilter[list.Length]; System.Array.Copy(list, 0, subfilters, 0, list.Length); return new AndTreeFilter.List(subfilters); }
/// <summary>Sets a filter.</summary> /// <remarks> /// Sets a filter. Can be used e.g. for restricting the tree walk to a set of /// files. /// </remarks> /// <param name="filter"></param> public virtual void SetFilter(TreeFilter filter) { this.filter = filter; }
public override TreeFilter Clone() { TreeFilter[] s = new TreeFilter[subfilters.Length]; for (int i = 0; i < s.Length; i++) { s[i] = subfilters[i].Clone(); } return new AndTreeFilter.List(s); }
private GitFileStatus GetFileStatusNoCache(string fileName) { if (Directory.Exists(fileName)) return GitFileStatus.Ignored; var fileNameRel = GetRelativeFileNameForGit(fileName); var dirCache = repository.ReadDirCache(); TreeWalk treeWalk = new TreeWalk(this.repository) { Recursive = true }; var head = repository.Resolve(Constants.HEAD); 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); if (treeWalk.Next()) { AbstractTreeIterator treeIterator = treeWalk.GetTree<AbstractTreeIterator>(TREE); DirCacheIterator dirCacheIterator = treeWalk.GetTree<DirCacheIterator>(INDEX); WorkingTreeIterator workingTreeIterator = treeWalk.GetTree<WorkingTreeIterator>(WORKDIR); if (dirCacheIterator != null) { DirCacheEntry dirCacheEntry = dirCacheIterator.GetDirCacheEntry(); if (dirCacheEntry != null && dirCacheEntry.Stage > 0) { return GitFileStatus.MergeConflict; } if (workingTreeIterator == null) { // in index, not in workdir => missing return GitFileStatus.Deleted; } else { if (workingTreeIterator.IsModified(dirCacheIterator.GetDirCacheEntry(), true)) { // in index, in workdir, content differs => modified return GitFileStatus.Modified; } } } if (treeIterator != null) { if (dirCacheIterator != null) { if (!treeIterator.IdEqual(dirCacheIterator) || treeIterator.EntryRawMode != dirCacheIterator.EntryRawMode) { // in repo, in index, content diff => changed return GitFileStatus.Staged; } } else { return GitFileStatus.Removed; } } else { if (dirCacheIterator != null) { // not in repo, in index => added return GitFileStatus.Added; } else { // not in repo, not in index => untracked if (workingTreeIterator != null) { return !workingTreeIterator.IsEntryIgnored() ? GitFileStatus.New : GitFileStatus.Ignored; } } } } 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 IList<string> GetChangedFiles() { var list = new List<string>(); 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()) { var fileName = GetFullPath(treeWalk.PathString); if (Directory.Exists(fileName)) continue; // this excludes sub modules list.Add(fileName); } return list; }
private NotTreeFilter(TreeFilter one) { a = one; }
internal RewriteTreeFilter(RevWalk walker, TreeFilter t) { repository = walker.repository; pathFilter = new TreeWalk(walker.reader); pathFilter.Filter = t; pathFilter.Recursive = t.ShouldBeRecursive(); }
/// <summary>Create a filter that negates the result of another filter.</summary> /// <remarks>Create a filter that negates the result of another filter.</remarks> /// <param name="a">filter to negate.</param> /// <returns>a filter that does the reverse of <code>a</code>.</returns> public static TreeFilter Create(TreeFilter a) { return new NGit.Treewalk.Filter.NotTreeFilter(a); }
private NotTreeFilter(TreeFilter one) { a = one; }
/// <summary>Create a filter around many filters, all of which must match.</summary> /// <remarks>Create a filter around many filters, all of which must match.</remarks> /// <param name="list"> /// list of filters to match against. Must contain at least 2 /// filters. /// </param> /// <returns>a filter that must match all input filters.</returns> public static TreeFilter Create(ICollection<TreeFilter> list) { if (list.Count < 2) { throw new ArgumentException(JGitText.Get().atLeastTwoFiltersNeeded); } TreeFilter[] subfilters = new TreeFilter[list.Count]; Sharpen.Collections.ToArray(list, subfilters); if (subfilters.Length == 2) { return Create(subfilters[0], subfilters[1]); } return new AndTreeFilter.List(subfilters); }
internal Binary(TreeFilter one, TreeFilter two) { a = one; b = two; }
/// <summary>Create a filter that negates the result of another filter.</summary> /// <remarks>Create a filter that negates the result of another filter.</remarks> /// <param name="a">filter to negate.</param> /// <returns>a filter that does the reverse of <code>a</code>.</returns> public static TreeFilter Create(TreeFilter a) { return(new NGit.Treewalk.Filter.NotTreeFilter(a)); }
internal List(TreeFilter[] list) { subfilters = list; }
public override TreeFilter Clone() { TreeFilter n = a.Clone(); return(n == a ? this : new NGit.Treewalk.Filter.NotTreeFilter(n)); }
public void FillCache() { 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(ObjectId.FromString(repository.Open(id).GetBytes(), 5)); //any better way? } 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()) { var fileName = GetFullPath(treeWalk.PathString); if (Directory.Exists(fileName)) continue; // this excludes sub modules var status = GetFileStatusNoCache(fileName); this.cache[fileName] = status; //Debug.WriteLine(string.Format("==== Fill cache for {0} <- {1}", fileName, status)); } }