Browse Source

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>
stable-3.0
Robin Rosenberg 12 years ago committed by Robin Stocker
parent
commit
b8e763fc19
  1. 14
      org.eclipse.jgit.test/tst/org/eclipse/jgit/api/TagCommandTest.java
  2. 1
      org.eclipse.jgit/resources/org/eclipse/jgit/internal/JGitText.properties
  3. 114
      org.eclipse.jgit/src/org/eclipse/jgit/api/TagCommand.java
  4. 1
      org.eclipse.jgit/src/org/eclipse/jgit/internal/JGitText.java

14
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. * and other copyright owners as documented in the project's IP log.
* *
* This program and the accompanying materials are made available * 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()); 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 @Test
public void testEmptyTagName() throws GitAPIException { public void testEmptyTagName() throws GitAPIException {
Git git = new Git(db); Git git = new Git(db);

1
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} 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} 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}" 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 minutesAgo={0} minutes ago
missingAccesskey=Missing accesskey. missingAccesskey=Missing accesskey.
missingConfigurationForKey=No value for key {0} found in configuration missingConfigurationForKey=No value for key {0} found in configuration

114
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; import org.eclipse.jgit.revwalk.RevWalk;
/** /**
* Create/update an annotated tag object. * Create/update an annotated tag object or a simple unannotated tag
* <p> * <p>
* Examples (<code>git</code> is a {@link Git} instance): * Examples (<code>git</code> is a {@link Git} instance):
* <p> * <p>
* Create a new annotated tag for the current commit: * Create a new tag for the current commit:
* *
* <pre> * <pre>
* git.tag().setName(&quot;v1.0&quot;).setMessage(&quot;First stable release&quot;).call(); * git.tag().setName(&quot;v1.0&quot;).setMessage(&quot;First stable release&quot;).call();
* </pre> * </pre>
* <p> * <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" * @see <a href="http://www.kernel.org/pub/software/scm/git/docs/git-tag.html"
* >Git documentation about Tag</a> * >Git documentation about Tag</a>
@ -95,6 +101,8 @@ public class TagCommand extends GitCommand<Ref> {
private boolean forceUpdate; private boolean forceUpdate;
private boolean annotated = true;
/** /**
* @param repo * @param repo
*/ */
@ -120,13 +128,8 @@ public class TagCommand extends GitCommand<Ref> {
RepositoryState state = repo.getRepositoryState(); RepositoryState state = repo.getRepositoryState();
processOptions(state); processOptions(state);
RevWalk revWalk = new RevWalk(repo);
try { 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 no id is set, we should attempt to use HEAD
if (id == null) { if (id == null) {
ObjectId objectId = repo.resolve(Constants.HEAD + "^{commit}"); //$NON-NLS-1$ ObjectId objectId = repo.resolve(Constants.HEAD + "^{commit}"); //$NON-NLS-1$
@ -134,20 +137,51 @@ public class TagCommand extends GitCommand<Ref> {
throw new NoHeadException( throw new NoHeadException(
JGitText.get().tagOnRepoWithoutHEADCurrentlyNotSupported); 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 // write the tag object
ObjectInserter inserter = repo.newObjectInserter(); ObjectInserter inserter = repo.newObjectInserter();
try { try {
ObjectId tagId = inserter.insert(newTag); ObjectId tagId = inserter.insert(newTag);
inserter.flush(); 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); RefUpdate tagRef = repo.updateRef(refName);
tagRef.setNewObjectId(tagId); tagRef.setNewObjectId(tagId);
tagRef.setForceUpdate(forceUpdate); tagRef.setForceUpdate(forceUpdate);
@ -159,31 +193,15 @@ public class TagCommand extends GitCommand<Ref> {
return repo.getRef(refName); return repo.getRef(refName);
case LOCK_FAILURE: case LOCK_FAILURE:
throw new ConcurrentRefUpdateException( throw new ConcurrentRefUpdateException(
JGitText.get().couldNotLockHEAD, JGitText.get().couldNotLockHEAD, tagRef.getRef(),
tagRef.getRef(), updateResult); updateResult);
case REJECTED: case REJECTED:
throw new RefAlreadyExistsException( throw new RefAlreadyExistsException(MessageFormat.format(
MessageFormat.format( JGitText.get().tagAlreadyExists, newTagToString));
JGitText.get().tagAlreadyExists,
newTag.toString()));
default: default:
throw new JGitInternalException(MessageFormat.format( 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) private void processOptions(RepositoryState state)
throws InvalidTagNameException { throws InvalidTagNameException {
if (tagger == null) if (tagger == null && annotated)
tagger = new PersonIdent(repo); tagger = new PersonIdent(repo);
if (name == null || !Repository.isValidRefName(Constants.R_TAGS + name)) if (name == null || !Repository.isValidRefName(Constants.R_TAGS + name))
throw new InvalidTagNameException(MessageFormat.format(JGitText throw new InvalidTagNameException(MessageFormat.format(JGitText
@ -323,4 +341,22 @@ public class TagCommand extends GitCommand<Ref> {
return this; 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;
}
} }

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

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

Loading…
Cancel
Save