wip

Author: machadoit

plugins/tool-utils.go

@@ -0,0 +1,133 @@
+package plugins
+
+import (
+	"embed"
+	"fmt"
+	"path"
+	"path/filepath"
+
+	"gopkg.in/yaml.v3"
+)
+
+//go:embed tools/*/plugin.yaml
+var toolsFS embed.FS
+
+// ToolBinary represents a binary executable provided by the tool
+type ToolBinary struct {
+	Name string `yaml:"name"`
+	Path string `yaml:"path"`
+}
+
+// Formatter represents a supported output format
+type Formatter struct {
+	Name string `yaml:"name"`
+	Flag string `yaml:"flag"`
+}
+
+// InstallationConfig holds the installation configuration from the plugin.yaml
+type InstallationConfig struct {
+	Command          string `yaml:"command"`
+	RegistryTemplate string `yaml:"registry_template"`
+}
+
+// OutputOptions holds configuration for output handling
+type OutputOptions struct {
+	FileFlag string `yaml:"file_flag"`
+}
+
+// AnalysisOptions holds configuration for analysis options
+type AnalysisOptions struct {
+	AutofixFlag string `yaml:"autofix_flag"`
+	DefaultPath string `yaml:"default_path"`
+}
+
+// ToolPluginConfig holds the structure of the tool plugin.yaml file
+type ToolPluginConfig struct {
+	Name            string            `yaml:"name"`
+	Description     string            `yaml:"description"`
+	Runtime         string            `yaml:"runtime"`
+	Installation    InstallationConfig `yaml:"installation"`
+	Binaries        []ToolBinary      `yaml:"binaries"`
+	Formatters      []Formatter       `yaml:"formatters"`
+	OutputOptions   OutputOptions     `yaml:"output_options"`
+	AnalysisOptions AnalysisOptions   `yaml:"analysis_options"`
+}
+
+// ToolConfig represents configuration for a tool
+type ToolConfig struct {
+	Name     string
+	Version  string
+	Registry string
+}
+
+// ToolInfo contains all processed information about a tool
+type ToolInfo struct {
+	Name        string
+	Version     string
+	Runtime     string
+	InstallDir  string
+	Binaries    map[string]string // Map of binary name to full path
+	Formatters  map[string]string // Map of formatter name to flag
+	OutputFlag  string
+	AutofixFlag string
+	DefaultPath string
+	// Installation info
+	InstallCommand    string
+	RegistryCommand   string
+}
+
+// ProcessTools processes a list of tool configurations and returns a map of tool information
+func ProcessTools(configs []ToolConfig, toolDir string) (map[string]*ToolInfo, error) {
+	result := make(map[string]*ToolInfo)
+	
+	for _, config := range configs {
+		// Load the tool plugin
+		pluginPath := filepath.Join("tools", config.Name, "plugin.yaml")
+		
+		// Read from embedded filesystem
+		data, err := toolsFS.ReadFile(pluginPath)
+		if err != nil {
+			return nil, fmt.Errorf("error reading plugin.yaml for %s: %w", config.Name, err)
+		}
+		
+		var pluginConfig ToolPluginConfig
+		err = yaml.Unmarshal(data, &pluginConfig)
+		if err != nil {
+			return nil, fmt.Errorf("error parsing plugin.yaml for %s: %w", config.Name, err)
+		}
+		
+		// Create the install directory path
+		installDir := path.Join(toolDir, fmt.Sprintf("%s@%s", config.Name, config.Version))
+		
+		// Create ToolInfo with basic information
+		info := &ToolInfo{
+			Name:        config.Name,
+			Version:     config.Version,
+			Runtime:     pluginConfig.Runtime,
+			InstallDir:  installDir,
+			Binaries:    make(map[string]string),
+			Formatters:  make(map[string]string),
+			OutputFlag:  pluginConfig.OutputOptions.FileFlag,
+			AutofixFlag: pluginConfig.AnalysisOptions.AutofixFlag,
+			DefaultPath: pluginConfig.AnalysisOptions.DefaultPath,
+			// Store raw command templates (processing will happen later)
+			InstallCommand:  pluginConfig.Installation.Command,
+			RegistryCommand: pluginConfig.Installation.RegistryTemplate,
+		}
+		
+		// Process binary paths
+		for _, binary := range pluginConfig.Binaries {
+			binaryPath := path.Join(installDir, binary.Path)
+			info.Binaries[binary.Name] = binaryPath
+		}
+		
+		// Process formatters
+		for _, formatter := range pluginConfig.Formatters {
+			info.Formatters[formatter.Name] = formatter.Flag
+		}
+		
+		result[config.Name] = info
+	}
+	
+	return result, nil
+}

plugins/tool-utils_test.go

@@ -0,0 +1,64 @@
+package plugins
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestProcessTools(t *testing.T) {
+	// Create a list of tool configs for testing
+	configs := []ToolConfig{
+		{
+			Name:    "eslint",
+			Version: "8.38.0",
+		},
+	}
+
+	// Define a test tool directory
+	toolDir := "/test/tools"
+
+	// Process the tools
+	toolInfos, err := ProcessTools(configs, toolDir)
+
+	// Assert no errors occurred
+	assert.NoError(t, err, "ProcessTools should not return an error")
+
+	// Assert we have the expected tool in the results
+	assert.Contains(t, toolInfos, "eslint")
+
+	// Get the eslint tool info
+	eslintInfo := toolInfos["eslint"]
+
+	// Assert the basic tool info is correct
+	assert.Equal(t, "eslint", eslintInfo.Name)
+	assert.Equal(t, "8.38.0", eslintInfo.Version)
+	assert.Equal(t, "node", eslintInfo.Runtime)
+
+	// Assert the install directory is correct
+	expectedInstallDir := filepath.Join(toolDir, "[email protected]")
+	assert.Equal(t, expectedInstallDir, eslintInfo.InstallDir)
+
+	// Assert binary paths are correctly set
+	assert.NotNil(t, eslintInfo.Binaries)
+	assert.Greater(t, len(eslintInfo.Binaries), 0)
+
+	// Check if eslint binary is present
+	eslintBinary := filepath.Join(expectedInstallDir, "node_modules/.bin/eslint")
+	assert.Equal(t, eslintBinary, eslintInfo.Binaries["eslint"])
+
+	// Assert formatters are correctly set
+	assert.NotNil(t, eslintInfo.Formatters)
+	assert.Greater(t, len(eslintInfo.Formatters), 0)
+	assert.Equal(t, "-f @microsoft/eslint-formatter-sarif", eslintInfo.Formatters["sarif"])
+
+	// Assert output and analysis options are correctly set
+	assert.Equal(t, "-o", eslintInfo.OutputFlag)
+	assert.Equal(t, "--fix", eslintInfo.AutofixFlag)
+	assert.Equal(t, ".", eslintInfo.DefaultPath)
+
+	// Assert installation command templates are correctly set
+	assert.Equal(t, "install --prefix {{.InstallDir}} {{.PackageName}}@{{.Version}} @microsoft/eslint-formatter-sarif", eslintInfo.InstallCommand)
+	assert.Equal(t, "{{if .Registry}}config set registry {{.Registry}}{{end}}", eslintInfo.RegistryCommand)
+}

plugins/tools/eslint/plugin.yaml

@@ -0,0 +1,17 @@
+name: eslint
+description: ESLint JavaScript linter
+runtime: node
+installation:
+  command: "install --prefix {{.InstallDir}} {{.PackageName}}@{{.Version}} @microsoft/eslint-formatter-sarif"
+  registry_template: "{{if .Registry}}config set registry {{.Registry}}{{end}}"
+binaries:
+  - name: eslint
+    path: "node_modules/.bin/eslint"
+formatters:
+  - name: sarif
+    flag: "-f @microsoft/eslint-formatter-sarif"
+output_options:
+  file_flag: "-o"
+analysis_options:
+  autofix_flag: "--fix"
+  default_path: "."