| /* |
| * 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); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| public Ref call() throws GitAPIException, RefAlreadyExistsException, |
| RefNotFoundException, InvalidRefNameException { |
| checkCallable(); |
| processOptions(); |
| try (RevWalk revWalk = new RevWalk(repo)) { |
| Ref refToCheck = repo.findRef(name); |
| boolean exists = refToCheck != null |
| && refToCheck.getName().startsWith(R_HEADS); |
| 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; |
| } |
| } |
