MergeCommand.java

  1. /*
  2.  * Copyright (C) 2010, Christian Halstrick <christian.halstrick@sap.com>
  3.  * Copyright (C) 2010, 2014, Stefan Lay <stefan.lay@sap.com>
  4.  * Copyright (C) 2016, 2021 Laurent Delaigue <laurent.delaigue@obeo.fr> and others
  5.  *
  6.  * This program and the accompanying materials are made available under the
  7.  * terms of the Eclipse Distribution License v. 1.0 which is available at
  8.  * https://www.eclipse.org/org/documents/edl-v10.php.
  9.  *
  10.  * SPDX-License-Identifier: BSD-3-Clause
  11.  */
  12. package org.eclipse.jgit.api;

  14. import java.io.IOException;
  15. import java.text.MessageFormat;
  16. import java.util.Arrays;
  17. import java.util.Collections;
  18. import java.util.LinkedList;
  19. import java.util.List;
  20. import java.util.Locale;
  21. import java.util.Map;

  23. import org.eclipse.jgit.annotations.Nullable;
  24. import org.eclipse.jgit.api.MergeResult.MergeStatus;
  25. import org.eclipse.jgit.api.errors.CheckoutConflictException;
  26. import org.eclipse.jgit.api.errors.ConcurrentRefUpdateException;
  27. import org.eclipse.jgit.api.errors.GitAPIException;
  28. import org.eclipse.jgit.api.errors.InvalidMergeHeadsException;
  29. import org.eclipse.jgit.api.errors.JGitInternalException;
  30. import org.eclipse.jgit.api.errors.NoHeadException;
  31. import org.eclipse.jgit.api.errors.NoMessageException;
  32. import org.eclipse.jgit.api.errors.WrongRepositoryStateException;
  33. import org.eclipse.jgit.dircache.DirCacheCheckout;
  34. import org.eclipse.jgit.events.WorkingTreeModifiedEvent;
  35. import org.eclipse.jgit.internal.JGitText;
  36. import org.eclipse.jgit.lib.AnyObjectId;
  37. import org.eclipse.jgit.lib.CommitConfig;
  38. import org.eclipse.jgit.lib.Config.ConfigEnum;
  39. import org.eclipse.jgit.lib.Constants;
  40. import org.eclipse.jgit.lib.NullProgressMonitor;
  41. import org.eclipse.jgit.lib.ObjectId;
  42. import org.eclipse.jgit.lib.ObjectIdRef;
  43. import org.eclipse.jgit.lib.ProgressMonitor;
  44. import org.eclipse.jgit.lib.Ref;
  45. import org.eclipse.jgit.lib.Ref.Storage;
  46. import org.eclipse.jgit.lib.RefUpdate;
  47. import org.eclipse.jgit.lib.RefUpdate.Result;
  48. import org.eclipse.jgit.lib.Repository;
  49. import org.eclipse.jgit.merge.ContentMergeStrategy;
  50. import org.eclipse.jgit.merge.MergeConfig;
  51. import org.eclipse.jgit.merge.MergeMessageFormatter;
  52. import org.eclipse.jgit.merge.MergeStrategy;
  53. import org.eclipse.jgit.merge.Merger;
  54. import org.eclipse.jgit.merge.ResolveMerger;
  55. import org.eclipse.jgit.merge.ResolveMerger.MergeFailureReason;
  56. import org.eclipse.jgit.merge.SquashMessageFormatter;
  57. import org.eclipse.jgit.revwalk.RevCommit;
  58. import org.eclipse.jgit.revwalk.RevWalk;
  59. import org.eclipse.jgit.revwalk.RevWalkUtils;
  60. import org.eclipse.jgit.treewalk.FileTreeIterator;
  61. import org.eclipse.jgit.util.StringUtils;

  63. /**
  64.  * A class used to execute a {@code Merge} command. It has setters for all
  65.  * supported options and arguments of this command and a {@link #call()} method
  66.  * to finally execute the command. Each instance of this class should only be
  67.  * used for one invocation of the command (means: one call to {@link #call()})
  68.  *
  69.  * @see <a href="http://www.kernel.org/pub/software/scm/git/docs/git-merge.html"
  70.  *      >Git documentation about Merge</a>
  71.  */
  72. public class MergeCommand extends GitCommand<MergeResult> {

  74.     private MergeStrategy mergeStrategy = MergeStrategy.RECURSIVE;

  76.     private ContentMergeStrategy contentStrategy;

  78.     private List<Ref> commits = new LinkedList<>();

  80.     private Boolean squash;

  82.     private FastForwardMode fastForwardMode;

  84.     private String message;

  86.     private boolean insertChangeId;

  88.     private ProgressMonitor monitor = NullProgressMonitor.INSTANCE;

  90.     /**
  91.      * Values for the "merge.conflictStyle" git config.
  92.      *
  93.      * @since 5.12
  94.      */
  95.     public enum ConflictStyle {

  97.         /** "merge" style: only ours/theirs. This is the default. */
  98.         MERGE,

  100.         /** "diff3" style: ours/base/theirs. */
  101.         DIFF3
  102.     }

  104.     /**
  105.      * The modes available for fast forward merges corresponding to the
  106.      * <code>--ff</code>, <code>--no-ff</code> and <code>--ff-only</code>
  107.      * options under <code>branch.&lt;name&gt;.mergeoptions</code>.
  108.      */
  109.     public enum FastForwardMode implements ConfigEnum {
  110.         /**
  111.          * Corresponds to the default --ff option (for a fast forward update the
  112.          * branch pointer only).
  113.          */
  114.         FF,
  115.         /**
  116.          * Corresponds to the --no-ff option (create a merge commit even for a
  117.          * fast forward).
  118.          */
  119.         NO_FF,
  120.         /**
  121.          * Corresponds to the --ff-only option (abort unless the merge is a fast
  122.          * forward).
  123.          */
  124.         FF_ONLY;

  126.         @Override
  127.         public String toConfigValue() {
  128.             return "--" + name().toLowerCase(Locale.ROOT).replace('_', '-'); //$NON-NLS-1$
  129.         }

  131.         @Override
  132.         public boolean matchConfigValue(String in) {
  133.             if (StringUtils.isEmptyOrNull(in))
  134.                 return false;
  135.             if (!in.startsWith("--")) //$NON-NLS-1$
  136.                 return false;
  137.             return name().equalsIgnoreCase(in.substring(2).replace('-', '_'));
  138.         }

  140.         /**
  141.          * The modes available for fast forward merges corresponding to the
  142.          * options under <code>merge.ff</code>.
  143.          */
  144.         public enum Merge {
  145.             /**
  146.              * {@link FastForwardMode#FF}.
  147.              */
  148.             TRUE,
  149.             /**
  150.              * {@link FastForwardMode#NO_FF}.
  151.              */
  152.             FALSE,
  153.             /**
  154.              * {@link FastForwardMode#FF_ONLY}.
  155.              */
  156.             ONLY;

  158.             /**
  159.              * Map from <code>FastForwardMode</code> to
  160.              * <code>FastForwardMode.Merge</code>.
  161.              *
  162.              * @param ffMode
  163.              *            the <code>FastForwardMode</code> value to be mapped
  164.              * @return the mapped <code>FastForwardMode.Merge</code> value
  165.              */
  166.             public static Merge valueOf(FastForwardMode ffMode) {
  167.                 switch (ffMode) {
  168.                 case NO_FF:
  169.                     return FALSE;
  170.                 case FF_ONLY:
  171.                     return ONLY;
  172.                 default:
  173.                     return TRUE;
  174.                 }
  175.             }
  176.         }

  178.         /**
  179.          * Map from <code>FastForwardMode.Merge</code> to
  180.          * <code>FastForwardMode</code>.
  181.          *
  182.          * @param ffMode
  183.          *            the <code>FastForwardMode.Merge</code> value to be mapped
  184.          * @return the mapped <code>FastForwardMode</code> value
  185.          */
  186.         public static FastForwardMode valueOf(FastForwardMode.Merge ffMode) {
  187.             switch (ffMode) {
  188.             case FALSE:
  189.                 return NO_FF;
  190.             case ONLY:
  191.                 return FF_ONLY;
  192.             default:
  193.                 return FF;
  194.             }
  195.         }
  196.     }

  198.     private Boolean commit;

  200.     /**
  201.      * Constructor for MergeCommand.
  202.      *
  203.      * @param repo
  204.      *            the {@link org.eclipse.jgit.lib.Repository}
  205.      */
  206.     protected MergeCommand(Repository repo) {
  207.         super(repo);
  208.     }

  210.     /**
  211.      * {@inheritDoc}
  212.      * <p>
  213.      * Execute the {@code Merge} command with all the options and parameters
  214.      * collected by the setter methods (e.g. {@link #include(Ref)}) of this
  215.      * class. Each instance of this class should only be used for one invocation
  216.      * of the command. Don't call this method twice on an instance.
  217.      */
  218.     @Override
  219.     @SuppressWarnings("boxing")
  220.     public MergeResult call() throws GitAPIException, NoHeadException,
  221.             ConcurrentRefUpdateException, CheckoutConflictException,
  222.             InvalidMergeHeadsException, WrongRepositoryStateException, NoMessageException {
  223.         checkCallable();
  224.         fallBackToConfiguration();
  225.         checkParameters();

  227.         DirCacheCheckout dco = null;
  228.         try (RevWalk revWalk = new RevWalk(repo)) {
  229.             Ref head = repo.exactRef(Constants.HEAD);
  230.             if (head == null)
  231.                 throw new NoHeadException(
  232.                         JGitText.get().commitOnRepoWithoutHEADCurrentlyNotSupported);
  233.             StringBuilder refLogMessage = new StringBuilder("merge "); //$NON-NLS-1$

  235.             // Check for FAST_FORWARD, ALREADY_UP_TO_DATE

  237.             // we know for now there is only one commit
  238.             Ref ref = commits.get(0);

  240.             refLogMessage.append(ref.getName());

  242.             // handle annotated tags
  243.             ref = repo.getRefDatabase().peel(ref);
  244.             ObjectId objectId = ref.getPeeledObjectId();
  245.             if (objectId == null)
  246.                 objectId = ref.getObjectId();

  248.             RevCommit srcCommit = revWalk.lookupCommit(objectId);

  250.             ObjectId headId = head.getObjectId();
  251.             if (headId == null) {
  252.                 revWalk.parseHeaders(srcCommit);
  253.                 dco = new DirCacheCheckout(repo,
  254.                         repo.lockDirCache(), srcCommit.getTree());
  255.                 dco.setFailOnConflict(true);
  256.                 dco.setProgressMonitor(monitor);
  257.                 dco.checkout();
  258.                 RefUpdate refUpdate = repo
  259.                         .updateRef(head.getTarget().getName());
  260.                 refUpdate.setNewObjectId(objectId);
  261.                 refUpdate.setExpectedOldObjectId(null);
  262.                 refUpdate.setRefLogMessage("initial pull", false); //$NON-NLS-1$
  263.                 if (refUpdate.update() != Result.NEW)
  264.                     throw new NoHeadException(
  265.                             JGitText.get().commitOnRepoWithoutHEADCurrentlyNotSupported);
  266.                 setCallable(false);
  267.                 return new MergeResult(srcCommit, srcCommit, new ObjectId[] {
  268.                         null, srcCommit }, MergeStatus.FAST_FORWARD,
  269.                         mergeStrategy, null, null);
  270.             }

  272.             RevCommit headCommit = revWalk.lookupCommit(headId);

  274.             if (revWalk.isMergedInto(srcCommit, headCommit)) {
  275.                 setCallable(false);
  276.                 return new MergeResult(headCommit, srcCommit, new ObjectId[] {
  277.                         headCommit, srcCommit },
  278.                         MergeStatus.ALREADY_UP_TO_DATE, mergeStrategy, null, null);
  279.             } else if (revWalk.isMergedInto(headCommit, srcCommit)
  280.                     && fastForwardMode != FastForwardMode.NO_FF) {
  281.                 // FAST_FORWARD detected: skip doing a real merge but only
  282.                 // update HEAD
  283.                 refLogMessage.append(": " + MergeStatus.FAST_FORWARD); //$NON-NLS-1$
  284.                 dco = new DirCacheCheckout(repo,
  285.                         headCommit.getTree(), repo.lockDirCache(),
  286.                         srcCommit.getTree());
  287.                 dco.setProgressMonitor(monitor);
  288.                 dco.setFailOnConflict(true);
  289.                 dco.checkout();
  290.                 String msg = null;
  291.                 ObjectId newHead, base = null;
  292.                 MergeStatus mergeStatus = null;
  293.                 if (!squash) {
  294.                     updateHead(refLogMessage, srcCommit, headId);
  295.                     newHead = base = srcCommit;
  296.                     mergeStatus = MergeStatus.FAST_FORWARD;
  297.                 } else {
  298.                     msg = JGitText.get().squashCommitNotUpdatingHEAD;
  299.                     newHead = base = headId;
  300.                     mergeStatus = MergeStatus.FAST_FORWARD_SQUASHED;
  301.                     List<RevCommit> squashedCommits = RevWalkUtils.find(
  302.                             revWalk, srcCommit, headCommit);
  303.                     String squashMessage = new SquashMessageFormatter().format(
  304.                             squashedCommits, head);
  305.                     repo.writeSquashCommitMsg(squashMessage);
  306.                 }
  307.                 setCallable(false);
  308.                 return new MergeResult(newHead, base, new ObjectId[] {
  309.                         headCommit, srcCommit }, mergeStatus, mergeStrategy,
  310.                         null, msg);
  311.             } else {
  312.                 if (fastForwardMode == FastForwardMode.FF_ONLY) {
  313.                     return new MergeResult(headCommit, srcCommit,
  314.                             new ObjectId[] { headCommit, srcCommit },
  315.                             MergeStatus.ABORTED, mergeStrategy, null, null);
  316.                 }
  317.                 String mergeMessage = ""; //$NON-NLS-1$
  318.                 if (!squash) {
  319.                     if (message != null)
  320.                         mergeMessage = message;
  321.                     else
  322.                         mergeMessage = new MergeMessageFormatter().format(
  323.                             commits, head);
  324.                     repo.writeMergeCommitMsg(mergeMessage);
  325.                     repo.writeMergeHeads(Arrays.asList(ref.getObjectId()));
  326.                 } else {
  327.                     List<RevCommit> squashedCommits = RevWalkUtils.find(
  328.                             revWalk, srcCommit, headCommit);
  329.                     String squashMessage = new SquashMessageFormatter().format(
  330.                             squashedCommits, head);
  331.                     repo.writeSquashCommitMsg(squashMessage);
  332.                 }
  333.                 Merger merger = mergeStrategy.newMerger(repo);
  334.                 merger.setProgressMonitor(monitor);
  335.                 boolean noProblems;
  336.                 Map<String, org.eclipse.jgit.merge.MergeResult<?>> lowLevelResults = null;
  337.                 Map<String, MergeFailureReason> failingPaths = null;
  338.                 List<String> unmergedPaths = null;
  339.                 if (merger instanceof ResolveMerger) {
  340.                     ResolveMerger resolveMerger = (ResolveMerger) merger;
  341.                     resolveMerger.setContentMergeStrategy(contentStrategy);
  342.                     resolveMerger.setCommitNames(new String[] {
  343.                             "BASE", "HEAD", ref.getName() }); //$NON-NLS-1$ //$NON-NLS-2$
  344.                     resolveMerger.setWorkingTreeIterator(new FileTreeIterator(repo));
  345.                     noProblems = merger.merge(headCommit, srcCommit);
  346.                     lowLevelResults = resolveMerger
  347.                             .getMergeResults();
  348.                     failingPaths = resolveMerger.getFailingPaths();
  349.                     unmergedPaths = resolveMerger.getUnmergedPaths();
  350.                     if (!resolveMerger.getModifiedFiles().isEmpty()) {
  351.                         repo.fireEvent(new WorkingTreeModifiedEvent(
  352.                                 resolveMerger.getModifiedFiles(), null));
  353.                     }
  354.                 } else
  355.                     noProblems = merger.merge(headCommit, srcCommit);
  356.                 refLogMessage.append(": Merge made by "); //$NON-NLS-1$
  357.                 if (!revWalk.isMergedInto(headCommit, srcCommit))
  358.                     refLogMessage.append(mergeStrategy.getName());
  359.                 else
  360.                     refLogMessage.append("recursive"); //$NON-NLS-1$
  361.                 refLogMessage.append('.');
  362.                 if (noProblems) {
  363.                     dco = new DirCacheCheckout(repo,
  364.                             headCommit.getTree(), repo.lockDirCache(),
  365.                             merger.getResultTreeId());
  366.                     dco.setFailOnConflict(true);
  367.                     dco.setProgressMonitor(monitor);
  368.                     dco.checkout();

  370.                     String msg = null;
  371.                     ObjectId newHeadId = null;
  372.                     MergeStatus mergeStatus = null;
  373.                     if (!commit && squash) {
  374.                         mergeStatus = MergeStatus.MERGED_SQUASHED_NOT_COMMITTED;
  375.                     }
  376.                     if (!commit && !squash) {
  377.                         mergeStatus = MergeStatus.MERGED_NOT_COMMITTED;
  378.                     }
  379.                     if (commit && !squash) {
  380.                         try (Git git = new Git(getRepository())) {
  381.                             newHeadId = git.commit()
  382.                                     .setReflogComment(refLogMessage.toString())
  383.                                     .setInsertChangeId(insertChangeId)
  384.                                     .call().getId();
  385.                         }
  386.                         mergeStatus = MergeStatus.MERGED;
  387.                         getRepository().autoGC(monitor);
  388.                     }
  389.                     if (commit && squash) {
  390.                         msg = JGitText.get().squashCommitNotUpdatingHEAD;
  391.                         newHeadId = headCommit.getId();
  392.                         mergeStatus = MergeStatus.MERGED_SQUASHED;
  393.                     }
  394.                     return new MergeResult(newHeadId, null,
  395.                             new ObjectId[] { headCommit.getId(),
  396.                                     srcCommit.getId() }, mergeStatus,
  397.                             mergeStrategy, null, msg);
  398.                 }
  399.                 if (failingPaths != null) {
  400.                     repo.writeMergeCommitMsg(null);
  401.                     repo.writeMergeHeads(null);
  402.                     return new MergeResult(null, merger.getBaseCommitId(),
  403.                             new ObjectId[] { headCommit.getId(),
  404.                                     srcCommit.getId() },
  405.                             MergeStatus.FAILED, mergeStrategy, lowLevelResults,
  406.                             failingPaths, null);
  407.                 }
  408.                 CommitConfig cfg = repo.getConfig().get(CommitConfig.KEY);
  409.                 char commentChar = cfg.getCommentChar(message);
  410.                 String mergeMessageWithConflicts = new MergeMessageFormatter()
  411.                         .formatWithConflicts(mergeMessage, unmergedPaths,
  412.                                 commentChar);
  413.                 repo.writeMergeCommitMsg(mergeMessageWithConflicts);
  414.                 return new MergeResult(null, merger.getBaseCommitId(),
  415.                         new ObjectId[] { headCommit.getId(),
  416.                                 srcCommit.getId() },
  417.                         MergeStatus.CONFLICTING, mergeStrategy, lowLevelResults,
  418.                         null);
  419.             }
  420.         } catch (org.eclipse.jgit.errors.CheckoutConflictException e) {
  421.             List<String> conflicts = (dco == null) ? Collections
  422.                     .<String> emptyList() : dco.getConflicts();
  423.             throw new CheckoutConflictException(conflicts, e);
  424.         } catch (IOException e) {
  425.             throw new JGitInternalException(
  426.                     MessageFormat.format(
  427.                             JGitText.get().exceptionCaughtDuringExecutionOfMergeCommand,
  428.                             e), e);
  429.         }
  430.     }

  432.     private void checkParameters() throws InvalidMergeHeadsException {
  433.         if (squash.booleanValue() && fastForwardMode == FastForwardMode.NO_FF) {
  434.             throw new JGitInternalException(
  435.                     JGitText.get().cannotCombineSquashWithNoff);
  436.         }

  438.         if (commits.size() != 1)
  439.             throw new InvalidMergeHeadsException(
  440.                     commits.isEmpty() ? JGitText.get().noMergeHeadSpecified
  441.                             : MessageFormat.format(
  442.                                     JGitText.get().mergeStrategyDoesNotSupportHeads,
  443.                                     mergeStrategy.getName(),
  444.                                     Integer.valueOf(commits.size())));
  445.     }

  447.     /**
  448.      * Use values from the configuration if they have not been explicitly
  449.      * defined via the setters
  450.      */
  451.     private void fallBackToConfiguration() {
  452.         MergeConfig config = MergeConfig.getConfigForCurrentBranch(repo);
  453.         if (squash == null)
  454.             squash = Boolean.valueOf(config.isSquash());
  455.         if (commit == null)
  456.             commit = Boolean.valueOf(config.isCommit());
  457.         if (fastForwardMode == null)
  458.             fastForwardMode = config.getFastForwardMode();
  459.     }

  461.     private void updateHead(StringBuilder refLogMessage, ObjectId newHeadId,
  462.             ObjectId oldHeadID) throws IOException,
  463.             ConcurrentRefUpdateException {
  464.         RefUpdate refUpdate = repo.updateRef(Constants.HEAD);
  465.         refUpdate.setNewObjectId(newHeadId);
  466.         refUpdate.setRefLogMessage(refLogMessage.toString(), false);
  467.         refUpdate.setExpectedOldObjectId(oldHeadID);
  468.         Result rc = refUpdate.update();
  469.         switch (rc) {
  470.         case NEW:
  471.         case FAST_FORWARD:
  472.             return;
  473.         case REJECTED:
  474.         case LOCK_FAILURE:
  475.             throw new ConcurrentRefUpdateException(
  476.                     JGitText.get().couldNotLockHEAD, refUpdate.getRef(), rc);
  477.         default:
  478.             throw new JGitInternalException(MessageFormat.format(
  479.                     JGitText.get().updatingRefFailed, Constants.HEAD,
  480.                     newHeadId.toString(), rc));
  481.         }
  482.     }

  484.     /**
  485.      * Set merge strategy
  486.      *
  487.      * @param mergeStrategy
  488.      *            the {@link org.eclipse.jgit.merge.MergeStrategy} to be used
  489.      * @return {@code this}
  490.      */
  491.     public MergeCommand setStrategy(MergeStrategy mergeStrategy) {
  492.         checkCallable();
  493.         this.mergeStrategy = mergeStrategy;
  494.         return this;
  495.     }

  497.     /**
  498.      * Sets the content merge strategy to use if the
  499.      * {@link #setStrategy(MergeStrategy) merge strategy} is "resolve" or
  500.      * "recursive".
  501.      *
  502.      * @param strategy
  503.      *            the {@link ContentMergeStrategy} to be used
  504.      * @return {@code this}
  505.      * @since 5.12
  506.      */
  507.     public MergeCommand setContentMergeStrategy(ContentMergeStrategy strategy) {
  508.         checkCallable();
  509.         this.contentStrategy = strategy;
  510.         return this;
  511.     }

  513.     /**
  514.      * Reference to a commit to be merged with the current head
  515.      *
  516.      * @param aCommit
  517.      *            a reference to a commit which is merged with the current head
  518.      * @return {@code this}
  519.      */
  520.     public MergeCommand include(Ref aCommit) {
  521.         checkCallable();
  522.         commits.add(aCommit);
  523.         return this;
  524.     }

  526.     /**
  527.      * Id of a commit which is to be merged with the current head
  528.      *
  529.      * @param aCommit
  530.      *            the Id of a commit which is merged with the current head
  531.      * @return {@code this}
  532.      */
  533.     public MergeCommand include(AnyObjectId aCommit) {
  534.         return include(aCommit.getName(), aCommit);
  535.     }

  537.     /**
  538.      * Include a commit
  539.      *
  540.      * @param name
  541.      *            a name of a {@code Ref} pointing to the commit
  542.      * @param aCommit
  543.      *            the Id of a commit which is merged with the current head
  544.      * @return {@code this}
  545.      */
  546.     public MergeCommand include(String name, AnyObjectId aCommit) {
  547.         return include(new ObjectIdRef.Unpeeled(Storage.LOOSE, name,
  548.                 aCommit.copy()));
  549.     }

  551.     /**
  552.      * If <code>true</code>, will prepare the next commit in working tree and
  553.      * index as if a real merge happened, but do not make the commit or move the
  554.      * HEAD. Otherwise, perform the merge and commit the result.
  555.      * <p>
  556.      * In case the merge was successful but this flag was set to
  557.      * <code>true</code> a {@link org.eclipse.jgit.api.MergeResult} with status
  558.      * {@link org.eclipse.jgit.api.MergeResult.MergeStatus#MERGED_SQUASHED} or
  559.      * {@link org.eclipse.jgit.api.MergeResult.MergeStatus#FAST_FORWARD_SQUASHED}
  560.      * is returned.
  561.      *
  562.      * @param squash
  563.      *            whether to squash commits or not
  564.      * @return {@code this}
  565.      * @since 2.0
  566.      */
  567.     public MergeCommand setSquash(boolean squash) {
  568.         checkCallable();
  569.         this.squash = Boolean.valueOf(squash);
  570.         return this;
  571.     }

  573.     /**
  574.      * Sets the fast forward mode.
  575.      *
  576.      * @param fastForwardMode
  577.      *            corresponds to the --ff/--no-ff/--ff-only options. If
  578.      *            {@code null} use the value of the {@code merge.ff} option
  579.      *            configured in git config. If this option is not configured
  580.      *            --ff is the built-in default.
  581.      * @return {@code this}
  582.      * @since 2.2
  583.      */
  584.     public MergeCommand setFastForward(
  585.             @Nullable FastForwardMode fastForwardMode) {
  586.         checkCallable();
  587.         this.fastForwardMode = fastForwardMode;
  588.         return this;
  589.     }

  591.     /**
  592.      * Controls whether the merge command should automatically commit after a
  593.      * successful merge
  594.      *
  595.      * @param commit
  596.      *            <code>true</code> if this command should commit (this is the
  597.      *            default behavior). <code>false</code> if this command should
  598.      *            not commit. In case the merge was successful but this flag was
  599.      *            set to <code>false</code> a
  600.      *            {@link org.eclipse.jgit.api.MergeResult} with type
  601.      *            {@link org.eclipse.jgit.api.MergeResult} with status
  602.      *            {@link org.eclipse.jgit.api.MergeResult.MergeStatus#MERGED_NOT_COMMITTED}
  603.      *            is returned
  604.      * @return {@code this}
  605.      * @since 3.0
  606.      */
  607.     public MergeCommand setCommit(boolean commit) {
  608.         this.commit = Boolean.valueOf(commit);
  609.         return this;
  610.     }

  612.     /**
  613.      * Set the commit message to be used for the merge commit (in case one is
  614.      * created)
  615.      *
  616.      * @param message
  617.      *            the message to be used for the merge commit
  618.      * @return {@code this}
  619.      * @since 3.5
  620.      */
  621.     public MergeCommand setMessage(String message) {
  622.         this.message = message;
  623.         return this;
  624.     }

  626.     /**
  627.      * If set to true a change id will be inserted into the commit message
  628.      *
  629.      * An existing change id is not replaced. An initial change id (I000...)
  630.      * will be replaced by the change id.
  631.      *
  632.      * @param insertChangeId
  633.      *            whether to insert a change id
  634.      * @return {@code this}
  635.      * @since 5.0
  636.      */
  637.     public MergeCommand setInsertChangeId(boolean insertChangeId) {
  638.         checkCallable();
  639.         this.insertChangeId = insertChangeId;
  640.         return this;
  641.     }

  643.     /**
  644.      * The progress monitor associated with the diff operation. By default, this
  645.      * is set to <code>NullProgressMonitor</code>
  646.      *
  647.      * @see NullProgressMonitor
  648.      * @param monitor
  649.      *            A progress monitor
  650.      * @return this instance
  651.      * @since 4.2
  652.      */
  653.     public MergeCommand setProgressMonitor(ProgressMonitor monitor) {
  654.         if (monitor == null) {
  655.             monitor = NullProgressMonitor.INSTANCE;
  656.         }
  657.         this.monitor = monitor;
  658.         return this;
  659.     }
  660. }
Created with JaCoCo 0.8.7.202105040129