TagCommand should be able to create unannotated tags too

Using the low level API's is just too cumbersome.

Change-Id: Id5b9f560ee095d6db0b2ea5b26aef3e53021626e
Signed-off-by: Robin Stocker <robin@nibor.org>

org.eclipse.jgit.test/tst/org/eclipse/jgit/api/TagCommandTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010, Chris Aniszczyk <caniszczyk@gmail.com>
+ * Copyright (C) 2010, 2013 Chris Aniszczyk <caniszczyk@gmail.com>
  * and other copyright owners as documented in the project's IP log.
  *
  * This program and the accompanying materials are made available
@@ -80,6 +80,18 @@ public class TagCommandTest extends RepositoryTestCase {
 		assertEquals(commit.getId(), db.peel(tagRef).getPeeledObjectId());
 	}
 
+	@Test
+	public void testUnannotatedTagging() throws GitAPIException,
+			JGitInternalException {
+		Git git = new Git(db);
+		git.commit().setMessage("initial commit").call();
+		RevCommit commit = git.commit().setMessage("second commit").call();
+		git.commit().setMessage("third commit").call();
+		Ref tagRef = git.tag().setObjectId(commit).setName("tag")
+				.setAnnotated(false).call();
+		assertEquals(commit.getId(), tagRef.getObjectId());
+	}
+
 	@Test
 	public void testEmptyTagName() throws GitAPIException {
 		Git git = new Git(db);

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

@@ -295,6 +295,7 @@ mergeStrategyDoesNotSupportHeads=merge strategy {0} does not support {1} heads t
 mergeUsingStrategyResultedInDescription=Merge of revisions {0} with base {1} using strategy {2} resulted in: {3}. {4}
 mergeRecursiveReturnedNoCommit=Merge returned no commit:\n Depth {0}\n Head one {1}\n Head two {2}
 mergeRecursiveTooManyMergeBasesFor = "More than {0} merge bases for:\n a {1}\n b {2} found:\n  count {3}"
+messageAndTaggerNotAllowedInUnannotatedTags = Unannotated tags cannot have a message or tagger
 minutesAgo={0} minutes ago
 missingAccesskey=Missing accesskey.
 missingConfigurationForKey=No value for key {0} found in configuration

org.eclipse.jgit/src/org/eclipse/jgit/api/TagCommand.java

@@ -66,18 +66,24 @@ import org.eclipse.jgit.revwalk.RevObject;
 import org.eclipse.jgit.revwalk.RevWalk;
 
 /**
- * Create/update an annotated tag object.
+ * Create/update an annotated tag object or a simple unannotated tag
  * <p>
  * Examples (<code>git</code> is a {@link Git} instance):
  * <p>
- * Create a new annotated tag for the current commit:
+ * Create a new tag for the current commit:
  *
  * <pre>
  * git.tag().setName(&quot;v1.0&quot;).setMessage(&quot;First stable release&quot;).call();
  * </pre>
  * <p>
- * Use {@link Repository#updateRef(String)} to create a lightweight tag (just a
+ *
- * named reference to a commit).
+ * <p>
+ * Create a new unannotated tag for the current commit:
+ *
+ * <pre>
+ * git.tag().setName(&quot;v1.0&quot;).setAnnotated(false).call();
+ * </pre>
+ * <p>
  *
  * @see <a href="http://www.kernel.org/pub/software/scm/git/docs/git-tag.html"
  *      >Git documentation about Tag</a>
@@ -95,6 +101,8 @@ public class TagCommand extends GitCommand<Ref> {
 
 	private boolean forceUpdate;
 
+	private boolean annotated = true;
+
 	/**
 	 * @param repo
 	 */
@@ -120,13 +128,8 @@ public class TagCommand extends GitCommand<Ref> {
 		RepositoryState state = repo.getRepositoryState();
 		processOptions(state);
 
+		RevWalk revWalk = new RevWalk(repo);
 		try {
-			// create the tag object
-			TagBuilder newTag = new TagBuilder();
-			newTag.setTag(name);
-			newTag.setMessage(message);
-			newTag.setTagger(tagger);
-
 			// if no id is set, we should attempt to use HEAD
 			if (id == null) {
 				ObjectId objectId = repo.resolve(Constants.HEAD + "^{commit}"); //$NON-NLS-1$
@@ -134,20 +137,51 @@ public class TagCommand extends GitCommand<Ref> {
 					throw new NoHeadException(
 							JGitText.get().tagOnRepoWithoutHEADCurrentlyNotSupported);
 
-				newTag.setObjectId(objectId, Constants.OBJ_COMMIT);
+				id = revWalk.parseCommit(objectId);
-			} else {
+			}
-				newTag.setObjectId(id);
+
+			if (!annotated) {
+				if (message != null || tagger != null)
+					throw new JGitInternalException(
+							JGitText.get().messageAndTaggerNotAllowedInUnannotatedTags);
+				return updateTagRef(id, revWalk, name,
+						"SimpleTag[" + name + " : " + id //$NON-NLS-1$ //$NON-NLS-2$
+								+ "]"); //$NON-NLS-1$
 			}
 
+			// create the tag object
+			TagBuilder newTag = new TagBuilder();
+			newTag.setTag(name);
+			newTag.setMessage(message);
+			newTag.setTagger(tagger);
+			newTag.setObjectId(id);
+
 			// write the tag object
 			ObjectInserter inserter = repo.newObjectInserter();
 			try {
 				ObjectId tagId = inserter.insert(newTag);
 				inserter.flush();
 
-				RevWalk revWalk = new RevWalk(repo);
+				String tag = newTag.getTag();
-				try {
+				return updateTagRef(tagId, revWalk, tag, newTag.toString());
-					String refName = Constants.R_TAGS + newTag.getTag();
+
+			} finally {
+				inserter.release();
+			}
+
+		} catch (IOException e) {
+			throw new JGitInternalException(
+					JGitText.get().exceptionCaughtDuringExecutionOfTagCommand,
+					e);
+		} finally {
+			revWalk.release();
+		}
+	}
+
+	private Ref updateTagRef(ObjectId tagId, RevWalk revWalk,
+			String tagName, String newTagToString) throws IOException,
+			ConcurrentRefUpdateException, RefAlreadyExistsException {
+		String refName = Constants.R_TAGS + tagName;
 		RefUpdate tagRef = repo.updateRef(refName);
 		tagRef.setNewObjectId(tagId);
 		tagRef.setForceUpdate(forceUpdate);
@@ -159,31 +193,15 @@ public class TagCommand extends GitCommand<Ref> {
 			return repo.getRef(refName);
 		case LOCK_FAILURE:
 			throw new ConcurrentRefUpdateException(
-								JGitText.get().couldNotLockHEAD,
+					JGitText.get().couldNotLockHEAD, tagRef.getRef(),
-								tagRef.getRef(), updateResult);
+					updateResult);
 		case REJECTED:
-						throw new RefAlreadyExistsException(
+			throw new RefAlreadyExistsException(MessageFormat.format(
-								MessageFormat.format(
+					JGitText.get().tagAlreadyExists, newTagToString));
-										JGitText.get().tagAlreadyExists,
-										newTag.toString()));
 		default:
 			throw new JGitInternalException(MessageFormat.format(
-								JGitText.get().updatingRefFailed, refName,
+					JGitText.get().updatingRefFailed, refName, newTagToString,
-								newTag.toString(), updateResult));
+					updateResult));
-					}
-
-				} finally {
-					revWalk.release();
-				}
-
-			} finally {
-				inserter.release();
-			}
-
-		} catch (IOException e) {
-			throw new JGitInternalException(
-					JGitText.get().exceptionCaughtDuringExecutionOfTagCommand,
-					e);
 		}
 	}
 
@@ -201,7 +219,7 @@ public class TagCommand extends GitCommand<Ref> {
 	 */
 	private void processOptions(RepositoryState state)
 			throws InvalidTagNameException {
-		if (tagger == null)
+		if (tagger == null && annotated)
 			tagger = new PersonIdent(repo);
 		if (name == null || !Repository.isValidRefName(Constants.R_TAGS + name))
 			throw new InvalidTagNameException(MessageFormat.format(JGitText
@@ -323,4 +341,22 @@ public class TagCommand extends GitCommand<Ref> {
 		return this;
 	}
 
+	/**
+	 * @param annotated
+	 * @return {@code this}
+	 * @since 3.0
+	 */
+	public TagCommand setAnnotated(boolean annotated) {
+		this.annotated = annotated;
+		return this;
+	}
+
+	/**
+	 * @return true if this command will create an annotated tag (default is
+	 *         true)
+	 * @since 3.0
+	 */
+	public boolean isAnnotated() {
+		return annotated;
+	}
 }

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

@@ -357,6 +357,7 @@ public class JGitText extends TranslationBundle {
 	/***/ public String mergeUsingStrategyResultedInDescription;
 	/***/ public String mergeRecursiveReturnedNoCommit;
 	/***/ public String mergeRecursiveTooManyMergeBasesFor;
+	/***/ public String messageAndTaggerNotAllowedInUnannotatedTags;
 	/***/ public String minutesAgo;
 	/***/ public String missingAccesskey;
 	/***/ public String missingConfigurationForKey;