import org.eclipse.jgit.api.RebaseCommand.Operation;
import org.eclipse.jgit.api.RebaseResult.Status;
import org.eclipse.jgit.api.errors.RefNotFoundException;
+import org.eclipse.jgit.api.errors.UnmergedPathsException;
import org.eclipse.jgit.api.errors.WrongRepositoryStateException;
import org.eclipse.jgit.dircache.DirCacheCheckout;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.lib.RefUpdate;
import org.eclipse.jgit.lib.RepositoryState;
import org.eclipse.jgit.lib.RepositoryTestCase;
import org.eclipse.jgit.revwalk.RevWalk;
public class RebaseCommandTest extends RepositoryTestCase {
+ private static final String FILE1 = "file1";
+
+ protected Git git;
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+ this.git = new Git(db);
+ }
+
private void createBranch(ObjectId objectId, String branchName)
throws IOException {
RefUpdate updateRef = db.updateRef(branchName);
IOException {
RevWalk walk = new RevWalk(db);
RevCommit head = walk.parseCommit(db.resolve(Constants.HEAD));
- DirCacheCheckout dco = new DirCacheCheckout(db, head.getTree(),
- db.lockDirCache(), commit.getTree());
+ DirCacheCheckout dco = new DirCacheCheckout(db, head.getTree(), db
+ .lockDirCache(), commit.getTree());
dco.setFailOnConflict(true);
dco.checkout();
walk.release();
}
public void testFastForwardWithNewFile() throws Exception {
- Git git = new Git(db);
-
// create file1 on master
- writeTrashFile("file1", "file1");
- git.add().addFilepattern("file1").call();
+ writeTrashFile(FILE1, FILE1);
+ git.add().addFilepattern(FILE1).call();
RevCommit first = git.commit().setMessage("Add file1").call();
- assertTrue(new File(db.getWorkTree(), "file1").exists());
+ assertTrue(new File(db.getWorkTree(), FILE1).exists());
// create a topic branch
createBranch(first, "refs/heads/topic");
// create file2 on master
}
public void testUpToDate() throws Exception {
- Git git = new Git(db);
-
// create file1 on master
- writeTrashFile("file1", "file1");
- git.add().addFilepattern("file1").call();
+ writeTrashFile(FILE1, FILE1);
+ git.add().addFilepattern(FILE1).call();
RevCommit first = git.commit().setMessage("Add file1").call();
- assertTrue(new File(db.getWorkTree(), "file1").exists());
+ assertTrue(new File(db.getWorkTree(), FILE1).exists());
RebaseResult res = git.rebase().setUpstream(first).call();
assertEquals(Status.UP_TO_DATE, res.getStatus());
}
public void testUnknownUpstream() throws Exception {
- Git git = new Git(db);
-
// create file1 on master
- writeTrashFile("file1", "file1");
- git.add().addFilepattern("file1").call();
+ writeTrashFile(FILE1, FILE1);
+ git.add().addFilepattern(FILE1).call();
git.commit().setMessage("Add file1").call();
- assertTrue(new File(db.getWorkTree(), "file1").exists());
+ assertTrue(new File(db.getWorkTree(), FILE1).exists());
try {
- git.rebase().setUpstream("refs/heads/xyz")
- .call();
+ git.rebase().setUpstream("refs/heads/xyz").call();
fail("expected exception was not thrown");
} catch (RefNotFoundException e) {
// expected exception
}
public void testConflictFreeWithSingleFile() throws Exception {
- Git git = new Git(db);
-
// create file1 on master
- File theFile = writeTrashFile("file1", "1\n2\n3\n");
- git.add().addFilepattern("file1").call();
+ File theFile = writeTrashFile(FILE1, "1\n2\n3\n");
+ git.add().addFilepattern(FILE1).call();
RevCommit second = git.commit().setMessage("Add file1").call();
- assertTrue(new File(db.getWorkTree(), "file1").exists());
+ assertTrue(new File(db.getWorkTree(), FILE1).exists());
// change first line in master and commit
- writeTrashFile("file1", "1master\n2\n3\n");
+ writeTrashFile(FILE1, "1master\n2\n3\n");
checkFile(theFile, "1master\n2\n3\n");
- git.add().addFilepattern("file1").call();
+ git.add().addFilepattern(FILE1).call();
RevCommit lastMasterChange = git.commit().setMessage(
"change file1 in master").call();
// we have the old content again
checkFile(theFile, "1\n2\n3\n");
- assertTrue(new File(db.getWorkTree(), "file1").exists());
+ assertTrue(new File(db.getWorkTree(), FILE1).exists());
// change third line in topic branch
- writeTrashFile("file1", "1\n2\n3\ntopic\n");
- git.add().addFilepattern("file1").call();
+ writeTrashFile(FILE1, "1\n2\n3\ntopic\n");
+ git.add().addFilepattern(FILE1).call();
git.commit().setMessage("change file1 in topic").call();
RebaseResult res = git.rebase().setUpstream("refs/heads/master").call();
}
public void testDetachedHead() throws Exception {
- Git git = new Git(db);
-
// create file1 on master
- File theFile = writeTrashFile("file1", "1\n2\n3\n");
- git.add().addFilepattern("file1").call();
+ File theFile = writeTrashFile(FILE1, "1\n2\n3\n");
+ git.add().addFilepattern(FILE1).call();
RevCommit second = git.commit().setMessage("Add file1").call();
- assertTrue(new File(db.getWorkTree(), "file1").exists());
+ assertTrue(new File(db.getWorkTree(), FILE1).exists());
// change first line in master and commit
- writeTrashFile("file1", "1master\n2\n3\n");
+ writeTrashFile(FILE1, "1master\n2\n3\n");
checkFile(theFile, "1master\n2\n3\n");
- git.add().addFilepattern("file1").call();
- RevCommit lastMasterChange = git.commit()
- .setMessage("change file1 in master").call();
+ git.add().addFilepattern(FILE1).call();
+ RevCommit lastMasterChange = git.commit().setMessage(
+ "change file1 in master").call();
// create a topic branch based on second commit
createBranch(second, "refs/heads/topic");
// we have the old content again
checkFile(theFile, "1\n2\n3\n");
- assertTrue(new File(db.getWorkTree(), "file1").exists());
+ assertTrue(new File(db.getWorkTree(), FILE1).exists());
// change third line in topic branch
- writeTrashFile("file1", "1\n2\n3\ntopic\n");
- git.add().addFilepattern("file1").call();
+ writeTrashFile(FILE1, "1\n2\n3\ntopic\n");
+ git.add().addFilepattern(FILE1).call();
RevCommit topicCommit = git.commit()
.setMessage("change file1 in topic").call();
checkoutBranch("refs/heads/master");
RebaseResult res = git.rebase().setUpstream("refs/heads/master").call();
assertEquals(Status.OK, res.getStatus());
checkFile(theFile, "1master\n2\n3\ntopic\n");
- assertEquals(lastMasterChange,
- new RevWalk(db).parseCommit(db.resolve(Constants.HEAD))
- .getParent(0));
+ assertEquals(lastMasterChange, new RevWalk(db).parseCommit(
+ db.resolve(Constants.HEAD)).getParent(0));
}
public void testFilesAddedFromTwoBranches() throws Exception {
- Git git = new Git(db);
-
// create file1 on master
- writeTrashFile("file1", "file1");
- git.add().addFilepattern("file1").call();
+ writeTrashFile(FILE1, FILE1);
+ git.add().addFilepattern(FILE1).call();
RevCommit masterCommit = git.commit().setMessage("Add file1 to master")
.call();
git.add().addFilepattern("file3").call();
git.commit().setMessage("Add file3 to branch file3").call();
- assertTrue(new File(db.getWorkTree(), "file1").exists());
+ assertTrue(new File(db.getWorkTree(), FILE1).exists());
assertFalse(new File(db.getWorkTree(), "file2").exists());
assertTrue(new File(db.getWorkTree(), "file3").exists());
RebaseResult res = git.rebase().setUpstream("refs/heads/file2").call();
assertEquals(Status.OK, res.getStatus());
- assertTrue(new File(db.getWorkTree(), "file1").exists());
+ assertTrue(new File(db.getWorkTree(), FILE1).exists());
assertTrue(new File(db.getWorkTree(), "file2").exists());
assertTrue(new File(db.getWorkTree(), "file3").exists());
db.resolve(Constants.HEAD)).getParent(0));
checkoutBranch("refs/heads/file2");
- assertTrue(new File(db.getWorkTree(), "file1").exists());
+ assertTrue(new File(db.getWorkTree(), FILE1).exists());
assertTrue(new File(db.getWorkTree(), "file2").exists());
assertFalse(new File(db.getWorkTree(), "file3").exists());
}
- public void testAbortOnConflict() throws Exception {
- Git git = new Git(db);
-
+ public void testStopOnConflict() throws Exception {
// create file1 on master
- File theFile = writeTrashFile("file1", "1\n2\n3\n");
- git.add().addFilepattern("file1").call();
- RevCommit firstInMaster = git.commit().setMessage("Add file1").call();
- assertTrue(new File(db.getWorkTree(), "file1").exists());
- // change first line in master and commit
- writeTrashFile("file1", "1master\n2\n3\n");
- checkFile(theFile, "1master\n2\n3\n");
- git.add().addFilepattern("file1").call();
- git.commit().setMessage("change file1 in master").call();
-
+ RevCommit firstInMaster = writeFileAndCommit(FILE1, "Add file1", "1",
+ "2", "3");
+ // change first line in master
+ writeFileAndCommit(FILE1, "change file1 in master", "1master", "2", "3");
+ checkFile(FILE1, "1master", "2", "3");
// create a topic branch based on second commit
createBranch(firstInMaster, "refs/heads/topic");
checkoutBranch("refs/heads/topic");
// we have the old content again
- checkFile(theFile, "1\n2\n3\n");
+ checkFile(FILE1, "1", "2", "3");
- assertTrue(new File(db.getWorkTree(), "file1").exists());
// add a line (non-conflicting)
- writeTrashFile("file1", "1\n2\n3\ntopic4\n");
- git.add().addFilepattern("file1").call();
- git.commit().setMessage("add a line to file1 in topic").call();
+ writeFileAndCommit(FILE1, "add a line to file1 in topic", "1", "2",
+ "3", "topic4");
// change first line (conflicting)
- writeTrashFile("file1", "1topic\n2\n3\ntopic4\n");
- git.add().addFilepattern("file1").call();
- RevCommit conflicting = git.commit()
- .setMessage("change file1 in topic").call();
+ RevCommit conflicting = writeFileAndCommit(FILE1,
+ "change file1 in topic", "1topic", "2", "3", "topic4");
- // change second line (not conflicting)
- writeTrashFile("file1", "1topic\n2topic\n3\ntopic4\n");
- git.add().addFilepattern("file1").call();
- RevCommit lastTopicCommit = git.commit().setMessage(
- "change file1 in topic again").call();
+ RevCommit lastTopicCommit = writeFileAndCommit(FILE1,
+ "change file1 in topic again", "1topic", "2", "3", "topic4");
RebaseResult res = git.rebase().setUpstream("refs/heads/master").call();
assertEquals(Status.STOPPED, res.getStatus());
assertEquals(conflicting, res.getCurrentCommit());
- checkFile(theFile,
- "<<<<<<< OURS\n1master\n=======\n1topic\n>>>>>>> THEIRS\n2\n3\ntopic4\n");
+ checkFile(FILE1,
+ "<<<<<<< OURS\n1master\n=======\n1topic\n>>>>>>> THEIRS\n2\n3\ntopic4");
assertEquals(RepositoryState.REBASING_INTERACTIVE, db
.getRepositoryState());
res = git.rebase().setOperation(Operation.ABORT).call();
assertEquals(res.getStatus(), Status.ABORTED);
assertEquals("refs/heads/topic", db.getFullBranch());
- checkFile(theFile, "1topic\n2topic\n3\ntopic4\n");
+ checkFile(FILE1, "1topic", "2", "3", "topic4");
RevWalk rw = new RevWalk(db);
assertEquals(lastTopicCommit, rw
.parseCommit(db.resolve(Constants.HEAD)));
assertFalse(new File(db.getDirectory(), "rebase-merge").exists());
}
- public void testAbortOnConflictFileCreationAndDeletion() throws Exception {
- Git git = new Git(db);
+ public void testStopOnConflictAndContinue() throws Exception {
+ // create file1 on master
+ RevCommit firstInMaster = writeFileAndCommit(FILE1, "Add file1", "1",
+ "2", "3");
+ // change in master
+ writeFileAndCommit(FILE1, "change file1 in master", "1master", "2", "3");
+
+ checkFile(FILE1, "1master", "2", "3");
+ // create a topic branch based on the first commit
+ createBranch(firstInMaster, "refs/heads/topic");
+ checkoutBranch("refs/heads/topic");
+ // we have the old content again
+ checkFile(FILE1, "1", "2", "3");
+
+ // add a line (non-conflicting)
+ writeFileAndCommit(FILE1, "add a line to file1 in topic", "1", "2",
+ "3", "4topic");
+
+ // change first line (conflicting)
+ writeFileAndCommit(FILE1,
+ "change file1 in topic\n\nThis is conflicting", "1topic", "2",
+ "3", "4topic");
+
+ // change second line (not conflicting)
+ writeFileAndCommit(FILE1, "change file1 in topic again", "1topic",
+ "2topic", "3", "4topic");
+
+ RebaseResult res = git.rebase().setUpstream("refs/heads/master").call();
+ assertEquals(Status.STOPPED, res.getStatus());
+
+ // continue should throw a meaningful exception
+ try {
+ res = git.rebase().setOperation(Operation.CONTINUE).call();
+ fail("Expected Exception not thrown");
+ } catch (UnmergedPathsException e) {
+ // expected
+ }
+
+ // merge the file; the second topic commit should go through
+ writeFileAndAdd(FILE1, "1topic", "2", "3", "4topic");
+
+ res = git.rebase().setOperation(Operation.CONTINUE).call();
+ assertNotNull(res);
+ assertEquals(Status.OK, res.getStatus());
+ assertEquals(RepositoryState.SAFE, db.getRepositoryState());
+
+ ObjectId headId = db.resolve(Constants.HEAD);
+ RevWalk rw = new RevWalk(db);
+ RevCommit rc = rw.parseCommit(headId);
+ RevCommit parent = rw.parseCommit(rc.getParent(0));
+ assertEquals("change file1 in topic\n\nThis is conflicting", parent
+ .getFullMessage());
+ }
+
+ public void testStopOnConflictAndFailContinueIfFileIsDirty()
+ throws Exception {
+ // create file1 on master
+ RevCommit firstInMaster = writeFileAndCommit(FILE1, "Add file1", "1",
+ "2", "3");
+ // change in master
+ writeFileAndCommit(FILE1, "change file1 in master", "1master", "2", "3");
+
+ checkFile(FILE1, "1master", "2", "3");
+ // create a topic branch based on the first commit
+ createBranch(firstInMaster, "refs/heads/topic");
+ checkoutBranch("refs/heads/topic");
+ // we have the old content again
+ checkFile(FILE1, "1", "2", "3");
+
+ // add a line (non-conflicting)
+ writeFileAndCommit(FILE1, "add a line to file1 in topic", "1", "2",
+ "3", "4topic");
+
+ // change first line (conflicting)
+ writeFileAndCommit(FILE1,
+ "change file1 in topic\n\nThis is conflicting", "1topic", "2",
+ "3", "4topic");
+
+ // change second line (not conflicting)
+ writeFileAndCommit(FILE1, "change file1 in topic again", "1topic",
+ "2topic", "3", "4topic");
+
+ RebaseResult res = git.rebase().setUpstream("refs/heads/master").call();
+ assertEquals(Status.STOPPED, res.getStatus());
+
+ git.add().addFilepattern(FILE1).call();
+ File trashFile = writeTrashFile(FILE1, "Some local change");
+
+ res = git.rebase().setOperation(Operation.CONTINUE).call();
+ assertNotNull(res);
+ assertEquals(Status.STOPPED, res.getStatus());
+ checkFile(trashFile, "Some local change");
+ }
+
+ public void testStopOnLastConflictAndContinue() throws Exception {
+ // create file1 on master
+ RevCommit firstInMaster = writeFileAndCommit(FILE1, "Add file1", "1",
+ "2", "3");
+ // change in master
+ writeFileAndCommit(FILE1, "change file1 in master", "1master", "2", "3");
+
+ checkFile(FILE1, "1master", "2", "3");
+ // create a topic branch based on the first commit
+ createBranch(firstInMaster, "refs/heads/topic");
+ checkoutBranch("refs/heads/topic");
+ // we have the old content again
+ checkFile(FILE1, "1", "2", "3");
+
+ // add a line (non-conflicting)
+ writeFileAndCommit(FILE1, "add a line to file1 in topic", "1", "2",
+ "3", "4topic");
+
+ // change first line (conflicting)
+ writeFileAndCommit(FILE1,
+ "change file1 in topic\n\nThis is conflicting", "1topic", "2",
+ "3", "4topic");
+
+ RebaseResult res = git.rebase().setUpstream("refs/heads/master").call();
+ assertEquals(Status.STOPPED, res.getStatus());
+
+ // merge the file; the second topic commit should go through
+ writeFileAndAdd(FILE1, "1topic", "2", "3", "4topic");
+
+ res = git.rebase().setOperation(Operation.CONTINUE).call();
+ assertNotNull(res);
+ assertEquals(Status.OK, res.getStatus());
+ assertEquals(RepositoryState.SAFE, db.getRepositoryState());
+ }
+
+ public void testStopOnLastConflictAndSkip() throws Exception {
+ // create file1 on master
+ RevCommit firstInMaster = writeFileAndCommit(FILE1, "Add file1", "1",
+ "2", "3");
+ // change in master
+ writeFileAndCommit(FILE1, "change file1 in master", "1master", "2", "3");
+
+ checkFile(FILE1, "1master", "2", "3");
+ // create a topic branch based on the first commit
+ createBranch(firstInMaster, "refs/heads/topic");
+ checkoutBranch("refs/heads/topic");
+ // we have the old content again
+ checkFile(FILE1, "1", "2", "3");
+
+ // add a line (non-conflicting)
+ writeFileAndCommit(FILE1, "add a line to file1 in topic", "1", "2",
+ "3", "4topic");
+
+ // change first line (conflicting)
+ writeFileAndCommit(FILE1,
+ "change file1 in topic\n\nThis is conflicting", "1topic", "2",
+ "3", "4topic");
+
+ RebaseResult res = git.rebase().setUpstream("refs/heads/master").call();
+ assertEquals(Status.STOPPED, res.getStatus());
+
+ // merge the file; the second topic commit should go through
+ writeFileAndAdd(FILE1, "1topic", "2", "3", "4topic");
+
+ res = git.rebase().setOperation(Operation.SKIP).call();
+ assertNotNull(res);
+ assertEquals(Status.OK, res.getStatus());
+ assertEquals(RepositoryState.SAFE, db.getRepositoryState());
+ }
+
+ public void testStopOnConflictAndSkipNoConflict() throws Exception {
+ // create file1 on master
+ RevCommit firstInMaster = writeFileAndCommit(FILE1, "Add file1", "1",
+ "2", "3");
+ // change in master
+ writeFileAndCommit(FILE1, "change file1 in master", "1master", "2", "3");
+
+ checkFile(FILE1, "1master", "2", "3");
+ // create a topic branch based on the first commit
+ createBranch(firstInMaster, "refs/heads/topic");
+ checkoutBranch("refs/heads/topic");
+ // we have the old content again
+ checkFile(FILE1, "1", "2", "3");
+
+ // add a line (non-conflicting)
+ writeFileAndCommit(FILE1, "add a line to file1 in topic", "1", "2",
+ "3", "4topic");
+
+ // change first line (conflicting)
+ writeFileAndCommit(FILE1,
+ "change file1 in topic\n\nThis is conflicting", "1topic", "2",
+ "3", "4topic");
+
+ // change third line (not conflicting)
+ writeFileAndCommit(FILE1, "change file1 in topic again", "1topic", "2",
+ "3topic", "4topic");
+
+ RebaseResult res = git.rebase().setUpstream("refs/heads/master").call();
+ assertEquals(Status.STOPPED, res.getStatus());
+
+ res = git.rebase().setOperation(Operation.SKIP).call();
+
+ checkFile(FILE1, "1master", "2", "3topic", "4topic");
+ assertEquals(Status.OK, res.getStatus());
+ }
+
+ public void testStopOnConflictAndSkipWithConflict() throws Exception {
+ // create file1 on master
+ RevCommit firstInMaster = writeFileAndCommit(FILE1, "Add file1", "1",
+ "2", "3", "4");
+ // change in master
+ writeFileAndCommit(FILE1, "change file1 in master", "1master", "2",
+ "3master", "4");
+
+ checkFile(FILE1, "1master", "2", "3master", "4");
+ // create a topic branch based on the first commit
+ createBranch(firstInMaster, "refs/heads/topic");
+ checkoutBranch("refs/heads/topic");
+ // we have the old content again
+ checkFile(FILE1, "1", "2", "3", "4");
+
+ // add a line (non-conflicting)
+ writeFileAndCommit(FILE1, "add a line to file1 in topic", "1", "2",
+ "3", "4", "5topic");
+
+ // change first line (conflicting)
+ writeFileAndCommit(FILE1,
+ "change file1 in topic\n\nThis is conflicting", "1topic", "2",
+ "3", "4", "5topic");
+
+ // change third line (conflicting)
+ writeFileAndCommit(FILE1, "change file1 in topic again", "1topic", "2",
+ "3topic", "4", "5topic");
+
+ RebaseResult res = git.rebase().setUpstream("refs/heads/master").call();
+ assertEquals(Status.STOPPED, res.getStatus());
+
+ res = git.rebase().setOperation(Operation.SKIP).call();
+ // TODO is this correct? It is what the command line returns
+ checkFile(FILE1,
+ "1master\n2\n<<<<<<< OURS\n3master\n=======\n3topic\n>>>>>>> THEIRS\n4\n5topic");
+ assertEquals(Status.STOPPED, res.getStatus());
+ }
+
+ public void testStopOnConflictCommitAndContinue() throws Exception {
+ // create file1 on master
+ RevCommit firstInMaster = writeFileAndCommit(FILE1, "Add file1", "1",
+ "2", "3");
+ // change in master
+ writeFileAndCommit(FILE1, "change file1 in master", "1master", "2", "3");
+
+ checkFile(FILE1, "1master", "2", "3");
+ // create a topic branch based on the first commit
+ createBranch(firstInMaster, "refs/heads/topic");
+ checkoutBranch("refs/heads/topic");
+ // we have the old content again
+ checkFile(FILE1, "1", "2", "3");
+
+ // add a line (non-conflicting)
+ writeFileAndCommit(FILE1, "add a line to file1 in topic", "1", "2",
+ "3", "4topic");
+
+ // change first line (conflicting)
+ writeFileAndCommit(FILE1,
+ "change file1 in topic\n\nThis is conflicting", "1topic", "2",
+ "3", "4topic");
+
+ // change second line (not conflicting)
+ writeFileAndCommit(FILE1, "change file1 in topic again", "1topic", "2",
+ "3topic", "4topic");
+
+ RebaseResult res = git.rebase().setUpstream("refs/heads/master").call();
+ assertEquals(Status.STOPPED, res.getStatus());
+
+ // continue should throw a meaningful exception
+ try {
+ res = git.rebase().setOperation(Operation.CONTINUE).call();
+ fail("Expected Exception not thrown");
+ } catch (UnmergedPathsException e) {
+ // expected
+ }
+
+ // merge the file; the second topic commit should go through
+ writeFileAndCommit(FILE1, "A different commit message", "1topic", "2",
+ "3", "4topic");
+
+ res = git.rebase().setOperation(Operation.CONTINUE).call();
+ assertNotNull(res);
+ assertEquals(Status.OK, res.getStatus());
+ assertEquals(RepositoryState.SAFE, db.getRepositoryState());
+
+ ObjectId headId = db.resolve(Constants.HEAD);
+ RevWalk rw = new RevWalk(db);
+ RevCommit rc = rw.parseCommit(headId);
+ RevCommit parent = rw.parseCommit(rc.getParent(0));
+ assertEquals("A different commit message", parent.getFullMessage());
+ }
+
+ private RevCommit writeFileAndCommit(String fileName, String commitMessage,
+ String... lines) throws Exception {
+ StringBuilder sb = new StringBuilder();
+ for (String line : lines) {
+ sb.append(line);
+ sb.append('\n');
+ }
+ writeTrashFile(fileName, sb.toString());
+ git.add().addFilepattern(fileName).call();
+ return git.commit().setMessage(commitMessage).call();
+ }
+ private void writeFileAndAdd(String fileName, String... lines)
+ throws Exception {
+ StringBuilder sb = new StringBuilder();
+ for (String line : lines) {
+ sb.append(line);
+ sb.append('\n');
+ }
+ writeTrashFile(fileName, sb.toString());
+ git.add().addFilepattern(fileName).call();
+ }
+
+ private void checkFile(String fileName, String... lines) throws Exception {
+ File file = new File(db.getWorkTree(), fileName);
+ StringBuilder sb = new StringBuilder();
+ for (String line : lines) {
+ sb.append(line);
+ sb.append('\n');
+ }
+ checkFile(file, sb.toString());
+ }
+
+ public void testStopOnConflictFileCreationAndDeletion() throws Exception {
// create file1 on master
- writeTrashFile("file1", "Hello World");
- git.add().addFilepattern("file1").call();
+ writeTrashFile(FILE1, "Hello World");
+ git.add().addFilepattern(FILE1).call();
// create file2 on master
File file2 = writeTrashFile("file2", "Hello World 2");
git.add().addFilepattern("file2").call();
writeTrashFile("folder6/file1", "Hello World folder6");
git.add().addFilepattern("folder6/file1").call();
- git.commit()
- .setMessage(
- "Add file 4 and folder folder6, delete file2 on master")
- .call();
+ git.commit().setMessage(
+ "Add file 4 and folder folder6, delete file2 on master").call();
// create a topic branch based on second commit
createBranch(firstInMaster, "refs/heads/topic");
deleteTrashFile("file5");
git.add().setUpdate(true).addFilepattern("file5").call();
- RevCommit conflicting = git.commit()
- .setMessage("Delete file5, add file folder6 and file7 in topic")
- .call();
+ RevCommit conflicting = git.commit().setMessage(
+ "Delete file5, add file folder6 and file7 in topic").call();
RebaseResult res = git.rebase().setUpstream("refs/heads/master").call();
assertEquals(Status.STOPPED, res.getStatus());
assertEquals(res.getStatus(), Status.ABORTED);
assertEquals("refs/heads/topic", db.getFullBranch());
RevWalk rw = new RevWalk(db);
- assertEquals(conflicting,
- rw.parseCommit(db.resolve(Constants.HEAD)));
+ assertEquals(conflicting, rw.parseCommit(db.resolve(Constants.HEAD)));
assertEquals(RepositoryState.SAFE, db.getRepositoryState());
// rebase- dir in .git must be deleted
}
+ public void testAuthorScriptConverter() throws Exception {
+ // -1 h timezone offset
+ PersonIdent ident = new PersonIdent("Author name", "a.mail@some.com",
+ 123456789123L, -60);
+ String convertedAuthor = git.rebase().toAuthorScript(ident);
+ String[] lines = convertedAuthor.split("\n");
+ assertEquals("GIT_AUTHOR_NAME='Author name'", lines[0]);
+ assertEquals("GIT_AUTHOR_EMAIL='a.mail@some.com'", lines[1]);
+ assertEquals("GIT_AUTHOR_DATE='123456789 -0100'", lines[2]);
+
+ PersonIdent parsedIdent = git.rebase().parseAuthor(
+ convertedAuthor.getBytes("UTF-8"));
+ assertEquals(ident.getName(), parsedIdent.getName());
+ assertEquals(ident.getEmailAddress(), parsedIdent.getEmailAddress());
+ // this is rounded to the last second
+ assertEquals(123456789000L, parsedIdent.getWhen().getTime());
+ assertEquals(ident.getTimeZoneOffset(), parsedIdent.getTimeZoneOffset());
+
+ // + 9.5h timezone offset
+ ident = new PersonIdent("Author name", "a.mail@some.com",
+ 123456789123L, +570);
+ convertedAuthor = git.rebase().toAuthorScript(ident);
+ lines = convertedAuthor.split("\n");
+ assertEquals("GIT_AUTHOR_NAME='Author name'", lines[0]);
+ assertEquals("GIT_AUTHOR_EMAIL='a.mail@some.com'", lines[1]);
+ assertEquals("GIT_AUTHOR_DATE='123456789 +0930'", lines[2]);
+
+ parsedIdent = git.rebase().parseAuthor(
+ convertedAuthor.getBytes("UTF-8"));
+ assertEquals(ident.getName(), parsedIdent.getName());
+ assertEquals(ident.getEmailAddress(), parsedIdent.getEmailAddress());
+ assertEquals(123456789000L, parsedIdent.getWhen().getTime());
+ assertEquals(ident.getTimeZoneOffset(), parsedIdent.getTimeZoneOffset());
+ }
+
+ public void testRepositoryStateChecks() throws Exception {
+ try {
+ git.rebase().setOperation(Operation.ABORT).call();
+ fail("Expected Exception not thrown");
+ } catch (WrongRepositoryStateException e) {
+ // expected
+ }
+ try {
+ git.rebase().setOperation(Operation.SKIP).call();
+ fail("Expected Exception not thrown");
+ } catch (WrongRepositoryStateException e) {
+ // expected
+ }
+ try {
+ git.rebase().setOperation(Operation.CONTINUE).call();
+ fail("Expected Exception not thrown");
+ } catch (WrongRepositoryStateException e) {
+ // expected
+ }
+ }
+
private int countPicks() throws IOException {
int count = 0;
File todoFile = new File(db.getDirectory(),
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
+import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import org.eclipse.jgit.JGitText;
import org.eclipse.jgit.api.RebaseResult.Status;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.api.errors.NoHeadException;
import org.eclipse.jgit.api.errors.RefNotFoundException;
+import org.eclipse.jgit.api.errors.UnmergedPathsException;
import org.eclipse.jgit.api.errors.WrongRepositoryStateException;
import org.eclipse.jgit.diff.DiffFormatter;
+import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.dircache.DirCacheCheckout;
+import org.eclipse.jgit.dircache.DirCacheIterator;
import org.eclipse.jgit.lib.AbbreviatedObjectId;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.NullProgressMonitor;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectReader;
+import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.lib.ProgressMonitor;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.RefUpdate;
import org.eclipse.jgit.lib.RefUpdate.Result;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevWalk;
+import org.eclipse.jgit.treewalk.TreeWalk;
+import org.eclipse.jgit.treewalk.filter.TreeFilter;
import org.eclipse.jgit.util.FileUtils;
import org.eclipse.jgit.util.IO;
import org.eclipse.jgit.util.RawParseUtils;
* >Git documentation about Rebase</a>
*/
public class RebaseCommand extends GitCommand<RebaseResult> {
+ /**
+ * The name of the "rebase-merge" folder
+ */
+ public static final String REBASE_MERGE = "rebase-merge";
+
+ /**
+ * The name of the "stopped-sha" file
+ */
+ public static final String STOPPED_SHA = "stopped-sha";
+
+ private static final String AUTHOR_SCRIPT = "author-script";
+
+ private static final String DONE = "done";
+
+ private static final String GIT_AUTHOR_DATE = "GIT_AUTHOR_DATE";
+
+ private static final String GIT_AUTHOR_EMAIL = "GIT_AUTHOR_EMAIL";
+
+ private static final String GIT_AUTHOR_NAME = "GIT_AUTHOR_NAME";
+
+ private static final String GIT_REBASE_TODO = "git-rebase-todo";
+
+ private static final String HEAD_NAME = "head-name";
+
+ private static final String INTERACTIVE = "interactive";
+
+ private static final String MESSAGE = "message";
+
+ private static final String ONTO = "onto";
+
+ private static final String PATCH = "patch";
+
+ private static final String REBASE_HEAD = "head";
+
/**
* The available operations
*/
protected RebaseCommand(Repository repo) {
super(repo);
walk = new RevWalk(repo);
- rebaseDir = new File(repo.getDirectory(), "rebase-merge");
+ rebaseDir = new File(repo.getDirectory(), REBASE_MERGE);
}
/**
*/
public RebaseResult call() throws NoHeadException, RefNotFoundException,
JGitInternalException, GitAPIException {
+ RevCommit newHead = null;
checkCallable();
checkParameters();
try {
case SKIP:
// fall through
case CONTINUE:
- String upstreamCommitName = readFile(rebaseDir, "onto");
+ String upstreamCommitName = readFile(rebaseDir, ONTO);
this.upstreamCommit = walk.parseCommit(repo
.resolve(upstreamCommitName));
break;
return abort();
if (this.operation == Operation.CONTINUE)
- throw new UnsupportedOperationException(
- "--continue Not yet implemented");
+ newHead = continueRebase();
- if (this.operation == Operation.SKIP)
- throw new UnsupportedOperationException(
- "--skip Not yet implemented");
+ List<Step> steps = loadSteps();
- RevCommit newHead = null;
+ if (this.operation == Operation.SKIP && !steps.isEmpty())
+ checkoutCurrentHead();
- List<Step> steps = loadSteps();
ObjectReader or = repo.newObjectReader();
int stepsToPop = 0;
}
stepsToPop++;
}
- if (newHead != null) {
+ if (newHead != null || steps.isEmpty()) {
// point the previous head (if any) to the new commit
- String headName = readFile(rebaseDir, "head-name");
+ String headName = readFile(rebaseDir, HEAD_NAME);
if (headName.startsWith(Constants.R_REFS)) {
RefUpdate rup = repo.updateRef(headName);
- rup.setNewObjectId(newHead);
- rup.forceUpdate();
+ if (newHead != null) {
+ rup.setNewObjectId(newHead);
+ rup.forceUpdate();
+ }
rup = repo.updateRef(Constants.HEAD);
rup.link(headName);
}
+ if (this.operation == Operation.SKIP && steps.isEmpty()) {
+ checkoutCurrentHead();
+ }
FileUtils.delete(rebaseDir, FileUtils.RECURSIVE);
return new RebaseResult(Status.OK);
}
}
}
+ private void checkoutCurrentHead() throws IOException, NoHeadException,
+ JGitInternalException {
+ ObjectId headTree = repo.resolve(Constants.HEAD + "^{tree}");
+ if (headTree == null)
+ throw new NoHeadException(
+ JGitText.get().cannotRebaseWithoutCurrentHead);
+ DirCache dc = repo.lockDirCache();
+ try {
+ DirCacheCheckout dco = new DirCacheCheckout(repo, dc, headTree);
+ dco.setFailOnConflict(false);
+ boolean needsDeleteFiles = dco.checkout();
+ if (needsDeleteFiles) {
+ List<String> fileList = dco.getToBeDeleted();
+ for (String filePath : fileList) {
+ File fileToDelete = new File(repo.getWorkTree(), filePath);
+ if (fileToDelete.exists())
+ FileUtils.delete(fileToDelete, FileUtils.RECURSIVE
+ | FileUtils.RETRY);
+ }
+ }
+ } finally {
+ dc.unlock();
+ }
+ }
+
+ /**
+ * @return the commit if we had to do a commit, otherwise null
+ * @throws GitAPIException
+ * @throws IOException
+ */
+ private RevCommit continueRebase() throws GitAPIException, IOException {
+ // if there are still conflicts, we throw a specific Exception
+ DirCache dc = repo.readDirCache();
+ boolean hasUnmergedPaths = dc.hasUnmergedPaths();
+ if (hasUnmergedPaths)
+ throw new UnmergedPathsException();
+
+ // determine whether we need to commit
+ TreeWalk treeWalk = new TreeWalk(repo);
+ treeWalk.reset();
+ treeWalk.setRecursive(true);
+ treeWalk.addTree(new DirCacheIterator(dc));
+ ObjectId id = repo.resolve(Constants.HEAD + "^{tree}");
+ if (id == null)
+ throw new NoHeadException(
+ JGitText.get().cannotRebaseWithoutCurrentHead);
+
+ treeWalk.addTree(id);
+
+ treeWalk.setFilter(TreeFilter.ANY_DIFF);
+
+ boolean needsCommit = treeWalk.next();
+ treeWalk.release();
+
+ if (needsCommit) {
+ CommitCommand commit = new Git(repo).commit();
+ commit.setMessage(readFile(rebaseDir, MESSAGE));
+ commit.setAuthor(parseAuthor());
+ return commit.call();
+ }
+ return null;
+ }
+
+ private PersonIdent parseAuthor() throws IOException {
+ File authorScriptFile = new File(rebaseDir, AUTHOR_SCRIPT);
+ byte[] raw;
+ try {
+ raw = IO.readFully(authorScriptFile);
+ } catch (FileNotFoundException notFound) {
+ return null;
+ }
+ return parseAuthor(raw);
+ }
+
private RebaseResult stop(RevCommit commitToPick) throws IOException {
- StringBuilder sb = new StringBuilder(100);
- sb.append("GIT_AUTHOR_NAME='");
- sb.append(commitToPick.getAuthorIdent().getName());
- sb.append("'\n");
- sb.append("GIT_AUTHOR_EMAIL='");
- sb.append(commitToPick.getAuthorIdent().getEmailAddress());
- sb.append("'\n");
- sb.append("GIT_AUTHOR_DATE='");
- sb.append(commitToPick.getAuthorIdent().getWhen());
- sb.append("'\n");
- createFile(rebaseDir, "author-script", sb.toString());
- createFile(rebaseDir, "message", commitToPick.getShortMessage());
+ PersonIdent author = commitToPick.getAuthorIdent();
+ String authorScript = toAuthorScript(author);
+ createFile(rebaseDir, AUTHOR_SCRIPT, authorScript);
+ createFile(rebaseDir, MESSAGE, commitToPick.getFullMessage());
ByteArrayOutputStream bos = new ByteArrayOutputStream();
DiffFormatter df = new DiffFormatter(bos);
df.setRepository(repo);
df.format(commitToPick.getParent(0), commitToPick);
- createFile(rebaseDir, "patch", new String(bos.toByteArray(), "UTF-8"));
- createFile(rebaseDir, "stopped-sha", repo.newObjectReader().abbreviate(
+ createFile(rebaseDir, PATCH, new String(bos.toByteArray(),
+ Constants.CHARACTER_ENCODING));
+ createFile(rebaseDir, STOPPED_SHA, repo.newObjectReader().abbreviate(
commitToPick).name());
return new RebaseResult(commitToPick);
}
+ String toAuthorScript(PersonIdent author) {
+ StringBuilder sb = new StringBuilder(100);
+ sb.append(GIT_AUTHOR_NAME);
+ sb.append("='");
+ sb.append(author.getName());
+ sb.append("'\n");
+ sb.append(GIT_AUTHOR_EMAIL);
+ sb.append("='");
+ sb.append(author.getEmailAddress());
+ sb.append("'\n");
+ // the command line uses the "external String"
+ // representation for date and timezone
+ sb.append(GIT_AUTHOR_DATE);
+ sb.append("='");
+ String externalString = author.toExternalString();
+ sb
+ .append(externalString.substring(externalString
+ .lastIndexOf('>') + 2));
+ sb.append("'\n");
+ return sb.toString();
+ }
+
/**
* Removes the number of lines given in the parameter from the
* <code>git-rebase-todo</code> file but preserves comments and other lines
return;
List<String> todoLines = new ArrayList<String>();
List<String> poppedLines = new ArrayList<String>();
- File todoFile = new File(rebaseDir, "git-rebase-todo");
- File doneFile = new File(rebaseDir, "done");
+ File todoFile = new File(rebaseDir, GIT_REBASE_TODO);
+ File doneFile = new File(rebaseDir, DONE);
BufferedReader br = new BufferedReader(new InputStreamReader(
- new FileInputStream(todoFile), "UTF-8"));
+ new FileInputStream(todoFile), Constants.CHARACTER_ENCODING));
try {
// check if the line starts with a action tag (pick, skip...)
while (poppedLines.size() < numSteps) {
}
BufferedWriter todoWriter = new BufferedWriter(new OutputStreamWriter(
- new FileOutputStream(todoFile), "UTF-8"));
+ new FileOutputStream(todoFile), Constants.CHARACTER_ENCODING));
try {
for (String writeLine : todoLines) {
todoWriter.write(writeLine);
// append here
BufferedWriter doneWriter = new BufferedWriter(
new OutputStreamWriter(
- new FileOutputStream(doneFile, true), "UTF-8"));
+ new FileOutputStream(doneFile, true),
+ Constants.CHARACTER_ENCODING));
try {
for (String writeLine : poppedLines) {
doneWriter.write(writeLine);
// create the folder for the meta information
rebaseDir.mkdir();
- createFile(repo.getDirectory(), "ORIG_HEAD", headId.name());
- createFile(rebaseDir, "head", headId.name());
- createFile(rebaseDir, "head-name", headName);
- createFile(rebaseDir, "onto", upstreamCommit.name());
- createFile(rebaseDir, "interactive", "");
+ createFile(repo.getDirectory(), Constants.ORIG_HEAD, headId.name());
+ createFile(rebaseDir, REBASE_HEAD, headId.name());
+ createFile(rebaseDir, HEAD_NAME, headName);
+ createFile(rebaseDir, ONTO, upstreamCommit.name());
+ createFile(rebaseDir, INTERACTIVE, "");
BufferedWriter fw = new BufferedWriter(new OutputStreamWriter(
- new FileOutputStream(new File(rebaseDir, "git-rebase-todo")),
- "UTF-8"));
+ new FileOutputStream(new File(rebaseDir, GIT_REBASE_TODO)),
+ Constants.CHARACTER_ENCODING));
fw.write("# Created by EGit: rebasing " + upstreamCommit.name()
+ " onto " + headId.name());
fw.newLine();
if (this.operation != Operation.BEGIN) {
// these operations are only possible while in a rebasing state
switch (repo.getRepositoryState()) {
- case REBASING:
- // fall through
case REBASING_INTERACTIVE:
- // fall through
- case REBASING_MERGE:
- // fall through
- case REBASING_REBASING:
break;
default:
throw new WrongRepositoryStateException(MessageFormat.format(
File file = new File(parentDir, name);
FileOutputStream fos = new FileOutputStream(file);
try {
- fos.write(content.getBytes("UTF-8"));
+ fos.write(content.getBytes(Constants.CHARACTER_ENCODING));
fos.write('\n');
} finally {
fos.close();
private RebaseResult abort() throws IOException {
try {
- String commitId = readFile(repo.getDirectory(), "ORIG_HEAD");
+ String commitId = readFile(repo.getDirectory(), Constants.ORIG_HEAD);
monitor.beginTask(MessageFormat.format(
JGitText.get().abortingRebase, commitId),
ProgressMonitor.UNKNOWN);
monitor.endTask();
}
try {
- String headName = readFile(rebaseDir, "head-name");
+ String headName = readFile(rebaseDir, HEAD_NAME);
if (headName.startsWith(Constants.R_REFS)) {
monitor.beginTask(MessageFormat.format(
JGitText.get().resettingHead, headName),
}
private List<Step> loadSteps() throws IOException {
- byte[] buf = IO.readFully(new File(rebaseDir, "git-rebase-todo"));
+ byte[] buf = IO.readFully(new File(rebaseDir, GIT_REBASE_TODO));
int ptr = 0;
int tokenBegin = 0;
ArrayList<Step> r = new ArrayList<Step>();
this.action = action;
}
}
+
+ PersonIdent parseAuthor(byte[] raw) {
+ if (raw.length == 0)
+ return null;
+
+ Map<String, String> keyValueMap = new HashMap<String, String>();
+ for (int p = 0; p < raw.length;) {
+ int end = RawParseUtils.nextLF(raw, p);
+ if (end == p)
+ break;
+ int equalsIndex = RawParseUtils.next(raw, p, '=');
+ if (equalsIndex == end)
+ break;
+ String key = RawParseUtils.decode(raw, p, equalsIndex - 1);
+ String value = RawParseUtils.decode(raw, equalsIndex + 1, end - 2);
+ p = end;
+ keyValueMap.put(key, value);
+ }
+
+ String name = keyValueMap.get(GIT_AUTHOR_NAME);
+ String email = keyValueMap.get(GIT_AUTHOR_EMAIL);
+ String time = keyValueMap.get(GIT_AUTHOR_DATE);
+
+ // the time is saved as <seconds since 1970> <timezone offset>
+ long when = Long.parseLong(time.substring(0, time.indexOf(' '))) * 1000;
+ String tzOffsetString = time.substring(time.indexOf(' ') + 1);
+ int multiplier = -1;
+ if (tzOffsetString.charAt(0) == '+')
+ multiplier = 1;
+ int hours = Integer.parseInt(tzOffsetString.substring(1, 3));
+ int minutes = Integer.parseInt(tzOffsetString.substring(3, 5));
+ // this is in format (+/-)HHMM (hours and minutes)
+ // we need to convert into minutes
+ int tz = (hours * 60 + minutes) * multiplier;
+ if (name != null && email != null)
+ return new PersonIdent(name, email, when, tz);
+ return null;
+ }
}
projects / jgit.git / commitdiff