motiejus
/
jgit
1
Fork 0
Code Releases Activity

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
This commit is contained in:
Christian Halstrick 2012-09-17 21:15:39 +02:00
parent 27b791c591
commit 84e171fbab
6 changed files with 137 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
org.eclipse.jgit.test/tst/org/eclipse/jgit/util/GitDateParserBadlyFormattedTest.java Normal file
View File

@ -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
}
}
}

25
org.eclipse.jgit.test/tst/org/eclipse/jgit/util/GitDateParserTest.java
View File

@ -62,30 +62,7 @@ public void setUp() {
}
@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());

1
org.eclipse.jgit/resources/org/eclipse/jgit/internal/JGitText.properties
View File

@ -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}

1
org.eclipse.jgit/src/org/eclipse/jgit/internal/JGitText.java
View File

@ -115,6 +115,7 @@ public static JGitText get() {
/***/ public String cannotMoveIndexTo;
/***/ public String cannotMovePackTo;
/***/ public String cannotOpenService;
/***/ public String cannotParseDate;
/***/ public String cannotParseGitURIish;
/***/ public String cannotPullOnARepoWithState;
/***/ public String cannotRead;

13
org.eclipse.jgit/src/org/eclipse/jgit/storage/file/GC.java
View File

@ -50,6 +50,7 @@
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 GC(FileRepository repo) {
*
* @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 void prunePacked() throws IOException {
* 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 {
public void prune(Set<ObjectId> objectsToKeep) throws IOException,
ParseException {
long expireDate = Long.MAX_VALUE;
if (expire == null && expireAgeMillis == -1) {

39
org.eclipse.jgit/src/org/eclipse/jgit/util/GitDateParser.java
View File

@ -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.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 @@ private ParseableSimpleDateFormat(String formatStr) {
* 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;
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