Tool version reporting

toolversions/toolversions.go

@@ -0,0 +1,122 @@
+package toolversions
+
+import (
+	"fmt"
+	"path/filepath"
+	"regexp"
+	"strings"
+
+	"github.com/bitrise-io/go-utils/v2/command"
+	"github.com/bitrise-io/go-utils/v2/env"
+	"github.com/bitrise-io/go-utils/v2/log"
+)
+
+type ToolVersionReporter interface {
+	// IsAvailable returns true if the tool version manager is available and actively manages the tool versions.
+	IsAvailable() bool
+
+	// CurrentToolVersions returns a snapshot of the currently active tools and versions.
+	// The returned map is keyed by tool name.
+	// Tool names and reported versions are implementation-specific. Tool names are normalized to lowercase.
+	CurrentToolVersions() (map[string]ToolVersion, error)
+}
+
+type ToolVersion struct {
+	Version        string
+	IsInstalled    bool
+	DeclaredByFile string
+	IsGlobal       bool
+}
+
+type ASDFVersionReporter struct {
+	cmdLocator  env.CommandLocator
+	cmdFactory  command.Factory
+	logger      log.Logger
+	userHomeDir string
+}
+
+func NewASDFVersionReporter(cmdLocator env.CommandLocator, cmdFactory command.Factory, logger log.Logger, userHomeDir string) ASDFVersionReporter {
+	return ASDFVersionReporter{
+		cmdLocator:  cmdLocator,
+		cmdFactory:  cmdFactory,
+		logger:      logger,
+		userHomeDir: userHomeDir,
+	}
+}
+
+func (r *ASDFVersionReporter) IsAvailable() bool {
+	_, err := r.cmdLocator.LookPath("asdf")
+	if err != nil {
+		r.logger.Debugf("asdf not found in path")
+		return false
+	}
+
+	code, err := r.cmdFactory.Create("asdf", []string{"current"}, &command.Opts{}).RunAndReturnExitCode()
+	if err != nil {
+		r.logger.Debugf("run asdf current: %s", err)
+		return false
+	}
+	if code != 0 {
+		r.logger.Debugf("run asdf current: nonzero exit code: %d", code)
+		return false
+	}
+
+	return true
+}
+
+func (r *ASDFVersionReporter) CurrentToolVersions() (map[string]ToolVersion, error) {
+	cmd := r.cmdFactory.Create("asdf", []string{"current"}, &command.Opts{})
+	out, err := cmd.RunAndReturnTrimmedCombinedOutput()
+	if err != nil {
+		return nil, fmt.Errorf("run asdf current: %s", err)
+	}
+
+	asdfVersionRegexp, err := regexp.Compile(`([a-z]+)\s+(\S+)\s+(.+)`)
+	if err != nil {
+		return nil, fmt.Errorf("compile regex: %s", err)
+	}
+
+	toolVersions := map[string]ToolVersion{}
+	for _, line := range strings.Split(out, "\n") {
+		matches := asdfVersionRegexp.FindAllStringSubmatch(line, -1)
+		if len(matches) == 0 {
+			continue
+		}
+		captureGroups := matches[0]
+		if len(captureGroups) != 4 {
+			// Entire match + 3 capture groups
+			return nil, fmt.Errorf("unexpected number of matches (%d) in input: %s, matches: %s", len(matches), line, matches)
+		}
+		tool := captureGroups[1]
+		version := captureGroups[2]
+		declaredBy := captureGroups[3]
+
+		if tool == "alias" {
+			// Meta-tool, ignore
+			continue
+		}
+
+		if version == "______" {
+			// No version is set globally, ignore
+			continue
+		}
+
+		isInstalled := !strings.HasPrefix(declaredBy, "Not installed.")
+		var declaredByFile string
+		var isGlobal bool
+		file := filepath.Base(declaredBy)
+		if file != "." && isInstalled {
+			declaredByFile = file
+			isGlobal = filepath.Dir(declaredBy) == r.userHomeDir
+		}
+
+		toolVersions[strings.ToLower(tool)] = ToolVersion{
+			Version:        version,
+			IsInstalled:    isInstalled,
+			DeclaredByFile: declaredByFile,
+			IsGlobal:       isGlobal,
+		}
+	}
+
+	return toolVersions, nil
+}

toolversions/toolversions_test.go

@@ -0,0 +1,217 @@
+package toolversions
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/bitrise-io/go-utils/v2/command"
+	"github.com/bitrise-io/go-utils/v2/log"
+	"github.com/stretchr/testify/assert"
+)
+
+const validASDFOutput = `alias           ______          No version is set. Run "asdf <global|shell|local> alias <version>"
+flutter         3.16.1-stable   /Users/bitrise/.tool-versions
+golang          1.18            /Users/bitrise/Projects/steps/.tool-versions
+java            17              Not installed. Run "asdf install java 17"
+nodejs          19.7.0          Not installed. Run "asdf install nodejs 19.7.0"
+ruby            3.1.3           /Users/bitrise/.tool-versions
+python		    ______          No version is set. Run "asdf <global|shell|local> python <version>"`
+
+func TestIsAvailable(t *testing.T) {
+	tests := []struct {
+		name        string
+		systemPath  string
+		cmdOutput   string
+		cmdExitCode int
+		expected    bool
+	}{
+		{
+			name:        "asdf is available",
+			systemPath:  "/bin:/usr/bin:/root/.asdf/bin/asdf",
+			cmdOutput:   validASDFOutput,
+			cmdExitCode: 0,
+			expected:    true,
+		},
+		{
+			name:        "asdf is not available",
+			systemPath:  "/bin:/usr/bin",
+			cmdOutput:   "",
+			cmdExitCode: 1,
+			expected:    false,
+		},
+		{
+			name:        "asdf is not working",
+			systemPath:  "/bin:/usr/bin:/root/.asdf/bin/asdf",
+			cmdOutput:   "",
+			cmdExitCode: 1,
+			expected:    false,
+		},
+
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			logger := log.NewLogger()
+			logger.EnableDebugLog(true)
+			r := NewASDFVersionReporter(
+				fakeCommandLocator{path: tt.systemPath},
+				fakeCommandFactory{stdout: tt.cmdOutput, exitCode: tt.cmdExitCode},
+				logger,
+				"/Users/bitrise",
+			)
+
+			result := r.IsAvailable()
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestCurrentToolVersions(t *testing.T) {
+	tests := []struct {
+		name      string
+		cmdOutput string
+		cmdError  error
+		expected  map[string]ToolVersion
+		expectErr bool
+	}{
+		{
+			name:      "valid output",
+			cmdOutput: validASDFOutput,
+			expected: map[string]ToolVersion{
+				"flutter": {
+					Version:        "3.16.1-stable",
+					IsInstalled:    true,
+					DeclaredByFile: ".tool-versions",
+					IsGlobal:       true,
+				},
+				"golang": {
+					Version:        "1.18",
+					IsInstalled:    true,
+					DeclaredByFile: ".tool-versions",
+					IsGlobal:       false,
+				},
+				"java": {
+					Version:        "17",
+					IsInstalled:    false,
+					DeclaredByFile: "",
+					IsGlobal:       false,
+				},
+				"nodejs": {
+					Version:        "19.7.0",
+					IsInstalled:    false,
+					DeclaredByFile: "",
+					IsGlobal:       false,
+				},
+				"ruby": {
+					Version:        "3.1.3",
+					IsInstalled:    true,
+					DeclaredByFile: ".tool-versions",
+					IsGlobal:       true,
+				},
+			},
+			expectErr: false,
+		},
+		{
+			name:      "empty output",
+			cmdOutput: "",
+			expected:  map[string]ToolVersion{},
+			expectErr: false,
+		},
+		{
+			name:      "invalid output",
+			cmdOutput: "error",
+			expected:  map[string]ToolVersion{},
+			expectErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			logger := log.NewLogger()
+			logger.EnableDebugLog(true)
+			r := NewASDFVersionReporter(
+				fakeCommandLocator{path: "/root/.asdf/bin/asdf"},
+				fakeCommandFactory{stdout: tt.cmdOutput},
+				logger,
+				"/Users/bitrise",
+			)
+
+			result, err := r.CurrentToolVersions()
+			if tt.expectErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.Equal(t, tt.expected, result)
+			}
+		})
+	}
+}
+
+type fakeCommandLocator struct {
+	path string
+}
+
+func (f fakeCommandLocator) LookPath(name string) (string, error) {
+	return f.path, nil
+}
+
+type fakeCommandFactory struct {
+	stdout   string
+	exitCode int
+}
+
+func (f fakeCommandFactory) Create(name string, args []string, opts *command.Opts) command.Command {
+	return fakeCommand{
+		command:  fmt.Sprintf("%s %s", name, strings.Join(args, " ")),
+		stdout:   f.stdout,
+		exitCode: f.exitCode,
+	}
+}
+
+type fakeCommand struct {
+	command  string
+	stdout   string
+	stderr   string
+	exitCode int
+}
+
+func (c fakeCommand) PrintableCommandArgs() string {
+	return c.command
+}
+
+func (c fakeCommand) Run() error {
+	if c.exitCode != 0 {
+		return fmt.Errorf("exit code %d", c.exitCode)
+	}
+	return nil
+}
+
+func (c fakeCommand) RunAndReturnExitCode() (int, error) {
+	if c.exitCode != 0 {
+		return c.exitCode, fmt.Errorf("exit code %d", c.exitCode)
+	}
+	return c.exitCode, nil
+}
+
+func (c fakeCommand) RunAndReturnTrimmedOutput() (string, error) {
+	if c.exitCode != 0 {
+		return "", fmt.Errorf("exit code %d", c.exitCode)
+	}
+	return c.stdout, nil
+}
+
+func (c fakeCommand) RunAndReturnTrimmedCombinedOutput() (string, error) {
+	if c.exitCode != 0 {
+		return "", fmt.Errorf("exit code %d", c.exitCode)
+	}
+	return fmt.Sprintf("%s%s", c.stdout, c.stderr), nil
+}
+
+func (c fakeCommand) Start() error {
+	return nil
+}
+
+func (c fakeCommand) Wait() error {
+	return nil
+}