import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import java.io.File;
import java.io.IOException;
import java.util.Iterator;
import org.eclipse.jgit.api.CherryPickResult.CherryPickStatus;
+import org.eclipse.jgit.api.ResetCommand.ResetType;
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.RepositoryState;
import org.eclipse.jgit.lib.RepositoryTestCase;
import org.eclipse.jgit.merge.ResolveMerger.MergeFailureReason;
MergeFailureReason.DIRTY_WORKTREE);
}
+ @Test
+ public void testCherryPickConflictResolution() throws Exception {
+ Git git = new Git(db);
+ RevCommit sideCommit = prepareCherryPick(git);
+
+ CherryPickResult result = git.cherryPick().include(sideCommit.getId())
+ .call();
+
+ assertEquals(CherryPickStatus.CONFLICTING, result.getStatus());
+ assertTrue(new File(db.getDirectory(), Constants.MERGE_MSG).exists());
+ assertEquals("side\n\nConflicts:\n\ta\n", db.readMergeCommitMsg());
+ assertTrue(new File(db.getDirectory(), Constants.CHERRY_PICK_HEAD)
+ .exists());
+ assertEquals(sideCommit.getId(), db.readCherryPickHead());
+ assertEquals(RepositoryState.CHERRY_PICKING, db.getRepositoryState());
+
+ // Resolve
+ writeTrashFile("a", "a");
+ git.add().addFilepattern("a").call();
+
+ assertEquals(RepositoryState.CHERRY_PICKING_RESOLVED,
+ db.getRepositoryState());
+
+ git.commit().setOnly("a").setMessage("resolve").call();
+
+ assertEquals(RepositoryState.SAFE, db.getRepositoryState());
+ }
+
+ @Test
+ public void testCherryPickConflictReset() throws Exception {
+ Git git = new Git(db);
+
+ RevCommit sideCommit = prepareCherryPick(git);
+
+ CherryPickResult result = git.cherryPick().include(sideCommit.getId())
+ .call();
+
+ assertEquals(CherryPickStatus.CONFLICTING, result.getStatus());
+ assertEquals(RepositoryState.CHERRY_PICKING, db.getRepositoryState());
+ assertTrue(new File(db.getDirectory(), Constants.CHERRY_PICK_HEAD)
+ .exists());
+
+ git.reset().setMode(ResetType.MIXED).setRef("HEAD").call();
+
+ assertEquals(RepositoryState.SAFE, db.getRepositoryState());
+ assertFalse(new File(db.getDirectory(), Constants.CHERRY_PICK_HEAD)
+ .exists());
+ }
+
private RevCommit prepareCherryPick(final Git git) throws Exception {
// create, add and commit file a
writeTrashFile("a", "a");
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.Ref.Storage;
import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.merge.MergeMessageFormatter;
import org.eclipse.jgit.merge.MergeStrategy;
import org.eclipse.jgit.merge.ResolveMerger;
import org.eclipse.jgit.revwalk.RevCommit;
if (merger.failed())
return new CherryPickResult(merger.getFailingPaths());
- // merge conflicts
+ // there are merge conflicts
+
+ String message = new MergeMessageFormatter()
+ .formatWithConflicts(srcCommit.getFullMessage(),
+ merger.getUnmergedPaths());
+
+ repo.writeCherryPickHead(srcCommit.getId());
+ repo.writeMergeCommitMsg(message);
+
return CherryPickResult.CONFLICT;
}
}
// used for merge commits
repo.writeMergeCommitMsg(null);
repo.writeMergeHeads(null);
+ } else if (state == RepositoryState.CHERRY_PICKING_RESOLVED) {
+ repo.writeMergeCommitMsg(null);
+ repo.writeCherryPickHead(null);
}
return revCommit;
}
Constants.CHARACTER_ENCODING));
createFile(rebaseDir, STOPPED_SHA, repo.newObjectReader().abbreviate(
commitToPick).name());
+ // Remove cherry pick state file created by CherryPickCommand, it's not
+ // needed for rebase
+ repo.writeCherryPickHead(null);
return new RebaseResult(commitToPick);
}
}
// cleanup the files
FileUtils.delete(rebaseDir, FileUtils.RECURSIVE);
+ repo.writeCherryPickHead(null);
return result;
} finally {
RevCommit commit;
try {
- boolean merging = false;
- if (repo.getRepositoryState().equals(RepositoryState.MERGING)
- || repo.getRepositoryState().equals(
- RepositoryState.MERGING_RESOLVED))
- merging = true;
+ RepositoryState state = repo.getRepositoryState();
+ final boolean merging = state.equals(RepositoryState.MERGING)
+ || state.equals(RepositoryState.MERGING_RESOLVED);
+ final boolean cherryPicking = state
+ .equals(RepositoryState.CHERRY_PICKING)
+ || state.equals(RepositoryState.CHERRY_PICKING_RESOLVED);
// resolve the ref to a commit
final ObjectId commitId;
}
- if (mode != ResetType.SOFT && merging)
- resetMerge();
+ if (mode != ResetType.SOFT) {
+ if (merging)
+ resetMerge();
+ else if (cherryPicking)
+ resetCherryPick();
+ }
setCallable(false);
r = ru.getRef();
repo.writeMergeCommitMsg(null);
}
+ private void resetCherryPick() throws IOException {
+ repo.writeCherryPickHead(null);
+ repo.writeMergeCommitMsg(null);
+ }
+
}
/** name of the file containing the IDs of the parents of a merge commit */
public static final String MERGE_HEAD = "MERGE_HEAD";
+ /** name of the file containing the ID of a cherry pick commit in case of conflicts */
+ public static final String CHERRY_PICK_HEAD = "CHERRY_PICK_HEAD";
+
/**
* name of the ref ORIG_HEAD used by certain commands to store the original
* value of HEAD
return RepositoryState.REBASING_MERGE;
// Both versions
- if (new File(getDirectory(), "MERGE_HEAD").exists()) {
+ if (new File(getDirectory(), Constants.MERGE_HEAD).exists()) {
// we are merging - now check whether we have unmerged paths
try {
if (!readDirCache().hasUnmergedPaths()) {
if (new File(getDirectory(), "BISECT_LOG").exists())
return RepositoryState.BISECTING;
+ if (new File(getDirectory(), Constants.CHERRY_PICK_HEAD).exists()) {
+ try {
+ if (!readDirCache().hasUnmergedPaths()) {
+ // no unmerged paths
+ return RepositoryState.CHERRY_PICKING_RESOLVED;
+ }
+ } catch (IOException e) {
+ // fall through to CHERRY_PICKING
+ e.printStackTrace();
+ }
+
+ return RepositoryState.CHERRY_PICKING;
+ }
+
return RepositoryState.SAFE;
}
FileUtils.delete(mergeHeadFile);
}
}
+
+ /**
+ * Return the information stored in the file $GIT_DIR/CHERRY_PICK_HEAD.
+ *
+ * @return object id from CHERRY_PICK_HEAD file or {@code null} if this file
+ * doesn't exist. Also if the file exists but is empty {@code null}
+ * will be returned
+ * @throws IOException
+ * @throws NoWorkTreeException
+ * if this is bare, which implies it has no working directory.
+ * See {@link #isBare()}.
+ */
+ public ObjectId readCherryPickHead() throws IOException,
+ NoWorkTreeException {
+ if (isBare() || getDirectory() == null)
+ throw new NoWorkTreeException();
+
+ File mergeHeadFile = new File(getDirectory(),
+ Constants.CHERRY_PICK_HEAD);
+ byte[] raw;
+ try {
+ raw = IO.readFully(mergeHeadFile);
+ } catch (FileNotFoundException notFound) {
+ return null;
+ }
+
+ if (raw.length == 0)
+ return null;
+
+ return ObjectId.fromString(raw, 0);
+ }
+
+ /**
+ * Write cherry pick commit into $GIT_DIR/CHERRY_PICK_HEAD. This is used in
+ * case of conflicts to store the cherry which was tried to be picked.
+ *
+ * @param head
+ * an object id of the cherry commit or <code>null</code> to
+ * delete the file
+ * @throws IOException
+ */
+ public void writeCherryPickHead(ObjectId head) throws IOException {
+ File cherryPickHeadFile = new File(gitDir, Constants.CHERRY_PICK_HEAD);
+ if (head != null) {
+ BufferedOutputStream bos = new BufferedOutputStream(
+ new FileOutputStream(cherryPickHeadFile));
+ try {
+ head.copyTo(bos);
+ bos.write('\n');
+ } finally {
+ bos.close();
+ }
+ } else {
+ FileUtils.delete(cherryPickHeadFile, FileUtils.SKIP_MISSING);
+ }
+ }
}
public String getDescription() { return JGitText.get().repositoryState_merged; }
},
+ /** An unfinished cherry-pick. Must resolve or reset before continuing normally
+ */
+ CHERRY_PICKING {
+ public boolean canCheckout() { return false; }
+ public boolean canResetHead() { return true; }
+ public boolean canCommit() { return false; }
+ public String getDescription() { return JGitText.get().repositoryState_conflicts; }
+ },
+
+ /**
+ * A cherry-pick where all conflicts have been resolved. The index does not
+ * contain any unmerged paths.
+ */
+ CHERRY_PICKING_RESOLVED {
+ public boolean canCheckout() { return true; }
+ public boolean canResetHead() { return true; }
+ public boolean canCommit() { return true; }
+ public String getDescription() { return JGitText.get().repositoryState_merged; }
+ },
+
/**
* An unfinished rebase or am. Must resolve, skip or abort before normal work can take place
*/
return sb.toString();
}
+ /**
+ * Add section with conflicting paths to merge message.
+ *
+ * @param message
+ * the original merge message
+ * @param conflictingPaths
+ * the paths with conflicts
+ * @return merge message with conflicting paths added
+ */
+ public String formatWithConflicts(String message,
+ List<String> conflictingPaths) {
+ StringBuilder sb = new StringBuilder(message);
+ if (!message.endsWith("\n"))
+ sb.append("\n");
+ sb.append("\n");
+ sb.append("Conflicts:\n");
+ for (String conflictingPath : conflictingPaths)
+ sb.append('\t').append(conflictingPath).append('\n');
+ return sb.toString();
+ }
+
private static String joinNames(List<String> names, String singular,
String plural) {
if (names.size() == 1)
/** The names of the additional refs supported by this class */
private static final String[] additionalRefsNames = new String[] {
- Constants.MERGE_HEAD, Constants.FETCH_HEAD, Constants.ORIG_HEAD };
+ Constants.MERGE_HEAD, Constants.FETCH_HEAD, Constants.ORIG_HEAD,
+ Constants.CHERRY_PICK_HEAD };
private final FileRepository parent;
projects / jgit.git / commitdiff