| /* | |
| * Copyright (C) 2010, Mathias Kinzler <mathias.kinzler@sap.com> | |
| * Copyright (C) 2010, Chris Aniszczyk <caniszczyk@gmail.com> and others | |
| * | |
| * This program and the accompanying materials are made available under the | |
| * terms of the Eclipse Distribution License v. 1.0 which is available at | |
| * https://www.eclipse.org/org/documents/edl-v10.php. | |
| * | |
| * SPDX-License-Identifier: BSD-3-Clause | |
| */ | |
| package org.eclipse.jgit.api; | |
| import static org.eclipse.jgit.lib.Constants.HEAD; | |
| import static org.eclipse.jgit.lib.Constants.R_HEADS; | |
| import java.io.IOException; | |
| import java.text.MessageFormat; | |
| import org.eclipse.jgit.api.errors.GitAPIException; | |
| import org.eclipse.jgit.api.errors.InvalidRefNameException; | |
| import org.eclipse.jgit.api.errors.JGitInternalException; | |
| import org.eclipse.jgit.api.errors.RefAlreadyExistsException; | |
| import org.eclipse.jgit.api.errors.RefNotFoundException; | |
| import org.eclipse.jgit.errors.AmbiguousObjectException; | |
| import org.eclipse.jgit.internal.JGitText; | |
| import org.eclipse.jgit.lib.ConfigConstants; | |
| import org.eclipse.jgit.lib.Constants; | |
| import org.eclipse.jgit.lib.ObjectId; | |
| import org.eclipse.jgit.lib.Ref; | |
| import org.eclipse.jgit.lib.RefUpdate; | |
| import org.eclipse.jgit.lib.RefUpdate.Result; | |
| import org.eclipse.jgit.lib.Repository; | |
| import org.eclipse.jgit.lib.StoredConfig; | |
| import org.eclipse.jgit.revwalk.RevCommit; | |
| import org.eclipse.jgit.revwalk.RevWalk; | |
| /** | |
| * Used to create a local branch. | |
| * | |
| * @see <a | |
| * href="http://www.kernel.org/pub/software/scm/git/docs/git-branch.html" | |
| * >Git documentation about Branch</a> | |
| */ | |
| public class CreateBranchCommand extends GitCommand<Ref> { | |
| private String name; | |
| private boolean force = false; | |
| private SetupUpstreamMode upstreamMode; | |
| private String startPoint = HEAD; | |
| private RevCommit startCommit; | |
| /** | |
| * The modes available for setting up the upstream configuration | |
| * (corresponding to the --set-upstream, --track, --no-track options | |
| * | |
| */ | |
| public enum SetupUpstreamMode { | |
| /** | |
| * Corresponds to the --track option | |
| */ | |
| TRACK, | |
| /** | |
| * Corresponds to the --no-track option | |
| */ | |
| NOTRACK, | |
| /** | |
| * Corresponds to the --set-upstream option | |
| */ | |
| SET_UPSTREAM; | |
| } | |
| /** | |
| * Constructor for CreateBranchCommand | |
| * | |
| * @param repo | |
| * the {@link org.eclipse.jgit.lib.Repository} | |
| */ | |
| protected CreateBranchCommand(Repository repo) { | |
| super(repo); | |
| } | |
| @Override | |
| public Ref call() throws GitAPIException, RefAlreadyExistsException, | |
| RefNotFoundException, InvalidRefNameException { | |
| checkCallable(); | |
| processOptions(); | |
| try (RevWalk revWalk = new RevWalk(repo)) { | |
| boolean exists = repo.findRef(R_HEADS + name) != null; | |
| if (!force && exists) | |
| throw new RefAlreadyExistsException(MessageFormat.format( | |
| JGitText.get().refAlreadyExists1, name)); | |
| ObjectId startAt = getStartPointObjectId(); | |
| String startPointFullName = null; | |
| if (startPoint != null) { | |
| Ref baseRef = repo.findRef(startPoint); | |
| if (baseRef != null) | |
| startPointFullName = baseRef.getName(); | |
| } | |
| // determine whether we are based on a commit, | |
| // a branch, or a tag and compose the reflog message | |
| String refLogMessage; | |
| String baseBranch = ""; //$NON-NLS-1$ | |
| if (startPointFullName == null) { | |
| String baseCommit; | |
| if (startCommit != null) | |
| baseCommit = startCommit.getShortMessage(); | |
| else { | |
| RevCommit commit = revWalk.parseCommit(repo | |
| .resolve(getStartPointOrHead())); | |
| baseCommit = commit.getShortMessage(); | |
| } | |
| if (exists) | |
| refLogMessage = "branch: Reset start-point to commit " //$NON-NLS-1$ | |
| + baseCommit; | |
| else | |
| refLogMessage = "branch: Created from commit " + baseCommit; //$NON-NLS-1$ | |
| } else if (startPointFullName.startsWith(R_HEADS) | |
| || startPointFullName.startsWith(Constants.R_REMOTES)) { | |
| baseBranch = startPointFullName; | |
| if (exists) | |
| refLogMessage = "branch: Reset start-point to branch " //$NON-NLS-1$ | |
| + startPointFullName; // TODO | |
| else | |
| refLogMessage = "branch: Created from branch " + baseBranch; //$NON-NLS-1$ | |
| } else { | |
| startAt = revWalk.peel(revWalk.parseAny(startAt)); | |
| if (exists) | |
| refLogMessage = "branch: Reset start-point to tag " //$NON-NLS-1$ | |
| + startPointFullName; | |
| else | |
| refLogMessage = "branch: Created from tag " //$NON-NLS-1$ | |
| + startPointFullName; | |
| } | |
| RefUpdate updateRef = repo.updateRef(R_HEADS + name); | |
| updateRef.setNewObjectId(startAt); | |
| updateRef.setRefLogMessage(refLogMessage, false); | |
| Result updateResult; | |
| if (exists && force) | |
| updateResult = updateRef.forceUpdate(); | |
| else | |
| updateResult = updateRef.update(); | |
| setCallable(false); | |
| boolean ok = false; | |
| switch (updateResult) { | |
| case NEW: | |
| ok = !exists; | |
| break; | |
| case NO_CHANGE: | |
| case FAST_FORWARD: | |
| case FORCED: | |
| ok = exists; | |
| break; | |
| default: | |
| break; | |
| } | |
| if (!ok) | |
| throw new JGitInternalException(MessageFormat.format(JGitText | |
| .get().createBranchUnexpectedResult, updateResult | |
| .name())); | |
| Ref result = repo.findRef(name); | |
| if (result == null) | |
| throw new JGitInternalException( | |
| JGitText.get().createBranchFailedUnknownReason); | |
| if (baseBranch.length() == 0) { | |
| return result; | |
| } | |
| // if we are based on another branch, see | |
| // if we need to configure upstream configuration: first check | |
| // whether the setting was done explicitly | |
| boolean doConfigure; | |
| if (upstreamMode == SetupUpstreamMode.SET_UPSTREAM | |
| || upstreamMode == SetupUpstreamMode.TRACK) | |
| // explicitly set to configure | |
| doConfigure = true; | |
| else if (upstreamMode == SetupUpstreamMode.NOTRACK) | |
| // explicitly set to not configure | |
| doConfigure = false; | |
| else { | |
| // if there was no explicit setting, check the configuration | |
| String autosetupflag = repo.getConfig().getString( | |
| ConfigConstants.CONFIG_BRANCH_SECTION, null, | |
| ConfigConstants.CONFIG_KEY_AUTOSETUPMERGE); | |
| if ("false".equals(autosetupflag)) { //$NON-NLS-1$ | |
| doConfigure = false; | |
| } else if ("always".equals(autosetupflag)) { //$NON-NLS-1$ | |
| doConfigure = true; | |
| } else { | |
| // in this case, the default is to configure | |
| // only in case the base branch was a remote branch | |
| doConfigure = baseBranch.startsWith(Constants.R_REMOTES); | |
| } | |
| } | |
| if (doConfigure) { | |
| StoredConfig config = repo.getConfig(); | |
| String remoteName = repo.getRemoteName(baseBranch); | |
| if (remoteName != null) { | |
| String branchName = repo | |
| .shortenRemoteBranchName(baseBranch); | |
| config | |
| .setString(ConfigConstants.CONFIG_BRANCH_SECTION, | |
| name, ConfigConstants.CONFIG_KEY_REMOTE, | |
| remoteName); | |
| config.setString(ConfigConstants.CONFIG_BRANCH_SECTION, | |
| name, ConfigConstants.CONFIG_KEY_MERGE, | |
| Constants.R_HEADS + branchName); | |
| } else { | |
| // set "." as remote | |
| config.setString(ConfigConstants.CONFIG_BRANCH_SECTION, | |
| name, ConfigConstants.CONFIG_KEY_REMOTE, "."); //$NON-NLS-1$ | |
| config.setString(ConfigConstants.CONFIG_BRANCH_SECTION, | |
| name, ConfigConstants.CONFIG_KEY_MERGE, baseBranch); | |
| } | |
| config.save(); | |
| } | |
| return result; | |
| } catch (IOException ioe) { | |
| throw new JGitInternalException(ioe.getMessage(), ioe); | |
| } | |
| } | |
| private ObjectId getStartPointObjectId() throws AmbiguousObjectException, | |
| RefNotFoundException, IOException { | |
| if (startCommit != null) | |
| return startCommit.getId(); | |
| String startPointOrHead = getStartPointOrHead(); | |
| ObjectId result = repo.resolve(startPointOrHead); | |
| if (result == null) | |
| throw new RefNotFoundException(MessageFormat.format( | |
| JGitText.get().refNotResolved, startPointOrHead)); | |
| return result; | |
| } | |
| private String getStartPointOrHead() { | |
| return startPoint != null ? startPoint : HEAD; | |
| } | |
| private void processOptions() throws InvalidRefNameException { | |
| if (name == null | |
| || !Repository.isValidRefName(R_HEADS + name) | |
| || !isValidBranchName(name)) | |
| throw new InvalidRefNameException(MessageFormat.format(JGitText | |
| .get().branchNameInvalid, name == null ? "<null>" : name)); //$NON-NLS-1$ | |
| } | |
| /** | |
| * Check if the given branch name is valid | |
| * | |
| * @param branchName | |
| * branch name to check | |
| * @return {@code true} if the branch name is valid | |
| * | |
| * @since 5.0 | |
| */ | |
| public static boolean isValidBranchName(String branchName) { | |
| if (HEAD.equals(branchName)) { | |
| return false; | |
| } | |
| return !branchName.startsWith("-"); //$NON-NLS-1$ | |
| } | |
| /** | |
| * Set the name of the new branch | |
| * | |
| * @param name | |
| * the name of the new branch | |
| * @return this instance | |
| */ | |
| public CreateBranchCommand setName(String name) { | |
| checkCallable(); | |
| this.name = name; | |
| return this; | |
| } | |
| /** | |
| * Set whether to create the branch forcefully | |
| * | |
| * @param force | |
| * if <code>true</code> and the branch with the given name | |
| * already exists, the start-point of an existing branch will be | |
| * set to a new start-point; if false, the existing branch will | |
| * not be changed | |
| * @return this instance | |
| */ | |
| public CreateBranchCommand setForce(boolean force) { | |
| checkCallable(); | |
| this.force = force; | |
| return this; | |
| } | |
| /** | |
| * Set the start point | |
| * | |
| * @param startPoint | |
| * corresponds to the start-point option; if <code>null</code>, | |
| * the current HEAD will be used | |
| * @return this instance | |
| */ | |
| public CreateBranchCommand setStartPoint(String startPoint) { | |
| checkCallable(); | |
| this.startPoint = startPoint; | |
| this.startCommit = null; | |
| return this; | |
| } | |
| /** | |
| * Set the start point | |
| * | |
| * @param startPoint | |
| * corresponds to the start-point option; if <code>null</code>, | |
| * the current HEAD will be used | |
| * @return this instance | |
| */ | |
| public CreateBranchCommand setStartPoint(RevCommit startPoint) { | |
| checkCallable(); | |
| this.startCommit = startPoint; | |
| this.startPoint = null; | |
| return this; | |
| } | |
| /** | |
| * Set the upstream mode | |
| * | |
| * @param mode | |
| * corresponds to the --track/--no-track/--set-upstream options; | |
| * may be <code>null</code> | |
| * @return this instance | |
| */ | |
| public CreateBranchCommand setUpstreamMode(SetupUpstreamMode mode) { | |
| checkCallable(); | |
| this.upstreamMode = mode; | |
| return this; | |
| } | |
| } |