CommitCommand.java

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

  12. import java.io.IOException;
  13. import java.io.InputStream;
  14. import java.io.PrintStream;
  15. import java.text.MessageFormat;
  16. import java.util.ArrayList;
  17. import java.util.Collections;
  18. import java.util.HashMap;
  19. import java.util.LinkedList;
  20. import java.util.List;

  22. import org.eclipse.jgit.api.errors.AbortedByHookException;
  23. import org.eclipse.jgit.api.errors.ConcurrentRefUpdateException;
  24. import org.eclipse.jgit.api.errors.EmptyCommitException;
  25. import org.eclipse.jgit.api.errors.GitAPIException;
  26. import org.eclipse.jgit.api.errors.JGitInternalException;
  27. import org.eclipse.jgit.api.errors.NoFilepatternException;
  28. import org.eclipse.jgit.api.errors.NoHeadException;
  29. import org.eclipse.jgit.api.errors.NoMessageException;
  30. import org.eclipse.jgit.api.errors.ServiceUnavailableException;
  31. import org.eclipse.jgit.api.errors.UnmergedPathsException;
  32. import org.eclipse.jgit.api.errors.UnsupportedSigningFormatException;
  33. import org.eclipse.jgit.api.errors.WrongRepositoryStateException;
  34. import org.eclipse.jgit.dircache.DirCache;
  35. import org.eclipse.jgit.dircache.DirCacheBuildIterator;
  36. import org.eclipse.jgit.dircache.DirCacheBuilder;
  37. import org.eclipse.jgit.dircache.DirCacheEntry;
  38. import org.eclipse.jgit.dircache.DirCacheIterator;
  39. import org.eclipse.jgit.errors.UnmergedPathException;
  40. import org.eclipse.jgit.hooks.CommitMsgHook;
  41. import org.eclipse.jgit.hooks.Hooks;
  42. import org.eclipse.jgit.hooks.PostCommitHook;
  43. import org.eclipse.jgit.hooks.PreCommitHook;
  44. import org.eclipse.jgit.internal.JGitText;
  45. import org.eclipse.jgit.lib.CommitBuilder;
  46. import org.eclipse.jgit.lib.Constants;
  47. import org.eclipse.jgit.lib.FileMode;
  48. import org.eclipse.jgit.lib.GpgConfig;
  49. import org.eclipse.jgit.lib.GpgConfig.GpgFormat;
  50. import org.eclipse.jgit.lib.GpgObjectSigner;
  51. import org.eclipse.jgit.lib.GpgSigner;
  52. import org.eclipse.jgit.lib.ObjectId;
  53. import org.eclipse.jgit.lib.ObjectInserter;
  54. import org.eclipse.jgit.lib.PersonIdent;
  55. import org.eclipse.jgit.lib.Ref;
  56. import org.eclipse.jgit.lib.RefUpdate;
  57. import org.eclipse.jgit.lib.RefUpdate.Result;
  58. import org.eclipse.jgit.lib.Repository;
  59. import org.eclipse.jgit.lib.RepositoryState;
  60. import org.eclipse.jgit.revwalk.RevCommit;
  61. import org.eclipse.jgit.revwalk.RevObject;
  62. import org.eclipse.jgit.revwalk.RevTag;
  63. import org.eclipse.jgit.revwalk.RevWalk;
  64. import org.eclipse.jgit.transport.CredentialsProvider;
  65. import org.eclipse.jgit.treewalk.CanonicalTreeParser;
  66. import org.eclipse.jgit.treewalk.FileTreeIterator;
  67. import org.eclipse.jgit.treewalk.TreeWalk;
  68. import org.eclipse.jgit.treewalk.TreeWalk.OperationType;
  69. import org.eclipse.jgit.util.ChangeIdUtil;

  71. /**
  72.  * A class used to execute a {@code Commit} command. It has setters for all
  73.  * supported options and arguments of this command and a {@link #call()} method
  74.  * to finally execute the command.
  75.  *
  76.  * @see <a
  77.  *      href="http://www.kernel.org/pub/software/scm/git/docs/git-commit.html"
  78.  *      >Git documentation about Commit</a>
  79.  */
  80. public class CommitCommand extends GitCommand<RevCommit> {
  81.     private PersonIdent author;

  83.     private PersonIdent committer;

  85.     private String message;

  87.     private boolean all;

  89.     private List<String> only = new ArrayList<>();

  91.     private boolean[] onlyProcessed;

  93.     private boolean amend;

  95.     private boolean insertChangeId;

  97.     /**
  98.      * parents this commit should have. The current HEAD will be in this list
  99.      * and also all commits mentioned in .git/MERGE_HEAD
  100.      */
  101.     private List<ObjectId> parents = new LinkedList<>();

  103.     private String reflogComment;

  105.     private boolean useDefaultReflogMessage = true;

  107.     /**
  108.      * Setting this option bypasses the pre-commit and commit-msg hooks.
  109.      */
  110.     private boolean noVerify;

  112.     private HashMap<String, PrintStream> hookOutRedirect = new HashMap<>(3);

  114.     private HashMap<String, PrintStream> hookErrRedirect = new HashMap<>(3);

  116.     private Boolean allowEmpty;

  118.     private Boolean signCommit;

  120.     private String signingKey;

  122.     private GpgSigner gpgSigner;

  124.     private GpgConfig gpgConfig;

  126.     private CredentialsProvider credentialsProvider;

  128.     /**
  129.      * Constructor for CommitCommand
  130.      *
  131.      * @param repo
  132.      *            the {@link org.eclipse.jgit.lib.Repository}
  133.      */
  134.     protected CommitCommand(Repository repo) {
  135.         super(repo);
  136.         this.credentialsProvider = CredentialsProvider.getDefault();
  137.     }

  139.     /**
  140.      * {@inheritDoc}
  141.      * <p>
  142.      * Executes the {@code commit} command with all the options and parameters
  143.      * collected by the setter methods of this class. Each instance of this
  144.      * class should only be used for one invocation of the command (means: one
  145.      * call to {@link #call()})
  146.      *
  147.      * @throws ServiceUnavailableException
  148.      *             if signing service is not available e.g. since it isn't
  149.      *             installed
  150.      */
  151.     @Override
  152.     public RevCommit call() throws GitAPIException, AbortedByHookException,
  153.             ConcurrentRefUpdateException, NoHeadException, NoMessageException,
  154.             ServiceUnavailableException, UnmergedPathsException,
  155.             WrongRepositoryStateException {
  156.         checkCallable();
  157.         Collections.sort(only);

  159.         try (RevWalk rw = new RevWalk(repo)) {
  160.             RepositoryState state = repo.getRepositoryState();
  161.             if (!state.canCommit())
  162.                 throw new WrongRepositoryStateException(MessageFormat.format(
  163.                         JGitText.get().cannotCommitOnARepoWithState,
  164.                         state.name()));

  166.             if (!noVerify) {
  167.                 Hooks.preCommit(repo, hookOutRedirect.get(PreCommitHook.NAME),
  168.                         hookErrRedirect.get(PreCommitHook.NAME))
  169.                         .call();
  170.             }

  172.             processOptions(state, rw);

  174.             if (all && !repo.isBare()) {
  175.                 try (Git git = new Git(repo)) {
  176.                     git.add()
  177.                             .addFilepattern(".") //$NON-NLS-1$
  178.                             .setUpdate(true).call();
  179.                 } catch (NoFilepatternException e) {
  180.                     // should really not happen
  181.                     throw new JGitInternalException(e.getMessage(), e);
  182.                 }
  183.             }

  185.             Ref head = repo.exactRef(Constants.HEAD);
  186.             if (head == null)
  187.                 throw new NoHeadException(
  188.                         JGitText.get().commitOnRepoWithoutHEADCurrentlyNotSupported);

  190.             // determine the current HEAD and the commit it is referring to
  191.             ObjectId headId = repo.resolve(Constants.HEAD + "^{commit}"); //$NON-NLS-1$
  192.             if (headId == null && amend)
  193.                 throw new WrongRepositoryStateException(
  194.                         JGitText.get().commitAmendOnInitialNotPossible);

  196.             if (headId != null)
  197.                 if (amend) {
  198.                     RevCommit previousCommit = rw.parseCommit(headId);
  199.                     for (RevCommit p : previousCommit.getParents())
  200.                         parents.add(p.getId());
  201.                     if (author == null)
  202.                         author = previousCommit.getAuthorIdent();
  203.                 } else {
  204.                     parents.add(0, headId);
  205.                 }

  207.             if (!noVerify) {
  208.                 message = Hooks
  209.                         .commitMsg(repo,
  210.                                 hookOutRedirect.get(CommitMsgHook.NAME),
  211.                                 hookErrRedirect.get(CommitMsgHook.NAME))
  212.                         .setCommitMessage(message).call();
  213.             }

  215.             // lock the index
  216.             DirCache index = repo.lockDirCache();
  217.             try (ObjectInserter odi = repo.newObjectInserter()) {
  218.                 if (!only.isEmpty())
  219.                     index = createTemporaryIndex(headId, index, rw);

  221.                 // Write the index as tree to the object database. This may
  222.                 // fail for example when the index contains unmerged paths
  223.                 // (unresolved conflicts)
  224.                 ObjectId indexTreeId = index.writeTree(odi);

  226.                 if (insertChangeId)
  227.                     insertChangeId(indexTreeId);

  229.                 // Check for empty commits
  230.                 if (headId != null && !allowEmpty.booleanValue()) {
  231.                     RevCommit headCommit = rw.parseCommit(headId);
  232.                     headCommit.getTree();
  233.                     if (indexTreeId.equals(headCommit.getTree())) {
  234.                         throw new EmptyCommitException(
  235.                                 JGitText.get().emptyCommit);
  236.                     }
  237.                 }

  239.                 // Create a Commit object, populate it and write it
  240.                 CommitBuilder commit = new CommitBuilder();
  241.                 commit.setCommitter(committer);
  242.                 commit.setAuthor(author);
  243.                 commit.setMessage(message);

  245.                 commit.setParentIds(parents);
  246.                 commit.setTreeId(indexTreeId);

  248.                 if (signCommit.booleanValue()) {
  249.                     if (gpgSigner == null) {
  250.                         throw new ServiceUnavailableException(
  251.                                 JGitText.get().signingServiceUnavailable);
  252.                     }
  253.                     if (gpgSigner instanceof GpgObjectSigner) {
  254.                         ((GpgObjectSigner) gpgSigner).signObject(commit,
  255.                                 signingKey, committer, credentialsProvider,
  256.                                 gpgConfig);
  257.                     } else {
  258.                         if (gpgConfig.getKeyFormat() != GpgFormat.OPENPGP) {
  259.                             throw new UnsupportedSigningFormatException(JGitText
  260.                                     .get().onlyOpenPgpSupportedForSigning);
  261.                         }
  262.                         gpgSigner.sign(commit, signingKey, committer,
  263.                                 credentialsProvider);
  264.                     }
  265.                 }

  267.                 ObjectId commitId = odi.insert(commit);
  268.                 odi.flush();

  270.                 RevCommit revCommit = rw.parseCommit(commitId);
  271.                 RefUpdate ru = repo.updateRef(Constants.HEAD);
  272.                 ru.setNewObjectId(commitId);
  273.                 if (!useDefaultReflogMessage) {
  274.                     ru.setRefLogMessage(reflogComment, false);
  275.                 } else {
  276.                     String prefix = amend ? "commit (amend): " //$NON-NLS-1$
  277.                             : parents.isEmpty() ? "commit (initial): " //$NON-NLS-1$
  278.                                     : "commit: "; //$NON-NLS-1$
  279.                     ru.setRefLogMessage(prefix + revCommit.getShortMessage(),
  280.                             false);
  281.                 }
  282.                 if (headId != null)
  283.                     ru.setExpectedOldObjectId(headId);
  284.                 else
  285.                     ru.setExpectedOldObjectId(ObjectId.zeroId());
  286.                 Result rc = ru.forceUpdate();
  287.                 switch (rc) {
  288.                 case NEW:
  289.                 case FORCED:
  290.                 case FAST_FORWARD: {
  291.                     setCallable(false);
  292.                     if (state == RepositoryState.MERGING_RESOLVED
  293.                             || isMergeDuringRebase(state)) {
  294.                         // Commit was successful. Now delete the files
  295.                         // used for merge commits
  296.                         repo.writeMergeCommitMsg(null);
  297.                         repo.writeMergeHeads(null);
  298.                     } else if (state == RepositoryState.CHERRY_PICKING_RESOLVED) {
  299.                         repo.writeMergeCommitMsg(null);
  300.                         repo.writeCherryPickHead(null);
  301.                     } else if (state == RepositoryState.REVERTING_RESOLVED) {
  302.                         repo.writeMergeCommitMsg(null);
  303.                         repo.writeRevertHead(null);
  304.                     }
  305.                     Hooks.postCommit(repo,
  306.                             hookOutRedirect.get(PostCommitHook.NAME),
  307.                             hookErrRedirect.get(PostCommitHook.NAME)).call();

  309.                     return revCommit;
  310.                 }
  311.                 case REJECTED:
  312.                 case LOCK_FAILURE:
  313.                     throw new ConcurrentRefUpdateException(
  314.                             JGitText.get().couldNotLockHEAD, ru.getRef(), rc);
  315.                 default:
  316.                     throw new JGitInternalException(MessageFormat.format(
  317.                             JGitText.get().updatingRefFailed, Constants.HEAD,
  318.                             commitId.toString(), rc));
  319.                 }
  320.             } finally {
  321.                 index.unlock();
  322.             }
  323.         } catch (UnmergedPathException e) {
  324.             throw new UnmergedPathsException(e);
  325.         } catch (IOException e) {
  326.             throw new JGitInternalException(
  327.                     JGitText.get().exceptionCaughtDuringExecutionOfCommitCommand, e);
  328.         }
  329.     }

  331.     private void insertChangeId(ObjectId treeId) {
  332.         ObjectId firstParentId = null;
  333.         if (!parents.isEmpty())
  334.             firstParentId = parents.get(0);
  335.         ObjectId changeId = ChangeIdUtil.computeChangeId(treeId, firstParentId,
  336.                 author, committer, message);
  337.         message = ChangeIdUtil.insertId(message, changeId);
  338.         if (changeId != null)
  339.             message = message.replaceAll("\nChange-Id: I" //$NON-NLS-1$
  340.                     + ObjectId.zeroId().getName() + "\n", "\nChange-Id: I" //$NON-NLS-1$ //$NON-NLS-2$
  341.                     + changeId.getName() + "\n"); //$NON-NLS-1$
  342.     }

  344.     private DirCache createTemporaryIndex(ObjectId headId, DirCache index,
  345.             RevWalk rw)
  346.             throws IOException {
  347.         ObjectInserter inserter = null;

  349.         // get DirCacheBuilder for existing index
  350.         DirCacheBuilder existingBuilder = index.builder();

  352.         // get DirCacheBuilder for newly created in-core index to build a
  353.         // temporary index for this commit
  354.         DirCache inCoreIndex = DirCache.newInCore();
  355.         DirCacheBuilder tempBuilder = inCoreIndex.builder();

  357.         onlyProcessed = new boolean[only.size()];
  358.         boolean emptyCommit = true;

  360.         try (TreeWalk treeWalk = new TreeWalk(repo)) {
  361.             treeWalk.setOperationType(OperationType.CHECKIN_OP);
  362.             int dcIdx = treeWalk
  363.                     .addTree(new DirCacheBuildIterator(existingBuilder));
  364.             FileTreeIterator fti = new FileTreeIterator(repo);
  365.             fti.setDirCacheIterator(treeWalk, 0);
  366.             int fIdx = treeWalk.addTree(fti);
  367.             int hIdx = -1;
  368.             if (headId != null)
  369.                 hIdx = treeWalk.addTree(rw.parseTree(headId));
  370.             treeWalk.setRecursive(true);

  372.             String lastAddedFile = null;
  373.             while (treeWalk.next()) {
  374.                 String path = treeWalk.getPathString();
  375.                 // check if current entry's path matches a specified path
  376.                 int pos = lookupOnly(path);

  378.                 CanonicalTreeParser hTree = null;
  379.                 if (hIdx != -1)
  380.                     hTree = treeWalk.getTree(hIdx, CanonicalTreeParser.class);

  382.                 DirCacheIterator dcTree = treeWalk.getTree(dcIdx,
  383.                         DirCacheIterator.class);

  385.                 if (pos >= 0) {
  386.                     // include entry in commit

  388.                     FileTreeIterator fTree = treeWalk.getTree(fIdx,
  389.                             FileTreeIterator.class);

  391.                     // check if entry refers to a tracked file
  392.                     boolean tracked = dcTree != null || hTree != null;
  393.                     if (!tracked)
  394.                         continue;

  396.                     // for an unmerged path, DirCacheBuildIterator will yield 3
  397.                     // entries, we only want to add one
  398.                     if (path.equals(lastAddedFile))
  399.                         continue;

  401.                     lastAddedFile = path;

  403.                     if (fTree != null) {
  404.                         // create a new DirCacheEntry with data retrieved from
  405.                         // disk
  406.                         final DirCacheEntry dcEntry = new DirCacheEntry(path);
  407.                         long entryLength = fTree.getEntryLength();
  408.                         dcEntry.setLength(entryLength);
  409.                         dcEntry.setLastModified(fTree.getEntryLastModifiedInstant());
  410.                         dcEntry.setFileMode(fTree.getIndexFileMode(dcTree));

  412.                         boolean objectExists = (dcTree != null
  413.                                 && fTree.idEqual(dcTree))
  414.                                 || (hTree != null && fTree.idEqual(hTree));
  415.                         if (objectExists) {
  416.                             dcEntry.setObjectId(fTree.getEntryObjectId());
  417.                         } else {
  418.                             if (FileMode.GITLINK.equals(dcEntry.getFileMode()))
  419.                                 dcEntry.setObjectId(fTree.getEntryObjectId());
  420.                             else {
  421.                                 // insert object
  422.                                 if (inserter == null)
  423.                                     inserter = repo.newObjectInserter();
  424.                                 long contentLength = fTree
  425.                                         .getEntryContentLength();
  426.                                 try (InputStream inputStream = fTree
  427.                                         .openEntryStream()) {
  428.                                     dcEntry.setObjectId(inserter.insert(
  429.                                             Constants.OBJ_BLOB, contentLength,
  430.                                             inputStream));
  431.                                 }
  432.                             }
  433.                         }

  435.                         // add to existing index
  436.                         existingBuilder.add(dcEntry);
  437.                         // add to temporary in-core index
  438.                         tempBuilder.add(dcEntry);

  440.                         if (emptyCommit
  441.                                 && (hTree == null || !hTree.idEqual(fTree)
  442.                                         || hTree.getEntryRawMode() != fTree
  443.                                                 .getEntryRawMode()))
  444.                             // this is a change
  445.                             emptyCommit = false;
  446.                     } else {
  447.                         // if no file exists on disk, neither add it to
  448.                         // index nor to temporary in-core index

  450.                         if (emptyCommit && hTree != null)
  451.                             // this is a change
  452.                             emptyCommit = false;
  453.                     }

  455.                     // keep track of processed path
  456.                     onlyProcessed[pos] = true;
  457.                 } else {
  458.                     // add entries from HEAD for all other paths
  459.                     if (hTree != null) {
  460.                         // create a new DirCacheEntry with data retrieved from
  461.                         // HEAD
  462.                         final DirCacheEntry dcEntry = new DirCacheEntry(path);
  463.                         dcEntry.setObjectId(hTree.getEntryObjectId());
  464.                         dcEntry.setFileMode(hTree.getEntryFileMode());

  466.                         // add to temporary in-core index
  467.                         tempBuilder.add(dcEntry);
  468.                     }

  470.                     // preserve existing entry in index
  471.                     if (dcTree != null)
  472.                         existingBuilder.add(dcTree.getDirCacheEntry());
  473.                 }
  474.             }
  475.         }

  477.         // there must be no unprocessed paths left at this point; otherwise an
  478.         // untracked or unknown path has been specified
  479.         for (int i = 0; i < onlyProcessed.length; i++)
  480.             if (!onlyProcessed[i])
  481.                 throw new JGitInternalException(MessageFormat.format(
  482.                         JGitText.get().entryNotFoundByPath, only.get(i)));

  484.         // there must be at least one change
  485.         if (emptyCommit && !allowEmpty.booleanValue())
  486.             // Would like to throw a EmptyCommitException. But this would break the API
  487.             // TODO(ch): Change this in the next release
  488.             throw new JGitInternalException(JGitText.get().emptyCommit);

  490.         // update index
  491.         existingBuilder.commit();
  492.         // finish temporary in-core index used for this commit
  493.         tempBuilder.finish();
  494.         return inCoreIndex;
  495.     }

  497.     /**
  498.      * Look an entry's path up in the list of paths specified by the --only/ -o
  499.      * option
  500.      *
  501.      * In case the complete (file) path (e.g. "d1/d2/f1") cannot be found in
  502.      * <code>only</code>, lookup is also tried with (parent) directory paths
  503.      * (e.g. "d1/d2" and "d1").
  504.      *
  505.      * @param pathString
  506.      *            entry's path
  507.      * @return the item's index in <code>only</code>; -1 if no item matches
  508.      */
  509.     private int lookupOnly(String pathString) {
  510.         String p = pathString;
  511.         while (true) {
  512.             int position = Collections.binarySearch(only, p);
  513.             if (position >= 0)
  514.                 return position;
  515.             int l = p.lastIndexOf('/');
  516.             if (l < 1)
  517.                 break;
  518.             p = p.substring(0, l);
  519.         }
  520.         return -1;
  521.     }

  523.     /**
  524.      * Sets default values for not explicitly specified options. Then validates
  525.      * that all required data has been provided.
  526.      *
  527.      * @param state
  528.      *            the state of the repository we are working on
  529.      * @param rw
  530.      *            the RevWalk to use
  531.      *
  532.      * @throws NoMessageException
  533.      *             if the commit message has not been specified
  534.      * @throws UnsupportedSigningFormatException
  535.      *             if the configured gpg.format is not supported
  536.      */
  537.     private void processOptions(RepositoryState state, RevWalk rw)
  538.             throws NoMessageException, UnsupportedSigningFormatException {
  539.         if (committer == null)
  540.             committer = new PersonIdent(repo);
  541.         if (author == null && !amend)
  542.             author = committer;
  543.         if (allowEmpty == null)
  544.             // JGit allows empty commits by default. Only when pathes are
  545.             // specified the commit should not be empty. This behaviour differs
  546.             // from native git but can only be adapted in the next release.
  547.             // TODO(ch) align the defaults with native git
  548.             allowEmpty = (only.isEmpty()) ? Boolean.TRUE : Boolean.FALSE;

  550.         // when doing a merge commit parse MERGE_HEAD and MERGE_MSG files
  551.         if (state == RepositoryState.MERGING_RESOLVED
  552.                 || isMergeDuringRebase(state)) {
  553.             try {
  554.                 parents = repo.readMergeHeads();
  555.                 if (parents != null)
  556.                     for (int i = 0; i < parents.size(); i++) {
  557.                         RevObject ro = rw.parseAny(parents.get(i));
  558.                         if (ro instanceof RevTag)
  559.                             parents.set(i, rw.peel(ro));
  560.                     }
  561.             } catch (IOException e) {
  562.                 throw new JGitInternalException(MessageFormat.format(
  563.                         JGitText.get().exceptionOccurredDuringReadingOfGIT_DIR,
  564.                         Constants.MERGE_HEAD, e), e);
  565.             }
  566.             if (message == null) {
  567.                 try {
  568.                     message = repo.readMergeCommitMsg();
  569.                 } catch (IOException e) {
  570.                     throw new JGitInternalException(MessageFormat.format(
  571.                             JGitText.get().exceptionOccurredDuringReadingOfGIT_DIR,
  572.                             Constants.MERGE_MSG, e), e);
  573.                 }
  574.             }
  575.         } else if (state == RepositoryState.SAFE && message == null) {
  576.             try {
  577.                 message = repo.readSquashCommitMsg();
  578.                 if (message != null)
  579.                     repo.writeSquashCommitMsg(null /* delete */);
  580.             } catch (IOException e) {
  581.                 throw new JGitInternalException(MessageFormat.format(
  582.                         JGitText.get().exceptionOccurredDuringReadingOfGIT_DIR,
  583.                         Constants.MERGE_MSG, e), e);
  584.             }

  586.         }
  587.         if (message == null)
  588.             // as long as we don't support -C option we have to have
  589.             // an explicit message
  590.             throw new NoMessageException(JGitText.get().commitMessageNotSpecified);

  592.         if (gpgConfig == null) {
  593.             gpgConfig = new GpgConfig(repo.getConfig());
  594.         }
  595.         if (signCommit == null) {
  596.             signCommit = gpgConfig.isSignCommits() ? Boolean.TRUE
  597.                     : Boolean.FALSE;
  598.         }
  599.         if (signingKey == null) {
  600.             signingKey = gpgConfig.getSigningKey();
  601.         }
  602.         if (gpgSigner == null) {
  603.             gpgSigner = GpgSigner.getDefault();
  604.         }
  605.     }

  607.     private boolean isMergeDuringRebase(RepositoryState state) {
  608.         if (state != RepositoryState.REBASING_INTERACTIVE
  609.                 && state != RepositoryState.REBASING_MERGE)
  610.             return false;
  611.         try {
  612.             return repo.readMergeHeads() != null;
  613.         } catch (IOException e) {
  614.             throw new JGitInternalException(MessageFormat.format(
  615.                     JGitText.get().exceptionOccurredDuringReadingOfGIT_DIR,
  616.                     Constants.MERGE_HEAD, e), e);
  617.         }
  618.     }

  620.     /**
  621.      * Set the commit message
  622.      *
  623.      * @param message
  624.      *            the commit message used for the {@code commit}
  625.      * @return {@code this}
  626.      */
  627.     public CommitCommand setMessage(String message) {
  628.         checkCallable();
  629.         this.message = message;
  630.         return this;
  631.     }

  633.     /**
  634.      * Set whether to allow to create an empty commit
  635.      *
  636.      * @param allowEmpty
  637.      *            whether it should be allowed to create a commit which has the
  638.      *            same tree as it's sole predecessor (a commit which doesn't
  639.      *            change anything). By default when creating standard commits
  640.      *            (without specifying paths) JGit allows to create such commits.
  641.      *            When this flag is set to false an attempt to create an "empty"
  642.      *            standard commit will lead to an EmptyCommitException.
  643.      *            <p>
  644.      *            By default when creating a commit containing only specified
  645.      *            paths an attempt to create an empty commit leads to a
  646.      *            {@link org.eclipse.jgit.api.errors.JGitInternalException}. By
  647.      *            setting this flag to <code>true</code> this exception will not
  648.      *            be thrown.
  649.      * @return {@code this}
  650.      * @since 4.2
  651.      */
  652.     public CommitCommand setAllowEmpty(boolean allowEmpty) {
  653.         this.allowEmpty = Boolean.valueOf(allowEmpty);
  654.         return this;
  655.     }

  657.     /**
  658.      * Get the commit message
  659.      *
  660.      * @return the commit message used for the <code>commit</code>
  661.      */
  662.     public String getMessage() {
  663.         return message;
  664.     }

  666.     /**
  667.      * Sets the committer for this {@code commit}. If no committer is explicitly
  668.      * specified because this method is never called or called with {@code null}
  669.      * value then the committer will be deduced from config info in repository,
  670.      * with current time.
  671.      *
  672.      * @param committer
  673.      *            the committer used for the {@code commit}
  674.      * @return {@code this}
  675.      */
  676.     public CommitCommand setCommitter(PersonIdent committer) {
  677.         checkCallable();
  678.         this.committer = committer;
  679.         return this;
  680.     }

  682.     /**
  683.      * Sets the committer for this {@code commit}. If no committer is explicitly
  684.      * specified because this method is never called then the committer will be
  685.      * deduced from config info in repository, with current time.
  686.      *
  687.      * @param name
  688.      *            the name of the committer used for the {@code commit}
  689.      * @param email
  690.      *            the email of the committer used for the {@code commit}
  691.      * @return {@code this}
  692.      */
  693.     public CommitCommand setCommitter(String name, String email) {
  694.         checkCallable();
  695.         return setCommitter(new PersonIdent(name, email));
  696.     }

  698.     /**
  699.      * Get the committer
  700.      *
  701.      * @return the committer used for the {@code commit}. If no committer was
  702.      *         specified {@code null} is returned and the default
  703.      *         {@link org.eclipse.jgit.lib.PersonIdent} of this repo is used
  704.      *         during execution of the command
  705.      */
  706.     public PersonIdent getCommitter() {
  707.         return committer;
  708.     }

  710.     /**
  711.      * Sets the author for this {@code commit}. If no author is explicitly
  712.      * specified because this method is never called or called with {@code null}
  713.      * value then the author will be set to the committer or to the original
  714.      * author when amending.
  715.      *
  716.      * @param author
  717.      *            the author used for the {@code commit}
  718.      * @return {@code this}
  719.      */
  720.     public CommitCommand setAuthor(PersonIdent author) {
  721.         checkCallable();
  722.         this.author = author;
  723.         return this;
  724.     }

  726.     /**
  727.      * Sets the author for this {@code commit}. If no author is explicitly
  728.      * specified because this method is never called then the author will be set
  729.      * to the committer or to the original author when amending.
  730.      *
  731.      * @param name
  732.      *            the name of the author used for the {@code commit}
  733.      * @param email
  734.      *            the email of the author used for the {@code commit}
  735.      * @return {@code this}
  736.      */
  737.     public CommitCommand setAuthor(String name, String email) {
  738.         checkCallable();
  739.         return setAuthor(new PersonIdent(name, email));
  740.     }

  742.     /**
  743.      * Get the author
  744.      *
  745.      * @return the author used for the {@code commit}. If no author was
  746.      *         specified {@code null} is returned and the default
  747.      *         {@link org.eclipse.jgit.lib.PersonIdent} of this repo is used
  748.      *         during execution of the command
  749.      */
  750.     public PersonIdent getAuthor() {
  751.         return author;
  752.     }

  754.     /**
  755.      * If set to true the Commit command automatically stages files that have
  756.      * been modified and deleted, but new files not known by the repository are
  757.      * not affected. This corresponds to the parameter -a on the command line.
  758.      *
  759.      * @param all
  760.      *            whether to auto-stage all files that have been modified and
  761.      *            deleted
  762.      * @return {@code this}
  763.      * @throws JGitInternalException
  764.      *             in case of an illegal combination of arguments/ options
  765.      */
  766.     public CommitCommand setAll(boolean all) {
  767.         checkCallable();
  768.         if (all && !only.isEmpty())
  769.             throw new JGitInternalException(MessageFormat.format(
  770.                     JGitText.get().illegalCombinationOfArguments, "--all", //$NON-NLS-1$
  771.                     "--only")); //$NON-NLS-1$
  772.         this.all = all;
  773.         return this;
  774.     }

  776.     /**
  777.      * Used to amend the tip of the current branch. If set to {@code true}, the
  778.      * previous commit will be amended. This is equivalent to --amend on the
  779.      * command line.
  780.      *
  781.      * @param amend
  782.      *            whether to ammend the tip of the current branch
  783.      * @return {@code this}
  784.      */
  785.     public CommitCommand setAmend(boolean amend) {
  786.         checkCallable();
  787.         this.amend = amend;
  788.         return this;
  789.     }

  791.     /**
  792.      * Commit dedicated path only.
  793.      * <p>
  794.      * This method can be called several times to add multiple paths. Full file
  795.      * paths are supported as well as directory paths; in the latter case this
  796.      * commits all files/directories below the specified path.
  797.      *
  798.      * @param only
  799.      *            path to commit (with <code>/</code> as separator)
  800.      * @return {@code this}
  801.      */
  802.     public CommitCommand setOnly(String only) {
  803.         checkCallable();
  804.         if (all)
  805.             throw new JGitInternalException(MessageFormat.format(
  806.                     JGitText.get().illegalCombinationOfArguments, "--only", //$NON-NLS-1$
  807.                     "--all")); //$NON-NLS-1$
  808.         String o = only.endsWith("/") ? only.substring(0, only.length() - 1) //$NON-NLS-1$
  809.                 : only;
  810.         // ignore duplicates
  811.         if (!this.only.contains(o))
  812.             this.only.add(o);
  813.         return this;
  814.     }

  816.     /**
  817.      * If set to true a change id will be inserted into the commit message
  818.      *
  819.      * An existing change id is not replaced. An initial change id (I000...)
  820.      * will be replaced by the change id.
  821.      *
  822.      * @param insertChangeId
  823.      *            whether to insert a change id
  824.      * @return {@code this}
  825.      */
  826.     public CommitCommand setInsertChangeId(boolean insertChangeId) {
  827.         checkCallable();
  828.         this.insertChangeId = insertChangeId;
  829.         return this;
  830.     }

  832.     /**
  833.      * Override the message written to the reflog
  834.      *
  835.      * @param reflogComment
  836.      *            the comment to be written into the reflog or <code>null</code>
  837.      *            to specify that no reflog should be written
  838.      * @return {@code this}
  839.      */
  840.     public CommitCommand setReflogComment(String reflogComment) {
  841.         this.reflogComment = reflogComment;
  842.         useDefaultReflogMessage = false;
  843.         return this;
  844.     }

  846.     /**
  847.      * Sets the {@link #noVerify} option on this commit command.
  848.      * <p>
  849.      * Both the pre-commit and commit-msg hooks can block a commit by their
  850.      * return value; setting this option to <code>true</code> will bypass these
  851.      * two hooks.
  852.      * </p>
  853.      *
  854.      * @param noVerify
  855.      *            Whether this commit should be verified by the pre-commit and
  856.      *            commit-msg hooks.
  857.      * @return {@code this}
  858.      * @since 3.7
  859.      */
  860.     public CommitCommand setNoVerify(boolean noVerify) {
  861.         this.noVerify = noVerify;
  862.         return this;
  863.     }

  865.     /**
  866.      * Set the output stream for all hook scripts executed by this command
  867.      * (pre-commit, commit-msg, post-commit). If not set it defaults to
  868.      * {@code System.out}.
  869.      *
  870.      * @param hookStdOut
  871.      *            the output stream for hook scripts executed by this command
  872.      * @return {@code this}
  873.      * @since 3.7
  874.      */
  875.     public CommitCommand setHookOutputStream(PrintStream hookStdOut) {
  876.         setHookOutputStream(PreCommitHook.NAME, hookStdOut);
  877.         setHookOutputStream(CommitMsgHook.NAME, hookStdOut);
  878.         setHookOutputStream(PostCommitHook.NAME, hookStdOut);
  879.         return this;
  880.     }

  882.     /**
  883.      * Set the error stream for all hook scripts executed by this command
  884.      * (pre-commit, commit-msg, post-commit). If not set it defaults to
  885.      * {@code System.err}.
  886.      *
  887.      * @param hookStdErr
  888.      *            the error stream for hook scripts executed by this command
  889.      * @return {@code this}
  890.      * @since 5.6
  891.      */
  892.     public CommitCommand setHookErrorStream(PrintStream hookStdErr) {
  893.         setHookErrorStream(PreCommitHook.NAME, hookStdErr);
  894.         setHookErrorStream(CommitMsgHook.NAME, hookStdErr);
  895.         setHookErrorStream(PostCommitHook.NAME, hookStdErr);
  896.         return this;
  897.     }

  899.     /**
  900.      * Set the output stream for a selected hook script executed by this command
  901.      * (pre-commit, commit-msg, post-commit). If not set it defaults to
  902.      * {@code System.out}.
  903.      *
  904.      * @param hookName
  905.      *            name of the hook to set the output stream for
  906.      * @param hookStdOut
  907.      *            the output stream to use for the selected hook
  908.      * @return {@code this}
  909.      * @since 4.5
  910.      */
  911.     public CommitCommand setHookOutputStream(String hookName,
  912.             PrintStream hookStdOut) {
  913.         if (!(PreCommitHook.NAME.equals(hookName)
  914.                 || CommitMsgHook.NAME.equals(hookName)
  915.                 || PostCommitHook.NAME.equals(hookName))) {
  916.             throw new IllegalArgumentException(
  917.                     MessageFormat.format(JGitText.get().illegalHookName,
  918.                             hookName));
  919.         }
  920.         hookOutRedirect.put(hookName, hookStdOut);
  921.         return this;
  922.     }

  924.     /**
  925.      * Set the error stream for a selected hook script executed by this command
  926.      * (pre-commit, commit-msg, post-commit). If not set it defaults to
  927.      * {@code System.err}.
  928.      *
  929.      * @param hookName
  930.      *            name of the hook to set the output stream for
  931.      * @param hookStdErr
  932.      *            the output stream to use for the selected hook
  933.      * @return {@code this}
  934.      * @since 5.6
  935.      */
  936.     public CommitCommand setHookErrorStream(String hookName,
  937.             PrintStream hookStdErr) {
  938.         if (!(PreCommitHook.NAME.equals(hookName)
  939.                 || CommitMsgHook.NAME.equals(hookName)
  940.                 || PostCommitHook.NAME.equals(hookName))) {
  941.             throw new IllegalArgumentException(MessageFormat
  942.                     .format(JGitText.get().illegalHookName, hookName));
  943.         }
  944.         hookErrRedirect.put(hookName, hookStdErr);
  945.         return this;
  946.     }

  948.     /**
  949.      * Sets the signing key
  950.      * <p>
  951.      * Per spec of user.signingKey: this will be sent to the GPG program as is,
  952.      * i.e. can be anything supported by the GPG program.
  953.      * </p>
  954.      * <p>
  955.      * Note, if none was set or <code>null</code> is specified a default will be
  956.      * obtained from the configuration.
  957.      * </p>
  958.      *
  959.      * @param signingKey
  960.      *            signing key (maybe <code>null</code>)
  961.      * @return {@code this}
  962.      * @since 5.3
  963.      */
  964.     public CommitCommand setSigningKey(String signingKey) {
  965.         checkCallable();
  966.         this.signingKey = signingKey;
  967.         return this;
  968.     }

  970.     /**
  971.      * Sets whether the commit should be signed.
  972.      *
  973.      * @param sign
  974.      *            <code>true</code> to sign, <code>false</code> to not sign and
  975.      *            <code>null</code> for default behavior (read from
  976.      *            configuration)
  977.      * @return {@code this}
  978.      * @since 5.3
  979.      */
  980.     public CommitCommand setSign(Boolean sign) {
  981.         checkCallable();
  982.         this.signCommit = sign;
  983.         return this;
  984.     }

  986.     /**
  987.      * Sets the {@link GpgSigner} to use if the commit is to be signed.
  988.      *
  989.      * @param signer
  990.      *            to use; if {@code null}, the default signer will be used
  991.      * @return {@code this}
  992.      * @since 5.11
  993.      */
  994.     public CommitCommand setGpgSigner(GpgSigner signer) {
  995.         checkCallable();
  996.         this.gpgSigner = signer;
  997.         return this;
  998.     }

  1000.     /**
  1001.      * Sets an external {@link GpgConfig} to use. Whether it will be used is at
  1002.      * the discretion of the {@link #setGpgSigner(GpgSigner)}.
  1003.      *
  1004.      * @param config
  1005.      *            to set; if {@code null}, the config will be loaded from the
  1006.      *            git config of the repository
  1007.      * @return {@code this}
  1008.      * @since 5.11
  1009.      */
  1010.     public CommitCommand setGpgConfig(GpgConfig config) {
  1011.         checkCallable();
  1012.         this.gpgConfig = config;
  1013.         return this;
  1014.     }

  1016.     /**
  1017.      * Sets a {@link CredentialsProvider}
  1018.      *
  1019.      * @param credentialsProvider
  1020.      *            the provider to use when querying for credentials (eg., during
  1021.      *            signing)
  1022.      * @since 5.3
  1023.      */
  1024.     public void setCredentialsProvider(
  1025.             CredentialsProvider credentialsProvider) {
  1026.         this.credentialsProvider = credentialsProvider;
  1027.     }
  1028. }
Created with JaCoCo 0.8.6.202009150832