Recursively find defined plugins

Author: andrecloutier

internal/resolve/resolve.go

@@ -5,6 +5,7 @@ package resolve
 
 import (
 	"fmt"
+	"iter"
 	"os"
 	"path"
 	"strings"
@@ -21,54 +22,100 @@ type ToolVersions struct {
 	Source    string
 }
 
+// AllVersions takes a set of plugins and a directory and resolves all tools to one or more
+// versions. This includes tools without a corresponding plugin.
+func AllVersions(conf config.Config, plugins []plugins.Plugin, directory string) (versions map[string]ToolVersions, err error) {
+	resolvedToolVersions := map[string]ToolVersions{}
+	for _, plugin := range plugins {
+		version, envVariableName, found := findVersionsInEnv(plugin.Name)
+		if found {
+			resolvedToolVersions[plugin.Name] = ToolVersions{Versions: version, Source: envVariableName}
+		}
+	}
+
+	for iterDir := range iterDirectories(conf, directory) {
+		for _, plugin := range plugins {
+			if _, isPluginResolved := resolvedToolVersions[plugin.Name]; !isPluginResolved {
+				version, found, err := findLegacyVersionsInDir(conf, plugin, iterDir)
+				if err != nil {
+					return versions, err
+				}
+				if found {
+					resolvedToolVersions[plugin.Name] = version
+				}
+			}
+		}
+
+		filepath := path.Join(iterDir, conf.DefaultToolVersionsFilename)
+		if _, err = os.Stat(filepath); err == nil {
+			if allVersions, err := toolversions.GetAllToolsAndVersions(filepath); err == nil {
+				for _, v := range allVersions {
+					if _, isPluginResolved := resolvedToolVersions[v.Name]; !isPluginResolved {
+						resolvedToolVersions[v.Name] = ToolVersions{Versions: v.Versions, Source: conf.DefaultToolVersionsFilename, Directory: iterDir}
+					}
+				}
+			}
+		}
+	}
+	return resolvedToolVersions, nil
+}
+
 // Version takes a plugin and a directory and resolves the tool to one or more
-// versions.
+// versions. Only returns results for the provided plugin.
 func Version(conf config.Config, plugin plugins.Plugin, directory string) (versions ToolVersions, found bool, err error) {
 	version, envVariableName, found := findVersionsInEnv(plugin.Name)
 	if found {
 		return ToolVersions{Versions: version, Source: envVariableName}, true, nil
 	}
 
-	for !found {
-		versions, found, err = findVersionsInDir(conf, plugin, directory)
+	for iterDir := range iterDirectories(conf, directory) {
+		versions, found, err = findVersionsInDir(conf, plugin, iterDir)
 		if err != nil {
 			return versions, false, err
 		}
+		if found {
+			return versions, found, err
+		}
+	}
+	return versions, found, err
+}
 
-		nextDir := path.Dir(directory)
-		// If current dir and next dir are the same it means we've reached `/` and
-		// have no more parent directories to search.
-		if nextDir == directory {
-			// If no version found, try current users home directory. I'd like to
-			// eventually remove this feature.
-			homeDir, osErr := os.UserHomeDir()
-			if osErr != nil {
+func iterDirectories(conf config.Config, directory string) iter.Seq[string] {
+	return func(yield func(string) bool) {
+		if !yield(directory) {
+			return
+		}
+		iterDir := directory
+		for {
+			nextDir := path.Dir(iterDir)
+			// If current dir and next dir are the same it means we've reached `/` and
+			// have no more parent directories to search.
+			if nextDir == iterDir {
 				break
 			}
-
-			versions, found, err = findVersionsInDir(conf, plugin, homeDir)
-			break
+			if !yield(iterDir) {
+				return
+			}
+			iterDir = nextDir
+		}
+		// If no version found, try current users home directory. I'd like to
+		// eventually remove this feature.
+		homeDir := conf.Home
+		// homeDir, osErr := os.UserHomeDir()
+		if homeDir != "" {
+			if !yield(homeDir) {
+				return
+			}
 		}
-		directory = nextDir
 	}
-
-	return versions, found, err
 }
 
 func findVersionsInDir(conf config.Config, plugin plugins.Plugin, directory string) (versions ToolVersions, found bool, err error) {
-	legacyFiles, err := conf.LegacyVersionFile()
-	if err != nil {
+	versions, found, err = findLegacyVersionsInDir(conf, plugin, directory)
+	if found || err != nil {
 		return versions, found, err
 	}
 
-	if legacyFiles {
-		versions, found, err := findVersionsInLegacyFile(plugin, directory)
-
-		if found || err != nil {
-			return versions, found, err
-		}
-	}
-
 	filepath := path.Join(directory, conf.DefaultToolVersionsFilename)
 
 	if _, err = os.Stat(filepath); err == nil {
@@ -81,6 +128,22 @@ func findVersionsInDir(conf config.Config, plugin plugins.Plugin, directory stri
 	return versions, found, nil
 }
 
+func findLegacyVersionsInDir(conf config.Config, plugin plugins.Plugin, directory string) (versions ToolVersions, found bool, err error) {
+	legacyFiles, err := conf.LegacyVersionFile()
+	if err != nil {
+		return versions, found, err
+	}
+
+	if legacyFiles {
+		versions, found, err := findVersionsInLegacyFile(plugin, directory)
+
+		if found || err != nil {
+			return versions, found, err
+		}
+	}
+	return versions, false, nil
+}
+
 // findVersionsInEnv returns the version from the environment if present
 func findVersionsInEnv(pluginName string) ([]string, string, bool) {
 	envVariableName := variableVersionName(pluginName)

internal/versions/versions.go

@@ -7,7 +7,6 @@ import (
 	"fmt"
 	"io"
 	"os"
-	"path"
 	"regexp"
 	"strings"
 
@@ -84,27 +83,30 @@ func InstallAll(conf config.Config, dir string, stdOut io.Writer, stdErr io.Writ
 		return []error{fmt.Errorf("unable to list plugins: %w", err)}
 	}
 
-	toolNames := map[string]bool{}
-	filepath := path.Join(dir, conf.DefaultToolVersionsFilename)
-	toolVersions, err := toolversions.GetAllToolsAndVersions(filepath)
-	if err == nil {
-		for _, version := range toolVersions {
-			toolNames[version.Name] = true
-		}
+	toolVersions, err := resolve.AllVersions(conf, plugins, dir)
+	if err != nil {
+		return []error{fmt.Errorf("unable to resolve versions: %w", err)}
 	}
 
 	// Ideally we should install these in the order they are specified in the
 	// closest .tool-versions file, but for now that is too complicated to
 	// implement.
 	for _, plugin := range plugins {
-		delete(toolNames, plugin.Name)
-		err := Install(conf, plugin, dir, stdOut, stdErr)
-		if err != nil {
+		if toolVersion, isPluginResolved := toolVersions[plugin.Name]; isPluginResolved {
+			delete(toolVersions, plugin.Name)
+			for _, version := range toolVersion.Versions {
+				err := InstallOneVersion(conf, plugin, version, false, stdOut, stdErr)
+				if err != nil {
+					failures = append(failures, err)
+				}
+			}
+		} else {
+			err := NoVersionSetError{toolName: plugin.Name}
 			failures = append(failures, err)
 		}
 	}
 
-	for toolName := range toolNames {
+	for toolName := range toolVersions {
 		err = MissingPluginError{toolName: toolName}
 		failures = append(failures, err)
 	}

internal/versions/versions_test.go

@@ -485,6 +485,7 @@ func generateConfig(t *testing.T) (config.Config, plugins.Plugin) {
 	conf, err := config.LoadConfig()
 	assert.Nil(t, err)
 	conf.DataDir = testDataDir
+	conf.Home = testDataDir
 
 	_, err = repotest.InstallPlugin("dummy_plugin", testDataDir, testPluginName)
 	assert.Nil(t, err)