feat: add support for variant selection

As a maintainer I need on a regular basis to pick specific server type to reproduce issues.
But patching source code to do so is:
a. cumbersome
b. error prone

And sometimes this can be useful for users as well (imagine you have a 8.4.5 installed with CLI only and 8.4.4 with FPM and CLI and your project requires FPM for instance).

This also lays the ground to pick more variants (debug or zts for example)

Author: tucksaun

store.go

@@ -151,13 +151,21 @@ func (s *PHPStore) BestVersionForDir(dir string) (*Version, string, string, erro
 // 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 := ""
+
+	// Check if versionPrefix has a expectedVariants 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:]
+		versionPrefix = versionPrefix[:pos]
+	}
 
 	// Check if versionPrefix is actually a patch version, if so first do an
 	// exact match lookup and fallback to a minor version check
 	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 {
+			if v.Version == versionPrefix && v.ForceVariant(variant) {
 				return v, source, "", nil
 			}
 		}
@@ -173,7 +181,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) {
+		if strings.HasPrefix(v.Version, versionPrefix) && v.ForceVariant(variant) {
 			return v, source, warning, nil
 		}
 	}

store_test.go

@@ -2,6 +2,7 @@ package phpstore
 
 import (
 	"path/filepath"
+	"sort"
 	"testing"
 )
 
@@ -17,6 +18,20 @@ func TestBestVersion(t *testing.T) {
 		}
 	}
 
+	{
+		v := "8.0.26"
+		ver := NewVersion(v)
+		ver.PHPPath = filepath.Join("/foo", v, "bin", "php")
+		ver.FPMPath = filepath.Join("/foo", v, "bin", "php-fpm")
+		store.addVersion(ver)
+
+		if !store.IsVersionAvailable(v) {
+			t.Errorf("Version %s should be shown as available", v)
+		}
+	}
+
+	sort.Sort(store.versions)
+
 	{
 		bestVersion, _, _, _ := store.bestVersion("8", "testing")
 		if bestVersion == nil {
@@ -56,4 +71,17 @@ func TestBestVersion(t *testing.T) {
 			t.Error("8.0.99 requirement should not trigger a warning")
 		}
 	}
+
+	{
+		bestVersion, _, warning, _ := store.bestVersion("8.0-fpm", "testing")
+		if bestVersion == nil {
+			t.Error("8.0-fpm requirement should find a best version")
+		} 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")
+		} else if warning != "" {
+			t.Error("8.0-fpm requirement should not trigger a warning")
+		}
+	}
 }

version.go

@@ -30,9 +30,10 @@ import (
 type serverType int
 
 const (
-	fpmServer serverType = iota
-	cgiServer
+	noServerType serverType = iota
 	cliServer
+	cgiServer
+	fpmServer
 	frankenphpServer
 )
 
@@ -49,6 +50,8 @@ type Version struct {
 	PHPdbgPath    string           `json:"phpdbg_path"`
 	IsSystem      bool             `json:"is_system"`
 	FrankenPHP    bool             `json:"frankenphp"`
+
+	typeOverride serverType
 }
 
 func NewVersion(v string) *Version {
@@ -116,6 +119,9 @@ func (v *Version) serverType() serverType {
 	if v.FrankenPHP {
 		return frankenphpServer
 	}
+	if v.typeOverride != noServerType {
+		return v.typeOverride
+	}
 	if v.FPMPath != "" {
 		return fpmServer
 	}
@@ -126,6 +132,56 @@ func (v *Version) serverType() serverType {
 	return cliServer
 }
 
+func (v *Version) ForceVariant(variant string) bool {
+	if variant == "" {
+		return true
+	}
+
+	if !v.SupportsVariant(variant) {
+		return false
+	}
+
+	switch variant {
+	case "cli":
+		v.typeOverride = cliServer
+		return true
+	case "cgi":
+		v.typeOverride = cgiServer
+		return true
+	case "fpm":
+		v.typeOverride = fpmServer
+		return true
+	case "frankenphp":
+		return true
+	}
+
+	return false
+}
+
+func (v *Version) SupportsVariant(variant string) bool {
+	if variant == "" {
+		return true
+	}
+
+	serverVariant := v.serverType()
+	if serverVariant == frankenphpServer {
+		return variant == "frankenphp"
+	}
+
+	if variant == "cli" {
+		return true
+	}
+
+	switch serverVariant {
+	case cgiServer:
+		return variant == "cgi"
+	case fpmServer:
+		return variant == "fpm"
+	}
+
+	return false
+}
+
 func (v *Version) setServer(fpm, cgi, phpconfig, phpize, phpdbg string) string {
 	msg := fmt.Sprintf("  Found PHP: %s", v.PHPPath)
 	fpm = filepath.Clean(fpm)

version_test.go

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2021-present Fabien Potencier <[email protected]>
+ *
+ * This file is part of Symfony CLI project
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package phpstore
+
+import (
+	"testing"
+
+	"github.com/symfony-cli/dumper"
+)
+
+func TestVersion_IsVariant(t *testing.T) {
+	testCases := []struct {
+		version          *Version
+		expectedVariants []string
+	}{
+		{
+			version: func() *Version {
+				v := NewVersion("8.1")
+				v.FPMPath = "/usr/bin/php-fpm8.1"
+				v.PHPPath = "/usr/bin/php-8.1"
+				return v
+			}(),
+			expectedVariants: []string{"fpm", "cli"},
+		},
+		{
+			version: func() *Version {
+				v := NewVersion("8.2")
+				v.CGIPath = "/usr/bin/php-cgi8.1"
+				v.PHPPath = "/usr/bin/php-8.1"
+				return v
+			}(),
+			expectedVariants: []string{"cgi", "cli"},
+		},
+		{
+			version: func() *Version {
+				v := NewVersion("8.3")
+				v.PHPPath = "/usr/bin/php-8.3"
+				return v
+			}(),
+			expectedVariants: []string{"cli"},
+		},
+		{
+			version: func() *Version {
+				v := NewVersion("8.4")
+				v.PHPPath = "/usr/bin/frankenphp"
+				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"},
+		},
+	}
+	for _, testCase := range testCases {
+		if !testCase.version.SupportsVariant("") {
+			t.Error("version.SupportsVariant('') should return true, got false")
+		}
+		for _, variant := range testCase.expectedVariants {
+			if !testCase.version.SupportsVariant(variant) {
+				dumper.Dump(testCase.version)
+				t.Errorf("version.SupportsVariant(%v) should return true, got false", variant)
+			}
+		}
+	variantsLoop:
+		for _, possibleVariant := range []string{"cli", "cgi", "fpm", "frankenphp", "franken"} {
+			for _, variant := range testCase.expectedVariants {
+				if variant == possibleVariant {
+					continue variantsLoop
+				}
+			}
+
+			if testCase.version.SupportsVariant(possibleVariant) {
+				t.Errorf("version.SupportsVariant(%v) should return false, got true", possibleVariant)
+			}
+		}
+	}
+}