Add revisions of merged branches before merge

scm-core/src/main/java/sonia/scm/repository/api/MergeCommandResult.java

@@ -15,18 +15,22 @@ public class MergeCommandResult {
 
   private final Collection<String> filesWithConflict;
   private final String newHeadRevision;
+  private final String targetRevision;
+  private final String revisionToMerge;
 
-  private MergeCommandResult(Collection<String> filesWithConflict, String newHeadRevision) {
+  private MergeCommandResult(Collection<String> filesWithConflict, String targetRevision, String revisionToMerge, String newHeadRevision) {
     this.filesWithConflict = filesWithConflict;
+    this.targetRevision = targetRevision;
+    this.revisionToMerge = revisionToMerge;
     this.newHeadRevision = newHeadRevision;
   }
 
- public static MergeCommandResult success(String newHeadRevision) {
+ public static MergeCommandResult success(String targetRevision, String revisionToMerge, String newHeadRevision) {
-    return new MergeCommandResult(emptyList(), newHeadRevision);
+    return new MergeCommandResult(emptyList(), targetRevision, revisionToMerge, newHeadRevision);
   }
 
-  public static MergeCommandResult failure(Collection<String> filesWithConflict) {
+  public static MergeCommandResult failure(String targetRevision, String revisionToMerge, Collection<String> filesWithConflict) {
-    return new MergeCommandResult(new HashSet<>(filesWithConflict), null);
+    return new MergeCommandResult(new HashSet<>(filesWithConflict), targetRevision, revisionToMerge, null);
   }
 
   /**
@@ -45,7 +49,25 @@ public class MergeCommandResult {
     return unmodifiableCollection(filesWithConflict);
   }
 
+  /**
+   * Returns the revision of the new head of the target branch, if the merge was successful ({@link #isSuccess()})
+   */
   public String getNewHeadRevision() {
     return newHeadRevision;
   }
+
+  /**
+   * Returns the revision of the target branch prior to the merge.
+   */
+  public String getTargetRevision() {
+    return targetRevision;
+  }
+
+  /**
+   * Returns the revision of the branch that was merged into the target (or in case of a conflict of the revision that
+   * should have been merged).
+   */
+  public String getRevisionToMerge() {
+    return revisionToMerge;
+  }
 }

scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/spi/GitFastForwardIfPossible.java

@@ -23,7 +23,7 @@ class GitFastForwardIfPossible extends GitMergeStrategy {
     MergeResult fastForwardResult = mergeWithFastForwardOnlyMode();
     if (fastForwardResult.getMergeStatus().isSuccessful()) {
       push();
-      return MergeCommandResult.success(fastForwardResult.getNewHead().toString());
+      return createSuccessResult(fastForwardResult.getNewHead().name());
     } else {
       return fallbackMerge.run();
     }

scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/spi/GitMergeCommit.java

@@ -29,7 +29,7 @@ class GitMergeCommit extends GitMergeStrategy {
     if (result.getMergeStatus().isSuccessful()) {
       RevCommit revCommit = doCommit().orElseThrow(() -> new NoChangesMadeException(getRepository()));
       push();
-      return MergeCommandResult.success(extractRevisionFromRevCommit(revCommit));
+      return createSuccessResult(extractRevisionFromRevCommit(revCommit));
     } else {
       return analyseFailure(result);
     }

scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/spi/GitMergeStrategy.java

@@ -26,37 +26,57 @@ abstract class GitMergeStrategy extends AbstractGitCommand.GitCloneWorker<MergeC
     "",
     "Automatic merge by SCM-Manager.");
 
-  private final String target;
+  private final String targetBranch;
-  private final String toMerge;
+  private final ObjectId targetRevision;
+  private final String branchToMerge;
+  private final ObjectId revisionToMerge;
   private final Person author;
   private final String messageTemplate;
 
   GitMergeStrategy(Git clone, MergeCommandRequest request, GitContext context, sonia.scm.repository.Repository repository) {
     super(clone, context, repository);
-    this.target = request.getTargetBranch();
+    this.targetBranch = request.getTargetBranch();
-    this.toMerge = request.getBranchToMerge();
+    this.branchToMerge = request.getBranchToMerge();
     this.author = request.getAuthor();
     this.messageTemplate = request.getMessageTemplate();
+    try {
+      this.targetRevision = resolveRevision(request.getTargetBranch());
+      this.revisionToMerge = resolveRevision(request.getBranchToMerge());
+    } catch (IOException e) {
+      throw new InternalRepositoryException(repository, "Could not resolve revisions of target branch or branch to merge", e);
+    }
   }
 
   MergeResult doMergeInClone(MergeCommand mergeCommand) throws IOException {
     MergeResult result;
     try {
-      ObjectId sourceRevision = resolveRevision(toMerge);
+      ObjectId sourceRevision = resolveRevision(branchToMerge);
       mergeCommand
         .setCommit(false) // we want to set the author manually
-        .include(toMerge, sourceRevision);
+        .include(branchToMerge, sourceRevision);
 
       result = mergeCommand.call();
     } catch (GitAPIException e) {
-      throw new InternalRepositoryException(getContext().getRepository(), "could not merge branch " + toMerge + " into " + target, e);
+      throw new InternalRepositoryException(getContext().getRepository(), "could not merge branch " + branchToMerge + " into " + targetBranch, e);
     }
     return result;
   }
 
   Optional<RevCommit> doCommit() {
-    logger.debug("merged branch {} into {}", toMerge, target);
+    logger.debug("merged branch {} into {}", branchToMerge, targetBranch);
-    return doCommit(MessageFormat.format(determineMessageTemplate(), toMerge, target), author);
+    return doCommit(MessageFormat.format(determineMessageTemplate(), branchToMerge, targetBranch), author);
+  }
+
+  MergeCommandResult createSuccessResult(String newRevision) {
+    return MergeCommandResult.success(targetRevision.name(), revisionToMerge.name(), newRevision);
+  }
+
+  ObjectId getTargetRevision() {
+    return targetRevision;
+  }
+
+  ObjectId getRevisionToMerge() {
+    return revisionToMerge;
   }
 
   private String determineMessageTemplate() {
@@ -68,7 +88,7 @@ abstract class GitMergeStrategy extends AbstractGitCommand.GitCloneWorker<MergeC
   }
 
   MergeCommandResult analyseFailure(MergeResult result) {
-    logger.info("could not merge branch {} into {} due to conflict in paths {}", toMerge, target, result.getConflicts().keySet());
+    logger.info("could not merge branch {} into {} due to conflict in paths {}", branchToMerge, targetBranch, result.getConflicts().keySet());
-    return MergeCommandResult.failure(result.getConflicts().keySet());
+    return MergeCommandResult.failure(targetRevision.name(), revisionToMerge.name(), result.getConflicts().keySet());
   }
 }

scm-plugins/scm-git-plugin/src/main/java/sonia/scm/repository/spi/GitMergeWithSquash.java

@@ -9,8 +9,6 @@ import sonia.scm.repository.Repository;
 import sonia.scm.repository.api.MergeCommandResult;
 
 import java.io.IOException;
-import java.util.Collections;
-import java.util.Optional;
 
 import static sonia.scm.repository.spi.GitRevisionExtractor.extractRevisionFromRevCommit;
 
@@ -29,7 +27,7 @@ class GitMergeWithSquash extends GitMergeStrategy {
     if (result.getMergeStatus().isSuccessful()) {
       RevCommit revCommit = doCommit().orElseThrow(() -> new NoChangesMadeException(getRepository()));
       push();
-      return MergeCommandResult.success(extractRevisionFromRevCommit(revCommit));
+      return MergeCommandResult.success(getTargetRevision().name(), revCommit.name(), extractRevisionFromRevCommit(revCommit));
     } else {
       return analyseFailure(result);
     }

scm-plugins/scm-git-plugin/src/test/java/sonia/scm/repository/spi/GitMergeCommandTest.java

@@ -71,6 +71,8 @@ public class GitMergeCommandTest extends AbstractGitCommandTestBase {
     MergeCommandResult mergeCommandResult = command.merge(request);
 
     assertThat(mergeCommandResult.isSuccess()).isTrue();
+    assertThat(mergeCommandResult.getRevisionToMerge()).isEqualTo("91b99de908fcd04772798a31c308a64aea1a5523");
+    assertThat(mergeCommandResult.getTargetRevision()).isEqualTo("fcd0ef1831e4002ac43ea539f4094334c79ea9ec");
 
     Repository repository = createContext().open();
     Iterable<RevCommit> commits = new Git(repository).log().add(repository.resolve("master")).setMaxCount(1).call();
@@ -229,6 +231,8 @@ public class GitMergeCommandTest extends AbstractGitCommandTestBase {
 
     Repository repository = createContext().open();
     assertThat(mergeCommandResult.isSuccess()).isTrue();
+    assertThat(mergeCommandResult.getRevisionToMerge()).isEqualTo(mergeCommandResult.getNewHeadRevision());
+    assertThat(mergeCommandResult.getTargetRevision()).isEqualTo("fcd0ef1831e4002ac43ea539f4094334c79ea9ec");
 
     Iterable<RevCommit> commits = new Git(repository).log().add(repository.resolve("master")).setMaxCount(1).call();
     RevCommit mergeCommit = commits.iterator().next();
@@ -279,6 +283,9 @@ public class GitMergeCommandTest extends AbstractGitCommandTestBase {
     request.setAuthor(new Person("Dirk Gently", "dirk@holistic.det"));
 
     MergeCommandResult mergeCommandResult = command.merge(request);
+    assertThat(mergeCommandResult.getNewHeadRevision()).isEqualTo("35597e9e98fe53167266583848bfef985c2adb27");
+    assertThat(mergeCommandResult.getRevisionToMerge()).isEqualTo("35597e9e98fe53167266583848bfef985c2adb27");
+    assertThat(mergeCommandResult.getTargetRevision()).isEqualTo("fcd0ef1831e4002ac43ea539f4094334c79ea9ec");
 
     assertThat(mergeCommandResult.isSuccess()).isTrue();