Preserve order in which tools are defined

Author: andrecloutier

internal/resolve/resolve.go

@@ -17,19 +17,23 @@ import (
 
 // ToolVersions represents a tool along with versions specified for it
 type ToolVersions struct {
+	Name      string
 	Versions  []string
 	Directory string
 	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{}
+func AllVersions(conf config.Config, plugins []plugins.Plugin, directory string) (versions []ToolVersions, err error) {
+	resolvedToolVersions := map[string]bool{}
+	var finalVersions []ToolVersions
+
 	for _, plugin := range plugins {
 		version, envVariableName, found := findVersionsInEnv(plugin.Name)
 		if found {
-			resolvedToolVersions[plugin.Name] = ToolVersions{Versions: version, Source: envVariableName}
+			resolvedToolVersions[plugin.Name] = true
+			finalVersions = append(finalVersions, ToolVersions{Name: plugin.Name, Versions: version, Source: envVariableName})
 		}
 	}
 
@@ -41,7 +45,8 @@ func AllVersions(conf config.Config, plugins []plugins.Plugin, directory string)
 					return versions, err
 				}
 				if found {
-					resolvedToolVersions[plugin.Name] = version
+					resolvedToolVersions[plugin.Name] = true
+					finalVersions = append(finalVersions, version)
 				}
 			}
 		}
@@ -51,21 +56,22 @@ func AllVersions(conf config.Config, plugins []plugins.Plugin, directory string)
 			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}
+						resolvedToolVersions[v.Name] = true
+						finalVersions = append(finalVersions, ToolVersions{Name: v.Name, Versions: v.Versions, Source: conf.DefaultToolVersionsFilename, Directory: iterDir})
 					}
 				}
 			}
 		}
 	}
-	return resolvedToolVersions, nil
+	return finalVersions, nil
 }
 
 // Version takes a plugin and a directory and resolves the tool to one or more
 // 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
+		return ToolVersions{Name: plugin.Name, Versions: version, Source: envVariableName}, true, nil
 	}
 
 	for iterDir := range iterDirectories(conf, directory) {
@@ -121,7 +127,7 @@ func findVersionsInDir(conf config.Config, plugin plugins.Plugin, directory stri
 	if _, err = os.Stat(filepath); err == nil {
 		versions, found, err := toolversions.FindToolVersions(filepath, plugin.Name)
 		if found || err != nil {
-			return ToolVersions{Versions: versions, Source: conf.DefaultToolVersionsFilename, Directory: directory}, found, err
+			return ToolVersions{Name: plugin.Name, Versions: versions, Source: conf.DefaultToolVersionsFilename, Directory: directory}, found, err
 		}
 	}
 
@@ -174,7 +180,7 @@ func findVersionsInLegacyFile(plugin plugins.Plugin, directory string) (versions
 			if len(versionsSlice) == 0 || (len(versionsSlice) == 1 && versionsSlice[0] == "") {
 				return versions, false, nil
 			}
-			return ToolVersions{Versions: versionsSlice, Source: filename, Directory: directory}, err == nil, err
+			return ToolVersions{Name: plugin.Name, Versions: versionsSlice, Source: filename, Directory: directory}, err == nil, err
 		}
 	}
 

internal/versions/versions.go

@@ -78,36 +78,37 @@ func (e VersionAlreadyInstalledError) Error() string {
 // installed, but it may be multiple versions if multiple versions for the tool
 // are specified in the .tool-versions file.
 func InstallAll(conf config.Config, dir string, stdOut io.Writer, stdErr io.Writer) (failures []error) {
-	plugins, err := plugins.List(conf, false, false)
+	installedPlugins, err := plugins.List(conf, false, false)
 	if err != nil {
 		return []error{fmt.Errorf("unable to list plugins: %w", err)}
 	}
+	pluginsMap := map[string]plugins.Plugin{}
+	for _, plugin := range installedPlugins {
+		pluginsMap[plugin.Name] = plugin
+	}
 
-	toolVersions, err := resolve.AllVersions(conf, plugins, dir)
+	toolVersions, err := resolve.AllVersions(conf, installedPlugins, 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 {
-		if toolVersion, isPluginResolved := toolVersions[plugin.Name]; isPluginResolved {
-			delete(toolVersions, plugin.Name)
+	for _, toolVersion := range toolVersions {
+		if plugin, isPluginResolved := pluginsMap[toolVersion.Name]; isPluginResolved {
+			delete(pluginsMap, 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}
+			err = MissingPluginError{toolName: toolVersion.Name}
 			failures = append(failures, err)
 		}
 	}
 
-	for toolName := range toolVersions {
-		err = MissingPluginError{toolName: toolName}
+	for _, plugin := range pluginsMap {
+		err := NoVersionSetError{toolName: plugin.Name}
 		failures = append(failures, err)
 	}