feat(golang-rewrite): add support for shim templates resolution (#2076)

Co-authored-by: Augusto Moura <[email protected]>

Author: Stratus3D

internal/plugins/plugins.go

@@ -56,6 +56,17 @@ func (e NoCallbackError) Error() string {
 	return fmt.Sprintf(hasNoCallbackMsg, e.plugin, e.callback)
 }
 
+// NoShimTemplateError is an error returned by ShimTemplatePath when an shim
+// template was not found in the plugin shims directory, or the file is not executable
+type NoShimTemplateError struct {
+	shimName string
+	plugin   string
+}
+
+func (e NoShimTemplateError) Error() string {
+	return fmt.Sprintf(hasNoCallbackMsg, e.plugin, e.shimName)
+}
+
 // NoCommandError is an error returned by ExtensionCommandPath when an extension
 // command with the given name does not exist
 type NoCommandError struct {
@@ -73,6 +84,7 @@ const (
 	pluginAlreadyExistsMsg = "Plugin named %s already added"
 	pluginMissingMsg       = "Plugin named %s not installed"
 	hasNoCallbackMsg       = "Plugin named %s does not have a callback named %s"
+	hasNoShimTemplateMsg   = "Plugin named %s does not have a shim template named %s"
 	hasNoCommandMsg        = "Plugin named %s does not have a extension command named %s"
 )
 
@@ -191,6 +203,20 @@ func (p Plugin) CallbackPath(name string) (string, error) {
 	return path, nil
 }
 
+// ShimTemplatePath returns the full file path to a shim, if it exists
+func (p Plugin) ShimTemplatePath(shimName string) (string, error) {
+	const executableMode = 0o111
+
+	path := filepath.Join(p.Dir, "shims", shimName)
+	stat, err := os.Stat(path)
+
+	if errors.Is(err, os.ErrNotExist) || stat.Mode()&executableMode == 0 {
+		return "", NoShimTemplateError{shimName: shimName, plugin: p.Name}
+	}
+
+	return path, nil
+}
+
 // GetExtensionCommands returns a slice of strings representing all available
 // extension commands for the plugin.
 func (p Plugin) GetExtensionCommands() ([]string, error) {

internal/shims/shims.go

@@ -56,7 +56,7 @@ func (e NoExecutableForPluginError) Error() string {
 
 // FindExecutable takes a shim name and a current directory and returns the path
 // to the executable that the shim resolves to.
-func FindExecutable(conf config.Config, shimName, currentDirectory string) (string, plugins.Plugin, string, bool, error) {
+func FindExecutable(conf config.Config, shimName, currentDirectory string) (path string, plugin plugins.Plugin, version string, found bool, err error) {
 	shimPath := Path(conf, shimName)
 
 	if _, err := os.Stat(shimPath); err != nil {
@@ -74,6 +74,11 @@ func FindExecutable(conf config.Config, shimName, currentDirectory string) (stri
 	for _, shimToolVersion := range toolVersions {
 		plugin := plugins.New(conf, shimToolVersion.Name)
 		if plugin.Exists() == nil {
+			// If a shim template is found, we can return it before looping through versions
+			shimTemplate, err := plugin.ShimTemplatePath(shimName)
+			if err == nil {
+				return shimTemplate, plugin, "", true, nil
+			}
 
 			versions, found, err := resolve.Version(conf, plugin, currentDirectory)
 
@@ -368,18 +373,23 @@ func ToolExecutables(conf config.Config, plugin plugins.Plugin, version toolvers
 
 // ExecutablePaths returns a slice of absolute directory paths that tool
 // executables are contained in.
-func ExecutablePaths(conf config.Config, plugin plugins.Plugin, version toolversions.Version) ([]string, error) {
+func ExecutablePaths(conf config.Config, plugin plugins.Plugin, version toolversions.Version) (paths []string, err error) {
 	dirs, err := ExecutableDirs(plugin)
 	if err != nil {
 		return []string{}, err
 	}
 
+	shimsDir, err := os.Stat(path.Join(plugin.Dir, "shims"))
+	if err == nil && shimsDir.IsDir() {
+		paths = append(paths, path.Join(plugin.Dir, "shims"))
+	}
+
 	installPath := installs.InstallPath(conf, plugin, version)
-	return dirsToPaths(dirs, installPath), nil
+	return append(paths, dirsToPaths(dirs, installPath)...), nil
 }
 
-// ExecutableDirs returns a slice of directory names that tool executables are
-// contained in
+// ExecutableDirs returns a slice of relative directory names that tool executables are
+// contained in, *inside installs*
 func ExecutableDirs(plugin plugins.Plugin) ([]string, error) {
 	var stdOut strings.Builder
 	var stdErr strings.Builder

internal/shims/shims_test.go

@@ -113,6 +113,27 @@ func TestFindExecutable(t *testing.T) {
 		assert.Equal(t, filepath.Base(executable), "dummy")
 		assert.True(t, strings.HasPrefix(executable, dir))
 	})
+
+	t.Run("returns string containing path to executable when shim template in plugin is set", func(t *testing.T) {
+		// write a version file
+		data := []byte("lua 1.1.0")
+		assert.Nil(t, os.WriteFile(filepath.Join(currentDir, ".tool-versions"), data, 0o666))
+
+		// write a shim template to the plugin shims dir
+		setupShimTemplate(t, plugin, "dummy", "echo 'shim template'")
+
+		executable, gotPlugin, version, found, err := FindExecutable(conf, "dummy", currentDir)
+		assert.Nil(t, err)
+
+		relativePath, err := filepath.Rel(conf.DataDir, executable)
+		assert.Nil(t, err)
+
+		assert.Equal(t, "plugins/lua/shims/dummy", relativePath)
+		assert.Equal(t, "dummy", filepath.Base(executable))
+		assert.Equal(t, plugin, gotPlugin)
+		assert.Equal(t, "", version)
+		assert.True(t, found)
+	})
 }
 
 func TestFindExecutable_Ref(t *testing.T) {
@@ -443,6 +464,27 @@ func TestExecutablePaths(t *testing.T) {
 		assert.Equal(t, filepath.Base(path1), "foo")
 		assert.Equal(t, filepath.Base(path2), "bar")
 	})
+
+	t.Run("returns list of executable paths for tool version containing shim templates", func(t *testing.T) {
+		data := []byte("echo 'foo bar'")
+		err := os.WriteFile(filepath.Join(plugin.Dir, "bin", "list-bin-paths"), data, 0o777)
+		assert.Nil(t, err)
+
+		// write a shim template to the plugin shims dir
+		setupShimTemplate(t, plugin, "dummy", "echo 'shim template'")
+
+		executables, err := ExecutablePaths(conf, plugin, toolversions.Version{Type: "version", Value: "1.2.3"})
+		assert.Nil(t, err)
+		path1 := executables[0]
+		path2 := executables[1]
+		path3 := executables[2]
+		assert.Equal(t, "foo", filepath.Base(path2))
+		assert.Equal(t, "bar", filepath.Base(path3))
+
+		relativePath, err := filepath.Rel(conf.DataDir, path1)
+		assert.Nil(t, err)
+		assert.Equal(t, "plugins/lua/shims", relativePath)
+	})
 }
 
 func TestExecutableDirs(t *testing.T) {
@@ -511,3 +553,19 @@ func installVersion(t *testing.T, conf config.Config, plugin plugins.Plugin, ver
 	err := installtest.InstallOneVersion(conf, plugin, "version", version)
 	assert.Nil(t, err)
 }
+
+func setupShimTemplate(t *testing.T, plugin plugins.Plugin, shimName string, script string) {
+	t.Helper()
+	shimsDirPath := filepath.Join(plugin.Dir, "shims")
+	os.MkdirAll(shimsDirPath, 0o777)
+
+	shimPath := filepath.Join(shimsDirPath, shimName)
+	contents := fmt.Sprintf("#!/usr/bin/env bash\n%s\n", script)
+	err := os.WriteFile(shimPath, []byte(contents), 0o777)
+	assert.Nil(t, err)
+
+	t.Cleanup(func() {
+		err := os.Remove(shimPath)
+		assert.Nil(t, err)
+	})
+}