Browse Source

Implement recursive merge strategy

Extend ResolveMerger with RecursiveMerger to merge two tips
that have up to 200 bases.

Bug: 380314
CQ: 6854
Change-Id: I6292bb7bda55c0242a448a94956f2d6a94fddbaa
Also-by: Christian Halstrick <christian.halstrick@sap.com>
Signed-off-by: Chris Aniszczyk <zx@twitter.com>
Signed-off-by: Matthias Sohn <matthias.sohn@sap.com>
stable-3.0
George C. Young 12 years ago committed by Matthias Sohn
parent
commit
ab99b78ca0
  1. 2
      README.md
  2. 578
      org.eclipse.jgit.test/tst/org/eclipse/jgit/merge/RecursiveMergerTest.java
  3. 66
      org.eclipse.jgit.test/tst/org/eclipse/jgit/merge/ResolveMergerTest.java
  4. 3
      org.eclipse.jgit/resources/org/eclipse/jgit/internal/JGitText.properties
  5. 124
      org.eclipse.jgit/src/org/eclipse/jgit/errors/NoMergeBaseException.java
  6. 4
      org.eclipse.jgit/src/org/eclipse/jgit/internal/JGitText.java
  7. 18
      org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeStrategy.java
  8. 44
      org.eclipse.jgit/src/org/eclipse/jgit/merge/Merger.java
  9. 274
      org.eclipse.jgit/src/org/eclipse/jgit/merge/RecursiveMerger.java
  10. 212
      org.eclipse.jgit/src/org/eclipse/jgit/merge/ResolveMerger.java
  11. 67
      org.eclipse.jgit/src/org/eclipse/jgit/merge/StrategyRecursive.java
  12. 3
      org.eclipse.jgit/src/org/eclipse/jgit/merge/ThreeWayMerger.java

2
README.md

@ -118,8 +118,6 @@ There are some missing features:
- gitattributes support
- Recursive merge strategy
Support
-------

578
org.eclipse.jgit.test/tst/org/eclipse/jgit/merge/RecursiveMergerTest.java

@ -0,0 +1,578 @@
/*
* Copyright (C) 2012, Christian Halstrick <christian.halstrick@sap.com>
* and other copyright owners as documented in the project's IP log.
*
* This program and the accompanying materials are made available
* under the terms of the Eclipse Distribution License v1.0 which
* accompanies this distribution, is reproduced below, and is
* available at http://www.eclipse.org/org/documents/edl-v10.php
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or
* without modification, are permitted provided that the following
* conditions are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* - Neither the name of the Eclipse Foundation, Inc. nor the
* names of its contributors may be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.eclipse.jgit.merge;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.dircache.DirCacheEditor;
import org.eclipse.jgit.dircache.DirCacheEntry;
import org.eclipse.jgit.errors.MissingObjectException;
import org.eclipse.jgit.errors.NoMergeBaseException;
import org.eclipse.jgit.errors.NoMergeBaseException.MergeBaseFailureReason;
import org.eclipse.jgit.junit.RepositoryTestCase;
import org.eclipse.jgit.junit.TestRepository;
import org.eclipse.jgit.junit.TestRepository.BranchBuilder;
import org.eclipse.jgit.lib.AnyObjectId;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.FileMode;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectLoader;
import org.eclipse.jgit.lib.ObjectReader;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.RevBlob;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.storage.file.FileRepository;
import org.eclipse.jgit.treewalk.FileTreeIterator;
import org.eclipse.jgit.treewalk.TreeWalk;
import org.eclipse.jgit.treewalk.filter.PathFilter;
import org.junit.Before;
import org.junit.experimental.theories.DataPoints;
import org.junit.experimental.theories.Theories;
import org.junit.experimental.theories.Theory;
import org.junit.runner.RunWith;
@RunWith(Theories.class)
public class RecursiveMergerTest extends RepositoryTestCase {
static int counter = 0;
@DataPoints
public static MergeStrategy[] strategiesUnderTest = new MergeStrategy[] {
MergeStrategy.RECURSIVE, MergeStrategy.RESOLVE };
public enum IndexState {
Bare, Missing, SameAsHead, SameAsOther, SameAsWorkTree, DifferentFromHeadAndOtherAndWorktree
}
@DataPoints
public static IndexState[] indexStates = IndexState.values();
public enum WorktreeState {
Bare, Missing, SameAsHead, DifferentFromHeadAndOther, SameAsOther;
}
@DataPoints
public static WorktreeState[] worktreeStates = WorktreeState.values();
private TestRepository<FileRepository> db_t;
@Override
@Before
public void setUp() throws Exception {
super.setUp();
db_t = new TestRepository<FileRepository>(db);
}
@Theory
/**
* Merging m2,s2 from the following topology. In master and side different
* files are touched. No need to do a real content merge.
*
* <pre>
* m0--m1--m2
* \ \/
* \ /\
* s1--s2
* </pre>
*/
public void crissCrossMerge(MergeStrategy strategy, IndexState indexState,
WorktreeState worktreeState) throws Exception {
if (!validateStates(indexState, worktreeState))
return;
// fill the repo
BranchBuilder master = db_t.branch("master");
RevCommit m0 = master.commit().add("m", ",m0").message("m0").create();
RevCommit m1 = master.commit().add("m", "m1").message("m1").create();
db_t.getRevWalk().parseCommit(m1);
BranchBuilder side = db_t.branch("side");
RevCommit s1 = side.commit().parent(m0).add("s", "s1").message("s1")
.create();
RevCommit s2 = side.commit().parent(m1).add("m", "m1")
.message("s2(merge)").create();
RevCommit m2 = master.commit().parent(s1).add("s", "s1")
.message("m2(merge)").create();
Git git = Git.wrap(db);
git.checkout().setName("master").call();
modifyWorktree(worktreeState, "m", "side");
modifyWorktree(worktreeState, "s", "side");
modifyIndex(indexState, "m", "side");
modifyIndex(indexState, "s", "side");
ResolveMerger merger = (ResolveMerger) strategy.newMerger(db,
worktreeState == WorktreeState.Bare);
if (worktreeState != WorktreeState.Bare)
merger.setWorkingTreeIterator(new FileTreeIterator(db));
try {
boolean expectSuccess = true;
if (!(indexState == IndexState.Bare
|| indexState == IndexState.Missing
|| indexState == IndexState.SameAsHead || indexState == IndexState.SameAsOther))
// index is dirty
expectSuccess = false;
assertEquals(Boolean.valueOf(expectSuccess),
Boolean.valueOf(merger.merge(new RevCommit[] { m2, s2 })));
assertEquals(MergeStrategy.RECURSIVE, strategy);
assertEquals("m1",
contentAsString(db, merger.getResultTreeId(), "m"));
assertEquals("s1",
contentAsString(db, merger.getResultTreeId(), "s"));
} catch (NoMergeBaseException e) {
assertEquals(MergeStrategy.RESOLVE, strategy);
assertEquals(e.getReason(),
MergeBaseFailureReason.MULTIPLE_MERGE_BASES_NOT_SUPPORTED);
}
}
@Theory
/**
* Merging m2,s2 from the following topology. The same file is modified
* in both branches. The modifications should be mergeable. m2 and s2
* contain branch specific conflict resolutions. Therefore m2 and don't contain the same content.
*
* <pre>
* m0--m1--m2
* \ \/
* \ /\
* s1--s2
* </pre>
*/
public void crissCrossMerge_mergeable(MergeStrategy strategy,
IndexState indexState, WorktreeState worktreeState)
throws Exception {
if (!validateStates(indexState, worktreeState))
return;
BranchBuilder master = db_t.branch("master");
RevCommit m0 = master.commit().add("f", "1\n2\n3\n4\n5\n6\n7\n8\n9\n")
.message("m0").create();
RevCommit m1 = master.commit()
.add("f", "1-master\n2\n3\n4\n5\n6\n7\n8\n9\n").message("m1")
.create();
db_t.getRevWalk().parseCommit(m1);
BranchBuilder side = db_t.branch("side");
RevCommit s1 = side.commit().parent(m0)
.add("f", "1\n2\n3\n4\n5\n6\n7\n8\n9-side\n").message("s1")
.create();
RevCommit s2 = side.commit().parent(m1)
.add("f", "1-master\n2\n3\n4\n5\n6\n7-res(side)\n8\n9-side\n")
.message("s2(merge)").create();
RevCommit m2 = master
.commit()
.parent(s1)
.add("f", "1-master\n2\n3-res(master)\n4\n5\n6\n7\n8\n9-side\n")
.message("m2(merge)").create();
Git git = Git.wrap(db);
git.checkout().setName("master").call();
modifyWorktree(worktreeState, "f", "side");
modifyIndex(indexState, "f", "side");
ResolveMerger merger = (ResolveMerger) strategy.newMerger(db,
worktreeState == WorktreeState.Bare);
if (worktreeState != WorktreeState.Bare)
merger.setWorkingTreeIterator(new FileTreeIterator(db));
try {
boolean expectSuccess = true;
if (!(indexState == IndexState.Bare
|| indexState == IndexState.Missing || indexState == IndexState.SameAsHead))
// index is dirty
expectSuccess = false;
else if (worktreeState == WorktreeState.DifferentFromHeadAndOther
|| worktreeState == WorktreeState.SameAsOther)
expectSuccess = false;
assertEquals(Boolean.valueOf(expectSuccess),
Boolean.valueOf(merger.merge(new RevCommit[] { m2, s2 })));
assertEquals(MergeStrategy.RECURSIVE, strategy);
if (!expectSuccess)
// if the merge was not successful skip testing the state of index and workingtree
return;
assertEquals(
"1-master\n2\n3-res(master)\n4\n5\n6\n7-res(side)\n8\n9-side",
contentAsString(db, merger.getResultTreeId(), "f"));
if (indexState != IndexState.Bare)
assertEquals(
"[f, mode:100644, content:1-master\n2\n3-res(master)\n4\n5\n6\n7-res(side)\n8\n9-side\n]",
indexState(RepositoryTestCase.CONTENT));
if (worktreeState != WorktreeState.Bare
&& worktreeState != WorktreeState.Missing)
assertEquals(
"1-master\n2\n3-res(master)\n4\n5\n6\n7-res(side)\n8\n9-side\n",
read("f"));
} catch (NoMergeBaseException e) {
assertEquals(MergeStrategy.RESOLVE, strategy);
assertEquals(e.getReason(),
MergeBaseFailureReason.MULTIPLE_MERGE_BASES_NOT_SUPPORTED);
}
}
@Theory
/**
* Merging m2,s2 from the following topology. The same file is modified
* in both branches. The modifications are not automatically
* mergeable. m2 and s2 contain branch specific conflict resolutions.
* Therefore m2 and s2 don't contain the same content.
*
* <pre>
* m0--m1--m2
* \ \/
* \ /\
* s1--s2
* </pre>
*/
public void crissCrossMerge_nonmergeable(MergeStrategy strategy,
IndexState indexState, WorktreeState worktreeState)
throws Exception {
if (!validateStates(indexState, worktreeState))
return;
BranchBuilder master = db_t.branch("master");
RevCommit m0 = master.commit().add("f", "1\n2\n3\n4\n5\n6\n7\n8\n9\n")
.message("m0").create();
RevCommit m1 = master.commit()
.add("f", "1-master\n2\n3\n4\n5\n6\n7\n8\n9\n").message("m1")
.create();
db_t.getRevWalk().parseCommit(m1);
BranchBuilder side = db_t.branch("side");
RevCommit s1 = side.commit().parent(m0)
.add("f", "1\n2\n3\n4\n5\n6\n7\n8\n9-side\n").message("s1")
.create();
RevCommit s2 = side.commit().parent(m1)
.add("f", "1-master\n2\n3\n4\n5\n6\n7-res(side)\n8\n9-side\n")
.message("s2(merge)").create();
RevCommit m2 = master.commit().parent(s1)
.add("f", "1-master\n2\n3\n4\n5\n6\n7-conflict\n8\n9-side\n")
.message("m2(merge)").create();
Git git = Git.wrap(db);
git.checkout().setName("master").call();
modifyWorktree(worktreeState, "f", "side");
modifyIndex(indexState, "f", "side");
ResolveMerger merger = (ResolveMerger) strategy.newMerger(db,
worktreeState == WorktreeState.Bare);
if (worktreeState != WorktreeState.Bare)
merger.setWorkingTreeIterator(new FileTreeIterator(db));
try {
assertFalse(merger.merge(new RevCommit[] { m2, s2 }));
assertEquals(MergeStrategy.RECURSIVE, strategy);
if (indexState == IndexState.SameAsHead
&& worktreeState == WorktreeState.SameAsHead) {
assertEquals(
"[f, mode:100644, stage:1, content:1-master\n2\n3\n4\n5\n6\n7\n8\n9-side\n]"
+ "[f, mode:100644, stage:2, content:1-master\n2\n3\n4\n5\n6\n7-conflict\n8\n9-side\n]"
+ "[f, mode:100644, stage:3, content:1-master\n2\n3\n4\n5\n6\n7-res(side)\n8\n9-side\n]",
indexState(RepositoryTestCase.CONTENT));
assertEquals(
"1-master\n2\n3\n4\n5\n6\n<<<<<<< OURS\n7-conflict\n=======\n7-res(side)\n>>>>>>> THEIRS\n8\n9-side\n",
read("f"));
}
} catch (NoMergeBaseException e) {
assertEquals(MergeStrategy.RESOLVE, strategy);
assertEquals(e.getReason(),
MergeBaseFailureReason.MULTIPLE_MERGE_BASES_NOT_SUPPORTED);
}
}
@Theory
/**
* Merging m2,s2 which have three common predecessors.The same file is modified
* in all branches. The modifications should be mergeable. m2 and s2
* contain branch specific conflict resolutions. Therefore m2 and s2
* don't contain the same content.
*
* <pre>
* m1-----m2
* / \/ /
* / /\ /
* m0--o1 x
* \ \/ \
* \ /\ \
* s1-----s2
* </pre>
*/
public void crissCrossMerge_ThreeCommonPredecessors(MergeStrategy strategy,
IndexState indexState, WorktreeState worktreeState)
throws Exception {
if (!validateStates(indexState, worktreeState))
return;
BranchBuilder master = db_t.branch("master");
RevCommit m0 = master.commit().add("f", "1\n2\n3\n4\n5\n6\n7\n8\n9\n")
.message("m0").create();
RevCommit m1 = master.commit()
.add("f", "1-master\n2\n3\n4\n5\n6\n7\n8\n9\n").message("m1")
.create();
BranchBuilder side = db_t.branch("side");
RevCommit s1 = side.commit().parent(m0)
.add("f", "1\n2\n3\n4\n5\n6\n7\n8\n9-side\n").message("s1")
.create();
BranchBuilder other = db_t.branch("other");
RevCommit o1 = other.commit().parent(m0)
.add("f", "1\n2\n3\n4\n5-other\n6\n7\n8\n9\n").message("o1")
.create();
RevCommit m2 = master
.commit()
.parent(s1)
.parent(o1)
.add("f",
"1-master\n2\n3-res(master)\n4\n5-other\n6\n7\n8\n9-side\n")
.message("m2(merge)").create();
RevCommit s2 = side
.commit()
.parent(m1)
.parent(o1)
.add("f",
"1-master\n2\n3\n4\n5-other\n6\n7-res(side)\n8\n9-side\n")
.message("s2(merge)").create();
Git git = Git.wrap(db);
git.checkout().setName("master").call();
modifyWorktree(worktreeState, "f", "side");
modifyIndex(indexState, "f", "side");
ResolveMerger merger = (ResolveMerger) strategy.newMerger(db,
worktreeState == WorktreeState.Bare);
if (worktreeState != WorktreeState.Bare)
merger.setWorkingTreeIterator(new FileTreeIterator(db));
try {
boolean expectSuccess = true;
if (!(indexState == IndexState.Bare
|| indexState == IndexState.Missing || indexState == IndexState.SameAsHead))
// index is dirty
expectSuccess = false;
else if (worktreeState == WorktreeState.DifferentFromHeadAndOther
|| worktreeState == WorktreeState.SameAsOther)
// workingtree is dirty
expectSuccess = false;
assertEquals(Boolean.valueOf(expectSuccess),
Boolean.valueOf(merger.merge(new RevCommit[] { m2, s2 })));
assertEquals(MergeStrategy.RECURSIVE, strategy);
if (!expectSuccess)
// if the merge was not successful skip testing the state of index and workingtree
return;
assertEquals(
"1-master\n2\n3-res(master)\n4\n5-other\n6\n7-res(side)\n8\n9-side",
contentAsString(db, merger.getResultTreeId(), "f"));
if (indexState != IndexState.Bare)
assertEquals(
"[f, mode:100644, content:1-master\n2\n3-res(master)\n4\n5-other\n6\n7-res(side)\n8\n9-side\n]",
indexState(RepositoryTestCase.CONTENT));
if (worktreeState != WorktreeState.Bare
&& worktreeState != WorktreeState.Missing)
assertEquals(
"1-master\n2\n3-res(master)\n4\n5-other\n6\n7-res(side)\n8\n9-side\n",
read("f"));
} catch (NoMergeBaseException e) {
assertEquals(MergeStrategy.RESOLVE, strategy);
assertEquals(e.getReason(),
MergeBaseFailureReason.MULTIPLE_MERGE_BASES_NOT_SUPPORTED);
}
}
void modifyIndex(IndexState indexState, String path, String other)
throws Exception {
RevBlob blob;
switch (indexState) {
case Missing:
setIndex(null, path);
break;
case SameAsHead:
setIndex(contentId(Constants.HEAD, path), path);
break;
case SameAsOther:
setIndex(contentId(other, path), path);
break;
case SameAsWorkTree:
blob = db_t.blob(read(path));
setIndex(blob, path);
break;
case DifferentFromHeadAndOtherAndWorktree:
blob = db_t.blob(Integer.toString(counter++));
setIndex(blob, path);
break;
case Bare:
File file = new File(db.getDirectory(), "index");
if (!file.exists())
return;
db.close();
file.delete();
db = new FileRepository(db.getDirectory());
db_t = new TestRepository<FileRepository>(db);
break;
}
}
private void setIndex(final ObjectId id, String path)
throws MissingObjectException, IOException {
DirCache lockedDircache;
DirCacheEditor dcedit;
lockedDircache = db.lockDirCache();
dcedit = lockedDircache.editor();
try {
if (id != null) {
final ObjectLoader contLoader = db.newObjectReader().open(id);
dcedit.add(new DirCacheEditor.PathEdit(path) {
@Override
public void apply(DirCacheEntry ent) {
ent.setFileMode(FileMode.REGULAR_FILE);
ent.setLength(contLoader.getSize());
ent.setObjectId(id);
}
});
} else
dcedit.add(new DirCacheEditor.DeletePath(path));
} finally {
dcedit.commit();
}
}
private ObjectId contentId(String revName, String path) throws Exception {
RevCommit headCommit = db_t.getRevWalk().parseCommit(
db.resolve(revName));
db_t.parseBody(headCommit);
return db_t.get(headCommit.getTree(), path).getId();
}
void modifyWorktree(WorktreeState worktreeState, String path, String other)
throws Exception {
FileOutputStream fos = null;
ObjectId bloblId;
try {
switch (worktreeState) {
case Missing:
new File(db.getWorkTree(), path).delete();
break;
case DifferentFromHeadAndOther:
write(new File(db.getWorkTree(), path),
Integer.toString(counter++));
break;
case SameAsHead:
bloblId = contentId(Constants.HEAD, path);
fos = new FileOutputStream(new File(db.getWorkTree(), path));
db.newObjectReader().open(bloblId).copyTo(fos);
break;
case SameAsOther:
bloblId = contentId(other, path);
fos = new FileOutputStream(new File(db.getWorkTree(), path));
db.newObjectReader().open(bloblId).copyTo(fos);
break;
case Bare:
if (db.isBare())
return;
File workTreeFile = db.getWorkTree();
db.getConfig().setBoolean("core", null, "bare", true);
db.getDirectory().renameTo(new File(workTreeFile, "test.git"));
db = new FileRepository(new File(workTreeFile, "test.git"));
db_t = new TestRepository<FileRepository>(db);
}
} finally {
if (fos != null)
fos.close();
}
}
private boolean validateStates(IndexState indexState,
WorktreeState worktreeState) {
if (worktreeState == WorktreeState.Bare
&& indexState != IndexState.Bare)
return false;
if (worktreeState != WorktreeState.Bare
&& indexState == IndexState.Bare)
return false;
if (worktreeState != WorktreeState.DifferentFromHeadAndOther
&& indexState == IndexState.SameAsWorkTree)
// would be a duplicate: the combination WorktreeState.X and
// IndexState.X already covered this
return false;
return true;
}
private String contentAsString(Repository r, ObjectId treeId, String path)
throws MissingObjectException, IOException {
TreeWalk tw = new TreeWalk(r);
tw.addTree(treeId);
tw.setFilter(PathFilter.create(path));
tw.setRecursive(true);
if (!tw.next())
return null;
AnyObjectId blobId = tw.getObjectId(0);
StringBuilder result = new StringBuilder();
BufferedReader br = null;
ObjectReader or = r.newObjectReader();
try {
br = new BufferedReader(new InputStreamReader(or.open(blobId)
.openStream()));
String line;
boolean first = true;
while ((line = br.readLine()) != null) {
if (!first)
result.append('\n');
result.append(line);
first = false;
}
return result.toString();
} finally {
if (br != null)
br.close();
}
}
}

66
org.eclipse.jgit.test/tst/org/eclipse/jgit/merge/ResolveMergerTest.java

@ -54,7 +54,10 @@ 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.CheckoutConflictException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.errors.NoMergeBaseException;
import org.eclipse.jgit.errors.NoMergeBaseException.MergeBaseFailureReason;
import org.eclipse.jgit.junit.RepositoryTestCase;
import org.eclipse.jgit.merge.ResolveMerger.MergeFailureReason;
import org.eclipse.jgit.revwalk.RevCommit;
@ -72,6 +75,9 @@ public class ResolveMergerTest extends RepositoryTestCase {
@DataPoint
public static MergeStrategy resolve = MergeStrategy.RESOLVE;
@DataPoint
public static MergeStrategy recursive = MergeStrategy.RECURSIVE;
@Theory
public void failingPathsShouldNotResultInOKReturnValue(
MergeStrategy strategy) throws Exception {
@ -396,6 +402,66 @@ public class ResolveMergerTest extends RepositoryTestCase {
}
}
/**
* Merging after criss-cross merges. In this case we merge together two
* commits which have two equally good common ancestors
*
* @param strategy
* @throws Exception
*/
@Theory
public void checkMergeCrissCross(MergeStrategy strategy) throws Exception {
Git git = Git.wrap(db);
writeTrashFile("1", "1\n2\n3");
git.add().addFilepattern("1").call();
RevCommit first = git.commit().setMessage("added 1").call();
writeTrashFile("1", "1master\n2\n3");
RevCommit masterCommit = git.commit().setAll(true)
.setMessage("modified 1 on master").call();
writeTrashFile("1", "1master2\n2\n3");
git.commit().setAll(true)
.setMessage("modified 1 on master again").call();
git.checkout().setCreateBranch(true).setStartPoint(first)
.setName("side").call();
writeTrashFile("1", "1\n2\na\nb\nc\n3side");
RevCommit sideCommit = git.commit().setAll(true)
.setMessage("modified 1 on side").call();
writeTrashFile("1", "1\n2\n3side2");
git.commit().setAll(true)
.setMessage("modified 1 on side again").call();
MergeResult result = git.merge().setStrategy(strategy)
.include(masterCommit).call();
assertEquals(MergeStatus.MERGED, result.getMergeStatus());
result.getNewHead();
git.checkout().setName("master").call();
result = git.merge().setStrategy(strategy).include(sideCommit).call();
assertEquals(MergeStatus.MERGED, result.getMergeStatus());
// we have two branches which are criss-cross merged. Try to merge the
// tips. This should succeed with RecursiveMerge and fail with
// ResolveMerge
try {
MergeResult mergeResult = git.merge().setStrategy(strategy)
.include(git.getRepository().getRef("refs/heads/side"))
.call();
assertEquals(MergeStrategy.RECURSIVE, strategy);
assertEquals(MergeResult.MergeStatus.MERGED,
mergeResult.getMergeStatus());
assertEquals("1master2\n2\n3side2\n", read("1"));
} catch (JGitInternalException e) {
assertEquals(MergeStrategy.RESOLVE, strategy);
assertTrue(e.getCause() instanceof NoMergeBaseException);
assertEquals(((NoMergeBaseException) e.getCause()).getReason(),
MergeBaseFailureReason.MULTIPLE_MERGE_BASES_NOT_SUPPORTED);
}
}
@Theory
public void checkLockedFilesToBeDeleted(MergeStrategy strategy)
throws Exception {

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

@ -288,6 +288,8 @@ mergeConflictOnNotes=Merge conflict on note {0}. base = {1}, ours = {2}, theirs
mergeStrategyAlreadyExistsAsDefault=Merge strategy "{0}" already exists as a default strategy
mergeStrategyDoesNotSupportHeads=merge strategy {0} does not support {1} heads to be merged into HEAD
mergeUsingStrategyResultedInDescription=Merge of revisions {0} with base {1} using strategy {2} resulted in: {3}. {4}
mergeRecursiveReturnedNoCommit=Merge returned no commit:\n Depth {0}\n Head one {1}\n Head two {2}
mergeRecursiveTooManyMergeBasesFor = "More than {0} merge bases for:\n a {1}\n b {2} found:\n count {3}"
minutesAgo={0} minutes ago
missingAccesskey=Missing accesskey.
missingConfigurationForKey=No value for key {0} found in configuration
@ -313,6 +315,7 @@ noApplyInDelete=No apply in delete
noClosingBracket=No closing {0} found for {1} at index {2}.
noHEADExistsAndNoExplicitStartingRevisionWasSpecified=No HEAD exists and no explicit starting revision was specified
noHMACsupport=No {0} support: {1}
noMergeBase=No merge base could be determined. Reason={0}. {1}
noMergeHeadSpecified=No merge head specified
noSuchRef=no such ref
notABoolean=Not a boolean: {0}

124
org.eclipse.jgit/src/org/eclipse/jgit/errors/NoMergeBaseException.java

@ -0,0 +1,124 @@
/*
* Copyright (C) 2013, Christian Halstrick <christian.halstrick@sap.com>
* and other copyright owners as documented in the project's IP log.
*
* This program and the accompanying materials are made available
* under the terms of the Eclipse Distribution License v1.0 which
* accompanies this distribution, is reproduced below, and is
* available at http://www.eclipse.org/org/documents/edl-v10.php
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or
* without modification, are permitted provided that the following
* conditions are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* - Neither the name of the Eclipse Foundation, Inc. nor the
* names of its contributors may be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.eclipse.jgit.errors;
import java.io.IOException;
import java.text.MessageFormat;
import org.eclipse.jgit.internal.JGitText;
import org.eclipse.jgit.merge.RecursiveMerger;
/**
* Exception thrown if a merge fails because no merge base could be determined.
*/
public class NoMergeBaseException extends IOException {
private static final long serialVersionUID = 1L;
private MergeBaseFailureReason reason;
/**
* An enum listing the different reason why no merge base could be
* determined.
*/
public static enum MergeBaseFailureReason {
/**
* Multiple merge bases have been found (e.g. the commits to be merged
* have multiple common predecessors) but the merge strategy doesn't
* support this (e.g. ResolveMerge)
*/
MULTIPLE_MERGE_BASES_NOT_SUPPORTED,
/**
* The number of merge bases exceeds {@link RecursiveMerger#MAX_BASES}
*/
TOO_MANY_MERGE_BASES,
/**
* In order to find a single merge base it may required to merge
* together multiple common predecessors. If during these merges
* conflicts occur the merge fails with this reason
*/
CONFLICTS_DURING_MERGE_BASE_CALCULATION
}
/**
* Construct a NoMergeBase exception
*
* @param reason
* the reason why no merge base could be found
* @param message
* a text describing the problem
*/
public NoMergeBaseException(MergeBaseFailureReason reason, String message) {
super(MessageFormat.format(JGitText.get().noMergeBase,
reason.toString(), message));
this.reason = reason;
}
/**
* Construct a NoMergeBase exception
*
* @param reason
* the reason why no merge base could be found
* @param message
* a text describing the problem
* @param why
* an exception causing this error
*/
public NoMergeBaseException(MergeBaseFailureReason reason, String message,
Throwable why) {
super(MessageFormat.format(JGitText.get().noMergeBase,
reason.toString(), message));
this.reason = reason;
initCause(why);
}
/**
* @return the reason why no merge base could be found
*/
public MergeBaseFailureReason getReason() {
return reason;
}
}

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

@ -1,5 +1,6 @@
/*
* Copyright (C) 2010, 2013 Sasa Zivkov <sasa.zivkov@sap.com>
* Copyright (C) 2012, Research In Motion Limited
* and other copyright owners as documented in the project's IP log.
*
* This program and the accompanying materials are made available
@ -349,6 +350,8 @@ public class JGitText extends TranslationBundle {
/***/ public String mergeStrategyAlreadyExistsAsDefault;
/***/ public String mergeStrategyDoesNotSupportHeads;
/***/ public String mergeUsingStrategyResultedInDescription;
/***/ public String mergeRecursiveReturnedNoCommit;
/***/ public String mergeRecursiveTooManyMergeBasesFor;
/***/ public String minutesAgo;
/***/ public String missingAccesskey;
/***/ public String missingConfigurationForKey;
@ -374,6 +377,7 @@ public class JGitText extends TranslationBundle {
/***/ public String noClosingBracket;
/***/ public String noHEADExistsAndNoExplicitStartingRevisionWasSpecified;
/***/ public String noHMACsupport;
/***/ public String noMergeBase;
/***/ public String noMergeHeadSpecified;
/***/ public String noSuchRef;
/***/ public String notABoolean;

18
org.eclipse.jgit/src/org/eclipse/jgit/merge/MergeStrategy.java

@ -1,6 +1,7 @@
/*
* Copyright (C) 2008-2009, Google Inc.
* Copyright (C) 2009, Matthias Sohn <matthias.sohn@sap.com>
* Copyright (C) 2012, Research In Motion Limited
* and other copyright owners as documented in the project's IP log.
*
* This program and the accompanying materials are made available
@ -66,9 +67,18 @@ public abstract class MergeStrategy {
/** Simple strategy to merge paths, without simultaneous edits. */
public static final ThreeWayMergeStrategy SIMPLE_TWO_WAY_IN_CORE = new StrategySimpleTwoWayInCore();
/** Simple strategy to merge paths. It tries to merge also contents. Multiple merge bases are not supported */
/**
* Simple strategy to merge paths. It tries to merge also contents. Multiple
* merge bases are not supported
*/
public static final ThreeWayMergeStrategy RESOLVE = new StrategyResolve();
/**
* Recursive strategy to merge paths. It tries to merge also contents.
* Multiple merge bases are supported
*/
public static final ThreeWayMergeStrategy RECURSIVE = new StrategyRecursive();
private static final HashMap<String, MergeStrategy> STRATEGIES = new HashMap<String, MergeStrategy>();
static {
@ -76,6 +86,7 @@ public abstract class MergeStrategy {
register(THEIRS);
register(SIMPLE_TWO_WAY_IN_CORE);
register(RESOLVE);
register(RECURSIVE);
}
/**
@ -103,7 +114,8 @@ public abstract class MergeStrategy {
public static synchronized void register(final String name,
final MergeStrategy imp) {
if (STRATEGIES.containsKey(name))
throw new IllegalArgumentException(MessageFormat.format(JGitText.get().mergeStrategyAlreadyExistsAsDefault, name));
throw new IllegalArgumentException(MessageFormat.format(
JGitText.get().mergeStrategyAlreadyExistsAsDefault, name));
STRATEGIES.put(name, imp);
}
@ -146,7 +158,7 @@ public abstract class MergeStrategy {
/**
* Create a new merge instance.
*
*
* @param db
* repository database the merger will read from, and eventually
* write results back to.

44
org.eclipse.jgit/src/org/eclipse/jgit/merge/Merger.java

@ -47,6 +47,8 @@ import java.io.IOException;
import java.text.MessageFormat;
import org.eclipse.jgit.errors.IncorrectObjectTypeException;
import org.eclipse.jgit.errors.NoMergeBaseException;
import org.eclipse.jgit.errors.NoMergeBaseException.MergeBaseFailureReason;
import org.eclipse.jgit.internal.JGitText;
import org.eclipse.jgit.lib.AnyObjectId;
import org.eclipse.jgit.lib.Constants;
@ -186,19 +188,19 @@ public abstract class Merger {
/**
* Create an iterator to walk the merge base of two commits.
*
* @param aIdx
* index of the first commit in {@link #sourceObjects}.
* @param bIdx
* index of the second commit in {@link #sourceObjects}.
* @param a
* the first commit in {@link #sourceObjects}.
* @param b
* the second commit in {@link #sourceObjects}.
* @return the new iterator
* @throws IncorrectObjectTypeException
* one of the input objects is not a commit.
* @throws IOException
* objects are missing or multiple merge bases were found.
*/
protected AbstractTreeIterator mergeBase(final int aIdx, final int bIdx)
protected AbstractTreeIterator mergeBase(RevCommit a, RevCommit b)
throws IOException {
RevCommit base = getBaseCommit(aIdx, bIdx);
RevCommit base = getBaseCommit(a, b);
return (base == null) ? new EmptyTreeIterator() : openTree(base.getTree());
}
@ -224,18 +226,38 @@ public abstract class Merger {
if (sourceCommits[bIdx] == null)
throw new IncorrectObjectTypeException(sourceObjects[bIdx],
Constants.TYPE_COMMIT);
return getBaseCommit(sourceCommits[aIdx], sourceCommits[bIdx]);
}
/**
* Return the merge base of two commits.
*
* @param a
* the first commit in {@link #sourceObjects}.
* @param b
* the second commit in {@link #sourceObjects}.
* @return the merge base of two commits
* @throws IncorrectObjectTypeException
* one of the input objects is not a commit.
* @throws IOException
* objects are missing or multiple merge bases were found.
*/
protected RevCommit getBaseCommit(RevCommit a, RevCommit b)
throws IncorrectObjectTypeException, IOException {
walk.reset();
walk.setRevFilter(RevFilter.MERGE_BASE);
walk.markStart(sourceCommits[aIdx]);
walk.markStart(sourceCommits[bIdx]);
walk.markStart(a);
walk.markStart(b);
final RevCommit base = walk.next();
if (base == null)
return null;
final RevCommit base2 = walk.next();
if (base2 != null) {
throw new IOException(MessageFormat.format(JGitText.get().multipleMergeBasesFor
, sourceCommits[aIdx].name(), sourceCommits[bIdx].name()
, base.name(), base2.name()));
throw new NoMergeBaseException(
MergeBaseFailureReason.MULTIPLE_MERGE_BASES_NOT_SUPPORTED,
MessageFormat.format(
JGitText.get().multipleMergeBasesFor, a.name(), b.name(),
base.name(), base2.name()));
}
return base;
}

274
org.eclipse.jgit/src/org/eclipse/jgit/merge/RecursiveMerger.java

@ -0,0 +1,274 @@
/*
* Copyright (C) 2012, Research In Motion Limited
* Copyright (C) 2012, Christian Halstrick <christian.halstrick@sap.com>
* and other copyright owners as documented in the project's IP log.
*
* This program and the accompanying materials are made available
* under the terms of the Eclipse Distribution License v1.0 which
* accompanies this distribution, is reproduced below, and is
* available at http://www.eclipse.org/org/documents/edl-v10.php
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or
* without modification, are permitted provided that the following
* conditions are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* - Neither the name of the Eclipse Foundation, Inc. nor the
* names of its contributors may be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* Contributors:
* George Young - initial API and implementation
* Christian Halstrick - initial API and implementation
*/
package org.eclipse.jgit.merge;
import java.io.IOException;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Logger;
import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.dircache.DirCacheBuilder;
import org.eclipse.jgit.dircache.DirCacheEntry;
import org.eclipse.jgit.errors.IncorrectObjectTypeException;
import org.eclipse.jgit.errors.NoMergeBaseException;
import org.eclipse.jgit.internal.JGitText;
import org.eclipse.jgit.lib.CommitBuilder;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectInserter;
import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.filter.RevFilter;
import org.eclipse.jgit.treewalk.TreeWalk;
import org.eclipse.jgit.treewalk.WorkingTreeIterator;
/**
* A three-way merger performing a content-merge if necessary across multiple
* bases using recursion
*
* This merger extends the resolve merger and does several things differently:
*
* - allow more than one merge base, up to a maximum
*
* - uses "Lists" instead of Arrays for chained types
*
* - recursively merges the merge bases together to compute a usable base
*
*/
public class RecursiveMerger extends ResolveMerger {
static Logger log = Logger.getLogger(RecursiveMerger.class.toString());
/**
* The maximum number of merge bases. This merge will stop when the number
* of merge bases exceeds this value
*/
public final int MAX_BASES = 200;
private PersonIdent ident = new PersonIdent(db);
/**
* Normal recursive merge when you want a choice of DirCache placement
* inCore
*
* @param local
* @param inCore
*/
protected RecursiveMerger(Repository local, boolean inCore) {
super(local, inCore);
}
/**
* Normal recursive merge, implies not inCore
*
* @param local
*/
protected RecursiveMerger(Repository local) {
this(local, false);
}
/**
* Get a single base commit for two given commits. If the two source commits
* have more than one base commit recursively merge the base commits
* together until you end up with a single base commit.
*
* @throws IOException
* @throws IncorrectObjectTypeException
*/
@Override
protected RevCommit getBaseCommit(RevCommit a, RevCommit b)
throws IncorrectObjectTypeException, IOException {
return getBaseCommit(a, b, 0);
}
/**
* Get a single base commit for two given commits. If the two source commits
* have more than one base commit recursively merge the base commits
* together until a virtual common base commit has been found.
*
* @param a
* the first commit to be merged
* @param b
* the second commit to be merged
* @param callDepth
* the callDepth when this method is called recursively
* @return the merge base of two commits
* @throws IOException
* @throws IncorrectObjectTypeException
* one of the input objects is not a commit.
* @throws NoMergeBaseException
* too many merge bases are found or the computation of a common
* merge base failed (e.g. because of a conflict).
*/
protected RevCommit getBaseCommit(RevCommit a, RevCommit b, int callDepth)
throws IOException {
ArrayList<RevCommit> baseCommits = new ArrayList<RevCommit>();
walk.reset();
walk.setRevFilter(RevFilter.MERGE_BASE);
walk.markStart(a);
walk.markStart(b);
RevCommit c;
while ((c = walk.next()) != null)
baseCommits.add(c);
if (baseCommits.isEmpty())
return null;
if (baseCommits.size() == 1)
return baseCommits.get(0);
if (baseCommits.size() >= MAX_BASES)
throw new NoMergeBaseException(NoMergeBaseException.MergeBaseFailureReason.TOO_MANY_MERGE_BASES, MessageFormat.format(
JGitText.get().mergeRecursiveTooManyMergeBasesFor,
Integer.valueOf(MAX_BASES), a.name(), b.name(),
Integer.valueOf(baseCommits.size())));
// We know we have more than one base commit. We have to do merges now
// to determine a single base commit. We don't want to spoil the current
// dircache and working tree with the results of this intermediate
// merges. Therefore set the dircache to a new in-memory dircache and
// disable that we update the working-tree. We set this back to the
// original values once a single base commit is created.
RevCommit currentBase = baseCommits.get(0);
DirCache oldDircache = dircache;
boolean oldIncore = inCore;
WorkingTreeIterator oldWTreeIt = workingTreeIterator;
workingTreeIterator = null;
try {
dircache = dircacheFromTree(currentBase.getTree());
inCore = true;
List<RevCommit> parents = new ArrayList<RevCommit>();
parents.add(currentBase);
for (int commitIdx = 1; commitIdx < baseCommits.size(); commitIdx++) {
RevCommit nextBase = baseCommits.get(commitIdx);
if (commitIdx >= MAX_BASES)
throw new NoMergeBaseException(
NoMergeBaseException.MergeBaseFailureReason.TOO_MANY_MERGE_BASES,
MessageFormat.format(
JGitText.get().mergeRecursiveTooManyMergeBasesFor,
Integer.valueOf(MAX_BASES), a.name(), b.name(),
Integer.valueOf(baseCommits.size())));
parents.add(nextBase);
if (mergeTrees(
openTree(getBaseCommit(currentBase, nextBase,
callDepth + 1).getTree()),
currentBase.getTree(),
nextBase.getTree()))
currentBase = createCommitForTree(resultTree, parents);
else
throw new NoMergeBaseException(
NoMergeBaseException.MergeBaseFailureReason.CONFLICTS_DURING_MERGE_BASE_CALCULATION,
MessageFormat.format(
JGitText.get().mergeRecursiveTooManyMergeBasesFor,
Integer.valueOf(MAX_BASES), a.name(),
b.name(),
Integer.valueOf(baseCommits.size())));
}
} finally {
inCore = oldIncore;
dircache = oldDircache;
workingTreeIterator = oldWTreeIt;
}
return currentBase;
}
/**
* Create a new commit by explicitly specifying the content tree and the
* parents. The commit message is not set and author/committer are set to
* the current user.
*
* @param tree
* the tree this commit should capture
* @param parents
* the list of parent commits
* @return a new (persisted) commit
* @throws IOException
*/
private RevCommit createCommitForTree(ObjectId tree, List<RevCommit> parents)
throws IOException {
CommitBuilder c = new CommitBuilder();
c.setParentIds(parents);
c.setTreeId(tree);
c.setAuthor(ident);
c.setCommitter(ident);
ObjectInserter odi = db.newObjectInserter();
ObjectId newCommitId = odi.insert(c);
odi.flush();
RevCommit ret = walk.lookupCommit(newCommitId);
walk.parseHeaders(ret);
return ret;
}
/**
* Create a new in memory dircache which has the same content as a given
* tree.
*
* @param treeId
* the tree which should be used to fill the dircache
* @return a new in memory dircache
* @throws IOException
*/
private DirCache dircacheFromTree(ObjectId treeId) throws IOException {
DirCache ret = DirCache.newInCore();
DirCacheBuilder builder = ret.builder();
TreeWalk tw = new TreeWalk(db);
tw.addTree(treeId);
tw.setRecursive(true);
while (tw.next()) {
DirCacheEntry e = new DirCacheEntry(tw.getRawPath());
e.setFileMode(tw.getFileMode(0));
e.setObjectId(tw.getObjectId(0));
builder.add(e);
}
builder.finish();
return ret;
}
}

212
org.eclipse.jgit/src/org/eclipse/jgit/merge/ResolveMerger.java

@ -1,6 +1,7 @@
/*
* Copyright (C) 2010, Christian Halstrick <christian.halstrick@sap.com>,
* Copyright (C) 2010-2012, Matthias Sohn <matthias.sohn@sap.com>
* Copyright (C) 2012, Research In Motion Limited
* and other copyright owners as documented in the project's IP log.
*
* This program and the accompanying materials are made available
@ -80,6 +81,8 @@ import org.eclipse.jgit.lib.FileMode;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectReader;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.RevTree;
import org.eclipse.jgit.treewalk.AbstractTreeIterator;
import org.eclipse.jgit.treewalk.CanonicalTreeParser;
import org.eclipse.jgit.treewalk.NameConflictTreeWalk;
import org.eclipse.jgit.treewalk.WorkingTreeIterator;
@ -104,7 +107,10 @@ public class ResolveMerger extends ThreeWayMerger {
private NameConflictTreeWalk tw;
private String commitNames[];
/**
* string versions of a list of commit SHA1s
*/
protected String commitNames[];
private static final int T_BASE = 0;
@ -118,7 +124,10 @@ public class ResolveMerger extends ThreeWayMerger {
private DirCacheBuilder builder;
private ObjectId resultTree;
/**
* merge result as tree
*/
protected ObjectId resultTree;
private List<String> unmergedPaths = new ArrayList<String>();
@ -134,13 +143,38 @@ public class ResolveMerger extends ThreeWayMerger {
private boolean enterSubtree;
private boolean inCore;
/**
* Set to true if this merge should work in-memory. The repos dircache and
* workingtree are not touched by this method. Eventually needed files are
* created as temporary files and a new empty, in-memory dircache will be
* used instead the repo's one. Often used for bare repos where the repo
* doesn't even have a workingtree and dircache.
*/
protected boolean inCore;
/**
* Set to true if this merger should use the default dircache of the
* repository and should handle locking and unlocking of the dircache. If
* this merger should work in-core or if an explicit dircache was specified
* during construction then this field is set to false.
*/
protected boolean implicitDirCache;
private DirCache dircache;
/**
* Directory cache
*/
protected DirCache dircache;
private WorkingTreeIterator workingTreeIterator;
/**
* The iterator to access the working tree. If set to <code>null</code> this
* merger will not touch the working tree.
*/
protected WorkingTreeIterator workingTreeIterator;
private MergeAlgorithm mergeAlgorithm;
/**
* our merge algorithm
*/
protected MergeAlgorithm mergeAlgorithm;
/**
* @param local
@ -153,11 +187,14 @@ public class ResolveMerger extends ThreeWayMerger {
ConfigConstants.CONFIG_KEY_ALGORITHM,
SupportedAlgorithm.HISTOGRAM);
mergeAlgorithm = new MergeAlgorithm(DiffAlgorithm.getAlgorithm(diffAlg));
commitNames = new String[] { "BASE", "OURS", "THEIRS" };
commitNames = new String[] { "BASE", "OURS", "THEIRS" }; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
this.inCore = inCore;
if (inCore) {
implicitDirCache = false;
dircache = DirCache.newInCore();
} else {
implicitDirCache = true;
}
}
@ -170,67 +207,11 @@ public class ResolveMerger extends ThreeWayMerger {
@Override
protected boolean mergeImpl() throws IOException {
boolean implicitDirCache = false;
if (dircache == null) {
if (implicitDirCache)
dircache = getRepository().lockDirCache();
implicitDirCache = true;
}
try {
builder = dircache.builder();
DirCacheBuildIterator buildIt = new DirCacheBuildIterator(builder);
tw = new NameConflictTreeWalk(db);
tw.addTree(mergeBase());
tw.addTree(sourceTrees[0]);
tw.addTree(sourceTrees[1]);
tw.addTree(buildIt);
if (workingTreeIterator != null)
tw.addTree(workingTreeIterator);
while (tw.next()) {
if (!processEntry(
tw.getTree(T_BASE, CanonicalTreeParser.class),
tw.getTree(T_OURS, CanonicalTreeParser.class),
tw.getTree(T_THEIRS, CanonicalTreeParser.class),
tw.getTree(T_INDEX, DirCacheBuildIterator.class),
(workingTreeIterator == null) ? null : tw.getTree(T_FILE, WorkingTreeIterator.class))) {
cleanUp();
return false;
}
if (tw.isSubtree() && enterSubtree)
tw.enterSubtree();
}
if (!inCore) {
// No problem found. The only thing left to be done is to
// checkout all files from "theirs" which have been selected to
// go into the new index.
checkout();
// All content-merges are successfully done. If we can now write the
// new index we are on quite safe ground. Even if the checkout of
// files coming from "theirs" fails the user can work around such
// failures by checking out the index again.
if (!builder.commit()) {
cleanUp();
throw new IndexWriteException();
}
builder = null;
} else {
builder.finish();
builder = null;
}
if (getUnmergedPaths().isEmpty() && !failed()) {
resultTree = dircache.writeTree(getObjectInserter());
return true;
} else {
resultTree = null;
return false;
}
return mergeTrees(mergeBase(), sourceTrees[0], sourceTrees[1]);
} finally {
if (implicitDirCache)
dircache.unlock();
@ -279,14 +260,15 @@ public class ResolveMerger extends ThreeWayMerger {
/**
* Reverts the worktree after an unsuccessful merge. We know that for all
* modified files the old content was in the old index and the index
* contained only stage 0. In case if inCore operation just clear
* the history of modified files.
* contained only stage 0. In case if inCore operation just clear the
* history of modified files.
*
* @throws IOException
* @throws CorruptObjectException
* @throws NoWorkTreeException
*/
private void cleanUp() throws NoWorkTreeException, CorruptObjectException, IOException {
private void cleanUp() throws NoWorkTreeException, CorruptObjectException,
IOException {
if (inCore) {
modifiedFiles.clear();
return;
@ -298,7 +280,10 @@ public class ResolveMerger extends ThreeWayMerger {
while(mpathsIt.hasNext()) {
String mpath=mpathsIt.next();
DirCacheEntry entry = dc.getEntry(mpath);
FileOutputStream fos = new FileOutputStream(new File(db.getWorkTree(), mpath));
if (entry == null)
continue;
FileOutputStream fos = new FileOutputStream(new File(
db.getWorkTree(), mpath));
try {
or.open(entry.getObjectId()).copyTo(fos);
} finally {
@ -610,6 +595,9 @@ public class ResolveMerger extends ThreeWayMerger {
}
private boolean isIndexDirty() {
if (inCore)
return false;
final int modeI = tw.getRawMode(T_INDEX);
final int modeO = tw.getRawMode(T_OURS);
@ -623,7 +611,7 @@ public class ResolveMerger extends ThreeWayMerger {
}
private boolean isWorktreeDirty(WorkingTreeIterator work) {
if (inCore || work == null)
if (work == null)
return false;
final int modeF = tw.getRawMode(T_FILE);
@ -862,19 +850,20 @@ public class ResolveMerger extends ThreeWayMerger {
/**
* Sets the DirCache which shall be used by this merger. If the DirCache is
* not set explicitly this merger will implicitly get and lock a default
* DirCache. If the DirCache is explicitly set the caller is responsible to
* lock it in advance. Finally the merger will call
* {@link DirCache#commit()} which requires that the DirCache is locked. If
* the {@link #mergeImpl()} returns without throwing an exception the lock
* will be released. In case of exceptions the caller is responsible to
* release the lock.
* not set explicitly and if this merger doesn't work in-core, this merger
* will implicitly get and lock a default DirCache. If the DirCache is
* explicitly set the caller is responsible to lock it in advance. Finally
* the merger will call {@link DirCache#commit()} which requires that the
* DirCache is locked. If the {@link #mergeImpl()} returns without throwing
* an exception the lock will be released. In case of exceptions the caller
* is responsible to release the lock.
*
* @param dc
* the DirCache to set
*/
public void setDirCache(DirCache dc) {
this.dircache = dc;
implicitDirCache = false;
}
/**
@ -891,4 +880,73 @@ public class ResolveMerger extends ThreeWayMerger {
public void setWorkingTreeIterator(WorkingTreeIterator workingTreeIterator) {
this.workingTreeIterator = workingTreeIterator;
}
/**
* The resolve conflict way of three way merging
*
* @param baseTree
* @param headTree
* @param mergeTree
* @return whether the trees merged cleanly
* @throws IOException
*/
protected boolean mergeTrees(AbstractTreeIterator baseTree,
RevTree headTree, RevTree mergeTree) throws IOException {
builder = dircache.builder();
DirCacheBuildIterator buildIt = new DirCacheBuildIterator(builder);
tw = new NameConflictTreeWalk(db);
tw.addTree(baseTree);
tw.addTree(headTree);
tw.addTree(mergeTree);
tw.addTree(buildIt);
if (workingTreeIterator != null)
tw.addTree(workingTreeIterator);
while (tw.next()) {
if (!processEntry(
tw.getTree(T_BASE, CanonicalTreeParser.class),
tw.getTree(T_OURS, CanonicalTreeParser.class),
tw.getTree(T_THEIRS, CanonicalTreeParser.class),
tw.getTree(T_INDEX, DirCacheBuildIterator.class),
(workingTreeIterator == null) ? null : tw.getTree(T_FILE,
WorkingTreeIterator.class))) {
cleanUp();
return false;
}
if (tw.isSubtree() && enterSubtree)
tw.enterSubtree();
}
if (!inCore) {
// No problem found. The only thing left to be done is to
// checkout all files from "theirs" which have been selected to
// go into the new index.
checkout();
// All content-merges are successfully done. If we can now write the
// new index we are on quite safe ground. Even if the checkout of
// files coming from "theirs" fails the user can work around such
// failures by checking out the index again.
if (!builder.commit()) {
cleanUp();
throw new IndexWriteException();
}
builder = null;
} else {
builder.finish();
builder = null;
}
if (getUnmergedPaths().isEmpty() && !failed()) {
resultTree = dircache.writeTree(getObjectInserter());
return true;
} else {
resultTree = null;
return false;
}
}
}

67
org.eclipse.jgit/src/org/eclipse/jgit/merge/StrategyRecursive.java

@ -0,0 +1,67 @@
/*
* Copyright (C) 2012, Research In Motion Limited
* and other copyright owners as documented in the project's IP log.
*
* This program and the accompanying materials are made available
* under the terms of the Eclipse Distribution License v1.0 which
* accompanies this distribution, is reproduced below, and is
* available at http://www.eclipse.org/org/documents/edl-v10.php
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or
* without modification, are permitted provided that the following
* conditions are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* - Neither the name of the Eclipse Foundation, Inc. nor the
* names of its contributors may be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.eclipse.jgit.merge;
import org.eclipse.jgit.lib.Repository;
/**
* A three-way merge strategy performing a content-merge if necessary
*/
public class StrategyRecursive extends StrategyResolve {
@Override
public ThreeWayMerger newMerger(Repository db) {
return new RecursiveMerger(db, false);
}
@Override
public ThreeWayMerger newMerger(Repository db, boolean inCore) {
return new RecursiveMerger(db, inCore);
}
@Override
public String getName() {
return "recursive";
}
}

3
org.eclipse.jgit/src/org/eclipse/jgit/merge/ThreeWayMerger.java

@ -1,5 +1,6 @@
/*
* Copyright (C) 2009, Google Inc.
* Copyright (C) 2012, Research In Motion Limited
* and other copyright owners as documented in the project's IP log.
*
* This program and the accompanying materials are made available
@ -118,6 +119,6 @@ public abstract class ThreeWayMerger extends Merger {
protected AbstractTreeIterator mergeBase() throws IOException {
if (baseTree != null)
return openTree(baseTree);
return mergeBase(0, 1);
return mergeBase(sourceCommits[0], sourceCommits[1]);
}
}

Loading…
Cancel
Save