Introduce ParseExceptions for GitDateParser

Instead of just returning null when something was not parseable we
should throw a real ParseException. This allows us to distinguish
between specifications which are unparseable and those which represent
no date (e.g. "never")

Change-Id: Ib3c1aa64b65ed0e0270791a365f2fa72ab78a3f4

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() {
+	public void yesterday() throws ParseException {
-		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() {
 		GregorianCalendar cal = new GregorianCalendar(SystemReader
 				.getInstance().getTimeZone(), SystemReader.getInstance()
 				.getLocale());

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/storage/file/GC.java

@@ -50,6 +50,7 @@ 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;
@@ -143,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);
@@ -256,9 +260,12 @@ 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)
+	public void prune(Set<ObjectId> objectsToKeep) throws IOException,
-			throws IOException {
+			ParseException {
 		long expireDate = Long.MAX_VALUE;
 
 		if (expire == null && 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}.
  *
@@ -135,32 +138,40 @@ 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
+	 * @return the parsed {@link Date}
-	 *         not parseable.
+	 * @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;
 		ret = parse_relative(dateStr, now);
 		if (ret != null)
 			return ret;
 		for (ParseableSimpleDateFormat f : ParseableSimpleDateFormat.values()) {
-			ret = parse_simple(dateStr, f);
+			try {
-			if (ret != null)
+				return parse_simple(dateStr, f);
-				return ret;
+			} 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);
-			dateFormat.setLenient(false);
+		return dateFormat.parse(dateStr);
-			return dateFormat.parse(dateStr);
-		} catch (ParseException e) {
-			return null;
-		}
 	}
 
 	// tries to parse a string with a relative time specification