Merge branch 'stable-2.1'

* stable-2.1:
  Prepare for 2.1 maintenance changes
  JGit v2.1.0.201209190230-r
  Introduce "never" as parseable date
  Introduce ParseExceptions for GitDateParser
  Support config param "gc.pruneexpire"

Change-Id: If149d7f968a3425d9425f6ba9ce135a8341776a7
Signed-off-by: Matthias Sohn <matthias.sohn@sap.com>

org.eclipse.jgit.test/tst/org/eclipse/jgit/util/GitDateParserBadlyFormattedTest.java

@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2012, Christian Halstrick
+ * 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.util;
+
+import static org.junit.Assert.fail;
+
+import java.text.ParseException;
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+
+import org.junit.experimental.theories.DataPoints;
+import org.junit.experimental.theories.Theories;
+import org.junit.experimental.theories.Theory;
+import org.junit.runner.RunWith;
+
+/**
+ * Tests which assert that unparseable Strings lead to ParseExceptions
+ */
+@RunWith(Theories.class)
+public class GitDateParserBadlyFormattedTest {
+	private String dateStr;
+
+	public GitDateParserBadlyFormattedTest(String dateStr) {
+		this.dateStr = dateStr;
+	}
+
+	@DataPoints
+	static public String[] getDataPoints() {
+		return new String[] { "", "1970", "3000.3000.3000", "3 yesterday ago",
+				"now yesterday ago", "yesterdays", "3.day. 2.week.ago",
+				"day ago", "Gra Feb 21 15:35:00 2007 +0100",
+				"Sun Feb 21 15:35:00 2007 +0100",
+				"Wed Feb 21 15:35:00 Grand +0100" };
+	}
+
+	@Theory
+	public void badlyFormattedWithExplicitRef() {
+		Calendar ref = new GregorianCalendar(SystemReader.getInstance()
+				.getTimeZone(), SystemReader.getInstance().getLocale());
+		try {
+			GitDateParser.parse(dateStr, ref);
+			fail("The expected ParseException while parsing '" + dateStr
+					+ "' did not occur.");
+		} catch (ParseException e) {
+			// expected
+		}
+	}
+
+	@Theory
+	public void badlyFormattedWithoutRef() {
+		try {
+			GitDateParser.parse(dateStr, null);
+			fail("The expected ParseException while parsing '" + dateStr
+					+ "' did not occur.");
+		} catch (ParseException e) {
+			// expected
+		}
+	}
+}

org.eclipse.jgit.test/tst/org/eclipse/jgit/util/GitDateParserTest.java

@@ -62,30 +62,7 @@ public class GitDateParserTest {
 	}
 
 	@Test
-	public void badlyFormatted() {
-		Calendar ref = new GregorianCalendar(SystemReader.getInstance()
-				.getTimeZone(), SystemReader.getInstance().getLocale());
-		Assert.assertNull(GitDateParser.parse("foo", ref));
-		Assert.assertNull(GitDateParser.parse("", ref));
-		Assert.assertNull(GitDateParser.parse("", null));
-		Assert.assertNull(GitDateParser.parse("1970", ref));
-		Assert.assertNull(GitDateParser.parse("3000.3000.3000", ref));
-		Assert.assertNull(GitDateParser.parse("3 yesterday ago", ref));
-		Assert.assertNull(GitDateParser.parse("now yesterday ago", ref));
-		Assert.assertNull(GitDateParser.parse("yesterdays", ref));
-		Assert.assertNull(GitDateParser.parse("3.day. 2.week.ago", ref));
-		Assert.assertNull(GitDateParser.parse("day ago", ref));
-		Assert.assertNull(GitDateParser.parse("Gra Feb 21 15:35:00 2007 +0100",
-				null));
-		Assert.assertNull(GitDateParser.parse("Sun Feb 21 15:35:00 2007 +0100",
-				null));
-		Assert.assertNull(GitDateParser.parse(
-				"Wed Feb 21 15:35:00 Grand +0100",
-				null));
-	}
-
-	@Test
-	public void yesterday() {
+	public void yesterday() throws ParseException {
 		GregorianCalendar cal = new GregorianCalendar(SystemReader
 				.getInstance().getTimeZone(), SystemReader.getInstance()
 				.getLocale());
@@ -99,6 +76,17 @@ public class GitDateParserTest {
 		Assert.assertEquals(cal.getTime(), parse);
 	}
 
+	@Test
+	public void never() throws ParseException {
+		GregorianCalendar cal = new GregorianCalendar(SystemReader
+				.getInstance().getTimeZone(), SystemReader.getInstance()
+				.getLocale());
+		Date parse = GitDateParser.parse("never", cal);
+		Assert.assertEquals(GitDateParser.NEVER, parse);
+		parse = GitDateParser.parse("never", null);
+		Assert.assertEquals(GitDateParser.NEVER, parse);
+	}
+
 	@Test
 	public void now() throws ParseException {
 		String dateStr = "2007-02-21 15:35:00 +0100";

org.eclipse.jgit/resources/org/eclipse/jgit/internal/JGitText.properties

@@ -55,6 +55,7 @@ cannotMatchOnEmptyString=Cannot match on empty string.
 cannotMoveIndexTo=Cannot move index to {0}
 cannotMovePackTo=Cannot move pack to {0}
 cannotOpenService=cannot open {0}
+cannotParseDate=The date specification "{0}" could not be parsed with the following formats: {1}
 cannotParseGitURIish=Cannot parse Git URI-ish
 cannotPullOnARepoWithState=Cannot pull into a repository with state: {0}
 cannotRead=Cannot read {0}

org.eclipse.jgit/src/org/eclipse/jgit/internal/JGitText.java

@@ -115,6 +115,7 @@ public class JGitText extends TranslationBundle {
 	/***/ public String cannotMoveIndexTo;
 	/***/ public String cannotMovePackTo;
 	/***/ public String cannotOpenService;
+	/***/ public String cannotParseDate;
 	/***/ public String cannotParseGitURIish;
 	/***/ public String cannotPullOnARepoWithState;
 	/***/ public String cannotRead;

org.eclipse.jgit/src/org/eclipse/jgit/lib/ConfigConstants.java

@@ -75,6 +75,9 @@ public class ConfigConstants {
 	/** The "submodule" section */
 	public static final String CONFIG_SUBMODULE_SECTION = "submodule";
 
+	/** The "gc" section */
+	public static final String CONFIG_GC_SECTION = "gc";
+
 	/** The "pack" section */
 	public static final String CONFIG_PACK_SECTION = "pack";
 
@@ -181,4 +184,7 @@ public class ConfigConstants {
 
 	/** The "precomposeunicode" key */
 	public static final String CONFIG_KEY_PRECOMPOSEUNICODE = "precomposeunicode";
+
+	/** The "pruneexpire" key */
+	public static final String CONFIG_KEY_PRUNEEXPIRE = "pruneexpire";
 }

org.eclipse.jgit/src/org/eclipse/jgit/storage/file/GC.java

@@ -50,9 +50,11 @@ import java.io.OutputStream;
 import java.nio.channels.Channels;
 import java.nio.channels.FileChannel;
 import java.text.MessageFormat;
+import java.text.ParseException;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.Date;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
@@ -68,6 +70,7 @@ import org.eclipse.jgit.errors.IncorrectObjectTypeException;
 import org.eclipse.jgit.errors.MissingObjectException;
 import org.eclipse.jgit.errors.NoWorkTreeException;
 import org.eclipse.jgit.internal.JGitText;
+import org.eclipse.jgit.lib.ConfigConstants;
 import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.FileMode;
 import org.eclipse.jgit.lib.NullProgressMonitor;
@@ -83,6 +86,7 @@ import org.eclipse.jgit.storage.pack.PackWriter;
 import org.eclipse.jgit.treewalk.TreeWalk;
 import org.eclipse.jgit.treewalk.filter.TreeFilter;
 import org.eclipse.jgit.util.FileUtils;
+import org.eclipse.jgit.util.GitDateParser;
 
 /**
  * A garbage collector for git {@link FileRepository}. Instances of this class
@@ -92,11 +96,15 @@ import org.eclipse.jgit.util.FileUtils;
  * adapted to FileRepositories.
  */
 public class GC {
+	private static final String PRUNE_EXPIRE_DEFAULT = "2.weeks.ago";
+
 	private final FileRepository repo;
 
 	private ProgressMonitor pm;
 
-	private long expireAgeMillis;
+	private long expireAgeMillis = -1;
+
+	private Date expire;
 
 	/**
 	 * the refs which existed during the last call to {@link #repack()}. This is
@@ -123,7 +131,6 @@ public class GC {
 	public GC(FileRepository repo) {
 		this.repo = repo;
 		this.pm = NullProgressMonitor.INSTANCE;
-		this.expireAgeMillis = 14 * 24 * 60 * 60 * 1000L;
 	}
 
 	/**
@@ -137,8 +144,11 @@ public class GC {
 	 *
 	 * @return the collection of {@link PackFile}'s which are newly created
 	 * @throws IOException
+	 * @throws ParseException
+	 *             If the configuration parameter "gc.pruneexpire" couldn't be
+	 *             parsed
 	 */
-	public Collection<PackFile> gc() throws IOException {
+	public Collection<PackFile> gc() throws IOException, ParseException {
 		pm.start(6 /* tasks */);
 		packRefs();
 		// TODO: implement reflog_expire(pm, repo);
@@ -250,11 +260,27 @@ public class GC {
 	 *            a set of objects which should explicitly not be pruned
 	 *
 	 * @throws IOException
+	 * @throws ParseException
+	 *             If the configuration parameter "gc.pruneexpire" couldn't be
+	 *             parsed
 	 */
-	public void prune(Set<ObjectId> objectsToKeep)
-			throws IOException {
-		long expireDate = (expireAgeMillis == 0) ? Long.MAX_VALUE : System
-				.currentTimeMillis() - expireAgeMillis;
+	public void prune(Set<ObjectId> objectsToKeep) throws IOException,
+			ParseException {
+		long expireDate = Long.MAX_VALUE;
+
+		if (expire == null && expireAgeMillis == -1) {
+			String pruneExpireStr = repo.getConfig().getString(
+					ConfigConstants.CONFIG_GC_SECTION, null,
+					ConfigConstants.CONFIG_KEY_PRUNEEXPIRE);
+			if (pruneExpireStr == null)
+				pruneExpireStr = PRUNE_EXPIRE_DEFAULT;
+			expire = GitDateParser.parse(pruneExpireStr, null);
+			expireAgeMillis = -1;
+		}
+		if (expire != null)
+			expireDate = expire.getTime();
+		if (expireAgeMillis != -1)
+			expireDate = System.currentTimeMillis() - expireAgeMillis;
 
 		// Collect all loose objects which are old enough, not referenced from
 		// the index and not in objectsToKeep
@@ -807,5 +833,21 @@ public class GC {
 	 */
 	public void setExpireAgeMillis(long expireAgeMillis) {
 		this.expireAgeMillis = expireAgeMillis;
+		expire = null;
+	}
+
+	/**
+	 * During gc() or prune() each unreferenced, loose object which has been
+	 * created or modified after <code>expire</code> will not be pruned. Only
+	 * older objects may be pruned. If set to null then every object is a
+	 * candidate for pruning.
+	 *
+	 * @param expire
+	 *            minimal age of objects to be pruned in milliseconds.
+	 */
+	public void setExpire(Date expire) {
+		this.expire = expire;
+		expireAgeMillis = -1;
 	}
+
 }

org.eclipse.jgit/src/org/eclipse/jgit/util/GitDateParser.java

@@ -42,6 +42,7 @@
  */
 package org.eclipse.jgit.util;
 
+import java.text.MessageFormat;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.Calendar;
@@ -50,6 +51,8 @@ import java.util.GregorianCalendar;
 import java.util.HashMap;
 import java.util.Map;
 
+import org.eclipse.jgit.internal.JGitText;
+
 /**
  * Parses strings with time and date specifications into {@link Date}.
  *
@@ -59,6 +62,12 @@ import java.util.Map;
  * understands.
  */
 public class GitDateParser {
+	/**
+	 * The Date representing never. Though this is a concrete value, most
+	 * callers are adviced to avoid depending on the actual value.
+	 */
+	public static final Date NEVER = new Date(Long.MAX_VALUE);
+
 	// Since SimpleDateFormat instances are expensive to instantiate they should
 	// be cached. Since they are also not threadsafe they are cached using
 	// ThreadLocal.
@@ -110,6 +119,7 @@ public class GitDateParser {
 	 * relative formats (e.g. "yesterday") the caller can specify the reference
 	 * date. These types of strings can be parsed:
 	 * <ul>
+	 * <li>"never"</li>
 	 * <li>"now"</li>
 	 * <li>"yesterday"</li>
 	 * <li>"(x) years|months|weeks|days|hours|minutes|seconds ago"<br>
@@ -135,32 +145,43 @@ public class GitDateParser {
 	 *            parser often but wants a consistent starting point for calls.<br>
 	 *            If set to <code>null</code> then the current time will be used
 	 *            instead.
-	 * @return the parsed {@link Date} or <code>null</code> if this string was
-	 *         not parseable.
+	 * @return the parsed {@link Date}
+	 * @throws ParseException
+	 *             if the given dateStr was not recognized
 	 */
-	public static Date parse(String dateStr, Calendar now) {
+	public static Date parse(String dateStr, Calendar now)
+			throws ParseException {
 		dateStr = dateStr.trim();
 		Date ret;
+
+		if ("never".equalsIgnoreCase(dateStr))
+			return NEVER;
 		ret = parse_relative(dateStr, now);
 		if (ret != null)
 			return ret;
 		for (ParseableSimpleDateFormat f : ParseableSimpleDateFormat.values()) {
-			ret = parse_simple(dateStr, f);
-			if (ret != null)
-				return ret;
+			try {
+				return parse_simple(dateStr, f);
+			} catch (ParseException e) {
+				// simply proceed with the next parser
+			}
 		}
-		return null;
+		ParseableSimpleDateFormat[] values = ParseableSimpleDateFormat.values();
+		StringBuilder allFormats = new StringBuilder("\"")
+				.append(values[0].formatStr);
+		for (int i = 1; i < values.length; i++)
+			allFormats.append("\", \"").append(values[i].formatStr);
+		allFormats.append("\"");
+		throw new ParseException(MessageFormat.format(
+				JGitText.get().cannotParseDate, dateStr, allFormats.toString()), 0);
 	}
 
 	// tries to parse a string with the formats supported by SimpleDateFormat
-	private static Date parse_simple(String dateStr, ParseableSimpleDateFormat f) {
+	private static Date parse_simple(String dateStr, ParseableSimpleDateFormat f)
+			throws ParseException {
 		SimpleDateFormat dateFormat = getDateFormat(f);
-		try {
-			dateFormat.setLenient(false);
-			return dateFormat.parse(dateStr);
-		} catch (ParseException e) {
-			return null;
-		}
+		dateFormat.setLenient(false);
+		return dateFormat.parse(dateStr);
 	}
 
 	// tries to parse a string with a relative time specification