github
/
jgit
mirror of https://gitee.com/github-mirror-repo/jgit.git
1
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

Merge changes Ib4d53bdd,I55bd512c 

* changes:
  Do not let PathFilter.create("a/b") match 'a' unless 'a' is a subtree
  Add tests for PathFilterGroup.Single
stable-4.3
Jonathan Nieder 9 years ago committed by Gerrit Code Review @ Eclipse.org
parent
a3e9876d8f 75a0dcac18
commit
cfa0b2fb3c
3 changed files with 125 additions and 38 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 150
      org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/filter/PathFilterGroupTest.java
  2. 7
      org.eclipse.jgit/src/org/eclipse/jgit/treewalk/TreeWalk.java
  3. 6
      org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/PathFilterGroup.java

150
org.eclipse.jgit.test/tst/org/eclipse/jgit/treewalk/filter/PathFilterGroupTest.java
Unescape View File

@ -43,11 +43,18 @@
package org.eclipse.jgit.treewalk.filter;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.dircache.DirCacheEditor;
@ -58,6 +65,7 @@ import org.eclipse.jgit.errors.MissingObjectException;
import org.eclipse.jgit.errors.StopWalkException;
import org.eclipse.jgit.lib.FileMode;
import org.eclipse.jgit.lib.ObjectReader;
import org.eclipse.jgit.lib.Sets;
import org.eclipse.jgit.treewalk.TreeWalk;
import org.junit.Before;
import org.junit.Test;
@ -66,6 +74,8 @@ public class PathFilterGroupTest {
private TreeFilter filter;
private Map<String, TreeFilter> singles;
@Before
public void setup() {
// @formatter:off
@ -81,64 +91,75 @@ public class PathFilterGroupTest {
};
// @formatter:on
filter = PathFilterGroup.createFromStrings(paths);
singles = new HashMap<>();
for (String path : paths) {
singles.put(path, PathFilterGroup.createFromStrings(path));
}
}
@Test
public void testExact() throws MissingObjectException,
IncorrectObjectTypeException, IOException {
assertTrue(filter.include(fakeWalk("a")));
assertTrue(filter.include(fakeWalk("b/c")));
assertTrue(filter.include(fakeWalk("c/d/e")));
assertTrue(filter.include(fakeWalk("c/d/f")));
assertTrue(filter.include(fakeWalk("d/e/f/g")));
assertTrue(filter.include(fakeWalk("d/e/f/g.x")));
assertMatches(Sets.of("a"), fakeWalk("a"));
assertMatches(Sets.of("b/c"), fakeWalk("b/c"));
assertMatches(Sets.of("c/d/e"), fakeWalk("c/d/e"));
assertMatches(Sets.of("c/d/f"), fakeWalk("c/d/f"));
assertMatches(Sets.of("d/e/f/g"), fakeWalk("d/e/f/g"));
assertMatches(Sets.of("d/e/f/g.x"), fakeWalk("d/e/f/g.x"));
}
@Test
public void testNoMatchButClose() throws MissingObjectException,
IncorrectObjectTypeException, IOException {
assertFalse(filter.include(fakeWalk("a+")));
assertFalse(filter.include(fakeWalk("b+/c")));
assertFalse(filter.include(fakeWalk("c+/d/e")));
assertFalse(filter.include(fakeWalk("c+/d/f")));
assertFalse(filter.include(fakeWalk("c/d.a")));
assertFalse(filter.include(fakeWalk("d+/e/f/g")));
assertNoMatches(fakeWalk("a+"));
assertNoMatches(fakeWalk("b+/c"));
assertNoMatches(fakeWalk("c+/d/e"));
assertNoMatches(fakeWalk("c+/d/f"));
assertNoMatches(fakeWalk("c/d.a"));
assertNoMatches(fakeWalk("d+/e/f/g"));
}
@Test
public void testJustCommonPrefixIsNotMatch() throws MissingObjectException,
IncorrectObjectTypeException, IOException {
assertFalse(filter.include(fakeWalk("b/a")));
assertFalse(filter.include(fakeWalk("b/d")));
assertFalse(filter.include(fakeWalk("c/d/a")));
assertFalse(filter.include(fakeWalk("d/e/e")));
assertNoMatches(fakeWalk("b/a"));
assertNoMatches(fakeWalk("b/d"));
assertNoMatches(fakeWalk("c/d/a"));
assertNoMatches(fakeWalk("d/e/e"));
assertNoMatches(fakeWalk("d/e/f/g.y"));
}
@Test
public void testKeyIsPrefixOfFilter() throws MissingObjectException,
IncorrectObjectTypeException, IOException {
assertTrue(filter.include(fakeWalk("b")));
assertTrue(filter.include(fakeWalk("c/d")));
assertTrue(filter.include(fakeWalk("c/d")));
assertTrue(filter.include(fakeWalk("c")));
assertTrue(filter.include(fakeWalk("d/e/f")));
assertTrue(filter.include(fakeWalk("d/e")));
assertTrue(filter.include(fakeWalk("d")));
assertMatches(Sets.of("b/c"), fakeWalkAtSubtree("b"));
assertMatches(Sets.of("c/d/e", "c/d/f"), fakeWalkAtSubtree("c/d"));
assertMatches(Sets.of("c/d/e", "c/d/f"), fakeWalkAtSubtree("c"));
assertMatches(Sets.of("d/e/f/g", "d/e/f/g.x"),
fakeWalkAtSubtree("d/e/f"));
assertMatches(Sets.of("d/e/f/g", "d/e/f/g.x"),
fakeWalkAtSubtree("d/e"));
assertMatches(Sets.of("d/e/f/g", "d/e/f/g.x"), fakeWalkAtSubtree("d"));
assertNoMatches(fakeWalk("b"));
assertNoMatches(fakeWalk("c/d"));
assertNoMatches(fakeWalk("c"));
assertNoMatches(fakeWalk("d/e/f"));
assertNoMatches(fakeWalk("d/e"));
assertNoMatches(fakeWalk("d"));
}
@Test
public void testFilterIsPrefixOfKey() throws MissingObjectException,
IncorrectObjectTypeException, IOException {
assertTrue(filter.include(fakeWalk("a/b")));
assertTrue(filter.include(fakeWalk("b/c/d")));
assertTrue(filter.include(fakeWalk("c/d/e/f")));
assertTrue(filter.include(fakeWalk("c/d/f/g")));
assertTrue(filter.include(fakeWalk("d/e/f/g/h")));
assertTrue(filter.include(fakeWalk("d/e/f/g/y")));
assertTrue(filter.include(fakeWalk("d/e/f/g.x/h")));
// listed before g/y, so can't StopWalk here, but it's not included
// either
assertFalse(filter.include(fakeWalk("d/e/f/g.y")));
assertMatches(Sets.of("a"), fakeWalk("a/b"));
assertMatches(Sets.of("b/c"), fakeWalk("b/c/d"));
assertMatches(Sets.of("c/d/e"), fakeWalk("c/d/e/f"));
assertMatches(Sets.of("c/d/f"), fakeWalk("c/d/f/g"));
assertMatches(Sets.of("d/e/f/g"), fakeWalk("d/e/f/g/h"));
assertMatches(Sets.of("d/e/f/g"), fakeWalk("d/e/f/g/y"));
assertMatches(Sets.of("d/e/f/g.x"), fakeWalk("d/e/f/g.x/h"));
}
@Test
@ -182,6 +203,10 @@ public class PathFilterGroupTest {
// less obvious #2 due to git sorting order
filter.include(fakeWalk("d/e/f/g/h.txt"));
// listed before g/y, so can't StopWalk here
filter.include(fakeWalk("d/e/f/g.y"));
singles.get("d/e/f/g").include(fakeWalk("d/e/f/g.y"));
// non-ascii
try {
filter.include(fakeWalk("\u00C0"));
@ -191,6 +216,44 @@ public class PathFilterGroupTest {
}
}
private void assertNoMatches(TreeWalk tw) throws MissingObjectException,
IncorrectObjectTypeException, IOException {
assertMatches(Sets.<String> of(), tw);
}
private void assertMatches(Set<String> expect, TreeWalk tw)
throws MissingObjectException, IncorrectObjectTypeException,
IOException {
List<String> actual = new ArrayList<>();
for (String path : singles.keySet()) {
if (includes(singles.get(path), tw)) {
actual.add(path);
}
}
String[] e = expect.toArray(new String[expect.size()]);
String[] a = actual.toArray(new String[actual.size()]);
Arrays.sort(e);
Arrays.sort(a);
assertArrayEquals(e, a);
if (expect.isEmpty()) {
assertFalse(includes(filter, tw));
} else {
assertTrue(includes(filter, tw));
}
}
private static boolean includes(TreeFilter f, TreeWalk tw)
throws MissingObjectException, IncorrectObjectTypeException,
IOException {
try {
return f.include(tw);
} catch (StopWalkException e) {
return false;
}
}
TreeWalk fakeWalk(final String path) throws IOException {
DirCache dc = DirCache.newInCore();
DirCacheEditor dce = dc.editor();
@ -210,4 +273,25 @@ public class PathFilterGroupTest {
return ret;
}
TreeWalk fakeWalkAtSubtree(final String path) throws IOException {
DirCache dc = DirCache.newInCore();
DirCacheEditor dce = dc.editor();
dce.add(new DirCacheEditor.PathEdit(path + "/README") {
public void apply(DirCacheEntry ent) {
ent.setFileMode(FileMode.REGULAR_FILE);
}
});
dce.finish();
TreeWalk ret = new TreeWalk((ObjectReader) null);
ret.addTree(new DirCacheIterator(dc));
ret.next();
while (!path.equals(ret.getPathString())) {
if (ret.isSubtree()) {
ret.enterSubtree();
}
ret.next();
}
return ret;
}
}

7
org.eclipse.jgit/src/org/eclipse/jgit/treewalk/TreeWalk.java
Unescape View File

@ -861,10 +861,13 @@ public class TreeWalk implements AutoCloseable, AttributesProvider {
* Test if the supplied path matches the current entry's path.
* <p>
* This method tests that the supplied path is exactly equal to the current
* entry, or is one of its parent directories. It is faster to use this
* entry or is one of its parent directories. It is faster to use this
* method then to use {@link #getPathString()} to first create a String
* object, then test <code>startsWith</code> or some other type of string
* match function.
* <p>
* If the current entry is a subtree, then all paths within the subtree
* are considered to match it.
*
* @param p
* path buffer to test. Callers should ensure the path does not
@ -900,7 +903,7 @@ public class TreeWalk implements AutoCloseable, AttributesProvider {
// If p[ci] == '/' then pattern matches this subtree,
// otherwise we cannot be certain so we return -1.
//
return p[ci] == '/' ? 0 : -1;
return p[ci] == '/' && FileMode.TREE.equals(t.mode) ? 0 : -1;
}
// Both strings are identical.

6
org.eclipse.jgit/src/org/eclipse/jgit/treewalk/filter/PathFilterGroup.java
Unescape View File

@ -245,9 +245,9 @@ public class PathFilterGroup {
int hash = hasher.nextHash();
if (fullpaths.contains(rp, hasher.length(), hash))
return true;
if (!hasher.hasNext())
if (prefixes.contains(rp, hasher.length(), hash))
return true;
if (!hasher.hasNext() && walker.isSubtree()
&& prefixes.contains(rp, hasher.length(), hash))
return true;
}
final int cmp = walker.isPathPrefix(max, max.length);

Write Preview
Loading…
Cancel
Save