Move the internal machinery utils to appropiate exported packages

- Go version checks and go-modules-based repo discovery moved to pkg/plugins/golang
- Command execution and user prompt moved to pkg/plugin/util

Signed-off-by: Adrian Orive <[email protected]>

pkg/plugins/internal/util/go_version.go → pkg/plugins/golang/go_version.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package util
+package golang
 
 import (
 	"fmt"
@@ -24,6 +24,96 @@ import (
 	"strings"
 )
 
+const (
+	goVerPattern = `^go(?P<major>[0-9]+)\.(?P<minor>[0-9]+)(?:\.(?P<patch>[0-9]+)|(?P<pre>(?:alpha|beta|rc)[0-9]+))?$`
+)
+
+var (
+	go113 = goVersion{
+		major: 1,
+		minor: 13,
+	}
+	go116alpha1 = goVersion{
+		major:      1,
+		minor:      16,
+		prerelease: "alpha1",
+	}
+
+	goVerRegexp = regexp.MustCompile(goVerPattern)
+)
+
+type goVersion struct {
+	major, minor, patch int
+	prerelease          string
+}
+
+func (v *goVersion) parse(verStr string) error {
+	m := goVerRegexp.FindStringSubmatch(verStr)
+	if m == nil {
+		return fmt.Errorf("invalid version string")
+	}
+
+	var err error
+
+	v.major, err = strconv.Atoi(m[1])
+	if err != nil {
+		return fmt.Errorf("error parsing major version '%s': %s", m[1], err)
+	}
+
+	v.minor, err = strconv.Atoi(m[2])
+	if err != nil {
+		return fmt.Errorf("error parsing minor version '%s': %s", m[2], err)
+	}
+
+	if m[3] != "" {
+		v.patch, err = strconv.Atoi(m[3])
+		if err != nil {
+			return fmt.Errorf("error parsing patch version '%s': %s", m[2], err)
+		}
+	}
+
+	v.prerelease = m[4]
+
+	return nil
+}
+
+func (v goVersion) compare(other goVersion) int {
+	if v.major > other.major {
+		return 1
+	}
+	if v.major < other.major {
+		return -1
+	}
+
+	if v.minor > other.minor {
+		return 1
+	}
+	if v.minor < other.minor {
+		return -1
+	}
+
+	if v.patch > other.patch {
+		return 1
+	}
+	if v.patch < other.patch {
+		return -1
+	}
+
+	if v.prerelease == other.prerelease {
+		return 0
+	}
+	if v.prerelease == "" {
+		return 1
+	}
+	if other.prerelease == "" {
+		return -1
+	}
+	if v.prerelease > other.prerelease {
+		return 1
+	}
+	return -1
+}
+
 // ValidateGoVersion verifies that Go is installed and the current go version is supported by kubebuilder
 func ValidateGoVersion() error {
 	err := fetchAndCheckGoVersion()
@@ -54,24 +144,13 @@ func fetchAndCheckGoVersion() error {
 // checkGoVersion should only ever check if the Go version >= 1.13, since the kubebuilder binary only cares
 // that the go binary supports go modules which were stabilized in that version (i.e. in go 1.13) by default
 func checkGoVersion(verStr string) error {
-	goVerRegex := `^go?([0-9]+)\.([0-9]+)[\.0-9A-Za-z\-]*$`
-	m := regexp.MustCompile(goVerRegex).FindStringSubmatch(verStr)
-	if m == nil {
-		return fmt.Errorf("invalid version string")
-	}
-
-	major, err := strconv.Atoi(m[1])
-	if err != nil {
-		return fmt.Errorf("error parsing major version '%s': %s", m[1], err)
-	}
-
-	minor, err := strconv.Atoi(m[2])
-	if err != nil {
-		return fmt.Errorf("error parsing minor version '%s': %s", m[2], err)
+	var version goVersion
+	if err := version.parse(verStr); err != nil {
+		return err
 	}
 
-	if major < 1 || minor < 13 {
-		return fmt.Errorf("requires version >= 1.13")
+	if version.compare(go113) < 0 || version.compare(go116alpha1) >= 0 {
+		return fmt.Errorf("requires 1.13 <= version < 1.16")
 	}
 
 	return nil

pkg/plugins/golang/go_version_test.go

@@ -0,0 +1,189 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+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 golang
+
+import (
+	"sort"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/ginkgo/extensions/table"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("goVersion", func() {
+	Context("parse", func() {
+		var v goVersion
+
+		BeforeEach(func() {
+			v = goVersion{}
+		})
+
+		DescribeTable("should succeed for valid versions",
+			func(version string, expected goVersion) {
+				Expect(v.parse(version)).NotTo(HaveOccurred())
+				Expect(v.major).To(Equal(expected.major))
+				Expect(v.minor).To(Equal(expected.minor))
+				Expect(v.patch).To(Equal(expected.patch))
+				Expect(v.prerelease).To(Equal(expected.prerelease))
+			},
+			Entry("for minor release", "go1.15", goVersion{
+				major: 1,
+				minor: 15,
+			}),
+			Entry("for patch release", "go1.15.1", goVersion{
+				major: 1,
+				minor: 15,
+				patch: 1,
+			}),
+			Entry("for alpha release", "go1.15alpha1", goVersion{
+				major:      1,
+				minor:      15,
+				prerelease: "alpha1",
+			}),
+			Entry("for beta release", "go1.15beta1", goVersion{
+				major:      1,
+				minor:      15,
+				prerelease: "beta1",
+			}),
+			Entry("for release candidate", "go1.15rc1", goVersion{
+				major:      1,
+				minor:      15,
+				prerelease: "rc1",
+			}),
+		)
+
+		DescribeTable("should fail for invalid versions",
+			func(version string) { Expect(v.parse(version)).To(HaveOccurred()) },
+			Entry("for invalid prefix", "g1.15"),
+			Entry("for missing major version", "go.15"),
+			Entry("for missing minor version", "go1."),
+			Entry("for patch and prerelease version", "go1.15.1rc1"),
+			Entry("for invalid major version", "goa.15"),
+			Entry("for invalid minor version", "go1.a"),
+			Entry("for invalid patch version", "go1.15.a"),
+		)
+	})
+
+	Context("compare", func() {
+		// Test compare() by sorting a list.
+		var (
+			versions = []goVersion{
+				{major: 1, minor: 15, prerelease: "rc2"},
+				{major: 1, minor: 15, patch: 1},
+				{major: 1, minor: 16},
+				{major: 1, minor: 15, prerelease: "beta1"},
+				{major: 1, minor: 15, prerelease: "alpha2"},
+				{major: 2, minor: 0},
+				{major: 1, minor: 15, prerelease: "alpha1"},
+				{major: 1, minor: 13},
+				{major: 1, minor: 15, prerelease: "rc1"},
+				{major: 1, minor: 15},
+				{major: 1, minor: 15, patch: 2},
+				{major: 1, minor: 14},
+				{major: 1, minor: 15, prerelease: "beta2"},
+				{major: 0, minor: 123},
+			}
+
+			sortedVersions = []goVersion{
+				{major: 0, minor: 123},
+				{major: 1, minor: 13},
+				{major: 1, minor: 14},
+				{major: 1, minor: 15, prerelease: "alpha1"},
+				{major: 1, minor: 15, prerelease: "alpha2"},
+				{major: 1, minor: 15, prerelease: "beta1"},
+				{major: 1, minor: 15, prerelease: "beta2"},
+				{major: 1, minor: 15, prerelease: "rc1"},
+				{major: 1, minor: 15, prerelease: "rc2"},
+				{major: 1, minor: 15},
+				{major: 1, minor: 15, patch: 1},
+				{major: 1, minor: 15, patch: 2},
+				{major: 1, minor: 16},
+				{major: 2, minor: 0},
+			}
+		)
+
+		It("sorts a valid list of versions correctly", func() {
+			sort.Slice(versions, func(i int, j int) bool {
+				return versions[i].compare(versions[j]) == -1
+			})
+			Expect(versions).To(Equal(sortedVersions))
+		})
+	})
+})
+
+var _ = Describe("checkGoVersion", func() {
+	DescribeTable("should return true for supported go versions",
+		func(version string) { Expect(checkGoVersion(version)).NotTo(HaveOccurred()) },
+		Entry("for go 1.13", "go1.13"),
+		Entry("for go 1.13.1", "go1.13.1"),
+		Entry("for go 1.13.2", "go1.13.2"),
+		Entry("for go 1.13.3", "go1.13.3"),
+		Entry("for go 1.13.4", "go1.13.4"),
+		Entry("for go 1.13.5", "go1.13.5"),
+		Entry("for go 1.13.6", "go1.13.6"),
+		Entry("for go 1.13.7", "go1.13.7"),
+		Entry("for go 1.13.8", "go1.13.8"),
+		Entry("for go 1.13.9", "go1.13.9"),
+		Entry("for go 1.13.10", "go1.13.10"),
+		Entry("for go 1.13.11", "go1.13.11"),
+		Entry("for go 1.13.12", "go1.13.12"),
+		Entry("for go 1.13.13", "go1.13.13"),
+		Entry("for go 1.13.14", "go1.13.14"),
+		Entry("for go 1.13.15", "go1.13.15"),
+		Entry("for go 1.14beta1", "go1.14beta1"),
+		Entry("for go 1.14rc1", "go1.14rc1"),
+		Entry("for go 1.14", "go1.14"),
+		Entry("for go 1.14.1", "go1.14.1"),
+		Entry("for go 1.14.2", "go1.14.2"),
+		Entry("for go 1.14.3", "go1.14.3"),
+		Entry("for go 1.14.4", "go1.14.4"),
+		Entry("for go 1.14.5", "go1.14.5"),
+		Entry("for go 1.14.6", "go1.14.6"),
+		Entry("for go 1.14.7", "go1.14.7"),
+		Entry("for go 1.14.8", "go1.14.8"),
+		Entry("for go 1.14.9", "go1.14.9"),
+		Entry("for go 1.14.10", "go1.14.10"),
+		Entry("for go 1.14.11", "go1.14.11"),
+		Entry("for go 1.14.12", "go1.14.12"),
+		Entry("for go 1.14.13", "go1.14.13"),
+		Entry("for go 1.14.14", "go1.14.14"),
+		Entry("for go 1.14.15", "go1.14.15"),
+		Entry("for go 1.15beta1", "go1.15beta1"),
+		Entry("for go 1.15rc1", "go1.15rc1"),
+		Entry("for go 1.15rc2", "go1.15rc2"),
+		Entry("for go 1.15", "go1.15"),
+		Entry("for go 1.15.1", "go1.15.1"),
+		Entry("for go 1.15.2", "go1.15.2"),
+		Entry("for go 1.15.3", "go1.15.3"),
+		Entry("for go 1.15.4", "go1.15.4"),
+		Entry("for go 1.15.5", "go1.15.5"),
+		Entry("for go 1.15.6", "go1.15.6"),
+		Entry("for go 1.15.7", "go1.15.7"),
+		Entry("for go 1.15.8", "go1.15.8"),
+	)
+
+	DescribeTable("should return false for non-supported go versions",
+		func(version string) { Expect(checkGoVersion(version)).To(HaveOccurred()) },
+		Entry("for invalid go versions", "go"),
+		Entry("for go 1.13beta1", "go1.13beta1"),
+		Entry("for go 1.13rc1", "go1.13rc1"),
+		Entry("for go 1.13rc2", "go1.13rc2"),
+		Entry("for go 1.16beta1", "go1.16beta1"),
+		Entry("for go 1.16rc1", "go1.16rc1"),
+		Entry("for go 1.16", "go1.16"),
+	)
+})

pkg/plugins/internal/util/repository.go → pkg/plugins/golang/repository.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package util
+package golang
 
 import (
 	"encoding/json"
@@ -34,12 +34,9 @@ type module struct {
 }
 
 // findGoModulePath finds the path of the current module, if present.
-func findGoModulePath(forceModules bool) (string, error) {
+func findGoModulePath() (string, error) {
 	cmd := exec.Command("go", "mod", "edit", "-json")
 	cmd.Env = append(cmd.Env, os.Environ()...)
-	if forceModules {
-		cmd.Env = append(cmd.Env, "GO111MODULE=on" /* turn on modules just for these commands */)
-	}
 	out, err := cmd.Output()
 	if err != nil {
 		if exitErr, isExitErr := err.(*exec.ExitError); isExitErr {
@@ -58,7 +55,7 @@ func findGoModulePath(forceModules bool) (string, error) {
 // though a combination of go/packages and `go mod` commands/tricks.
 func FindCurrentRepo() (string, error) {
 	// easiest case: existing go module
-	path, err := findGoModulePath(false)
+	path, err := findGoModulePath()
 	if err == nil {
 		return path, nil
 	}
@@ -79,7 +76,6 @@ func FindCurrentRepo() (string, error) {
 	// otherwise, try to get `go mod init` to guess for us -- it's pretty good
 	cmd := exec.Command("go", "mod", "init")
 	cmd.Env = append(cmd.Env, os.Environ()...)
-	cmd.Env = append(cmd.Env, "GO111MODULE=on" /* turn on modules just for these commands */)
 	if _, err := cmd.Output(); err != nil {
 		if exitErr, isExitErr := err.(*exec.ExitError); isExitErr {
 			err = fmt.Errorf("%s", string(exitErr.Stderr))
@@ -90,5 +86,5 @@ func FindCurrentRepo() (string, error) {
 	}
 	//nolint:errcheck
 	defer os.Remove("go.mod") // clean up after ourselves
-	return findGoModulePath(true)
+	return findGoModulePath()
 }

pkg/plugins/golang/v2/api.go

@@ -31,9 +31,9 @@ import (
 	"sigs.k8s.io/kubebuilder/v3/pkg/model"
 	"sigs.k8s.io/kubebuilder/v3/pkg/model/resource"
 	"sigs.k8s.io/kubebuilder/v3/pkg/plugin"
+	"sigs.k8s.io/kubebuilder/v3/pkg/plugin/util"
 	"sigs.k8s.io/kubebuilder/v3/pkg/plugins/golang/v2/scaffolds"
 	"sigs.k8s.io/kubebuilder/v3/pkg/plugins/internal/cmdutil"
-	"sigs.k8s.io/kubebuilder/v3/pkg/plugins/internal/util"
 	"sigs.k8s.io/kubebuilder/v3/plugins/addon"
 )