try {
clone.setURI(uri).setDirectory(destination).setBranch(branch).setBare(bare);
clone.call();
- } catch (RuntimeException e) {
+ } catch (Exception e) {
log("Could not clone repository: " + e, e, Project.MSG_ERR);
throw new BuildException("Could not clone repository: " + e.getMessage(), e);
}
InitCommand init = Git.init();
init.setBare(bare).setDirectory(destination);
init.call();
- } catch (JGitInternalException e) {
+ } catch (Exception e) {
throw new BuildException("Could not initialize repository", e);
}
}
import java.io.IOException;
import java.io.PrintWriter;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.NoFilepatternException;
import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.dircache.DirCacheBuilder;
public class AddCommandTest extends RepositoryTestCase {
@Test
- public void testAddNothing() {
+ public void testAddNothing() throws GitAPIException {
Git git = new Git(db);
try {
}
@Test
- public void testAddNonExistingSingleFile() throws NoFilepatternException {
+ public void testAddNonExistingSingleFile() throws GitAPIException {
Git git = new Git(db);
DirCache dc = git.add().addFilepattern("a.txt").call();
}
@Test
- public void testAddExistingSingleFile() throws IOException, NoFilepatternException {
+ public void testAddExistingSingleFile() throws IOException, GitAPIException {
File file = new File(db.getWorkTree(), "a.txt");
FileUtils.createNewFile(file);
PrintWriter writer = new PrintWriter(file);
@Test
public void testAddExistingSingleSmallFileWithNewLine() throws IOException,
- NoFilepatternException {
+ GitAPIException {
File file = new File(db.getWorkTree(), "a.txt");
FileUtils.createNewFile(file);
PrintWriter writer = new PrintWriter(file);
@Test
public void testAddExistingSingleMediumSizeFileWithNewLine()
- throws IOException, NoFilepatternException {
+ throws IOException, GitAPIException {
File file = new File(db.getWorkTree(), "a.txt");
FileUtils.createNewFile(file);
StringBuilder data = new StringBuilder();
@Test
public void testAddExistingSingleBinaryFile() throws IOException,
- NoFilepatternException {
+ GitAPIException {
File file = new File(db.getWorkTree(), "a.txt");
FileUtils.createNewFile(file);
PrintWriter writer = new PrintWriter(file);
}
@Test
- public void testAddExistingSingleFileInSubDir() throws IOException, NoFilepatternException {
+ public void testAddExistingSingleFileInSubDir() throws IOException,
+ GitAPIException {
FileUtils.mkdir(new File(db.getWorkTree(), "sub"));
File file = new File(db.getWorkTree(), "sub/a.txt");
FileUtils.createNewFile(file);
}
@Test
- public void testAddExistingSingleFileTwice() throws IOException, NoFilepatternException {
+ public void testAddExistingSingleFileTwice() throws IOException,
+ GitAPIException {
File file = new File(db.getWorkTree(), "a.txt");
FileUtils.createNewFile(file);
PrintWriter writer = new PrintWriter(file);
public Ref createBranch(Git actGit, String name, boolean force,
String startPoint, SetupUpstreamMode mode)
- throws JGitInternalException, RefAlreadyExistsException,
- RefNotFoundException,
- InvalidRefNameException {
+ throws JGitInternalException, GitAPIException {
CreateBranchCommand cmd = actGit.branchCreate();
cmd.setName(name);
cmd.setForce(force);
import java.io.IOException;
import org.eclipse.jgit.api.CheckoutResult.Status;
-import org.eclipse.jgit.api.errors.CheckoutConflictException;
-import org.eclipse.jgit.api.errors.InvalidRefNameException;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
-import org.eclipse.jgit.api.errors.RefAlreadyExistsException;
import org.eclipse.jgit.api.errors.RefNotFoundException;
import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.dircache.DirCacheEntry;
}
@Test
- public void testCheckoutToNonExistingBranch() throws JGitInternalException,
- RefAlreadyExistsException, InvalidRefNameException,
- CheckoutConflictException {
+ public void testCheckoutToNonExistingBranch() throws GitAPIException {
try {
git.checkout().setName("badbranch").call();
fail("Should have failed");
@Test
public void testDetachedHeadOnCheckout() throws JGitInternalException,
- RefAlreadyExistsException, RefNotFoundException,
- InvalidRefNameException, IOException, CheckoutConflictException {
+ IOException, GitAPIException {
CheckoutCommand co = git.checkout();
co.setName("master").call();
import static org.junit.Assert.assertTrue;
-import java.io.IOException;
import java.util.Set;
import java.util.TreeSet;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.errors.NoWorkTreeException;
import org.eclipse.jgit.lib.RepositoryTestCase;
import org.junit.Before;
}
@Test
- public void testClean() throws NoWorkTreeException, IOException {
+ public void testClean() throws NoWorkTreeException, GitAPIException {
// create status
StatusCommand command = git.status();
Status status = command.call();
}
@Test
- public void testCleanWithPaths() throws NoWorkTreeException, IOException {
+ public void testCleanWithPaths() throws NoWorkTreeException,
+ GitAPIException {
// create status
StatusCommand command = git.status();
Status status = command.call();
}
@Test
- public void testCleanWithDryRun() throws NoWorkTreeException, IOException {
+ public void testCleanWithDryRun() throws NoWorkTreeException,
+ GitAPIException {
// create status
StatusCommand command = git.status();
Status status = command.call();
import java.util.Map;
import org.eclipse.jgit.api.ListBranchCommand.ListMode;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.junit.TestRepository;
import org.eclipse.jgit.lib.ConfigConstants;
}
@Test
- public void testCloneRepository() throws IOException {
+ public void testCloneRepository() throws IOException,
+ JGitInternalException, GitAPIException {
File directory = createTempDirectory("testCloneRepository");
CloneCommand command = Git.cloneRepository();
command.setDirectory(directory);
}
@Test
- public void testCloneRepositoryWithBranch() throws IOException {
+ public void testCloneRepositoryWithBranch() throws IOException,
+ JGitInternalException, GitAPIException {
File directory = createTempDirectory("testCloneRepositoryWithBranch");
CloneCommand command = Git.cloneRepository();
command.setBranch("refs/heads/master");
}
@Test
- public void testCloneRepositoryOnlyOneBranch() throws IOException {
+ public void testCloneRepositoryOnlyOneBranch() throws IOException,
+ JGitInternalException, GitAPIException {
File directory = createTempDirectory("testCloneRepositoryWithBranch");
CloneCommand command = Git.cloneRepository();
command.setBranch("refs/heads/master");
@Test
public void testCloneRepositoryWhenDestinationDirectoryExistsAndIsNotEmpty()
- throws IOException {
+ throws IOException, JGitInternalException, GitAPIException {
String dirName = "testCloneTargetDirectoryNotEmpty";
File directory = createTempDirectory(dirName);
CloneCommand command = Git.cloneRepository();
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
-import org.eclipse.jgit.api.errors.ConcurrentRefUpdateException;
+
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
-import org.eclipse.jgit.api.errors.NoFilepatternException;
-import org.eclipse.jgit.api.errors.NoHeadException;
import org.eclipse.jgit.api.errors.NoMessageException;
-import org.eclipse.jgit.api.errors.WrongRepositoryStateException;
import org.eclipse.jgit.errors.IncorrectObjectTypeException;
import org.eclipse.jgit.errors.MissingObjectException;
-import org.eclipse.jgit.errors.UnmergedPathException;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.PersonIdent;
*/
public class CommitAndLogCommandTests extends RepositoryTestCase {
@Test
- public void testSomeCommits() throws NoHeadException, NoMessageException,
- ConcurrentRefUpdateException, JGitInternalException,
- WrongRepositoryStateException, IOException {
+ public void testSomeCommits() throws JGitInternalException, IOException,
+ GitAPIException {
// do 4 commits
Git git = new Git(db);
}
@Test
- public void testLogWithFilter() throws IOException, NoFilepatternException,
- NoHeadException, NoMessageException, ConcurrentRefUpdateException,
- JGitInternalException, WrongRepositoryStateException {
+ public void testLogWithFilter() throws IOException, JGitInternalException,
+ GitAPIException {
Git git = new Git(db);
// try to do a commit without specifying a message. Should fail!
@Test
- public void testWrongParams() throws UnmergedPathException,
- NoHeadException, ConcurrentRefUpdateException,
- JGitInternalException, WrongRepositoryStateException {
+ public void testWrongParams() throws GitAPIException {
Git git = new Git(db);
try {
git.commit().setAuthor(author).call();
// try to work with Commands after command has been invoked. Should throw
// exceptions
@Test
- public void testMultipleInvocations() throws NoHeadException,
- ConcurrentRefUpdateException, NoMessageException,
- UnmergedPathException, JGitInternalException,
- WrongRepositoryStateException {
+ public void testMultipleInvocations() throws GitAPIException {
Git git = new Git(db);
CommitCommand commitCmd = git.commit();
commitCmd.setMessage("initial commit").call();
}
@Test
- public void testMergeEmptyBranches() throws IOException, NoHeadException,
- NoMessageException, ConcurrentRefUpdateException,
- JGitInternalException, WrongRepositoryStateException {
+ public void testMergeEmptyBranches() throws IOException,
+ JGitInternalException, GitAPIException {
Git git = new Git(db);
git.commit().setMessage("initial commit").call();
RefUpdate r = db.updateRef("refs/heads/side");
}
@Test
- public void testAddUnstagedChanges() throws IOException, NoHeadException,
- NoMessageException, ConcurrentRefUpdateException,
- JGitInternalException, WrongRepositoryStateException,
- NoFilepatternException {
+ public void testAddUnstagedChanges() throws IOException,
+ JGitInternalException, GitAPIException {
File file = new File(db.getWorkTree(), "a.txt");
FileUtils.createNewFile(file);
PrintWriter writer = new PrintWriter(file);
}
@Test
- public void testModeChange() throws IOException, NoFilepatternException,
- NoHeadException, NoMessageException, ConcurrentRefUpdateException,
- JGitInternalException, WrongRepositoryStateException {
+ public void testModeChange() throws IOException, GitAPIException {
Git git = new Git(db);
// create file
}
@Test
- public void testCommitRange() throws NoHeadException, NoMessageException,
- UnmergedPathException, ConcurrentRefUpdateException,
- JGitInternalException, WrongRepositoryStateException,
- IncorrectObjectTypeException, MissingObjectException {
+ public void testCommitRange() throws GitAPIException,
+ JGitInternalException, MissingObjectException,
+ IncorrectObjectTypeException {
// do 4 commits and set the range to the second and fourth one
Git git = new Git(db);
git.commit().setMessage("first commit").call();
}
@Test
- public void testCommitAmend() throws NoHeadException, NoMessageException,
- ConcurrentRefUpdateException, JGitInternalException,
- WrongRepositoryStateException, IOException {
+ public void testCommitAmend() throws JGitInternalException, IOException,
+ GitAPIException {
Git git = new Git(db);
git.commit().setMessage("first comit").call(); // typo
git.commit().setAmend(true).setMessage("first commit").call();
}
@Test
- public void testInsertChangeId() throws NoHeadException,
- NoMessageException,
- UnmergedPathException, ConcurrentRefUpdateException,
- JGitInternalException, WrongRepositoryStateException {
+ public void testInsertChangeId() throws JGitInternalException,
+ GitAPIException {
Git git = new Git(db);
String messageHeader = "Some header line\n\nSome detail explanation\n";
String changeIdTemplate = "\nChange-Id: I"
import java.io.IOException;
import org.eclipse.jgit.api.ListBranchCommand.ListMode;
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.errors.RepositoryNotFoundException;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.RepositoryTestCase;
}
@Test
- public void testWrap() {
+ public void testWrap() throws JGitInternalException, GitAPIException {
Git git = Git.wrap(db);
assertEquals(1, git.branchList().call().size());
}
@Test
- public void testOpen() throws IOException {
+ public void testOpen() throws IOException, JGitInternalException,
+ GitAPIException {
Git git = Git.open(db.getDirectory());
assertEquals(1, git.branchList().call().size());
import java.io.File;
import java.io.IOException;
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.RepositoryTestCase;
import org.junit.Before;
}
@Test
- public void testInitRepository() throws IOException {
+ public void testInitRepository() throws IOException, JGitInternalException,
+ GitAPIException {
File directory = createTempDirectory("testInitRepository");
InitCommand command = new InitCommand();
command.setDirectory(directory);
}
@Test
- public void testInitNonEmptyRepository() throws IOException {
+ public void testInitNonEmptyRepository() throws IOException,
+ JGitInternalException, GitAPIException {
File directory = createTempDirectory("testInitRepository2");
File someFile = new File(directory, "someFile");
someFile.createNewFile();
}
@Test
- public void testInitBareRepository() throws IOException {
+ public void testInitBareRepository() throws IOException,
+ JGitInternalException, GitAPIException {
File directory = createTempDirectory("testInitBareRepository");
InitCommand command = new InitCommand();
command.setDirectory(directory);
import java.io.PrintWriter;
import org.eclipse.jgit.api.ResetCommand.ResetType;
-import org.eclipse.jgit.api.errors.ConcurrentRefUpdateException;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
-import org.eclipse.jgit.api.errors.NoFilepatternException;
-import org.eclipse.jgit.api.errors.NoHeadException;
-import org.eclipse.jgit.api.errors.NoMessageException;
-import org.eclipse.jgit.api.errors.WrongRepositoryStateException;
import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.dircache.DirCacheEntry;
import org.eclipse.jgit.errors.AmbiguousObjectException;
private DirCacheEntry prestage;
- public void setupRepository() throws IOException, NoFilepatternException,
- NoHeadException, NoMessageException, ConcurrentRefUpdateException,
- JGitInternalException, WrongRepositoryStateException {
+ public void setupRepository() throws IOException, JGitInternalException,
+ GitAPIException {
// create initial commit
git = new Git(db);
@Test
public void testHardReset() throws JGitInternalException,
- AmbiguousObjectException, IOException, NoFilepatternException,
- NoHeadException, NoMessageException, ConcurrentRefUpdateException,
- WrongRepositoryStateException {
+ AmbiguousObjectException, IOException, GitAPIException {
setupRepository();
ObjectId prevHead = db.resolve(Constants.HEAD);
git.reset().setMode(ResetType.HARD).setRef(initialCommit.getName())
@Test
public void testResetToNonexistingHEAD() throws JGitInternalException,
- AmbiguousObjectException, IOException {
+ AmbiguousObjectException, IOException, GitAPIException {
// create a file in the working tree of a fresh repo
git = new Git(db);
@Test
public void testSoftReset() throws JGitInternalException,
- AmbiguousObjectException, IOException, NoFilepatternException,
- NoHeadException, NoMessageException, ConcurrentRefUpdateException,
- WrongRepositoryStateException {
+ AmbiguousObjectException, IOException, GitAPIException {
setupRepository();
ObjectId prevHead = db.resolve(Constants.HEAD);
git.reset().setMode(ResetType.SOFT).setRef(initialCommit.getName())
@Test
public void testMixedReset() throws JGitInternalException,
- AmbiguousObjectException, IOException, NoFilepatternException,
- NoHeadException, NoMessageException, ConcurrentRefUpdateException,
- WrongRepositoryStateException {
+ AmbiguousObjectException, IOException, GitAPIException {
setupRepository();
ObjectId prevHead = db.resolve(Constants.HEAD);
git.reset().setMode(ResetType.MIXED).setRef(initialCommit.getName())
import java.io.IOException;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
-import org.eclipse.jgit.api.errors.NoFilepatternException;
import org.eclipse.jgit.lib.RepositoryTestCase;
import org.junit.Before;
import org.junit.Test;
@Test
public void testRemove() throws JGitInternalException,
- NoFilepatternException, IllegalStateException, IOException {
+ IllegalStateException, IOException, GitAPIException {
assertEquals("[test.txt, mode:100644, content:Hello world]",
indexState(CONTENT));
RmCommand command = git.rm();
import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.NoFilepatternException;
+import org.eclipse.jgit.errors.NoWorkTreeException;
import org.eclipse.jgit.lib.RepositoryTestCase;
import org.junit.Test;
public class StatusCommandTest extends RepositoryTestCase {
@Test
- public void testEmptyStatus() throws IOException {
+ public void testEmptyStatus() throws NoWorkTreeException,
+ GitAPIException {
Git git = new Git(db);
Status stat = git.status().call();
import java.io.IOException;
import java.util.List;
-import org.eclipse.jgit.api.errors.ConcurrentRefUpdateException;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.InvalidTagNameException;
import org.eclipse.jgit.api.errors.JGitInternalException;
-import org.eclipse.jgit.api.errors.NoHeadException;
-import org.eclipse.jgit.api.errors.NoMessageException;
-import org.eclipse.jgit.api.errors.WrongRepositoryStateException;
-import org.eclipse.jgit.errors.IncorrectObjectTypeException;
-import org.eclipse.jgit.errors.MissingObjectException;
-import org.eclipse.jgit.errors.UnmergedPathException;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.RepositoryTestCase;
public class TagCommandTest extends RepositoryTestCase {
@Test
- public void testTaggingOnHead() throws NoHeadException, NoMessageException,
- ConcurrentRefUpdateException, JGitInternalException,
- WrongRepositoryStateException, InvalidTagNameException,
- MissingObjectException, IncorrectObjectTypeException, IOException {
+ public void testTaggingOnHead() throws GitAPIException, IOException {
Git git = new Git(db);
RevCommit commit = git.commit().setMessage("initial commit").call();
Ref tagRef = git.tag().setName("tag").call();
}
@Test
- public void testTagging() throws NoHeadException, NoMessageException,
- UnmergedPathException, ConcurrentRefUpdateException,
- JGitInternalException, WrongRepositoryStateException,
- InvalidTagNameException {
+ public void testTagging() throws GitAPIException, JGitInternalException {
Git git = new Git(db);
git.commit().setMessage("initial commit").call();
RevCommit commit = git.commit().setMessage("second commit").call();
}
@Test
- public void testEmptyTagName() throws NoHeadException, NoMessageException,
- UnmergedPathException, ConcurrentRefUpdateException,
- JGitInternalException, WrongRepositoryStateException {
+ public void testEmptyTagName() throws GitAPIException {
Git git = new Git(db);
git.commit().setMessage("initial commit").call();
try {
}
@Test
- public void testInvalidTagName() throws NoHeadException,
- NoMessageException, UnmergedPathException,
- ConcurrentRefUpdateException, JGitInternalException,
- WrongRepositoryStateException {
+ public void testInvalidTagName() throws GitAPIException {
Git git = new Git(db);
git.commit().setMessage("initial commit").call();
try {
}
@Test
- public void testFailureOnSignedTags() throws NoHeadException,
- NoMessageException, UnmergedPathException,
- ConcurrentRefUpdateException, JGitInternalException,
- WrongRepositoryStateException, InvalidTagNameException {
+ public void testFailureOnSignedTags() throws GitAPIException {
Git git = new Git(db);
git.commit().setMessage("initial commit").call();
try {
import java.util.Arrays;
import org.eclipse.jgit.api.Git;
-import org.eclipse.jgit.api.errors.CheckoutConflictException;
-import org.eclipse.jgit.api.errors.InvalidRefNameException;
-import org.eclipse.jgit.api.errors.JGitInternalException;
-import org.eclipse.jgit.api.errors.RefAlreadyExistsException;
-import org.eclipse.jgit.api.errors.RefNotFoundException;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.dircache.InvalidPathException;
-import org.eclipse.jgit.errors.IncorrectObjectTypeException;
-import org.eclipse.jgit.errors.MissingObjectException;
import org.eclipse.jgit.junit.MockSystemReader;
import org.eclipse.jgit.revwalk.RevWalk;
import org.eclipse.jgit.util.SystemReader;
* perform the actual test on the second checkout
* @param path
* to the blob, one or more levels
+ * @throws GitAPIException
* @throws IOException
- * @throws RefAlreadyExistsException
- * @throws RefNotFoundException
- * @throws InvalidRefNameException
- * @throws MissingObjectException
- * @throws IncorrectObjectTypeException
- * @throws CheckoutConflictException
- * @throws JGitInternalException
*/
- private void testMaliciousPath(boolean good, boolean secondCheckout, String... path)
- throws IOException, RefAlreadyExistsException,
- RefNotFoundException, InvalidRefNameException,
- MissingObjectException, IncorrectObjectTypeException,
- JGitInternalException, CheckoutConflictException {
+ private void testMaliciousPath(boolean good, boolean secondCheckout,
+ String... path) throws GitAPIException, IOException {
Git git = new Git(db);
ObjectInserter newObjectInserter;
newObjectInserter = git.getRepository().newObjectInserter();
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.MergeResult;
import org.eclipse.jgit.api.MergeResult.MergeStatus;
-import org.eclipse.jgit.api.errors.NoFilepatternException;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.dircache.DirCacheEditor;
import org.eclipse.jgit.dircache.DirCacheEditor.PathEdit;
}
@Test
- public void testModified() throws IOException, NoFilepatternException {
+ public void testModified() throws IOException, GitAPIException {
writeTrashFile("file2", "file2");
writeTrashFile("dir/file3", "dir/file3");
}
@Test
- public void testUnchangedSimple() throws IOException,
- NoFilepatternException {
+ public void testUnchangedSimple() throws IOException, GitAPIException {
writeTrashFile("a.b", "a.b");
writeTrashFile("a.c", "a.c");
writeTrashFile("a=c", "a=c");
* used by Git.
*
* @throws IOException
- * @throws NoFilepatternException
+ * @throws GitAPIException
*/
@Test
- public void testUnchangedComplex() throws IOException,
- NoFilepatternException {
+ public void testUnchangedComplex() throws IOException, GitAPIException {
Git git = new Git(db);
writeTrashFile("a.b", "a.b");
writeTrashFile("a.c", "a.c");
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.Status;
import org.eclipse.jgit.api.SubmoduleAddCommand;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.dircache.DirCacheEditor;
public class SubmoduleAddTest extends RepositoryTestCase {
@Test
- public void commandWithNullPath() {
+ public void commandWithNullPath() throws GitAPIException {
try {
new SubmoduleAddCommand(db).setURI("uri").call();
fail("Exception not thrown");
}
@Test
- public void commandWithEmptyPath() {
+ public void commandWithEmptyPath() throws GitAPIException {
try {
new SubmoduleAddCommand(db).setPath("").setURI("uri").call();
fail("Exception not thrown");
}
@Test
- public void commandWithNullUri() {
+ public void commandWithNullUri() throws GitAPIException {
try {
new SubmoduleAddCommand(db).setPath("sub").call();
fail("Exception not thrown");
}
@Test
- public void commandWithEmptyUri() {
+ public void commandWithEmptyUri() throws GitAPIException {
try {
new SubmoduleAddCommand(db).setPath("sub").setURI("").call();
fail("Exception not thrown");
import java.util.Collection;
import org.eclipse.jgit.api.SubmoduleInitCommand;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.dircache.DirCacheEditor;
public class SubmoduleInitTest extends RepositoryTestCase {
@Test
- public void repositoryWithNoSubmodules() {
+ public void repositoryWithNoSubmodules() throws GitAPIException {
SubmoduleInitCommand command = new SubmoduleInitCommand(db);
Collection<String> modules = command.call();
assertNotNull(modules);
@Test
public void repositoryWithUninitializedModule() throws IOException,
- ConfigInvalidException {
+ ConfigInvalidException, GitAPIException {
final String path = addSubmoduleToIndex();
SubmoduleWalk generator = SubmoduleWalk.forIndex(db);
@Test
public void resolveOneLevelHigherRelativeUrl() throws IOException,
- ConfigInvalidException {
+ ConfigInvalidException, GitAPIException {
final String path = addSubmoduleToIndex();
String base = "git://server/repo.git";
@Test
public void resolveTwoLevelHigherRelativeUrl() throws IOException,
- ConfigInvalidException {
+ ConfigInvalidException, GitAPIException {
final String path = addSubmoduleToIndex();
String base = "git://server/repo.git";
@Test
public void resolveWorkingDirectoryRelativeUrl() throws IOException,
- ConfigInvalidException {
+ GitAPIException, ConfigInvalidException {
final String path = addSubmoduleToIndex();
String base = db.getWorkTree().getAbsolutePath();
@Test
public void resolveInvalidParentUrl() throws IOException,
- ConfigInvalidException {
+ ConfigInvalidException, GitAPIException {
final String path = addSubmoduleToIndex();
String base = "no_slash";
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.SubmoduleStatusCommand;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.dircache.DirCacheEditor;
import org.eclipse.jgit.dircache.DirCacheEditor.PathEdit;
public class SubmoduleStatusTest extends RepositoryTestCase {
@Test
- public void repositoryWithNoSubmodules() {
+ public void repositoryWithNoSubmodules() throws GitAPIException {
SubmoduleStatusCommand command = new SubmoduleStatusCommand(db);
Map<String, SubmoduleStatus> statuses = command.call();
assertNotNull(statuses);
}
@Test
- public void repositoryWithMissingSubmodule() throws IOException {
+ public void repositoryWithMissingSubmodule() throws IOException,
+ GitAPIException {
final ObjectId id = ObjectId
.fromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
final String path = "sub";
}
@Test
- public void repositoryWithUninitializedSubmodule() throws IOException {
+ public void repositoryWithUninitializedSubmodule() throws IOException,
+ GitAPIException {
final ObjectId id = ObjectId
.fromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
final String path = "sub";
}
@Test
- public void repositoryWithNoHeadInSubmodule() throws IOException {
+ public void repositoryWithNoHeadInSubmodule() throws IOException,
+ GitAPIException {
final ObjectId id = ObjectId
.fromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
final String path = "sub";
}
@Test
- public void repositoryWithNoSubmoduleRepository() throws IOException {
+ public void repositoryWithNoSubmoduleRepository() throws IOException,
+ GitAPIException {
final ObjectId id = ObjectId
.fromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
final String path = "sub";
}
@Test
- public void repositoryWithInitializedSubmodule() throws IOException {
+ public void repositoryWithInitializedSubmodule() throws IOException,
+ GitAPIException {
final ObjectId id = ObjectId
.fromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
final String path = "sub";
@Test
public void repositoryWithDifferentRevCheckedOutSubmodule()
- throws IOException {
+ throws IOException, GitAPIException {
final ObjectId id = ObjectId
.fromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
final String path = "sub";
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.SubmoduleSyncCommand;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.dircache.DirCacheEditor;
import org.eclipse.jgit.dircache.DirCacheEditor.PathEdit;
public class SubmoduleSyncTest extends RepositoryTestCase {
@Test
- public void repositoryWithNoSubmodules() {
+ public void repositoryWithNoSubmodules() throws GitAPIException {
SubmoduleSyncCommand command = new SubmoduleSyncCommand(db);
Map<String, String> modules = command.call();
assertNotNull(modules);
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.SubmoduleUpdateCommand;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.dircache.DirCacheEditor;
import org.eclipse.jgit.dircache.DirCacheEditor.PathEdit;
public class SubmoduleUpdateTest extends RepositoryTestCase {
@Test
- public void repositoryWithNoSubmodules() {
+ public void repositoryWithNoSubmodules() throws GitAPIException {
SubmoduleUpdateCommand command = new SubmoduleUpdateCommand(db);
Collection<String> modules = command.call();
assertNotNull(modules);
}
@Test
- public void repositoryWithUnconfiguredSubmodule() throws IOException {
+ public void repositoryWithUnconfiguredSubmodule() throws IOException,
+ GitAPIException {
final ObjectId id = ObjectId
.fromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
final String path = "sub";
}
@Test
- public void repositoryWithInitializedSubmodule() throws IOException {
+ public void repositoryWithInitializedSubmodule() throws IOException,
+ GitAPIException {
final ObjectId id = ObjectId
.fromString("abcd1234abcd1234abcd1234abcd1234abcd1234");
final String path = "sub";
import java.util.Collection;
import java.util.LinkedList;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.api.errors.NoFilepatternException;
import org.eclipse.jgit.dircache.DirCache;
*
* @return the DirCache after Add
*/
- public DirCache call() throws NoFilepatternException {
+ public DirCache call() throws GitAPIException, NoFilepatternException {
if (filepatterns.isEmpty())
throw new NoFilepatternException(JGitText.get().atLeastOnePatternIsRequired);
import java.io.IOException;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.lib.CommitBuilder;
import org.eclipse.jgit.lib.Constants;
super(repo);
}
- /**
- * @throws JGitInternalException
- * upon internal failure
- */
- public Note call() throws JGitInternalException {
+ public Note call() throws GitAPIException {
checkCallable();
RevWalk walk = new RevWalk(repo);
ObjectInserter inserter = repo.newObjectInserter();
import java.util.Collection;
import java.util.Collections;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.blame.BlameGenerator;
import org.eclipse.jgit.blame.BlameResult;
*
* @return list of lines
*/
- public BlameResult call() throws JGitInternalException {
+ public BlameResult call() throws GitAPIException {
checkCallable();
BlameGenerator gen = new BlameGenerator(repo, path);
try {
import org.eclipse.jgit.api.CheckoutResult.Status;
import org.eclipse.jgit.api.errors.CheckoutConflictException;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.InvalidRefNameException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.api.errors.RefAlreadyExistsException;
* @throws InvalidRefNameException
* if the provided name is <code>null</code> or otherwise
* invalid
+ * @throws CheckoutConflictException
+ * if the checkout results in a conflict
* @return the newly created branch
*/
- public Ref call() throws JGitInternalException, RefAlreadyExistsException,
+ public Ref call() throws GitAPIException, RefAlreadyExistsException,
RefNotFoundException, InvalidRefNameException,
CheckoutConflictException {
checkCallable();
import java.util.Set;
import java.util.TreeSet;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.util.FileUtils;
*
* @return a set of strings representing each file cleaned.
*/
- public Set<String> call() {
+ public Set<String> call() throws GitAPIException {
Set<String> files = new TreeSet<String>();
try {
StatusCommand command = new StatusCommand(repo);
/**
* If dryRun is set, the paths in question will not actually be deleted.
- *
+ *
* @param dryRun
* whether to do a dry run or not
* @return {@code this}
import java.util.Collection;
import java.util.List;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.InvalidRemoteException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.dircache.DirCache;
/**
* Executes the {@code Clone} command.
*
- * @throws JGitInternalException
- * if the repository can't be created
* @return the newly created {@code Git} object with associated repository
*/
- public Git call() throws JGitInternalException {
+ public Git call() throws GitAPIException {
try {
URIish u = new URIish(uri);
Repository repository = init(u);
}
}
- private Repository init(URIish u) {
+ private Repository init(URIish u) throws GitAPIException {
InitCommand command = Git.init();
command.setBare(bare);
if (directory == null)
}
private FetchResult fetch(Repository clonedRepo, URIish u)
- throws URISyntaxException,
- JGitInternalException,
- InvalidRemoteException, IOException {
+ throws URISyntaxException, IOException, GitAPIException {
// create the remote config and save it
RemoteConfig config = new RemoteConfig(clonedRepo.getConfig(), remote);
config.addURI(u);
}
private void checkout(Repository clonedRepo, FetchResult result)
- throws JGitInternalException,
- MissingObjectException, IncorrectObjectTypeException, IOException {
+ throws MissingObjectException, IncorrectObjectTypeException,
+ IOException, GitAPIException {
Ref head = result.getAdvertisedRef(branch);
if (branch.equals(Constants.HEAD)) {
}
}
- private void cloneSubmodules(Repository clonedRepo) throws IOException {
+ private void cloneSubmodules(Repository clonedRepo) throws IOException,
+ GitAPIException {
SubmoduleInitCommand init = new SubmoduleInitCommand(clonedRepo);
if (init.call().isEmpty())
return;
import java.util.List;
import org.eclipse.jgit.api.errors.ConcurrentRefUpdateException;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.api.errors.NoFilepatternException;
import org.eclipse.jgit.api.errors.NoHeadException;
import org.eclipse.jgit.api.errors.NoMessageException;
+import org.eclipse.jgit.api.errors.UnmergedPathsException;
import org.eclipse.jgit.api.errors.WrongRepositoryStateException;
import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.dircache.DirCacheBuilder;
* when called on a git repo without a HEAD reference
* @throws NoMessageException
* when called without specifying a commit message
- * @throws UnmergedPathException
+ * @throws UnmergedPathsException
* when the current index contained unmerged paths (conflicts)
+ * @throws ConcurrentRefUpdateException
+ * when HEAD or branch ref is updated concurrently by someone
+ * else
* @throws WrongRepositoryStateException
* when repository is not in the right state for committing
- * @throws JGitInternalException
- * a low-level exception of JGit has occurred. The original
- * exception can be retrieved by calling
- * {@link Exception#getCause()}. Expect only
- * {@code IOException's} to be wrapped. Subclasses of
- * {@link IOException} (e.g. {@link UnmergedPathException}) are
- * typically not wrapped here but thrown as original exception
*/
- public RevCommit call() throws NoHeadException, NoMessageException,
- UnmergedPathException, ConcurrentRefUpdateException,
- JGitInternalException, WrongRepositoryStateException {
+ public RevCommit call() throws GitAPIException, NoHeadException,
+ NoMessageException, UnmergedPathsException,
+ ConcurrentRefUpdateException,
+ WrongRepositoryStateException {
checkCallable();
RepositoryState state = repo.getRepositoryState();
index.unlock();
}
} catch (UnmergedPathException e) {
- // since UnmergedPathException is a subclass of IOException
- // which should not be wrapped by a JGitInternalException we
- // have to catch and re-throw it here
- throw e;
+ throw new UnmergedPathsException(e);
} catch (IOException e) {
throw new JGitInternalException(
JGitText.get().exceptionCaughtDuringExecutionOfCommitCommand, e);
import java.io.IOException;
import java.text.MessageFormat;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.InvalidRefNameException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.api.errors.RefAlreadyExistsException;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.RefUpdate;
+import org.eclipse.jgit.lib.RefUpdate.Result;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.StoredConfig;
-import org.eclipse.jgit.lib.RefUpdate.Result;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevWalk;
* invalid
* @return the newly created branch
*/
- public Ref call() throws JGitInternalException, RefAlreadyExistsException,
+ public Ref call() throws GitAPIException, RefAlreadyExistsException,
RefNotFoundException, InvalidRefNameException {
checkCallable();
processOptions();
import java.util.Set;
import org.eclipse.jgit.api.errors.CannotDeleteCurrentBranchException;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.api.errors.NotMergedException;
import org.eclipse.jgit.internal.JGitText;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.RefUpdate;
+import org.eclipse.jgit.lib.RefUpdate.Result;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.StoredConfig;
-import org.eclipse.jgit.lib.RefUpdate.Result;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevWalk;
* @throws NotMergedException
* when trying to delete a branch which has not been merged into
* the currently checked out branch without force
+ * @throws CannotDeleteCurrentBranchException
* @return the list with the (full) names of the deleted branches
*/
- public List<String> call() throws JGitInternalException,
+ public List<String> call() throws GitAPIException,
NotMergedException, CannotDeleteCurrentBranchException {
checkCallable();
List<String> result = new ArrayList<String>();
import java.util.List;
import java.util.Set;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.internal.JGitText;
import org.eclipse.jgit.lib.Ref;
}
/**
- * @throws JGitInternalException
- * when trying to delete a tag that doesn't exist
- *
* @return the list with the full names of the deleted tags
*/
- public List<String> call() throws JGitInternalException {
+ public List<String> call() throws GitAPIException {
checkCallable();
List<String> result = new ArrayList<String>();
if (tags.isEmpty())
import java.util.List;
import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.api.errors.NoHeadException;
import org.eclipse.jgit.diff.DiffEntry;
import org.eclipse.jgit.diff.DiffFormatter;
*
* @return a DiffEntry for each path which is different
*/
- public List<DiffEntry> call() throws GitAPIException, IOException {
+ public List<DiffEntry> call() throws GitAPIException {
final DiffFormatter diffFmt;
if (out != null && !showNameAndStatusOnly)
diffFmt = new DiffFormatter(new BufferedOutputStream(out));
diffFmt.flush();
return result;
}
+ } catch (IOException e) {
+ throw new JGitInternalException(e.getMessage(), e);
} finally {
diffFmt.release();
}
import java.util.ArrayList;
import java.util.List;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.InvalidRemoteException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.errors.NoRemoteRepositoryException;
* result
* @throws InvalidRemoteException
* when called with an invalid remote uri
- * @throws JGitInternalException
- * a low-level exception of JGit has occurred. The original
- * exception can be retrieved by calling
- * {@link Exception#getCause()}.
+ * @throws org.eclipse.jgit.api.errors.TransportException
+ * when an error occurs during transport
*/
- public FetchResult call() throws JGitInternalException,
- InvalidRemoteException {
+ public FetchResult call() throws GitAPIException, InvalidRemoteException,
+ org.eclipse.jgit.api.errors.TransportException {
checkCallable();
try {
throw new InvalidRemoteException(MessageFormat.format(
JGitText.get().invalidRemote, remote), e);
} catch (TransportException e) {
- throw new JGitInternalException(
+ throw new org.eclipse.jgit.api.errors.TransportException(
JGitText.get().exceptionCaughtDuringExecutionOfFetchCommand,
e);
} catch (URISyntaxException e) {
import java.text.MessageFormat;
import java.util.concurrent.Callable;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.internal.JGitText;
import org.eclipse.jgit.lib.Repository;
JGitText.get().commandWasCalledInTheWrongState
, this.getClass().getName()));
}
+
+ /**
+ * Executes the command
+ *
+ * @return T a result. Each command has its own return type
+ * @throws GitAPIException
+ * or subclass thereof when an error occurs
+ */
+ public abstract T call() throws GitAPIException;
}
import java.io.IOException;
import java.util.concurrent.Callable;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.Repository;
/**
* Executes the {@code Init} command.
*
- * @throws JGitInternalException
- * if the repository can't be created
* @return the newly created {@code Git} object with associated repository
*/
- public Git call() throws JGitInternalException {
+ public Git call() throws GitAPIException {
try {
RepositoryBuilder builder = new RepositoryBuilder();
if (bare)
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
+import java.util.HashMap;
import java.util.List;
import java.util.Map;
-import java.util.HashMap;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.Ref;
super(repo);
}
- /**
- * @throws JGitInternalException
- * upon internal failure
- */
- public List<Ref> call() throws JGitInternalException {
+ public List<Ref> call() throws GitAPIException {
checkCallable();
Map<String, Ref> refList;
try {
import java.util.Iterator;
import java.util.List;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.Ref;
}
/**
- * @throws JGitInternalException
- * upon internal failure
+ * @return the requested notes
*/
- public List<Note> call() throws JGitInternalException {
+ public List<Note> call() throws GitAPIException {
checkCallable();
List<Note> notes = new ArrayList<Note>();
RevWalk walk = new RevWalk(repo);
import java.util.List;
import java.util.Map;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.Ref;
}
/**
- * @throws JGitInternalException
- * upon internal failure
* @return the tags available
*/
- public List<Ref> call() throws JGitInternalException {
+ public List<Ref> call() throws GitAPIException {
checkCallable();
Map<String, Ref> refList;
List<Ref> tags = new ArrayList<Ref>();
import java.util.ArrayList;
import java.util.List;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.api.errors.NoHeadException;
import org.eclipse.jgit.errors.IncorrectObjectTypeException;
* method twice on an instance.
*
* @return an iteration over RevCommits
+ * @throws NoHeadException
+ * of the references ref cannot be resolved
*/
- public Iterable<RevCommit> call() throws NoHeadException,
- JGitInternalException {
+ public Iterable<RevCommit> call() throws GitAPIException, NoHeadException {
checkCallable();
if (pathFilters.size() > 0)
walk.setTreeFilter(AndTreeFilter.create(
* typically not wrapped here but thrown as original exception
*/
public LogCommand add(AnyObjectId start) throws MissingObjectException,
- IncorrectObjectTypeException, JGitInternalException {
+ IncorrectObjectTypeException {
return add(true, start);
}
* typically not wrapped here but thrown as original exception
*/
public LogCommand not(AnyObjectId start) throws MissingObjectException,
- IncorrectObjectTypeException, JGitInternalException {
+ IncorrectObjectTypeException {
return add(false, start);
}
* typically not wrapped here but thrown as original exception
*/
public LogCommand addRange(AnyObjectId since, AnyObjectId until)
- throws MissingObjectException, IncorrectObjectTypeException,
- JGitInternalException {
+ throws MissingObjectException, IncorrectObjectTypeException {
return not(since).add(until);
}
* @return a collection of references in the remote repository
* @throws InvalidRemoteException
* when called with an invalid remote uri
- * @throws JGitInternalException
- * a low-level exception of JGit has occurred. The original
- * exception can be retrieved by calling
- * {@link Exception#getCause()}.
+ * @throws org.eclipse.jgit.api.errors.TransportException
+ * for errors that occurs during transport
*/
public Collection<Ref> call() throws GitAPIException,
- JGitInternalException {
+ org.eclipse.jgit.api.errors.TransportException {
checkCallable();
Transport transport = null;
import org.eclipse.jgit.api.MergeResult.MergeStatus;
import org.eclipse.jgit.api.errors.CheckoutConflictException;
import org.eclipse.jgit.api.errors.ConcurrentRefUpdateException;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.InvalidMergeHeadsException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.api.errors.NoHeadException;
*
* @return the result of the merge
*/
- public MergeResult call() throws NoHeadException,
+ public MergeResult call() throws GitAPIException, NoHeadException,
ConcurrentRefUpdateException, CheckoutConflictException,
InvalidMergeHeadsException, WrongRepositoryStateException, NoMessageException {
checkCallable();
*
* @return the result of the pull
*/
- public PullResult call() throws WrongRepositoryStateException,
+ public PullResult call() throws GitAPIException, WrongRepositoryStateException,
InvalidConfigurationException, DetachedHeadException,
InvalidRemoteException, CanceledException, RefNotFoundException,
NoHeadException {
import java.util.Collections;
import java.util.List;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.InvalidRemoteException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.errors.NotSupportedException;
* @return an iteration over {@link PushResult} objects
* @throws InvalidRemoteException
* when called with an invalid remote uri
- * @throws JGitInternalException
- * a low-level exception of JGit has occurred. The original
- * exception can be retrieved by calling
- * {@link Exception#getCause()}.
*/
- public Iterable<PushResult> call() throws JGitInternalException,
+ public Iterable<PushResult> call() throws GitAPIException,
InvalidRemoteException {
checkCallable();
* @throws JGitInternalException
* the reference name cannot be resolved.
*/
- public PushCommand add(String nameOrSpec) throws JGitInternalException {
+ public PushCommand add(String nameOrSpec) {
if (0 <= nameOrSpec.indexOf(':')) {
refSpecs.add(new RefSpec(nameOrSpec));
} else {
*
* @return an object describing the result of this command
*/
- public RebaseResult call() throws NoHeadException, RefNotFoundException,
- JGitInternalException, GitAPIException {
+ public RebaseResult call() throws GitAPIException, NoHeadException,
+ RefNotFoundException {
RevCommit newHead = null;
boolean lastStepWasForward = false;
checkCallable();
}
}
- private RevCommit checkoutCurrentHead() throws IOException,
- NoHeadException, JGitInternalException {
+ private RevCommit checkoutCurrentHead() throws IOException, NoHeadException {
ObjectId headTree = repo.resolve(Constants.HEAD + "^{tree}");
if (headTree == null)
throw new NoHeadException(
}
}
- private RebaseResult initFilesAndRewind() throws RefNotFoundException,
- IOException, NoHeadException, JGitInternalException {
+ private RebaseResult initFilesAndRewind() throws IOException,
+ GitAPIException {
// we need to store everything into files so that we can implement
// --skip, --continue, and --abort
*
* @param newCommit
* @return the new head, or null
- * @throws RefNotFoundException
* @throws IOException
+ * @throws GitAPIException
*/
- public RevCommit tryFastForward(RevCommit newCommit)
- throws RefNotFoundException, IOException {
+ public RevCommit tryFastForward(RevCommit newCommit) throws IOException,
+ GitAPIException {
Ref head = repo.getRef(Constants.HEAD);
if (head == null || head.getObjectId() == null)
throw new RefNotFoundException(MessageFormat.format(
}
private RevCommit tryFastForward(String headName, RevCommit oldCommit,
- RevCommit newCommit) throws IOException, JGitInternalException {
+ RevCommit newCommit) throws IOException, GitAPIException {
boolean tryRebase = false;
for (RevCommit parentCommit : newCommit.getParents())
if (parentCommit.equals(oldCommit))
import java.text.MessageFormat;
import java.util.Collection;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.InvalidRefNameException;
import org.eclipse.jgit.internal.JGitText;
import org.eclipse.jgit.lib.Constants;
return this;
}
- public Collection<ReflogEntry> call() throws Exception {
+ public Collection<ReflogEntry> call() throws GitAPIException {
checkCallable();
try {
import java.io.IOException;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.lib.CommitBuilder;
import org.eclipse.jgit.lib.Constants;
super(repo);
}
- /**
- * @throws JGitInternalException
- * upon internal failure
- */
- public Note call() throws JGitInternalException {
+ public Note call() throws GitAPIException {
checkCallable();
RevWalk walk = new RevWalk(repo);
ObjectInserter inserter = repo.newObjectInserter();
import java.util.Arrays;
import org.eclipse.jgit.api.errors.DetachedHeadException;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.InvalidRefNameException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.api.errors.RefAlreadyExistsException;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.RefRename;
+import org.eclipse.jgit.lib.RefUpdate.Result;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.StoredConfig;
-import org.eclipse.jgit.lib.RefUpdate.Result;
/**
* Used to rename branches.
* if rename is tried without specifying the old name and HEAD
* is detached
*/
- public Ref call() throws RefNotFoundException, InvalidRefNameException,
+ public Ref call() throws GitAPIException, RefNotFoundException, InvalidRefNameException,
RefAlreadyExistsException, DetachedHeadException {
checkCallable();
import java.util.Collection;
import java.util.LinkedList;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.dircache.DirCacheCheckout;
*
* @return the Ref after reset
*/
- public Ref call() throws IOException {
+ public Ref call() throws GitAPIException {
checkCallable();
Ref r;
import org.eclipse.jgit.api.MergeResult.MergeStatus;
import org.eclipse.jgit.api.errors.GitAPIException;
-import org.eclipse.jgit.api.errors.MultipleParentsNotAllowedException;
import org.eclipse.jgit.api.errors.JGitInternalException;
+import org.eclipse.jgit.api.errors.MultipleParentsNotAllowedException;
import org.eclipse.jgit.api.errors.NoHeadException;
import org.eclipse.jgit.dircache.DirCacheCheckout;
import org.eclipse.jgit.internal.JGitText;
import java.util.Collection;
import java.util.LinkedList;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.api.errors.NoFilepatternException;
import org.eclipse.jgit.dircache.DirCache;
*
* @return the DirCache after Rm
*/
- public DirCache call() throws NoFilepatternException {
+ public DirCache call() throws GitAPIException,
+ NoFilepatternException {
if (filepatterns.isEmpty())
throw new NoFilepatternException(JGitText.get().atLeastOnePatternIsRequired);
import java.io.IOException;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.Ref;
super(repo);
}
- /**
- * @throws JGitInternalException
- * upon internal failure
- */
- public Note call() throws JGitInternalException {
+ public Note call() throws GitAPIException {
checkCallable();
RevWalk walk = new RevWalk(repo);
NoteMap map = NoteMap.newEmptyMap();
return false;
}
- private ObjectId getHeadTree() throws JGitInternalException,
- GitAPIException {
+ private ObjectId getHeadTree() throws GitAPIException {
final ObjectId headTree;
try {
headTree = repo.resolve(Constants.HEAD + "^{tree}");
return headTree;
}
- private ObjectId getStashId() throws JGitInternalException, GitAPIException {
+ private ObjectId getStashId() throws GitAPIException {
final String revision = stashRef != null ? stashRef : DEFAULT_REF;
final ObjectId stashId;
try {
*
* @return id of stashed commit that was applied
*/
- public ObjectId call() throws GitAPIException, JGitInternalException {
+ public ObjectId call() throws GitAPIException {
checkCallable();
if (repo.getRepositoryState() != RepositoryState.SAFE)
*
* @return stashed commit or null if no changes to stash
*/
- public RevCommit call() throws GitAPIException, JGitInternalException {
+ public RevCommit call() throws GitAPIException {
checkCallable();
Ref head = getHead();
*
* @return commit id of stash reference or null if no more stashed changes
*/
- public ObjectId call() throws GitAPIException, JGitInternalException {
+ public ObjectId call() throws GitAPIException {
checkCallable();
Ref stashRef = getRef();
import java.util.Collections;
import java.util.List;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.InvalidRefNameException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.internal.JGitText;
super(repo);
}
- public Collection<RevCommit> call() throws Exception {
+ public Collection<RevCommit> call() throws GitAPIException {
checkCallable();
try {
import java.io.IOException;
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.errors.NoWorkTreeException;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.IndexDiff;
* @return a {@link Status} object telling about each path where working
* tree, index or HEAD differ from each other.
*/
- public Status call() throws IOException, NoWorkTreeException {
+ public Status call() throws GitAPIException, NoWorkTreeException {
if (workingTreeIt == null)
workingTreeIt = new FileTreeIterator(repo);
- IndexDiff diff = new IndexDiff(repo, Constants.HEAD, workingTreeIt);
- diff.diff();
-
- return new Status(diff);
+ try {
+ IndexDiff diff = new IndexDiff(repo, Constants.HEAD, workingTreeIt);
+ diff.diff();
+ return new Status(diff);
+ } catch (IOException e) {
+ throw new JGitInternalException(e.getMessage(), e);
+ }
}
/**
import java.io.IOException;
import java.text.MessageFormat;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.api.errors.NoFilepatternException;
import org.eclipse.jgit.errors.ConfigInvalidException;
return SubmoduleWalk.forIndex(repo).setFilter(filter).next();
}
- public Repository call() throws JGitInternalException {
+ public Repository call() throws GitAPIException {
checkCallable();
if (path == null || path.length() == 0)
throw new IllegalArgumentException(JGitText.get().pathNotConfigured);
import java.util.Collection;
import java.util.List;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.errors.ConfigInvalidException;
import org.eclipse.jgit.lib.ConfigConstants;
return this;
}
- public Collection<String> call() throws JGitInternalException {
+ public Collection<String> call() throws GitAPIException {
checkCallable();
try {
import java.util.HashMap;
import java.util.Map;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.errors.ConfigInvalidException;
import org.eclipse.jgit.lib.Constants;
return this;
}
- public Map<String, SubmoduleStatus> call() throws JGitInternalException {
+ public Map<String, SubmoduleStatus> call() throws GitAPIException {
checkCallable();
try {
import java.util.HashMap;
import java.util.Map;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.errors.ConfigInvalidException;
import org.eclipse.jgit.lib.ConfigConstants;
return null;
}
- public Map<String, String> call() throws JGitInternalException {
+ public Map<String, String> call() throws GitAPIException {
checkCallable();
try {
return this;
}
- public Collection<String> call() throws JGitInternalException {
+ public Collection<String> call() throws GitAPIException {
checkCallable();
try {
import java.text.MessageFormat;
import org.eclipse.jgit.api.errors.ConcurrentRefUpdateException;
+import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.InvalidTagNameException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.api.errors.NoHeadException;
* @return a {@link Ref} a ref pointing to a tag
* @throws NoHeadException
* when called on a git repo without a HEAD reference
- * @throws JGitInternalException
- * a low-level exception of JGit has occurred. The original
- * exception can be retrieved by calling
- * {@link Exception#getCause()}. Expect only
- * {@code IOException's} to be wrapped.
* @since 2.0
*/
- public Ref call() throws JGitInternalException,
- ConcurrentRefUpdateException, InvalidTagNameException, NoHeadException {
+ public Ref call() throws GitAPIException, ConcurrentRefUpdateException,
+ InvalidTagNameException, NoHeadException {
checkCallable();
RepositoryState state = repo.getRepositoryState();
* The default constructor with a default message
*/
public UnmergedPathsException() {
- super(JGitText.get().unmergedPaths);
+ this(null);
+ }
+
+ /**
+ * The default constructor with a default message
+ *
+ * @param cause
+ * original exception
+ */
+ public UnmergedPathsException(Throwable cause) {
+ super(JGitText.get().unmergedPaths, cause);
}
}
projects / jgit.git / commitdiff