variant -> flavor

Author: tucksaun

store.go

@@ -143,20 +143,23 @@ func (s *PHPStore) BestVersionForDir(dir string) (*Version, string, string, erro
 }
 
 // bestVersion returns the latest patch version for the given major (X),
-// minor (X.Y), or patch (X.Y.Z). version can be 7 or 7.1 or 7.1.2.
-// Non-symlinked versions have priority
+// minor (X.Y), or patch (X.Y.Z).
+// Version can be 7 or 7.1 or 7.1.2 and optionally suffixed with a flavor.
+// Non-symlinked versions have priority.
+// If the asked version contains a flavor (e.g. "7.4-fpm"), it will only accept
+// versions supporting this flavor.
 // If the asked version is a patch one (X.Y.Z) and is not available, the lookup
 // will fallback to the last patch version for the minor version (X.Y).
 // There's no fallback to the major version because PHP is known to occasionally
 // break BC in minor versions, so we can't safely fall back.
 func (s *PHPStore) bestVersion(versionPrefix, source string) (*Version, string, string, error) {
 	warning := ""
-	variant := ""
+	flavor := ""
 
-	// Check if versionPrefix has a expectedVariants constraint, if so first do an
+	// Check if versionPrefix has a expectedFlavors constraint, if so first do an
 	// exact match lookup and fallback to a minor version check
 	if pos := strings.LastIndexByte(versionPrefix, '-'); pos != -1 {
-		variant = versionPrefix[pos+1:]
+		flavor = versionPrefix[pos+1:]
 		versionPrefix = versionPrefix[:pos]
 	}
 
@@ -165,7 +168,7 @@ func (s *PHPStore) bestVersion(versionPrefix, source string) (*Version, string,
 	if pos := strings.LastIndexByte(versionPrefix, '.'); pos != strings.IndexByte(versionPrefix, '.') {
 		// look for an exact match, the order does not matter here
 		for _, v := range s.versions {
-			if v.Version == versionPrefix && v.ForceVariant(variant) {
+			if v.Version == versionPrefix && v.ForceFlavorIfSupported(flavor) {
 				return v, source, "", nil
 			}
 		}
@@ -181,7 +184,7 @@ func (s *PHPStore) bestVersion(versionPrefix, source string) (*Version, string,
 	// start from the end as versions are always sorted
 	for i := len(s.versions) - 1; i >= 0; i-- {
 		v := s.versions[i]
-		if strings.HasPrefix(v.Version, versionPrefix) && v.ForceVariant(variant) {
+		if strings.HasPrefix(v.Version, versionPrefix) && v.ForceFlavorIfSupported(flavor) {
 			return v, source, warning, nil
 		}
 	}

store_test.go

@@ -79,7 +79,7 @@ func TestBestVersion(t *testing.T) {
 		} else if bestVersion.Version != "8.0.26" {
 			t.Errorf("8.0-fpm requirement should find 8.0.26 as best version, got %s", bestVersion.Version)
 		} else if bestVersion.serverType() != fpmServer {
-			t.Error("8.0-fpm requirement should find an FPM expectedVariants")
+			t.Error("8.0-fpm requirement should find an FPM expectedFlavors")
 		} else if warning != "" {
 			t.Error("8.0-fpm requirement should not trigger a warning")
 		}

version.go

@@ -37,6 +37,13 @@ const (
 	frankenphpServer
 )
 
+const (
+	FlavorCLI        string = "cli"
+	FlavorCGI        string = "cgi"
+	FlavorFPM        string = "fpm"
+	FlavorFrankenPHP string = "frankenphp"
+)
+
 // Version stores information about an installed PHP version
 type Version struct {
 	FullVersion   *version.Version `json:"-"`
@@ -116,6 +123,8 @@ func (v *Version) IsFrankenPHPServer() bool {
 }
 
 func (v *Version) serverType() serverType {
+	// FrankenPHP is a special case as it will not support several server types
+	// for a single installation.
 	if v.FrankenPHP {
 		return frankenphpServer
 	}
@@ -132,51 +141,54 @@ func (v *Version) serverType() serverType {
 	return cliServer
 }
 
-func (v *Version) ForceVariant(variant string) bool {
-	if variant == "" {
+func (v *Version) ForceFlavorIfSupported(flavor string) bool {
+	if flavor == "" {
 		return true
 	}
 
-	if !v.SupportsVariant(variant) {
+	if !v.SupportsFlavor(flavor) {
 		return false
 	}
 
-	switch variant {
-	case "cli":
+	switch flavor {
+	case FlavorCLI:
 		v.typeOverride = cliServer
 		return true
-	case "cgi":
+	case FlavorCGI:
 		v.typeOverride = cgiServer
 		return true
-	case "fpm":
+	case FlavorFPM:
 		v.typeOverride = fpmServer
 		return true
-	case "frankenphp":
+	case FlavorFrankenPHP:
+		// FrankenPHP installations does not support multiple flavors so there's
+		// no need to set the typeOverride.
 		return true
 	}
 
 	return false
 }
 
-func (v *Version) SupportsVariant(variant string) bool {
-	if variant == "" {
+func (v *Version) SupportsFlavor(flavor string) bool {
+	if flavor == "" {
 		return true
 	}
 
-	serverVariant := v.serverType()
-	if serverVariant == frankenphpServer {
-		return variant == "frankenphp"
+	serverFlavor := v.serverType()
+	if serverFlavor == frankenphpServer {
+		return flavor == FlavorFrankenPHP
 	}
 
-	if variant == "cli" {
+	// CLI flavor is always supported
+	if flavor == FlavorCLI {
 		return true
 	}
 
-	switch serverVariant {
+	switch serverFlavor {
 	case cgiServer:
-		return variant == "cgi"
+		return flavor == FlavorCGI
 	case fpmServer:
-		return variant == "fpm"
+		return flavor == FlavorFPM
 	}
 
 	return false

version_test.go

@@ -23,10 +23,10 @@ import (
 	"testing"
 )
 
-func TestVersion_IsVariant(t *testing.T) {
+func TestVersion_SupportsFlavor(t *testing.T) {
 	testCases := []struct {
-		version          *Version
-		expectedVariants []string
+		version         *Version
+		expectedFlavors []string
 	}{
 		{
 			version: func() *Version {
@@ -35,7 +35,7 @@ func TestVersion_IsVariant(t *testing.T) {
 				v.PHPPath = "/usr/bin/php-8.1"
 				return v
 			}(),
-			expectedVariants: []string{"fpm", "cli"},
+			expectedFlavors: []string{FlavorFPM, FlavorCLI},
 		},
 		{
 			version: func() *Version {
@@ -44,15 +44,15 @@ func TestVersion_IsVariant(t *testing.T) {
 				v.PHPPath = "/usr/bin/php-8.1"
 				return v
 			}(),
-			expectedVariants: []string{"cgi", "cli"},
+			expectedFlavors: []string{FlavorCGI, FlavorCLI},
 		},
 		{
 			version: func() *Version {
 				v := NewVersion("8.3")
 				v.PHPPath = "/usr/bin/php-8.3"
 				return v
 			}(),
-			expectedVariants: []string{"cli"},
+			expectedFlavors: []string{FlavorCLI},
 		},
 		{
 			version: func() *Version {
@@ -61,37 +61,28 @@ func TestVersion_IsVariant(t *testing.T) {
 				v.FrankenPHP = true
 				return v
 			}(),
-			expectedVariants: []string{"frankenphp"},
-		},
-		{
-			version: func() *Version {
-				v := NewVersion("7.4")
-				v.PHPPath = "/usr/bin/php"
-				v.FPMPath = "/usr/bin/php-fpm"
-				return v
-			}(),
-			expectedVariants: []string{"fpm", "cli"},
+			expectedFlavors: []string{FlavorFrankenPHP},
 		},
 	}
 	for _, testCase := range testCases {
-		if !testCase.version.SupportsVariant("") {
-			t.Error("version.SupportsVariant('') should return true, got false")
+		if !testCase.version.SupportsFlavor("") {
+			t.Error("version.SupportsFlavor('') should return true, got false")
 		}
-		for _, variant := range testCase.expectedVariants {
-			if !testCase.version.SupportsVariant(variant) {
-				t.Errorf("version.SupportsVariant(%v) should return true, got false", variant)
+		for _, flavor := range testCase.expectedFlavors {
+			if !testCase.version.SupportsFlavor(flavor) {
+				t.Errorf("version.SupportsFlavor(%v) should return true, got false", flavor)
 			}
 		}
-	variantsLoop:
-		for _, possibleVariant := range []string{"cli", "cgi", "fpm", "frankenphp", "franken"} {
-			for _, variant := range testCase.expectedVariants {
-				if variant == possibleVariant {
-					continue variantsLoop
+	flavorLoop:
+		for _, possibleFlavor := range []string{FlavorCLI, FlavorCGI, FlavorFPM, FlavorFrankenPHP} {
+			for _, flavor := range testCase.expectedFlavors {
+				if flavor == possibleFlavor {
+					continue flavorLoop
 				}
 			}
 
-			if testCase.version.SupportsVariant(possibleVariant) {
-				t.Errorf("version.SupportsVariant(%v) should return false, got true", possibleVariant)
+			if testCase.version.SupportsFlavor(possibleFlavor) {
+				t.Errorf("version.SupportsFlavor(%v) should return false, got true", possibleFlavor)
 			}
 		}
 	}