Merge changes I62befa4a,Ia9c3d123,I7fcf6534

* changes:
  Delete deprecated PackWriter.preparePack() methods
  Delete deprecated class IgnoreRule
  Delete deprecated checkoutEntry() methods in DirCacheCheckout

org.eclipse.jgit.test/tst/org/eclipse/jgit/attributes/AttributesMatcherTest.java

@@ -51,9 +51,6 @@ import org.junit.Test;
 
 /**
  * Tests git attributes pattern matches
- * <p>
- * Inspired by {@link org.eclipse.jgit.ignore.IgnoreMatcherTest}
- * </p>
  */
 public class AttributesMatcherTest {
 

org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/FastIgnoreRuleTest.java

@@ -47,30 +47,11 @@ 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 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<Boolean[]> 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 class FastIgnoreRuleTest {
 		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!");
-
-		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", 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", 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", 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", assume);
-		assertMatched("/**/a/**/b", "c/d/a/e/b", assume);
-		assertMatched("/**/**/a/**/**/b", "c/d/a/e/b", assume);
-
-		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", "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");
+		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");
+		assertMatched("a/b/**", "a/b/c");
+		assertMatched("a/b/**", "a/b/c/d/");
+		assertMatched("a/b/**/**", "a/b/c/d");
+
+		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");
+		assertMatched("/**/a/**/b", "c/d/a/e/b");
+		assertMatched("/**/**/a/**/**/b", "c/d/a/e/b");
+
+		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/**/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 class FastIgnoreRuleTest {
 				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 class FastIgnoreRuleTest {
 	 */
 	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.

org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreMatcherParametrizedTest.java

@@ -47,31 +47,14 @@ import static org.junit.Assert.assertTrue;
 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<Boolean[]> 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 class IgnoreMatcherParametrizedTest {
 
 	@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 class IgnoreMatcherParametrizedTest {
 	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 @@ public class IgnoreMatcherParametrizedTest {
 	 */
 	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);
 	}

org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreMatcherTest.java

@@ -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("/"));
-	}
-}

org.eclipse.jgit.test/tst/org/eclipse/jgit/ignore/IgnoreRuleSpecialCasesTest.java

@@ -46,64 +46,32 @@ package org.eclipse.jgit.ignore;
 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<Boolean[]> 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 class IgnoreRuleSpecialCasesTest {
 
 	@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 class IgnoreRuleSpecialCasesTest {
 
 	@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

org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheCheckout.java

@@ -1129,73 +1129,6 @@ public class DirCacheCheckout {
 		}
 	}
 
-	/**
-	 * Updates the file in the working tree with content and mode from an entry
-	 * in the index. The new content is first written to a new temporary file in
-	 * the same directory as the real file. Then that new file is renamed to the
-	 * final filename. Use this method only for checkout of a single entry.
-	 * Otherwise use
-	 * {@code checkoutEntry(Repository, File f, DirCacheEntry, ObjectReader)}
-	 * instead which allows to reuse one {@code ObjectReader} for multiple
-	 * entries.
-	 *
-	 * <p>
-	 * TODO: this method works directly on File IO, we may need another
-	 * abstraction (like WorkingTreeIterator). This way we could tell e.g.
-	 * Eclipse that Files in the workspace got changed
-	 * </p>
-	 *
-	 * @param repository
-	 * @param f
-	 *            this parameter is ignored.
-	 * @param entry
-	 *            the entry containing new mode and content
-	 * @throws IOException
-	 * @deprecated Use the overloaded form that accepts {@link ObjectReader}.
-	 */
-	@Deprecated
-	public static void checkoutEntry(final Repository repository, File f,
-			DirCacheEntry entry) throws IOException {
-		ObjectReader or = repository.newObjectReader();
-		try {
-			checkoutEntry(repository, f, entry, or);
-		} finally {
-			or.release();
-		}
-	}
-
-	/**
-	 * Updates the file in the working tree with content and mode from an entry
-	 * in the index. The new content is first written to a new temporary file in
-	 * the same directory as the real file. Then that new file is renamed to the
-	 * final filename.
-	 *
-	 * <p>
-	 * TODO: this method works directly on File IO, we may need another
-	 * abstraction (like WorkingTreeIterator). This way we could tell e.g.
-	 * Eclipse that Files in the workspace got changed
-	 * </p>
-	 *
-	 * @param repo
-	 * @param f
-	 *            this parameter is ignored.
-	 * @param entry
-	 *            the entry containing new mode and content
-	 * @param or
-	 *            object reader to use for checkout
-	 * @throws IOException
-	 * @deprecated Do not pass File object.
-	 */
-	@Deprecated
-	public static void checkoutEntry(final Repository repo, File f,
-			DirCacheEntry entry, ObjectReader or) throws IOException {
-		if (f == null || repo.getWorkTree() == null)
-			throw new IllegalArgumentException();
-		if (!f.equals(new File(repo.getWorkTree(), entry.getPathString())))
-			throw new IllegalArgumentException();
-		checkoutEntry(repo, entry, or);
-	}
-
 	/**
 	 * Updates the file in the working tree with content and mode from an entry
 	 * in the index. The new content is first written to a new temporary file in

org.eclipse.jgit/src/org/eclipse/jgit/ignore/IgnoreRule.java

@@ -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.
-	 * <br>
-	 * 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 <code>isMatch(String, boolean)</code> 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;
-	}
-}

org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/pack/PackWriter.java

@@ -136,8 +136,8 @@ import org.eclipse.jgit.util.TemporaryBuffer;
  * Typical usage consists of creating instance intended for some pack,
  * configuring options, preparing the list of objects by calling
  * {@link #preparePack(Iterator)} or
- * {@link #preparePack(ProgressMonitor, Collection, Collection)}, and finally
- * producing the stream with
+ * {@link #preparePack(ProgressMonitor, Set, Set)}, and finally producing the
+ * stream with
  * {@link #writePack(ProgressMonitor, ProgressMonitor, OutputStream)}.
  * </p>
  * <p>
@@ -293,7 +293,7 @@ public class PackWriter implements AutoCloseable {
 	 * Create writer for specified repository.
 	 * <p>
 	 * Objects for packing are specified in {@link #preparePack(Iterator)} or
-	 * {@link #preparePack(ProgressMonitor, Collection, Collection)}.
+	 * {@link #preparePack(ProgressMonitor, Set, Set)}.
 	 *
 	 * @param repo
 	 *            repository where objects are stored.
@@ -306,7 +306,7 @@ public class PackWriter implements AutoCloseable {
 	 * Create a writer to load objects from the specified reader.
 	 * <p>
 	 * Objects for packing are specified in {@link #preparePack(Iterator)} or
-	 * {@link #preparePack(ProgressMonitor, Collection, Collection)}.
+	 * {@link #preparePack(ProgressMonitor, Set, Set)}.
 	 *
 	 * @param reader
 	 *            reader to read from the repository with.
@@ -319,7 +319,7 @@ public class PackWriter implements AutoCloseable {
 	 * Create writer for specified repository.
 	 * <p>
 	 * Objects for packing are specified in {@link #preparePack(Iterator)} or
-	 * {@link #preparePack(ProgressMonitor, Collection, Collection)}.
+	 * {@link #preparePack(ProgressMonitor, Set, Set)}.
 	 *
 	 * @param repo
 	 *            repository where objects are stored.
@@ -334,7 +334,7 @@ public class PackWriter implements AutoCloseable {
 	 * Create writer with a specified configuration.
 	 * <p>
 	 * Objects for packing are specified in {@link #preparePack(Iterator)} or
-	 * {@link #preparePack(ProgressMonitor, Collection, Collection)}.
+	 * {@link #preparePack(ProgressMonitor, Set, Set)}.
 	 *
 	 * @param config
 	 *            configuration for the pack writer.
@@ -495,7 +495,7 @@ public class PackWriter implements AutoCloseable {
 	/**
 	 * @return true to ignore objects that are uninteresting and also not found
 	 *         on local disk; false to throw a {@link MissingObjectException}
-	 *         out of {@link #preparePack(ProgressMonitor, Collection, Collection)} if an
+	 *         out of {@link #preparePack(ProgressMonitor, Set, Set)} if an
 	 *         uninteresting object is not in the source repository. By default,
 	 *         true, permitting gracefully ignoring of uninteresting objects.
 	 */
@@ -648,86 +648,6 @@ public class PackWriter implements AutoCloseable {
 		}
 	}
 
-	/**
-	 * Prepare the list of objects to be written to the pack stream.
-	 * <p>
-	 * Basing on these 2 sets, another set of objects to put in a pack file is
-	 * created: this set consists of all objects reachable (ancestors) from
-	 * interesting objects, except uninteresting objects and their ancestors.
-	 * This method uses class {@link ObjectWalk} extensively to find out that
-	 * appropriate set of output objects and their optimal order in output pack.
-	 * Order is consistent with general git in-pack rules: sort by object type,
-	 * recency, path and delta-base first.
-	 * </p>
-	 *
-	 * @param countingMonitor
-	 *            progress during object enumeration.
-	 * @param want
-	 *            collection of objects to be marked as interesting (start
-	 *            points of graph traversal).
-	 * @param have
-	 *            collection of objects to be marked as uninteresting (end
-	 *            points of graph traversal).
-	 * @throws IOException
-	 *             when some I/O problem occur during reading objects.
-	 * @deprecated to be removed in 2.0; use the Set version of this method.
-	 */
-	@Deprecated
-	public void preparePack(ProgressMonitor countingMonitor,
-			final Collection<? extends ObjectId> want,
-			final Collection<? extends ObjectId> have) throws IOException {
-		preparePack(countingMonitor, ensureSet(want), ensureSet(have));
-	}
-
-	/**
-	 * Prepare the list of objects to be written to the pack stream.
-	 * <p>
-	 * Basing on these 2 sets, another set of objects to put in a pack file is
-	 * created: this set consists of all objects reachable (ancestors) from
-	 * interesting objects, except uninteresting objects and their ancestors.
-	 * This method uses class {@link ObjectWalk} extensively to find out that
-	 * appropriate set of output objects and their optimal order in output pack.
-	 * Order is consistent with general git in-pack rules: sort by object type,
-	 * recency, path and delta-base first.
-	 * </p>
-	 *
-	 * @param countingMonitor
-	 *            progress during object enumeration.
-	 * @param walk
-	 *            ObjectWalk to perform enumeration.
-	 * @param interestingObjects
-	 *            collection of objects to be marked as interesting (start
-	 *            points of graph traversal).
-	 * @param uninterestingObjects
-	 *            collection of objects to be marked as uninteresting (end
-	 *            points of graph traversal).
-	 * @throws IOException
-	 *             when some I/O problem occur during reading objects.
-	 * @deprecated to be removed in 2.0; use the Set version of this method.
-	 */
-	@Deprecated
-	public void preparePack(ProgressMonitor countingMonitor,
-			ObjectWalk walk,
-			final Collection<? extends ObjectId> interestingObjects,
-			final Collection<? extends ObjectId> uninterestingObjects)
-			throws IOException {
-		preparePack(countingMonitor, walk,
-				ensureSet(interestingObjects),
-				ensureSet(uninterestingObjects));
-	}
-
-	@SuppressWarnings("unchecked")
-	private static Set<ObjectId> ensureSet(Collection<? extends ObjectId> objs) {
-		Set<ObjectId> set;
-		if (objs instanceof Set<?>)
-			set = (Set<ObjectId>) objs;
-		else if (objs == null)
-			set = Collections.emptySet();
-		else
-			set = new HashSet<ObjectId>(objs);
-		return set;
-	}
-
 	/**
 	 * Prepare the list of objects to be written to the pack stream.
 	 * <p>