Version parsing rehaul

plugin/set_test.go

@@ -45,12 +45,12 @@ func TestSet(t *testing.T) {
 	set.RegisterProvisioner("example-2", new(MockProvisioner))
 	set.RegisterDatasource("example", new(MockDatasource))
 	set.RegisterDatasource("example-2", new(MockDatasource))
-	set.SetVersion(pluginVersion.InitializePluginVersion(
-		"1.1.1", ""))
+	set.SetVersion(pluginVersion.NewPluginVersion(
+		"1.1.1", "", ""))
 
 	outputDesc := set.description()
 
-	sdkVersion := pluginVersion.InitializePluginVersion(pluginVersion.Version, pluginVersion.VersionPrerelease)
+	sdkVersion := pluginVersion.NewPluginVersion(pluginVersion.Version, pluginVersion.VersionPrerelease, "")
 	if diff := cmp.Diff(SetDescription{
 		Version:        "1.1.1",
 		SDKVersion:     sdkVersion.String(),

version/version.go

@@ -6,7 +6,6 @@
 package version
 
 import (
-	"bytes"
 	"fmt"
 
 	"github.com/hashicorp/go-version"
@@ -23,29 +22,71 @@ var Version = "0.5.3"
 // such as "dev" (in development), "beta", "rc1", etc.
 var VersionPrerelease = "dev"
 
+// The metadata for the version, this is optional information to add around
+// a particular release.
+//
+// This has no impact on the ordering of plugins, and is ignored for non-human eyes.
+var VersionMetadata = ""
+
 // SDKVersion is used by the plugin set to allow Packer to recognize
 // what version of the sdk the plugin is.
-var SDKVersion = InitializePluginVersion(Version, VersionPrerelease)
+var SDKVersion = NewPluginVersion(Version, VersionPrerelease, VersionMetadata)
 
 // InitializePluginVersion initializes the SemVer and returns a version var.
-// If the provided "version" string is not valid, the call to version.Must
-// will panic. Therefore, this function should always be called in a package
-// init() function to make sure that plugins are following proper semantic
-// versioning and to make sure that plugins which aren't following proper
-// semantic versioning crash immediately rather than later.
+//
+// Deprecated: InitializePluginVersion does not support metadata out of the
+// box, and should be replaced by either NewPluginVersion or NewRawVersion.
 func InitializePluginVersion(vers, versionPrerelease string) *PluginVersion {
-	if vers == "" {
+	return NewPluginVersion(vers, versionPrerelease, "")
+}
+
+// NewRawVersion is made for more freeform version strings. It won't accept
+// much more than what `NewPluginVersion` already does, but is another
+// convenient form to create a version if preferred.
+//
+// As NewRawVersion, if the version is invalid, it will panic.
+func NewRawVersion(rawSemVer string) *PluginVersion {
+	vers := version.Must(version.NewVersion(rawSemVer))
+
+	if len(vers.Segments()) != 3 {
+		panic(fmt.Sprintf("versions should only have 3 segments, %q had %d", rawSemVer, len(vers.Segments())))
+	}
+
+	return &PluginVersion{
+		version:           vers.Core().String(),
+		versionPrerelease: vers.Prerelease(),
+		versionMetadata:   vers.Metadata(),
+		semVer:            vers,
+	}
+}
+
+// NewPluginVersion initializes the SemVer and returns a PluginVersion from it.
+// If the provided "version" string is not valid, the call to version.Must
+// will panic.
+//
+// This function should always be called in a package init() function to make
+// sure that plugins are following proper semantic versioning and to make sure
+// that plugins which aren't following proper semantic versioning crash
+// immediately rather than later.
+//
+// If the core version number is empty, it will default to 0.0.0.
+func NewPluginVersion(vers, versionPrerelease, versionMetadata string) *PluginVersion {
+	var versionRawString = vers
+
+	if versionRawString == "" {
 		// Defaults to "0.0.0". Useful when binary is created for development purpose.
-		vers = "0.0.0"
+		versionRawString = "0.0.0"
 	}
-	pv := PluginVersion{
-		version:           vers,
-		versionPrerelease: versionPrerelease,
+
+	if versionPrerelease != "" {
+		versionRawString = fmt.Sprintf("%s-%s", versionRawString, versionPrerelease)
+	}
+
+	if versionMetadata != "" {
+		versionRawString = fmt.Sprintf("%s+%s", versionRawString, versionMetadata)
 	}
-	// This call initializes the SemVer to make sure that if Packer crashes due
-	// to an invalid SemVer it's at the very beginning of the Packer run.
-	pv.semVer = version.Must(version.NewVersion(vers))
-	return &pv
+
+	return NewRawVersion(versionRawString)
 }
 
 type PluginVersion struct {
@@ -55,22 +96,30 @@ type PluginVersion struct {
 	// then it means that it is a final release. Otherwise, this is a pre-release
 	// such as "dev" (in development), "beta", "rc1", etc.
 	versionPrerelease string
+	// Extra metadata that can be part of the version.
+	//
+	// This is legal in semver, and has to be the last part of the version
+	// string, starting with a `+`.
+	versionMetadata string
 	// The Semantic Version of the plugin. Used for version constraint comparisons
 	semVer *version.Version
 }
 
+func (p *PluginVersion) SetMetadata(meta string) {
+	p.versionMetadata = meta
+}
+
 func (p *PluginVersion) FormattedVersion() string {
-	var versionString bytes.Buffer
-	fmt.Fprintf(&versionString, "%s", p.version)
-	if p.versionPrerelease != "" {
-		fmt.Fprintf(&versionString, "-%s", p.versionPrerelease)
-
-		if GitCommit != "" {
-			fmt.Fprintf(&versionString, " (%s)", GitCommit)
-		}
+	versionString := p.semVer.String()
+
+	// Given there could be some metadata already, we add the commit to the
+	// reported version as part of the metadata, with a `-` spearator if
+	// the metadata is already there, otherwise we make it the metadata
+	if GitCommit != "" {
+		versionString = fmt.Sprintf("%s (%s)", versionString, GitCommit)
 	}
 
-	return versionString.String()
+	return versionString
 }
 
 func (p *PluginVersion) SemVer() *version.Version {
@@ -91,10 +140,11 @@ func (p *PluginVersion) GetVersionPrerelease() string {
 	return p.versionPrerelease
 }
 
+func (p *PluginVersion) GetMetadata() string {
+	return p.versionMetadata
+}
+
 // String returns the complete version string, including prerelease
 func (p *PluginVersion) String() string {
-	if p.versionPrerelease != "" {
-		return fmt.Sprintf("%s-%s", p.version, p.versionPrerelease)
-	}
-	return p.version
+	return p.semVer.String()
 }

version/version_test.go

@@ -0,0 +1,121 @@
+package version
+
+import (
+	"fmt"
+	"testing"
+)
+
+func Test_PluginVersionCreate(t *testing.T) {
+	tests := []struct {
+		name                string
+		coreVersion         string
+		preVersion          string
+		metaVersion         string
+		expectError         bool
+		expectVersionString string
+	}{
+		{
+			"Valid semver core only version",
+			"1.0.0",
+			"",
+			"",
+			false,
+			"1.0.0",
+		},
+		{
+			"Valid semver, should get canonical version",
+			"01.001.001",
+			"",
+			"",
+			false,
+			"1.1.1",
+		},
+		{
+			"Valid semver with prerelease, should get canonical version",
+			"1.001.010",
+			"dev",
+			"",
+			false,
+			"1.1.10-dev",
+		},
+		{
+			"Valid semver with metadata, should get canonical version",
+			"1.001.010",
+			"",
+			"123abcdef",
+			false,
+			"1.1.10+123abcdef",
+		},
+		{
+			"Valid semver with prerelease and metadata, should get canonical version",
+			"1.001.010",
+			"dev",
+			"123abcdef",
+			false,
+			"1.1.10-dev+123abcdef",
+		},
+		{
+			"Invalid version, should fail",
+			".1.1",
+			"",
+			"",
+			true,
+			"",
+		},
+		{
+			"4-parts version, should not be accepted",
+			"1.1.1.1",
+			"",
+			"",
+			true,
+			"",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			defer func() {
+				panicMsg := recover()
+				if !tt.expectError && panicMsg != nil {
+					t.Errorf("creating version panicked, should not have.")
+				}
+
+				if tt.expectError && panicMsg == nil {
+					t.Errorf("creating version should have panicked, but did not.")
+				}
+
+				if panicMsg != nil {
+					t.Logf("panic message was: %v", panicMsg)
+				}
+			}()
+
+			ver := NewPluginVersion(tt.coreVersion, tt.preVersion, tt.metaVersion)
+			verStr := ver.String()
+			if verStr != tt.expectVersionString {
+				t.Errorf("string format mismatch, version created is %q, expected %q", verStr, tt.expectVersionString)
+			}
+		})
+	}
+}
+
+func TestFormattedVersionString(t *testing.T) {
+	GitCommit = "abcdef12345"
+	defer func() {
+		GitCommit = ""
+	}()
+
+	expectedVersion := fmt.Sprintf("1.0.0-dev (%s)", GitCommit)
+
+	ver := InitializePluginVersion("1.0.0", "dev")
+	formatted := ver.FormattedVersion()
+	if formatted != expectedVersion {
+		t.Errorf("Expected formatted version %q; got %q", expectedVersion, formatted)
+	}
+
+	expectedVersion = fmt.Sprintf("1.0.0-dev+meta (%s)", GitCommit)
+	ver = NewPluginVersion("1.0.0", "dev", "meta")
+	formatted = ver.FormattedVersion()
+	if formatted != expectedVersion {
+		t.Errorf("Expected formatted version %q; got %q", expectedVersion, formatted)
+	}
+}