diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/attributes/AttributesMatcherTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/attributes/AttributesMatcherTest.java
index 686540692..9f82b8a1e 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/attributes/AttributesMatcherTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/attributes/AttributesMatcherTest.java
@@ -51,9 +51,6 @@
/**
* Tests git attributes pattern matches
- *
- * Inspired by {@link org.eclipse.jgit.ignore.IgnoreMatcherTest}
- *
*/
public class AttributesMatcherTest {
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/FastIgnoreRuleTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/FastIgnoreRuleTest.java
index 007bdcc5f..a4b799a72 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/FastIgnoreRuleTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/FastIgnoreRuleTest.java
@@ -47,30 +47,11 @@
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeFalse;
-import static org.junit.Assume.assumeTrue;
-
-import java.util.Arrays;
import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameter;
-import org.junit.runners.Parameterized.Parameters;
-@SuppressWarnings("deprecation")
-@RunWith(Parameterized.class)
public class FastIgnoreRuleTest {
- @Parameters(name = "OldRule? {0}")
- public static Iterable data() {
- return Arrays.asList(new Boolean[][] { { Boolean.FALSE },
- { Boolean.TRUE } });
- }
-
- @Parameter
- public Boolean useOldRule;
-
@Test
public void testSimpleCharClass() {
assertMatched("[a]", "a");
@@ -385,58 +366,46 @@ public void testSegmentsDoNotMatch() {
assertNotMatched("a/b/", "c/a/b/c");
}
- @SuppressWarnings("boxing")
@Test
public void testWildmatch() {
- if (useOldRule)
- System.err
- .println("IgnoreRule can't understand wildmatch rules, skipping testWildmatch!");
+ assertMatched("**/a/b", "a/b");
+ assertMatched("**/a/b", "c/a/b");
+ assertMatched("**/a/b", "c/d/a/b");
+ assertMatched("**/**/a/b", "c/d/a/b");
- Boolean assume = useOldRule;
- assertMatched("**/a/b", "a/b", assume);
- assertMatched("**/a/b", "c/a/b", assume);
- assertMatched("**/a/b", "c/d/a/b", assume);
- assertMatched("**/**/a/b", "c/d/a/b", assume);
+ assertMatched("/**/a/b", "a/b");
+ assertMatched("/**/a/b", "c/a/b");
+ assertMatched("/**/a/b", "c/d/a/b");
+ assertMatched("/**/**/a/b", "c/d/a/b");
- assertMatched("/**/a/b", "a/b", assume);
- assertMatched("/**/a/b", "c/a/b", assume);
- assertMatched("/**/a/b", "c/d/a/b", assume);
- assertMatched("/**/**/a/b", "c/d/a/b", assume);
+ assertMatched("a/b/**", "a/b");
+ assertMatched("a/b/**", "a/b/c");
+ assertMatched("a/b/**", "a/b/c/d/");
+ assertMatched("a/b/**/**", "a/b/c/d");
- assertMatched("a/b/**", "a/b", assume);
- assertMatched("a/b/**", "a/b/c", assume);
- assertMatched("a/b/**", "a/b/c/d/", assume);
- assertMatched("a/b/**/**", "a/b/c/d", assume);
+ assertMatched("**/a/**/b", "c/d/a/b");
+ assertMatched("**/a/**/b", "c/d/a/e/b");
+ assertMatched("**/**/a/**/**/b", "c/d/a/e/b");
- assertMatched("**/a/**/b", "c/d/a/b", assume);
- assertMatched("**/a/**/b", "c/d/a/e/b", assume);
- assertMatched("**/**/a/**/**/b", "c/d/a/e/b", assume);
+ assertMatched("/**/a/**/b", "c/d/a/b");
+ assertMatched("/**/a/**/b", "c/d/a/e/b");
+ assertMatched("/**/**/a/**/**/b", "c/d/a/e/b");
- assertMatched("/**/a/**/b", "c/d/a/b", assume);
- assertMatched("/**/a/**/b", "c/d/a/e/b", assume);
- assertMatched("/**/**/a/**/**/b", "c/d/a/e/b", assume);
+ assertMatched("a/**/b", "a/b");
+ assertMatched("a/**/b", "a/c/b");
+ assertMatched("a/**/b", "a/c/d/b");
+ assertMatched("a/**/**/b", "a/c/d/b");
- assertMatched("a/**/b", "a/b", assume);
- assertMatched("a/**/b", "a/c/b", assume);
- assertMatched("a/**/b", "a/c/d/b", assume);
- assertMatched("a/**/**/b", "a/c/d/b", assume);
-
- assertMatched("a/**/b/**/c", "a/c/b/d/c", assume);
- assertMatched("a/**/**/b/**/**/c", "a/c/b/d/c", assume);
+ assertMatched("a/**/b/**/c", "a/c/b/d/c");
+ assertMatched("a/**/**/b/**/**/c", "a/c/b/d/c");
}
- @SuppressWarnings("boxing")
@Test
public void testWildmatchDoNotMatch() {
- if (useOldRule)
- System.err
- .println("IgnoreRule can't understand wildmatch rules, skipping testWildmatchDoNotMatch!");
-
- Boolean assume = useOldRule;
- assertNotMatched("**/a/b", "a/c/b", assume);
- assertNotMatched("!/**/*.zip", "c/a/b.zip", assume);
- assertNotMatched("!**/*.zip", "c/a/b.zip", assume);
- assertNotMatched("a/**/b", "a/c/bb", assume);
+ assertNotMatched("**/a/b", "a/c/b");
+ assertNotMatched("!/**/*.zip", "c/a/b.zip");
+ assertNotMatched("!**/*.zip", "c/a/b.zip");
+ assertNotMatched("a/**/b", "a/c/bb");
}
@SuppressWarnings("unused")
@@ -478,55 +447,43 @@ public void testSplit() {
split("/a/b/c/", '/').toArray());
}
- public void assertMatched(String pattern, String path, Boolean... assume) {
+ public void assertMatched(String pattern, String path) {
boolean match = match(pattern, path);
String result = path + " is " + (match ? "ignored" : "not ignored")
+ " via '" + pattern + "' rule";
- if (!match)
+ if (!match) {
System.err.println(result);
- if (assume.length == 0 || !assume[0].booleanValue())
- assertTrue("Expected a match for: " + pattern + " with: " + path,
- match);
- else
- assumeTrue("Expected a match for: " + pattern + " with: " + path,
+ }
+ assertTrue("Expected a match for: " + pattern + " with: " + path,
match);
- if (pattern.startsWith("!"))
+ if (pattern.startsWith("!")) {
pattern = pattern.substring(1);
- else
+ } else {
pattern = "!" + pattern;
+ }
match = match(pattern, path);
- if (assume.length == 0 || !assume[0].booleanValue())
- assertFalse("Expected no match for: " + pattern + " with: " + path,
- match);
- else
- assumeFalse("Expected no match for: " + pattern + " with: " + path,
- match);
+ assertFalse("Expected no match for: " + pattern + " with: " + path,
+ match);
}
- public void assertNotMatched(String pattern, String path, Boolean... assume) {
+ public void assertNotMatched(String pattern, String path) {
boolean match = match(pattern, path);
String result = path + " is " + (match ? "ignored" : "not ignored")
+ " via '" + pattern + "' rule";
- if (match)
+ if (match) {
System.err.println(result);
- if (assume.length == 0 || !assume[0].booleanValue())
- assertFalse("Expected no match for: " + pattern + " with: " + path,
- match);
- else
- assumeFalse("Expected no match for: " + pattern + " with: " + path,
+ }
+ assertFalse("Expected no match for: " + pattern + " with: " + path,
match);
- if (pattern.startsWith("!"))
+ if (pattern.startsWith("!")) {
pattern = pattern.substring(1);
- else
+ } else {
pattern = "!" + pattern;
+ }
match = match(pattern, path);
- if (assume.length == 0 || !assume[0].booleanValue())
- assertTrue("Expected a match for: " + pattern + " with: " + path,
- match);
- else
- assumeTrue("Expected a match for: " + pattern + " with: " + path,
+ assertTrue("Expected a match for: " + pattern + " with: " + path,
match);
}
@@ -542,16 +499,6 @@ public void assertNotMatched(String pattern, String path, Boolean... assume) {
*/
private boolean match(String pattern, String target) {
boolean isDirectory = target.endsWith("/");
- if (useOldRule.booleanValue()) {
- IgnoreRule r = new IgnoreRule(pattern);
- // If speed of this test is ever an issue, we can use a presetRule
- // field
- // to avoid recompiling a pattern each time.
- boolean match = r.isMatch(target, isDirectory);
- if (r.getNegation())
- match = !match;
- return match;
- }
FastIgnoreRule r = new FastIgnoreRule(pattern);
// If speed of this test is ever an issue, we can use a presetRule field
// to avoid recompiling a pattern each time.
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreMatcherParametrizedTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreMatcherParametrizedTest.java
index 699542c57..529c75ff3 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreMatcherParametrizedTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreMatcherParametrizedTest.java
@@ -47,31 +47,14 @@
import static org.junit.Assume.assumeFalse;
import static org.junit.Assume.assumeTrue;
-import java.util.Arrays;
-
import org.eclipse.jgit.junit.Assert;
import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameter;
-import org.junit.runners.Parameterized.Parameters;
/**
* Tests ignore pattern matches
*/
-@SuppressWarnings("deprecation")
-@RunWith(Parameterized.class)
public class IgnoreMatcherParametrizedTest {
- @Parameters(name = "OldRule? {0}")
- public static Iterable data() {
- return Arrays.asList(new Boolean[][] { { Boolean.FALSE },
- { Boolean.TRUE } });
- }
-
- @Parameter
- public Boolean useOldRule;
-
@Test
public void testBasic() {
String pattern = "/test.stp";
@@ -252,47 +235,38 @@ public void testDirModeAndNoRegex() {
@Test
public void testDirModeAndRegex1() {
- // IgnoreRule was buggy for some cases below, therefore using "Assume"
- Boolean assume = useOldRule;
-
String pattern = "a/*/src/";
assertMatched(pattern, "a/b/src/");
assertMatched(pattern, "a/b/src/new");
assertMatched(pattern, "a/b/src/new/a.c");
assertMatched(pattern, "a/b/src/a.c");
// no match as a "file" pattern, because rule is for directories only
- assertNotMatched(pattern, "a/b/src", assume);
+ assertNotMatched(pattern, "a/b/src");
assertNotMatched(pattern, "a/b/srcA/");
}
@Test
public void testDirModeAndRegex2() {
- // IgnoreRule was buggy for some cases below, therefore using "Assume"
- Boolean assume = useOldRule;
-
String pattern = "a/[a-b]/src/";
assertMatched(pattern, "a/b/src/");
assertMatched(pattern, "a/b/src/new");
assertMatched(pattern, "a/b/src/new/a.c");
assertMatched(pattern, "a/b/src/a.c");
// no match as a "file" pattern, because rule is for directories only
- assertNotMatched(pattern, "a/b/src", assume);
+ assertNotMatched(pattern, "a/b/src");
assertNotMatched(pattern, "a/b/srcA/");
}
@Test
public void testDirModeAndRegex3() {
- // IgnoreRule was buggy for some cases below, therefore using "Assume"
- Boolean assume = useOldRule;
-
String pattern = "**/src/";
- assertMatched(pattern, "a/b/src/", assume);
- assertMatched(pattern, "a/b/src/new", assume);
- assertMatched(pattern, "a/b/src/new/a.c", assume);
- assertMatched(pattern, "a/b/src/a.c", assume);
+ assertMatched(pattern, "a/b/src/");
+ assertMatched(pattern, "a/b/src/new");
+ assertMatched(pattern, "a/b/src/new/a.c");
+ assertMatched(pattern, "a/b/src/a.c");
// no match as a "file" pattern, because rule is for directories only
- assertNotMatched(pattern, "a/b/src", assume);
- assertNotMatched(pattern, "a/b/srcA/", assume);
+ assertNotMatched(pattern, "a/b/src");
+ assertNotMatched(pattern, "a/b/srcA/");
}
@Test
@@ -416,13 +390,8 @@ public void assertNotMatched(String pattern, String target,
private boolean match(String pattern, String target) {
boolean isDirectory = target.endsWith("/");
boolean match;
- if (useOldRule.booleanValue()) {
- IgnoreRule r = new IgnoreRule(pattern);
- match = r.isMatch(target, isDirectory);
- } else {
- FastIgnoreRule r = new FastIgnoreRule(pattern);
- match = r.isMatch(target, isDirectory);
- }
+ FastIgnoreRule r = new FastIgnoreRule(pattern);
+ match = r.isMatch(target, isDirectory);
if (isDirectory) {
boolean noTrailingSlash = matchAsDir(pattern,
@@ -447,10 +416,6 @@ private boolean match(String pattern, String target) {
*/
private boolean matchAsDir(String pattern, String target) {
assertFalse(target.endsWith("/"));
- if (useOldRule.booleanValue()) {
- IgnoreRule r = new IgnoreRule(pattern);
- return r.isMatch(target, true);
- }
FastIgnoreRule r = new FastIgnoreRule(pattern);
return r.isMatch(target, true);
}
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreMatcherTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreMatcherTest.java
deleted file mode 100644
index 0713b1ad1..000000000
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreMatcherTest.java
+++ /dev/null
@@ -1,400 +0,0 @@
-/*
- * Copyright (C) 2010, Red Hat Inc.
- * and other copyright owners as documented in the project's IP log.
- *
- * This program and the accompanying materials are made available
- * under the terms of the Eclipse Distribution License v1.0 which
- * accompanies this distribution, is reproduced below, and is
- * available at http://www.eclipse.org/org/documents/edl-v10.php
- *
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or
- * without modification, are permitted provided that the following
- * conditions are met:
- *
- * - Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *
- * - Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- *
- * - Neither the name of the Eclipse Foundation, Inc. nor the
- * names of its contributors may be used to endorse or promote
- * products derived from this software without specific prior
- * written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-package org.eclipse.jgit.ignore;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-import org.junit.Test;
-
-
-/**
- * Tests ignore pattern matches
- */
-@SuppressWarnings("deprecation")
-public class IgnoreMatcherTest {
-
- @Test
- public void testBasic() {
- String pattern = "/test.stp";
- assertMatched(pattern, "/test.stp");
-
- pattern = "#/test.stp";
- assertNotMatched(pattern, "/test.stp");
- }
-
- @Test
- public void testFileNameWildcards() {
- //Test basic * and ? for any pattern + any character
- String pattern = "*.st?";
- assertMatched(pattern, "/test.stp");
- assertMatched(pattern, "/anothertest.stg");
- assertMatched(pattern, "/anothertest.st0");
- assertNotMatched(pattern, "/anothertest.sta1");
- //Check that asterisk does not expand to "/"
- assertNotMatched(pattern, "/another/test.sta1");
-
- //Same as above, with a leading slash to ensure that doesn't cause problems
- pattern = "/*.st?";
- assertMatched(pattern, "/test.stp");
- assertMatched(pattern, "/anothertest.stg");
- assertMatched(pattern, "/anothertest.st0");
- assertNotMatched(pattern, "/anothertest.sta1");
- //Check that asterisk does not expand to "/"
- assertNotMatched(pattern, "/another/test.sta1");
-
- //Test for numbers
- pattern = "*.sta[0-5]";
- assertMatched(pattern, "/test.sta5");
- assertMatched(pattern, "/test.sta4");
- assertMatched(pattern, "/test.sta3");
- assertMatched(pattern, "/test.sta2");
- assertMatched(pattern, "/test.sta1");
- assertMatched(pattern, "/test.sta0");
- assertMatched(pattern, "/anothertest.sta2");
- assertNotMatched(pattern, "test.stag");
- assertNotMatched(pattern, "test.sta6");
-
- //Test for letters
- pattern = "/[tv]est.sta[a-d]";
- assertMatched(pattern, "/test.staa");
- assertMatched(pattern, "/test.stab");
- assertMatched(pattern, "/test.stac");
- assertMatched(pattern, "/test.stad");
- assertMatched(pattern, "/vest.stac");
- assertNotMatched(pattern, "test.stae");
- assertNotMatched(pattern, "test.sta9");
-
- //Test child directory/file is matched
- pattern = "/src/ne?";
- assertMatched(pattern, "/src/new/");
- assertMatched(pattern, "/src/new");
- assertMatched(pattern, "/src/new/a.c");
- assertMatched(pattern, "/src/new/a/a.c");
- assertNotMatched(pattern, "/src/new.c");
-
- //Test name-only fnmatcher matches
- pattern = "ne?";
- assertMatched(pattern, "/src/new/");
- assertMatched(pattern, "/src/new");
- assertMatched(pattern, "/src/new/a.c");
- assertMatched(pattern, "/src/new/a/a.c");
- assertMatched(pattern, "/neb");
- assertNotMatched(pattern, "/src/new.c");
- }
-
- @Test
- public void testTargetWithoutLeadingSlash() {
- //Test basic * and ? for any pattern + any character
- String pattern = "/*.st?";
- assertMatched(pattern, "test.stp");
- assertMatched(pattern, "anothertest.stg");
- assertMatched(pattern, "anothertest.st0");
- assertNotMatched(pattern, "anothertest.sta1");
- //Check that asterisk does not expand to ""
- assertNotMatched(pattern, "another/test.sta1");
-
- //Same as above, with a leading slash to ensure that doesn't cause problems
- pattern = "/*.st?";
- assertMatched(pattern, "test.stp");
- assertMatched(pattern, "anothertest.stg");
- assertMatched(pattern, "anothertest.st0");
- assertNotMatched(pattern, "anothertest.sta1");
- //Check that asterisk does not expand to ""
- assertNotMatched(pattern, "another/test.sta1");
-
- //Test for numbers
- pattern = "/*.sta[0-5]";
- assertMatched(pattern, "test.sta5");
- assertMatched(pattern, "test.sta4");
- assertMatched(pattern, "test.sta3");
- assertMatched(pattern, "test.sta2");
- assertMatched(pattern, "test.sta1");
- assertMatched(pattern, "test.sta0");
- assertMatched(pattern, "anothertest.sta2");
- assertNotMatched(pattern, "test.stag");
- assertNotMatched(pattern, "test.sta6");
-
- //Test for letters
- pattern = "/[tv]est.sta[a-d]";
- assertMatched(pattern, "test.staa");
- assertMatched(pattern, "test.stab");
- assertMatched(pattern, "test.stac");
- assertMatched(pattern, "test.stad");
- assertMatched(pattern, "vest.stac");
- assertNotMatched(pattern, "test.stae");
- assertNotMatched(pattern, "test.sta9");
-
- //Test child directory/file is matched
- pattern = "/src/ne?";
- assertMatched(pattern, "src/new/");
- assertMatched(pattern, "src/new");
- assertMatched(pattern, "src/new/a.c");
- assertMatched(pattern, "src/new/a/a.c");
- assertNotMatched(pattern, "src/new.c");
-
- //Test name-only fnmatcher matches
- pattern = "ne?";
- assertMatched(pattern, "src/new/");
- assertMatched(pattern, "src/new");
- assertMatched(pattern, "src/new/a.c");
- assertMatched(pattern, "src/new/a/a.c");
- assertMatched(pattern, "neb");
- assertNotMatched(pattern, "src/new.c");
- }
-
- @Test
- public void testParentDirectoryGitIgnores() {
- //Contains git ignore patterns such as might be seen in a parent directory
-
- //Test for wildcards
- String pattern = "/*/*.c";
- assertMatched(pattern, "/file/a.c");
- assertMatched(pattern, "/src/a.c");
- assertNotMatched(pattern, "/src/new/a.c");
-
- //Test child directory/file is matched
- pattern = "/src/new";
- assertMatched(pattern, "/src/new/");
- assertMatched(pattern, "/src/new");
- assertMatched(pattern, "/src/new/a.c");
- assertMatched(pattern, "/src/new/a/a.c");
- assertNotMatched(pattern, "/src/new.c");
-
- //Test child directory is matched, slash after name
- pattern = "/src/new/";
- assertMatched(pattern, "/src/new/");
- assertMatched(pattern, "/src/new/a.c");
- assertMatched(pattern, "/src/new/a/a.c");
- assertNotMatched(pattern, "/src/new");
- assertNotMatched(pattern, "/src/new.c");
-
- //Test directory is matched by name only
- pattern = "b1";
- assertMatched(pattern, "/src/new/a/b1/a.c");
- assertNotMatched(pattern, "/src/new/a/b2/file.c");
- assertNotMatched(pattern, "/src/new/a/bb1/file.c");
- assertNotMatched(pattern, "/src/new/a/file.c");
- }
-
- @Test
- public void testTrailingSlash() {
- String pattern = "/src/";
- assertMatched(pattern, "/src/");
- assertMatched(pattern, "/src/new");
- assertMatched(pattern, "/src/new/a.c");
- assertMatched(pattern, "/src/a.c");
- assertNotMatched(pattern, "/src");
- assertNotMatched(pattern, "/srcA/");
- }
-
- @Test
- public void testNameOnlyMatches() {
- /*
- * Name-only matches do not contain any path separators
- */
- //Test matches for file extension
- String pattern = "*.stp";
- assertMatched(pattern, "/test.stp");
- assertMatched(pattern, "/src/test.stp");
- assertNotMatched(pattern, "/test.stp1");
- assertNotMatched(pattern, "/test.astp");
-
- //Test matches for name-only, applies to file name or folder name
- pattern = "src";
- assertMatched(pattern, "/src");
- assertMatched(pattern, "/src/");
- assertMatched(pattern, "/src/a.c");
- assertMatched(pattern, "/src/new/a.c");
- assertMatched(pattern, "/new/src/a.c");
- assertMatched(pattern, "/file/src");
-
- //Test matches for name-only, applies only to folder names
- pattern = "src/";
- assertMatched(pattern, "/src/");
- assertMatched(pattern, "/src/a.c");
- assertMatched(pattern, "/src/new/a.c");
- assertMatched(pattern, "/new/src/a.c");
- assertNotMatched(pattern, "/src");
- assertNotMatched(pattern, "/file/src");
-
- //Test matches for name-only, applies to file name or folder name
- //With a small wildcard
- pattern = "?rc";
- assertMatched(pattern, "/src/a.c");
- assertMatched(pattern, "/src/new/a.c");
- assertMatched(pattern, "/new/src/a.c");
- assertMatched(pattern, "/file/src");
- assertMatched(pattern, "/src/");
-
- //Test matches for name-only, applies to file name or folder name
- //With a small wildcard
- pattern = "?r[a-c]";
- assertMatched(pattern, "/src/a.c");
- assertMatched(pattern, "/src/new/a.c");
- assertMatched(pattern, "/new/src/a.c");
- assertMatched(pattern, "/file/src");
- assertMatched(pattern, "/src/");
- assertMatched(pattern, "/srb/a.c");
- assertMatched(pattern, "/grb/new/a.c");
- assertMatched(pattern, "/new/crb/a.c");
- assertMatched(pattern, "/file/3rb");
- assertMatched(pattern, "/xrb/");
- assertMatched(pattern, "/3ra/a.c");
- assertMatched(pattern, "/5ra/new/a.c");
- assertMatched(pattern, "/new/1ra/a.c");
- assertMatched(pattern, "/file/dra");
- assertMatched(pattern, "/era/");
- assertNotMatched(pattern, "/crg");
- assertNotMatched(pattern, "/cr3");
- }
-
- @Test
- public void testNegation() {
- String pattern = "!/test.stp";
- assertMatched(pattern, "/test.stp");
- }
-
- @Test
- public void testGetters() {
- IgnoreRule r = new IgnoreRule("/pattern/");
- assertFalse(r.getNameOnly());
- assertTrue(r.dirOnly());
- assertFalse(r.getNegation());
- assertEquals(r.getPattern(), "/pattern");
-
- r = new IgnoreRule("/patter?/");
- assertFalse(r.getNameOnly());
- assertTrue(r.dirOnly());
- assertFalse(r.getNegation());
- assertEquals(r.getPattern(), "/patter?");
-
- r = new IgnoreRule("patt*");
- assertTrue(r.getNameOnly());
- assertFalse(r.dirOnly());
- assertFalse(r.getNegation());
- assertEquals(r.getPattern(), "patt*");
-
- r = new IgnoreRule("pattern");
- assertTrue(r.getNameOnly());
- assertFalse(r.dirOnly());
- assertFalse(r.getNegation());
- assertEquals(r.getPattern(), "pattern");
-
- r = new IgnoreRule("!pattern");
- assertTrue(r.getNameOnly());
- assertFalse(r.dirOnly());
- assertTrue(r.getNegation());
- assertEquals(r.getPattern(), "pattern");
-
- r = new IgnoreRule("!/pattern");
- assertFalse(r.getNameOnly());
- assertFalse(r.dirOnly());
- assertTrue(r.getNegation());
- assertEquals(r.getPattern(), "/pattern");
-
- r = new IgnoreRule("!/patter?");
- assertFalse(r.getNameOnly());
- assertFalse(r.dirOnly());
- assertTrue(r.getNegation());
- assertEquals(r.getPattern(), "/patter?");
- }
-
- @Test
- public void testResetState() {
- String pattern = "/build/*";
- String target = "/build";
- // Don't use the assert methods of this class, as we want to test
- // whether the state in IgnoreRule is reset properly
- IgnoreRule r = new IgnoreRule(pattern);
- // Result should be the same for the same inputs
- assertFalse(r.isMatch(target, true));
- assertFalse(r.isMatch(target, true));
- }
-
- /**
- * Check for a match. If target ends with "/", match will assume that the
- * target is meant to be a directory.
- * @param pattern
- * Pattern as it would appear in a .gitignore file
- * @param target
- * Target file path relative to repository's GIT_DIR
- */
- public void assertMatched(String pattern, String target) {
- boolean value = match(pattern, target);
- assertTrue("Expected a match for: " + pattern + " with: " + target,
- value);
- }
-
- /**
- * Check for a match. If target ends with "/", match will assume that the
- * target is meant to be a directory.
- * @param pattern
- * Pattern as it would appear in a .gitignore file
- * @param target
- * Target file path relative to repository's GIT_DIR
- */
- public void assertNotMatched(String pattern, String target) {
- boolean value = match(pattern, target);
- assertFalse("Expected no match for: " + pattern + " with: " + target,
- value);
- }
-
- /**
- * Check for a match. If target ends with "/", match will assume that the
- * target is meant to be a directory.
- *
- * @param pattern
- * Pattern as it would appear in a .gitignore file
- * @param target
- * Target file path relative to repository's GIT_DIR
- * @return Result of IgnoreRule.isMatch(String, boolean)
- */
- private static boolean match(String pattern, String target) {
- IgnoreRule r = new IgnoreRule(pattern);
- //If speed of this test is ever an issue, we can use a presetRule field
- //to avoid recompiling a pattern each time.
- return r.isMatch(target, target.endsWith("/"));
- }
-}
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreRuleSpecialCasesTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreRuleSpecialCasesTest.java
index 7afa69f44..a7a78f841 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreRuleSpecialCasesTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreRuleSpecialCasesTest.java
@@ -46,64 +46,32 @@
import static org.junit.Assert.assertEquals;
import static org.junit.Assume.assumeTrue;
-import java.util.Arrays;
-
import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameter;
-import org.junit.runners.Parameterized.Parameters;
-@RunWith(Parameterized.class)
-@SuppressWarnings({ "deprecation", "boxing" })
+@SuppressWarnings({ "boxing" })
public class IgnoreRuleSpecialCasesTest {
- @Parameters(name = "OldRule? {0}")
- public static Iterable data() {
- return Arrays.asList(new Boolean[][] { { Boolean.FALSE },
- { Boolean.TRUE } });
- }
-
- @Parameter
- public Boolean useOldRule;
-
private void assertMatch(final String pattern, final String input,
final boolean matchExpected, Boolean... assume) {
boolean assumeDir = input.endsWith("/");
- if (useOldRule.booleanValue()) {
- final IgnoreRule matcher = new IgnoreRule(pattern);
- if (assume.length == 0 || !assume[0].booleanValue())
- assertEquals(matchExpected, matcher.isMatch(input, assumeDir));
- else
- assumeTrue(matchExpected == matcher.isMatch(input, assumeDir));
+ FastIgnoreRule matcher = new FastIgnoreRule(pattern);
+ if (assume.length == 0 || !assume[0].booleanValue()) {
+ assertEquals(matchExpected, matcher.isMatch(input, assumeDir));
} else {
- FastIgnoreRule matcher = new FastIgnoreRule(pattern);
- if (assume.length == 0 || !assume[0].booleanValue())
- assertEquals(matchExpected, matcher.isMatch(input, assumeDir));
- else
- assumeTrue(matchExpected == matcher.isMatch(input, assumeDir));
+ assumeTrue(matchExpected == matcher.isMatch(input, assumeDir));
}
}
private void assertFileNameMatch(final String pattern, final String input,
final boolean matchExpected) {
boolean assumeDir = input.endsWith("/");
- if (useOldRule.booleanValue()) {
- final IgnoreRule matcher = new IgnoreRule(pattern);
- assertEquals(matchExpected, matcher.isMatch(input, assumeDir));
- } else {
- FastIgnoreRule matcher = new FastIgnoreRule(pattern);
- assertEquals(matchExpected, matcher.isMatch(input, assumeDir));
- }
+ FastIgnoreRule matcher = new FastIgnoreRule(pattern);
+ assertEquals(matchExpected, matcher.isMatch(input, assumeDir));
}
@Test
public void testVerySimplePatternCase0() throws Exception {
- if (useOldRule)
- System.err
- .println("IgnoreRule can't understand blank lines, skipping");
- Boolean assume = useOldRule;
- assertMatch("", "", false, assume);
+ assertMatch("", "", false);
}
@Test
@@ -805,12 +773,9 @@ public void testSpecialGroupCase9() throws Exception {
@Test
public void testSpecialGroupCase10() throws Exception {
- if (useOldRule)
- System.err.println("IgnoreRule can't understand [[:], skipping");
- Boolean assume = useOldRule;
// Second bracket is threated literally, so both [ and : should match
- assertMatch("[[:]", ":", true, assume);
- assertMatch("[[:]", "[", true, assume);
+ assertMatch("[[:]", ":", true);
+ assertMatch("[[:]", "[", true);
}
@Test
@@ -866,12 +831,8 @@ public void testEscapedBracket6() throws Exception {
@Test
public void testEscapedBackslash() throws Exception {
- if (useOldRule)
- System.err
- .println("IgnoreRule can't understand escaped backslashes, skipping");
- Boolean assume = useOldRule;
// In Git CLI a\\b matches a\b file
- assertMatch("a\\\\b", "a\\b", true, assume);
+ assertMatch("a\\\\b", "a\\b", true);
}
@Test
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/ignore/IgnoreRule.java b/org.eclipse.jgit/src/org/eclipse/jgit/ignore/IgnoreRule.java
deleted file mode 100644
index f14d1bd0b..000000000
--- a/org.eclipse.jgit/src/org/eclipse/jgit/ignore/IgnoreRule.java
+++ /dev/null
@@ -1,278 +0,0 @@
-/*
- * Copyright (C) 2010, Red Hat Inc.
- * and other copyright owners as documented in the project's IP log.
- *
- * This program and the accompanying materials are made available
- * under the terms of the Eclipse Distribution License v1.0 which
- * accompanies this distribution, is reproduced below, and is
- * available at http://www.eclipse.org/org/documents/edl-v10.php
- *
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or
- * without modification, are permitted provided that the following
- * conditions are met:
- *
- * - Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *
- * - Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- *
- * - Neither the name of the Eclipse Foundation, Inc. nor the
- * names of its contributors may be used to endorse or promote
- * products derived from this software without specific prior
- * written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
- * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-package org.eclipse.jgit.ignore;
-
-import org.eclipse.jgit.errors.InvalidPatternException;
-import org.eclipse.jgit.fnmatch.FileNameMatcher;
-
-/**
- * A single ignore rule corresponding to one line in a .gitignore or ignore
- * file. Parses the ignore pattern
- *
- * Inspiration from: Ferry Huberts
- *
- * @deprecated this rule does not support double star pattern and is slow
- * parsing glob expressions. Consider to use {@link FastIgnoreRule}
- * instead. See https://bugs.eclipse.org/bugs/show_bug.cgi?id=440732
- */
-@Deprecated
-public class IgnoreRule {
- private String pattern;
- private boolean negation;
- private boolean nameOnly;
- private boolean dirOnly;
- private FileNameMatcher matcher;
-
- /**
- * Create a new ignore rule with the given pattern. Assumes that
- * the pattern is already trimmed.
- *
- * @param pattern
- * Base pattern for the ignore rule. This pattern will
- * be parsed to generate rule parameters.
- */
- public IgnoreRule (String pattern) {
- this.pattern = pattern;
- negation = false;
- nameOnly = false;
- dirOnly = false;
- matcher = null;
- setup();
- }
-
- /**
- * Remove leading/trailing characters as needed. Set up
- * rule variables for later matching.
- */
- private void setup() {
- int startIndex = 0;
- int endIndex = pattern.length();
- if (pattern.startsWith("!")) { //$NON-NLS-1$
- startIndex++;
- negation = true;
- }
-
- if (pattern.endsWith("/")) { //$NON-NLS-1$
- endIndex --;
- dirOnly = true;
- }
-
- pattern = pattern.substring(startIndex, endIndex);
- boolean hasSlash = pattern.contains("/"); //$NON-NLS-1$
-
- if (!hasSlash)
- nameOnly = true;
- else if (!pattern.startsWith("/")) { //$NON-NLS-1$
- //Contains "/" but does not start with one
- //Adding / to the start should not interfere with matching
- pattern = "/" + pattern; //$NON-NLS-1$
- }
-
- if (pattern.contains("*") || pattern.contains("?") || pattern.contains("[")) { //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
- try {
- matcher = new FileNameMatcher(pattern, Character.valueOf('/'));
- } catch (InvalidPatternException e) {
- // Ignore pattern exceptions
- }
- }
- }
-
-
- /**
- * @return
- * True if the pattern is just a file name and not a path
- */
- public boolean getNameOnly() {
- return nameOnly;
- }
-
- /**
- *
- * @return
- * True if the pattern should match directories only
- */
- public boolean dirOnly() {
- return dirOnly;
- }
-
- /**
- *
- * @return
- * True if the pattern had a "!" in front of it
- */
- public boolean getNegation() {
- return negation;
- }
-
- /**
- * @return
- * The blob pattern to be used as a matcher
- */
- public String getPattern() {
- return pattern;
- }
-
- /**
- * Returns true if a match was made.
- *
- * This function does NOT return the actual ignore status of the
- * target! Please consult {@link #getResult()} for the ignore status. The actual
- * ignore status may be true or false depending on whether this rule is
- * an ignore rule or a negation rule.
- *
- * @param target
- * Name pattern of the file, relative to the base directory of this rule
- * @param isDirectory
- * Whether the target file is a directory or not
- * @return
- * True if a match was made. This does not necessarily mean that
- * the target is ignored. Call {@link IgnoreRule#getResult() getResult()} for the result.
- */
- public boolean isMatch(String target, boolean isDirectory) {
- if (!target.startsWith("/")) //$NON-NLS-1$
- target = "/" + target; //$NON-NLS-1$
-
- if (matcher == null) {
- if (target.equals(pattern)) {
- //Exact match
- if (dirOnly && !isDirectory)
- //Directory expectations not met
- return false;
- else
- //Directory expectations met
- return true;
- }
-
- /*
- * Add slashes for startsWith check. This avoids matching e.g.
- * "/src/new" to /src/newfile" but allows "/src/new" to match
- * "/src/new/newfile", as is the git standard
- */
- if ((target).startsWith(pattern + "/")) //$NON-NLS-1$
- return true;
-
- if (nameOnly) {
- //Iterate through each sub-name
- final String[] segments = target.split("/"); //$NON-NLS-1$
- for (int idx = 0; idx < segments.length; idx++) {
- final String segmentName = segments[idx];
- // String.split("/") creates empty segment for leading slash
- if (segmentName.length() == 0)
- continue;
- if (segmentName.equals(pattern) &&
- doesMatchDirectoryExpectations(isDirectory, idx, segments.length))
- return true;
- }
- }
-
- } else {
- matcher.reset();
- matcher.append(target);
- if (matcher.isMatch())
- return true;
-
- final String[] segments = target.split("/"); //$NON-NLS-1$
- if (nameOnly) {
- for (int idx = 0; idx < segments.length; idx++) {
- final String segmentName = segments[idx];
- // String.split("/") creates empty segment for leading slash
- if (segmentName.length() == 0)
- continue;
- //Iterate through each sub-directory
- matcher.reset();
- matcher.append(segmentName);
- if (matcher.isMatch() &&
- doesMatchDirectoryExpectations(isDirectory, idx, segments.length))
- return true;
- }
- } else {
- //TODO: This is the slowest operation
- //This matches e.g. "/src/ne?" to "/src/new/file.c"
- matcher.reset();
-
- for (int idx = 0; idx < segments.length; idx++) {
- final String segmentName = segments[idx];
- // String.split("/") creates empty segment for leading slash
- if (segmentName.length() == 0)
- continue;
-
- matcher.append("/" + segmentName); //$NON-NLS-1$
-
- if (matcher.isMatch()
- && doesMatchDirectoryExpectations(isDirectory, idx,
- segments.length))
- return true;
- }
- }
- }
-
- return false;
- }
-
- /**
- * If a call to isMatch(String, boolean)
was previously
- * made, this will return whether or not the target was ignored. Otherwise
- * this just indicates whether the rule is non-negation or negation.
- *
- * @return
- * True if the target is to be ignored, false otherwise.
- */
- public boolean getResult() {
- return !negation;
- }
-
- private boolean doesMatchDirectoryExpectations(boolean isDirectory, int segmentIdx, int segmentLength) {
- // The segment we are checking is a directory, expectations are met.
- if (segmentIdx < segmentLength - 1) {
- return true;
- }
-
- // We are checking the last part of the segment for which isDirectory has to be considered.
- return !dirOnly || isDirectory;
- }
-
- @Override
- public String toString() {
- return pattern;
- }
-}