From 5f831a622337d6a1d33a28a21391ba682030f21f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B8rn=20Erik=20Pedersen?= Date: Wed, 5 Jul 2017 10:23:07 +0200 Subject: [PATCH] releaser: Replace the magic version handling Take the new version as a string value. --- commands/release.go | 12 ++++-- helpers/hugo.go | 54 ++++++++++++++++++++------ helpers/hugo_test.go | 8 ++++ releaser/releaser.go | 30 ++++++--------- releaser/releaser_test.go | 79 --------------------------------------- 5 files changed, 69 insertions(+), 114 deletions(-) delete mode 100644 releaser/releaser_test.go diff --git a/commands/release.go b/commands/release.go index 74dc7012..0764685f 100644 --- a/commands/release.go +++ b/commands/release.go @@ -16,6 +16,8 @@ package commands import ( + "errors" + "github.com/gohugoio/hugo/releaser" "github.com/spf13/cobra" ) @@ -27,8 +29,7 @@ func init() { type releaseCommandeer struct { cmd *cobra.Command - // Will be zero for main releases. - patchLevel int + version string skipPublish bool try bool @@ -51,7 +52,7 @@ func createReleaser() *releaseCommandeer { return r.release() } - r.cmd.PersistentFlags().IntVarP(&r.patchLevel, "patch", "p", 0, "patch level, defaults to 0 for main releases") + r.cmd.PersistentFlags().StringVarP(&r.version, "rel", "r", "", "new release version, i.e. 0.25.1") r.cmd.PersistentFlags().IntVarP(&r.step, "step", "s", -1, "release step, defaults to -1 for all steps.") r.cmd.PersistentFlags().BoolVarP(&r.skipPublish, "skip-publish", "", false, "skip all publishing pipes of the release") r.cmd.PersistentFlags().BoolVarP(&r.try, "try", "", false, "simulate a release, i.e. no changes") @@ -60,5 +61,8 @@ func createReleaser() *releaseCommandeer { } func (r *releaseCommandeer) release() error { - return releaser.New(r.patchLevel, r.step, r.skipPublish, r.try).Run() + if r.version == "" { + return errors.New("must set the --rel flag to the relevant version number") + } + return releaser.New(r.version, r.step, r.skipPublish, r.try).Run() } diff --git a/helpers/hugo.go b/helpers/hugo.go index 6315847a..89833be2 100644 --- a/helpers/hugo.go +++ b/helpers/hugo.go @@ -14,6 +14,7 @@ package helpers import ( + "errors" "fmt" "strings" @@ -37,6 +38,29 @@ func (v HugoVersion) String() string { return hugoVersion(v.Number, v.PatchLevel, v.Suffix) } +func ParseHugoVersion(s string) (HugoVersion, error) { + var vv HugoVersion + + if strings.Contains(s, "DEV") { + return vv, errors.New("DEV versions not supported by parse") + } + + v, p := parseVersion(s) + + vv.Number = v + vv.PatchLevel = p + + return vv, nil +} + +func MustParseHugoVersion(s string) HugoVersion { + vv, err := ParseHugoVersion(s) + if err != nil { + panic(err) + } + return vv +} + // ReleaseVersion represents the release version. func (v HugoVersion) ReleaseVersion() HugoVersion { v.Suffix = "" @@ -100,18 +124,7 @@ func compareVersions(inVersion float32, inPatchVersion int, in interface{}) int return -1 } - var ( - v float32 - p int - ) - - if strings.Count(s, ".") == 2 { - li := strings.LastIndex(s, ".") - p = cast.ToInt(s[li+1:]) - s = s[:li] - } - - v = float32(cast.ToFloat64(s)) + v, p := parseVersion(s) if v == inVersion && p == inPatchVersion { return 0 @@ -125,6 +138,23 @@ func compareVersions(inVersion float32, inPatchVersion int, in interface{}) int } } +func parseVersion(s string) (float32, int) { + var ( + v float32 + p int + ) + + if strings.Count(s, ".") == 2 { + li := strings.LastIndex(s, ".") + p = cast.ToInt(s[li+1:]) + s = s[:li] + } + + v = float32(cast.ToFloat64(s)) + + return v, p +} + func compareFloatVersions(version float32, v float32) int { if v == version { return 0 diff --git a/helpers/hugo_test.go b/helpers/hugo_test.go index c96a1351..a59d8ee1 100644 --- a/helpers/hugo_test.go +++ b/helpers/hugo_test.go @@ -49,3 +49,11 @@ func TestCompareVersions(t *testing.T) { require.Equal(t, 1, compareVersions(0.20, 1, "0.20.2")) require.Equal(t, 1, compareVersions(0.21, 1, "0.22.1")) } + +func TestParseHugoVersion(t *testing.T) { + require.Equal(t, "0.25", MustParseHugoVersion("0.25").String()) + require.Equal(t, "0.25.2", MustParseHugoVersion("0.25.2").String()) + + _, err := ParseHugoVersion("0.25-DEV") + require.Error(t, err) +} diff --git a/releaser/releaser.go b/releaser/releaser.go index 52a74dc7..52589e8b 100644 --- a/releaser/releaser.go +++ b/releaser/releaser.go @@ -31,7 +31,7 @@ import ( const commitPrefix = "releaser:" type ReleaseHandler struct { - patch int + cliVersion string // If set, we do the releases in 3 steps: // 1: Create and write a draft release notes @@ -62,24 +62,16 @@ func (r ReleaseHandler) shouldPrepareVersions() bool { return r.step < 1 || r.step == 2 } -func (r ReleaseHandler) calculateVersions(current helpers.HugoVersion) (helpers.HugoVersion, helpers.HugoVersion) { - var ( - newVersion = current - finalVersion = current - ) +func (r ReleaseHandler) calculateVersions() (helpers.HugoVersion, helpers.HugoVersion) { + + newVersion := helpers.MustParseHugoVersion(r.cliVersion) + finalVersion := newVersion + finalVersion.PatchLevel = 0 newVersion.Suffix = "" - if r.shouldContinue() { - // The version in the current code base is in the state we want for - // the release. - if r.patch == 0 { - finalVersion = newVersion.Next() - } - } else if r.patch > 0 { - newVersion = helpers.CurrentHugoVersion.NextPatchLevel(r.patch) - } else { - finalVersion = newVersion.Next() + if newVersion.PatchLevel == 0 { + finalVersion = finalVersion.Next() } finalVersion.Suffix = "-DEV" @@ -87,8 +79,8 @@ func (r ReleaseHandler) calculateVersions(current helpers.HugoVersion) (helpers. return newVersion, finalVersion } -func New(patch, step int, skipPublish, try bool) *ReleaseHandler { - rh := &ReleaseHandler{patch: patch, step: step, skipPublish: skipPublish, try: try} +func New(version string, step int, skipPublish, try bool) *ReleaseHandler { + rh := &ReleaseHandler{cliVersion: version, step: step, skipPublish: skipPublish, try: try} if try { rh.git = func(args ...string) (string, error) { @@ -107,7 +99,7 @@ func (r *ReleaseHandler) Run() error { return errors.New("GITHUB_TOKEN not set, create one here with the repo scope selected: https://github.com/settings/tokens/new") } - newVersion, finalVersion := r.calculateVersions(helpers.CurrentHugoVersion) + newVersion, finalVersion := r.calculateVersions() version := newVersion.String() tag := "v" + version diff --git a/releaser/releaser_test.go b/releaser/releaser_test.go deleted file mode 100644 index 2e5a545a..00000000 --- a/releaser/releaser_test.go +++ /dev/null @@ -1,79 +0,0 @@ -// Copyright 2017-present The Hugo Authors. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -// Package commands defines and implements command-line commands and flags -// used by Hugo. Commands and flags are implemented using Cobra. - -package releaser - -import ( - "testing" - - "github.com/gohugoio/hugo/helpers" - "github.com/stretchr/testify/require" -) - -// TODO(bep) fixme -func _TestCalculateVersions(t *testing.T) { - startVersion := helpers.HugoVersion{Number: 0.20, Suffix: "-DEV"} - - tests := []struct { - handler *ReleaseHandler - version helpers.HugoVersion - v1 string - v2 string - }{ - { - New(0, 0, true, true), - startVersion, - "0.20", - "0.21-DEV", - }, - { - New(2, 0, true, true), - startVersion, - "0.20.2", - "0.20-DEV", - }, - { - New(0, 1, true, true), - startVersion, - "0.20", - "0.21-DEV", - }, - { - New(0, 3, true, true), - startVersion, - "0.20", - "0.21-DEV", - }, - { - New(3, 1, true, true), - startVersion, - "0.20.3", - "0.20-DEV", - }, - { - New(3, 3, true, true), - startVersion.Next(), - "0.21", - "0.21-DEV", - }, - } - - for _, test := range tests { - v1, v2 := test.handler.calculateVersions(test.version) - require.Equal(t, test.v1, v1.String(), "Release version") - require.Equal(t, test.v2, v2.String(), "Final version") - } -}