MergeScenarioReport report = new MergeScenarioReport();
Iterator<DiffEntry> diffs = command(DiffTree.class).setOldTree(ancestor.get())
.setReportTrees(true).setNewTree(mergeInto.getId()).call();
while (diffs.hasNext()) {
DiffEntry diff = diffs.next();
String path = diff.oldPath() == null ? diff.newPath() : diff.oldPath();
mergeIntoDiffs.put(path, diff);
}
Iterator<DiffEntry> toMergeDiffs = command(DiffTree.class).setOldTree(ancestor.get())
.setReportTrees(true).setNewTree(toMerge.getId()).call();
while (toMergeDiffs.hasNext()) {
DiffEntry toMergeDiff = toMergeDiffs.next();
String path = toMergeDiff.oldPath() == null ? toMergeDiff.newPath() : toMergeDiff
.oldPath();
if (mergeIntoDiffs.containsKey(path)) {
RevCommit ancestorCommit = command(RevObjectParse.class)
.setRefSpec(ancestor.get().toString()).call(RevCommit.class).get();
RevTree ancestorTree = command(RevObjectParse.class)
.setObjectId(ancestorCommit.getTreeId()).call(RevTree.class).get();
Optional<NodeRef> ancestorVersion = command(FindTreeChild.class).setChildPath(path)
.setParent(ancestorTree).call();
ObjectId ancestorVersionId = ancestorVersion.isPresent() ? ancestorVersion.get()
.getNode().getObjectId() : ObjectId.NULL;
ObjectId theirs = toMergeDiff.getNewObject() == null ? ObjectId.NULL : toMergeDiff
.getNewObject().objectId();
DiffEntry mergeIntoDiff = mergeIntoDiffs.get(path);
ObjectId ours = mergeIntoDiff.getNewObject() == null ? ObjectId.NULL
: mergeIntoDiff.getNewObject().objectId();
if (!mergeIntoDiff.changeType().equals(toMergeDiff.changeType())) {
report.addConflict(new Conflict(path, ancestorVersionId, ours, theirs));
continue;
}
switch (toMergeDiff.changeType()) {
case ADDED:
if (toMergeDiff.getNewObject().equals(mergeIntoDiff.getNewObject())) {
// already added in current branch, no need to do anything
} else {
TYPE type = command(ResolveObjectType.class).setObjectId(
toMergeDiff.getNewObject().objectId()).call();
if (TYPE.TREE.equals(type)) {
boolean conflict = !toMergeDiff.getNewObject().getMetadataId()
.equals(mergeIntoDiff.getNewObject().getMetadataId());
if (conflict) {
// In this case, we store the metadata id, not the element id
ancestorVersionId = ancestorVersion.isPresent() ? ancestorVersion
.get().getMetadataId() : ObjectId.NULL;
ours = mergeIntoDiff.getNewObject().getMetadataId();
theirs = toMergeDiff.getNewObject().getMetadataId();
report.addConflict(new Conflict(path, ancestorVersionId, ours,
theirs));
}
// if the metadata ids match, it means both branches have added the same
// tree, maybe with different content, but there is no need to do
// anything. The correct tree is already there and the merge can be run
// safely, so we do not add it neither as a conflicted change nor as an
// unconflicted one
} else {
report.addConflict(new Conflict(path, ancestorVersionId, ours, theirs));
}
}
break;
case REMOVED:
// removed by both histories => no conflict and no need to do anything
break;
case MODIFIED:
TYPE type = command(ResolveObjectType.class).setObjectId(
toMergeDiff.getNewObject().objectId()).call();
if (TYPE.TREE.equals(type)) {
boolean conflict = !toMergeDiff.getNewObject().getMetadataId()
.equals(mergeIntoDiff.getNewObject().getMetadataId());
if (conflict) {
// In this case, we store the metadata id, not the element id
ancestorVersionId = ancestorVersion.isPresent() ? ancestorVersion.get()
.getMetadataId() : ObjectId.NULL;
ours = mergeIntoDiff.getNewObject().getMetadataId();
theirs = toMergeDiff.getNewObject().getMetadataId();
report.addConflict(new Conflict(path, ancestorVersionId, ours, theirs));
}
} else {
FeatureDiff toMergeFeatureDiff = command(DiffFeature.class)
.setOldVersion(Suppliers.ofInstance(toMergeDiff.getOldObject()))
.setNewVersion(Suppliers.ofInstance(toMergeDiff.getNewObject()))
.call();
FeatureDiff mergeIntoFeatureDiff = command(DiffFeature.class)
.setOldVersion(Suppliers.ofInstance(mergeIntoDiff.getOldObject()))
.setNewVersion(Suppliers.ofInstance(mergeIntoDiff.getNewObject()))
.call();
if (toMergeFeatureDiff.conflicts(mergeIntoFeatureDiff)) {
report.addConflict(new Conflict(path, ancestorVersionId, ours, theirs));
} else {
// if the feature types are different we report a conflict and do not
// try to perform automerge
if (!toMergeDiff.getNewObject().getMetadataId()
.equals(mergeIntoDiff.getNewObject().getMetadataId())) {
report.addConflict(new Conflict(path, ancestorVersionId, ours,
theirs));
} else if (!toMergeFeatureDiff.equals(mergeIntoFeatureDiff)) {
Feature mergedFeature = command(MergeFeaturesOp.class)
.setFirstFeature(mergeIntoDiff.getNewObject())
.setSecondFeature(toMergeDiff.getNewObject())
.setAncestorFeature(mergeIntoDiff.getOldObject()).call();
RevFeature revFeature = RevFeatureBuilder.build(mergedFeature);
if (revFeature.getId().equals(toMergeDiff.newObjectId())) {
// the resulting merged feature equals the feature to merge from
// the branch, which means that it exists in the repo and there
// is no need to add it
report.addUnconflicted(toMergeDiff);
} else {
RevFeatureType featureType = command(RevObjectParse.class)
.setObjectId(
mergeIntoDiff.getNewObject().getMetadataId())
.call(RevFeatureType.class).get();
FeatureInfo merged = new FeatureInfo(mergedFeature,
featureType, path);
report.addMerged(merged);
}