Reapply "release: Support alpha, beta, and RC releases"

This reverts commit e66a33d369f2a5aee472fdcd82efefbb9efde8d7.

Closes #14466

diff --git a/commands/release.go b/commands/release.go
index 059f04eb8bd9aef68ac4d26bbbdba6f0e65958a9..ae97cadc777d643d8683380e63e9f7154a604b6f 100644 (file)
--- a/commands/release.go
+++ b/commands/release.go
@@ -28,13 +28,14 @@ func newReleaseCommand() simplecobra.Commander {
                step     int
                skipPush bool
                try      bool
+               version  string
        )
 
        return &simpleCommand{
                name:  "release",
                short: "Release a new version of Hugo",
                run: func(ctx context.Context, cd *simplecobra.Commandeer, r *rootCommand, args []string) error {
-                       rel, err := releaser.New(skipPush, try, step)
+                       rel, err := releaser.New(skipPush, try, step, version)
                        if err != nil {
                                return err
                        }
@@ -47,6 +48,7 @@ func newReleaseCommand() simplecobra.Commander {
                        cmd.PersistentFlags().BoolVarP(&skipPush, "skip-push", "", false, "skip pushing to remote")
                        cmd.PersistentFlags().BoolVarP(&try, "try", "", false, "no changes")
                        cmd.PersistentFlags().IntVarP(&step, "step", "", 0, "step to run (1: set new version 2: prepare next dev version)")
+                       cmd.PersistentFlags().StringVarP(&version, "version", "", "", "version to release (derived from branch name if not set)")
                        _ = cmd.RegisterFlagCompletionFunc("step", cobra.FixedCompletions([]string{"1", "2"}, cobra.ShellCompDirectiveNoFileComp))
                },
        }

diff --git a/common/version/version.go b/common/version/version.go
index eae43e8c1835ef55124f02be916dd04914365bd7..34ed9bfd1a4992485ebffe22feb2fee020efefe3 100644 (file)
--- a/common/version/version.go
+++ b/common/version/version.go
@@ -47,6 +47,13 @@ var (
        _ compare.Comparer = (*VersionString)(nil)
 )
 
+// IsAlphaBetaOrRC returns whether this version is an alpha, beta, or release candidate.
+func (v Version) IsAlphaBetaOrRC() bool {
+       s := strings.ToLower(v.Suffix)
+       // e.g. "alpha.1", "beta.2", "rc.3"
+       return strings.Contains(s, "alpha.") || strings.Contains(s, "beta.") || strings.Contains(s, "rc.")
+}
+
 func (v Version) IsZero() bool {
        return v.Major == 0 && v.Minor == 0 && v.PatchLevel == 0 && v.Suffix == ""
 }

diff --git a/releaser/releaser.go b/releaser/releaser.go
index 74770dfbd99482b8adb8e27d577fa3966b236b13..6e3fd3afa484dd7e477f6cabad8f60822a27d09c 100644 (file)
--- a/releaser/releaser.go
+++ b/releaser/releaser.go
@@ -30,28 +30,32 @@ import (
 const commitPrefix = "releaser:"
 
 // New initializes a ReleaseHandler.
-func New(skipPush, try bool, step int) (*ReleaseHandler, error) {
+// Note that version is only used for testig. In CI we derive the version from the branch name.
+func New(skipPush, try bool, step int, version string) (*ReleaseHandler, error) {
        if step < 1 || step > 2 {
                return nil, fmt.Errorf("step must be 1 or 2")
        }
 
-       prefix := "release-"
-       branch, err := git("rev-parse", "--abbrev-ref", "HEAD")
-       if err != nil {
-               return nil, err
-       }
-       branch = strings.TrimSpace(branch)
+       if version == "" {
+               prefix := "release-"
+               branch, err := git("rev-parse", "--abbrev-ref", "HEAD")
+               if err != nil {
+                       return nil, err
+               }
+               branch = strings.TrimSpace(branch)
+
+               if !strings.HasPrefix(branch, prefix) {
+                       return nil, fmt.Errorf("branch %q is not a release branch", branch)
+               }
 
-       if !strings.HasPrefix(branch, prefix) {
-               return nil, fmt.Errorf("branch %q is not a release branch", branch)
+               version = strings.TrimPrefix(branch, prefix)
        }
 
-       version := strings.TrimPrefix(branch, prefix)
        version = strings.TrimPrefix(version, "v")
 
-       logf("Branch: %s|Version: v%s\n", branch, version)
+       logf("Version: v%s\n", version)
 
-       rh := &ReleaseHandler{branchVersion: version, skipPush: skipPush, try: try, step: step}
+       rh := &ReleaseHandler{version: version, skipPush: skipPush, try: try, step: step}
 
        if try {
                rh.git = func(args ...string) (string, error) {
@@ -70,7 +74,7 @@ func New(skipPush, try bool, step int) (*ReleaseHandler, error) {
 // go run -tags release main.go release --skip-publish --try -r 0.90.0
 // Or a variation of the above -- the skip-publish flag makes sure that any changes are performed to the local Git only.
 type ReleaseHandler struct {
-       branchVersion string
+       version string
 
        // 1 or 2.
        step int
@@ -89,8 +93,8 @@ func (r *ReleaseHandler) Run() error {
        newVersion, finalVersion := r.calculateVersions()
        version := newVersion.String()
        tag := "v" + version
-       mainVersion := newVersion
-       mainVersion.PatchLevel = 0
+
+       logf("New version %q (prerelease: %t), final version %q\n", newVersion, newVersion.IsAlphaBetaOrRC(), finalVersion)
 
        r.gitPull()
 
@@ -167,14 +171,15 @@ func (r *ReleaseHandler) bumpVersions(ver version.Version) error {
 }
 
 func (r ReleaseHandler) calculateVersions() (version.Version, version.Version) {
-       newVersion := version.MustParseVersion(r.branchVersion)
-       finalVersion := newVersion.Next()
-       finalVersion.PatchLevel = 0
-
-       if newVersion.Suffix != "-test" {
-               newVersion.Suffix = ""
+       newVersion := version.MustParseVersion(r.version)
+       var finalVersion version.Version
+       if newVersion.IsAlphaBetaOrRC() {
+               finalVersion = newVersion
+       } else {
+               finalVersion = newVersion.Next()
        }
 
+       finalVersion.PatchLevel = 0
        finalVersion.Suffix = "-DEV"
 
        return newVersion, finalVersion