The Git-Flow Maven Plugin supports various Git workflows, including GitFlow and GitHub Flow. This plugin runs Git and Maven commands from the command line.
try {
// check uncommitted changes
checkUncommittedChanges();
// git for-each-ref --format='%(refname:short)' refs/heads/release/*
String releaseBranch = gitFindBranches(gitFlowConfig.getReleaseBranchPrefix(), false).trim();
if (StringUtils.isBlank(releaseBranch)) {
if (fetchRemote) {
releaseBranch = gitFetchAndFindRemoteBranches(gitFlowConfig.getOrigin(),
gitFlowConfig.getReleaseBranchPrefix(), false).trim();
if (StringUtils.isBlank(releaseBranch)) {
throw new MojoFailureException("There is no remote or local release branch.");
}
// remove remote name with slash from branch name
releaseBranch = releaseBranch.substring(gitFlowConfig.getOrigin().length() + 1);
if (StringUtils.countMatches(releaseBranch, gitFlowConfig.getReleaseBranchPrefix()) > 1) {
throw new MojoFailureException(
"More than one remote release branch exists. Cannot finish release.");
}
gitCreateAndCheckout(releaseBranch, gitFlowConfig.getOrigin() + "/" + releaseBranch);
} else {
throw new MojoFailureException("There is no release branch.");
}
}
if (StringUtils.countMatches(releaseBranch, gitFlowConfig.getReleaseBranchPrefix()) > 1) {
throw new MojoFailureException(
"More than one release branch exists. Cannot finish release.");
}
// check snapshots dependencies
if (!allowSnapshots) {
gitCheckout(releaseBranch);
checkSnapshotDependencies();
}
if (fetchRemote) {
// fetch and check remote
gitFetchRemoteAndCompare(releaseBranch);
// checkout from remote if doesn't exist
gitFetchRemoteAndCreate(gitFlowConfig.getDevelopmentBranch());
// fetch and check remote
gitFetchRemoteAndCompare(gitFlowConfig.getDevelopmentBranch());
if (notSameProdDevName()) {
// checkout from remote if doesn't exist
gitFetchRemoteAndCreate(gitFlowConfig.getProductionBranch());
// fetch and check remote
gitFetchRemoteAndCompare(gitFlowConfig
.getProductionBranch());
}
}
// git checkout release/...
gitCheckout(releaseBranch);
if (!skipTestProject) {
// mvn clean test
mvnCleanTest();
}
// maven goals before merge
if (StringUtils.isNotBlank(preReleaseGoals)) {
mvnRun(preReleaseGoals);
}
String currentReleaseVersion = getCurrentProjectVersion();
Map<String, String> messageProperties = new HashMap<String, String>();
messageProperties.put("version", currentReleaseVersion);
if (useSnapshotInRelease && ArtifactUtils.isSnapshot(currentReleaseVersion)) {
String commitVersion = currentReleaseVersion.replace("-" + Artifact.SNAPSHOT_VERSION, "");
mvnSetVersions(commitVersion);
messageProperties.put("version", commitVersion);
gitCommit(commitMessages.getReleaseFinishMessage(), messageProperties);
}
if (!skipReleaseMergeProdBranch) {
// git checkout master
gitCheckout(gitFlowConfig.getProductionBranch());
gitMerge(releaseBranch, releaseRebase, releaseMergeNoFF, releaseMergeFFOnly, commitMessages.getReleaseFinishMergeMessage(),
messageProperties);
}
// get current project version from pom
final String currentVersion = getCurrentProjectVersion();
if (!skipTag) {
String tagVersion = currentVersion;
if ((tychoBuild || useSnapshotInRelease) && ArtifactUtils.isSnapshot(currentVersion)) {
tagVersion = currentVersion.replace("-"
+ Artifact.SNAPSHOT_VERSION, "");
}
messageProperties.put("version", tagVersion);
// git tag -a ...
gitTag(gitFlowConfig.getVersionTagPrefix() + tagVersion,
commitMessages.getTagReleaseMessage(), gpgSignTag, messageProperties);
}
// maven goals after merge
if (StringUtils.isNotBlank(postReleaseGoals)) {
mvnRun(postReleaseGoals);
}
if (notSameProdDevName()) {
if (!commitDevelopmentVersionAtStart && mergeDevelopmentVersion) {
gitCheckout(releaseBranch);
commitSnapshotVersion(currentVersion);
}
// git checkout develop
gitCheckout(gitFlowConfig.getDevelopmentBranch());
// get develop version
final String developReleaseVersion = getCurrentProjectVersion();
if (commitDevelopmentVersionAtStart && useSnapshotInRelease) {
// updating develop poms to master version to avoid merge conflicts
mvnSetVersions(currentVersion);
// commit the changes
gitCommit(commitMessages.getUpdateDevToAvoidConflictsMessage());
}
// merge branch master into develop
gitMerge(releaseBranch, releaseRebase, releaseMergeNoFF, false,
commitMessages.getReleaseFinishDevMergeMessage(), messageProperties);
if (commitDevelopmentVersionAtStart && useSnapshotInRelease) {
// updating develop poms version back to pre merge state
mvnSetVersions(developReleaseVersion);
// commit the changes
gitCommit(commitMessages.getUpdateDevBackPreMergeStateMessage());
}
}
if (commitDevelopmentVersionAtStart && !notSameProdDevName()) {
getLog().warn(
"The commitDevelopmentVersionAtStart will not have effect. "
+ "It can be enabled only when there are separate branches for development and production.");
commitDevelopmentVersionAtStart = false;
}
if (!commitDevelopmentVersionAtStart) {
commitSnapshotVersion(currentVersion);
}
if (installProject) {
// mvn clean install
mvnCleanInstall();
}
if (pushRemote) {
gitPush(gitFlowConfig.getProductionBranch(), !skipTag);
if (notSameProdDevName()) {
gitPush(gitFlowConfig.getDevelopmentBranch(), !skipTag);
}
if (!keepBranch) {
gitPushDelete(releaseBranch);
}
}
if (!keepBranch) {
// git branch -d release/...
gitBranchDelete(releaseBranch);
}
} catch (Exception e) {
throw new MojoFailureException("release-finish", e);
}
}
private void commitSnapshotVersion(final String currentVersion) throws MojoFailureException, VersionParseException, CommandLineException {
// get next snapshot version
final String nextSnapshotVersion;
if (!settings.isInteractiveMode() && StringUtils.isNotBlank(developmentVersion)) {
nextSnapshotVersion = developmentVersion;
} else {
GitFlowVersionInfo versionInfo = new GitFlowVersionInfo(currentVersion);
if (digitsOnlyDevVersion) {
versionInfo = versionInfo.digitsVersionInfo();
}
nextSnapshotVersion = versionInfo.nextSnapshotVersion(versionDigitToIncrement);
}
if (StringUtils.isBlank(nextSnapshotVersion)) {
throw new MojoFailureException("Next snapshot version is blank.");
}
// mvn versions:set -DnewVersion=... -DgenerateBackupPoms=false
mvnSetVersions(nextSnapshotVersion);
final Map<String, String> messageProperties = new HashMap<>();
messageProperties.put("version", nextSnapshotVersion);
// git commit -a -m updating for next development version
gitCommit(commitMessages.getReleaseFinishMessage(), messageProperties);
Hallo, we use another kind of save merge from release branch to develop. We make following steps:
Is it possible to include such scenario into gitflow:release-finish goal?
I have already implemented this change (it is quite simple), but I'm not able push change to your repo.
Here is my change `/*
import java.util.HashMap; import java.util.Map;
import org.apache.maven.artifact.Artifact; import org.apache.maven.artifact.ArtifactUtils; import org.apache.maven.plugin.MojoExecutionException; import org.apache.maven.plugin.MojoFailureException; import org.apache.maven.plugins.annotations.Mojo; import org.apache.maven.plugins.annotations.Parameter; import org.apache.maven.shared.release.versions.VersionParseException; import org.codehaus.plexus.util.StringUtils; import org.codehaus.plexus.util.cli.CommandLineException;
/**
*/ @Mojo(name = "release-finish", aggregator = true) public class GitFlowReleaseFinishMojo extends AbstractGitFlowMojo {
/* Whether to skip tagging the release in Git. / @Parameter(property = "skipTag", defaultValue = "false") private boolean skipTag = false;
/* Whether to keep release branch after finish. / @Parameter(property = "keepBranch", defaultValue = "false") private boolean keepBranch = false;
/**
/**
/**
true
then rebase will/**
--no-ff
option when merging./**
/**
--ff-only
option when merging./**
/**
/**
/**
/**
/**
/**
/**
/**
/**
commitDevelopmentVersionAtStart
parameter is set to true./* {@inheritDoc} / @Override public void execute() throws MojoExecutionException, MojoFailureException { validateConfiguration(preReleaseGoals, postReleaseGoals);
}
private void commitSnapshotVersion(final String currentVersion) throws MojoFailureException, VersionParseException, CommandLineException { // get next snapshot version final String nextSnapshotVersion; if (!settings.isInteractiveMode() && StringUtils.isNotBlank(developmentVersion)) { nextSnapshotVersion = developmentVersion; } else { GitFlowVersionInfo versionInfo = new GitFlowVersionInfo(currentVersion); if (digitsOnlyDevVersion) { versionInfo = versionInfo.digitsVersionInfo(); }
} } `