Enable marking entries using TreeFilters in DiffEntry

This adds a new optional TreeFilter[] argument to DiffEntry.scan. All
filters will be checked during the scan to determine if an entry should
be "marked" with regard to that filter.

After having called scan, the user can then call isMarked(int) on the
entries to find out whether they matched the TreeFilter with the passed
index.

An example use case for this is in the file diff viewer of EGit's
History view, where we'd like to highlight entries that are matching the
current filter.

See EGit change I03da4b38d1591495cb290909f0e4c6e52270e97f.

Bug: 393610
Change-Id: Icf911fe6fca131b2567514f54d66636a44561af1
Signed-off-by: Robin Stocker <robin@nibor.org>
Signed-off-by: Matthias Sohn <matthias.sohn@sap.com>

1 files changed, 69 insertions, 1 deletions

diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/DiffEntryTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/DiffEntryTest.java
index cb7cad8340..4c9c54f214 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/DiffEntryTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/diff/DiffEntryTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011, Dariusz Luksza <dariusz@luksza.org>
+ * Copyright (C) 2011, 2013 Dariusz Luksza <dariusz@luksza.org>
  * and other copyright owners as documented in the project's IP log.
  *
  * This program and the accompanying materials are made available
@@ -47,6 +47,7 @@ import static org.eclipse.jgit.util.FileUtils.delete;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.notNullValue;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 
@@ -65,6 +66,8 @@ import org.eclipse.jgit.revwalk.RevCommit;
 import org.eclipse.jgit.treewalk.EmptyTreeIterator;
 import org.eclipse.jgit.treewalk.FileTreeIterator;
 import org.eclipse.jgit.treewalk.TreeWalk;
+import org.eclipse.jgit.treewalk.filter.PathFilterGroup;
+import org.eclipse.jgit.treewalk.filter.TreeFilter;
 import org.eclipse.jgit.util.FileUtils;
 import org.junit.Test;
 
@@ -265,6 +268,71 @@ public class DiffEntryTest extends RepositoryTestCase {
 		assertThat(entry.getNewPath(), is("b.txt"));
 	}
 
+	@Test
+	public void shouldMarkEntriesWhenGivenMarkTreeFilter() throws Exception {
+		// given
+		Git git = new Git(db);
+		RevCommit c1 = git.commit().setMessage("initial commit").call();
+		FileUtils.mkdir(new File(db.getWorkTree(), "b"));
+		writeTrashFile("a.txt", "a");
+		writeTrashFile("b/1.txt", "b1");
+		writeTrashFile("b/2.txt", "b2");
+		writeTrashFile("c.txt", "c");
+		git.add().addFilepattern("a.txt").addFilepattern("b")
+				.addFilepattern("c.txt").call();
+		RevCommit c2 = git.commit().setMessage("second commit").call();
+		TreeFilter filterA = PathFilterGroup.createFromStrings("a.txt");
+		TreeFilter filterB = PathFilterGroup.createFromStrings("b");
+		TreeFilter filterB2 = PathFilterGroup.createFromStrings("b/2.txt");
+
+		// when
+		TreeWalk walk = new TreeWalk(db);
+		walk.addTree(c1.getTree());
+		walk.addTree(c2.getTree());
+		List<DiffEntry> result = DiffEntry.scan(walk, true, new TreeFilter[] {
+				filterA, filterB, filterB2 });
+
+		// then
+		assertThat(result, notNullValue());
+		assertEquals(5, result.size());
+
+		DiffEntry entryA = result.get(0);
+		DiffEntry entryB = result.get(1);
+		DiffEntry entryB1 = result.get(2);
+		DiffEntry entryB2 = result.get(3);
+		DiffEntry entryC = result.get(4);
+
+		assertThat(entryA.getNewPath(), is("a.txt"));
+		assertTrue(entryA.isMarked(0));
+		assertFalse(entryA.isMarked(1));
+		assertFalse(entryA.isMarked(2));
+		assertEquals(1, entryA.getTreeFilterMarks());
+
+		assertThat(entryB.getNewPath(), is("b"));
+		assertFalse(entryB.isMarked(0));
+		assertTrue(entryB.isMarked(1));
+		assertTrue(entryB.isMarked(2));
+		assertEquals(6, entryB.getTreeFilterMarks());
+
+		assertThat(entryB1.getNewPath(), is("b/1.txt"));
+		assertFalse(entryB1.isMarked(0));
+		assertTrue(entryB1.isMarked(1));
+		assertFalse(entryB1.isMarked(2));
+		assertEquals(2, entryB1.getTreeFilterMarks());
+
+		assertThat(entryB2.getNewPath(), is("b/2.txt"));
+		assertFalse(entryB2.isMarked(0));
+		assertTrue(entryB2.isMarked(1));
+		assertTrue(entryB2.isMarked(2));
+		assertEquals(6, entryB2.getTreeFilterMarks());
+
+		assertThat(entryC.getNewPath(), is("c.txt"));
+		assertFalse(entryC.isMarked(0));
+		assertFalse(entryC.isMarked(1));
+		assertFalse(entryC.isMarked(2));
+		assertEquals(0, entryC.getTreeFilterMarks());
+	}
+
 	@Test(expected = IllegalArgumentException.class)
 	public void shouldThrowIAEWhenTreeWalkHasLessThanTwoTrees()
 			throws Exception {