breaking: support use of codacy api token - PLUTO-1379

cmd/root.go

@@ -48,6 +48,7 @@ func showWelcomeMessage() {
 	fmt.Println()
 	cyan.Println("Initialize your project with:")
 	fmt.Println("  codacy-cli init --repository-token YOUR_TOKEN")
+	fmt.Println("  codacy-cli init --codacy-api-token YOUR_TOKEN")
 	fmt.Println()
 	fmt.Println("Or run without a token to use local configuration:")
 	fmt.Println("  codacy-cli init")

domain/patternConfiguration.go

@@ -0,0 +1,15 @@
+package domain
+
+type ParameterConfiguration struct {
+	Name  string `json:"name"`
+	Value string `json:"value"`
+}
+
+type PatternDefinition struct {
+	Id string `json:"id"`
+}
+
+type PatternConfiguration struct {
+	PatternDefinition PatternDefinition `json:"patternDefinition"`
+	Parameters        []ParameterConfiguration
+}

plugins/tool-utils.go

@@ -294,3 +294,34 @@ func getDownloadURL(urlTemplate string, fileName string, version string, mappedA
 
 	return buf.String()
 }
+
+// GetSupportedTools returns a map of supported tool names based on the tools folder
+func GetSupportedTools() (map[string]struct{}, error) {
+	supportedTools := make(map[string]struct{})
+
+	// Read all directories in the tools folder
+	entries, err := toolsFS.ReadDir("tools")
+	if err != nil {
+		return nil, fmt.Errorf("failed to read tools directory: %w", err)
+	}
+
+	// For each directory, check if it has a plugin.yaml file
+	for _, entry := range entries {
+		if !entry.IsDir() {
+			continue
+		}
+
+		toolName := entry.Name()
+		pluginPath := filepath.Join("tools", toolName, "plugin.yaml")
+
+		// Check if plugin.yaml exists
+		_, err := toolsFS.ReadFile(pluginPath)
+		if err != nil {
+			continue // Skip if no plugin.yaml
+		}
+
+		supportedTools[toolName] = struct{}{}
+	}
+
+	return supportedTools, nil
+}

plugins/tool-utils_test.go

@@ -152,3 +152,45 @@ func TestProcessToolsWithDownload(t *testing.T) {
 	}
 	assert.Contains(t, trivyInfo.DownloadURL, expectedArch)
 }
+
+func TestGetSupportedTools(t *testing.T) {
+	tests := []struct {
+		name          string
+		expectedTools []string
+		expectedError bool
+	}{
+		{
+			name: "should return supported tools",
+			expectedTools: []string{
+				"eslint",
+				"pmd",
+				"pylint",
+				"trivy",
+			},
+			expectedError: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			supportedTools, err := GetSupportedTools()
+
+			if tt.expectedError {
+				assert.Error(t, err)
+				return
+			}
+
+			assert.NoError(t, err)
+			assert.NotNil(t, supportedTools)
+
+			// Check that all expected tools are supported
+			for _, expectedTool := range tt.expectedTools {
+				_, exists := supportedTools[expectedTool]
+				assert.True(t, exists, "tool %s should be supported", expectedTool)
+			}
+
+			// Check that we have exactly the expected number of tools
+			assert.Equal(t, len(tt.expectedTools), len(supportedTools), "number of supported tools should match")
+		})
+	}
+}

tools/eslintConfigCreator.go

@@ -1,6 +1,7 @@
 package tools
 
 import (
+	"codacy/cli-v2/domain"
 	"encoding/json"
 	"fmt"
 	"strings"
@@ -18,14 +19,14 @@
 	}
 }
 
-func CreateEslintConfig(configuration ToolConfiguration) string {
+func CreateEslintConfig(configuration []domain.PatternConfiguration) string {
 	result := `export default [
     {
         rules: {
 `
 
-	for _, patternConfiguration := range configuration.PatternsConfiguration {
-		rule := strings.TrimPrefix(patternConfiguration.PatternId, "ESLint8_")
+	for _, patternConfiguration := range configuration {
+		rule := strings.TrimPrefix(patternConfiguration.PatternDefinition.Id, "ESLint8_")
 
 		const tempstring = "TEMPORARYSTRING"
 		rule = strings.ReplaceAll(rule, "__", tempstring)
@@ -34,15 +35,15 @@
 
 		parametersString := ""
 
-		for _, parameter := range patternConfiguration.ParameterConfigurations {
+		for _, parameter := range patternConfiguration.Parameters {
 			if parameter.Name == "unnamedParam" {
 				parametersString += quoteWhenIsNotJson(parameter.Value)
 			}
 		}
 
 		// build named parameters json object
 		namedParametersString := ""
-		for _, parameter := range patternConfiguration.ParameterConfigurations {
+		for _, parameter := range patternConfiguration.Parameters {
 
 			if parameter.Name != "unnamedParam" {
 				if len(namedParametersString) == 0 {

tools/eslintConfigCreator_test.go

@@ -1,19 +1,20 @@
 package tools
 
 import (
+	"codacy/cli-v2/domain"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 )
 
-func testConfig(t *testing.T, configuration ToolConfiguration, expected string) {
+func testConfig(t *testing.T, configuration []domain.PatternConfiguration, expected string) {
 	actual := CreateEslintConfig(configuration)
 	assert.Equal(t, expected, actual)
 }
 
 func TestCreateEslintConfigEmptyConfig(t *testing.T) {
 	testConfig(t,
-		ToolConfiguration{},
+		[]domain.PatternConfiguration{},
 		`export default [
     {
         rules: {
@@ -24,10 +25,10 @@ func TestCreateEslintConfigEmptyConfig(t *testing.T) {
 
 func TestCreateEslintConfigConfig1(t *testing.T) {
 	testConfig(t,
-		ToolConfiguration{
-			PatternsConfiguration: []PatternConfiguration{
-				{
-					PatternId: "ESLint8_semi",
+		[]domain.PatternConfiguration{
+			{
+				PatternDefinition: domain.PatternDefinition{
+					Id: "ESLint8_semi",
 				},
 			},
 		},
@@ -42,15 +43,15 @@ func TestCreateEslintConfigConfig1(t *testing.T) {
 
 func TestCreateEslintConfigUnnamedParam(t *testing.T) {
 	testConfig(t,
-		ToolConfiguration{
-			PatternsConfiguration: []PatternConfiguration{
-				{
-					PatternId: "ESLint8_semi",
-					ParameterConfigurations: []PatternParameterConfiguration{
-						{
-							Name:  "unnamedParam",
-							Value: "never",
-						},
+		[]domain.PatternConfiguration{
+			{
+				PatternDefinition: domain.PatternDefinition{
+					Id: "ESLint8_semi",
+				},
+				Parameters: []domain.ParameterConfiguration{
+					{
+						Name:  "unnamedParam",
+						Value: "never",
 					},
 				},
 			},
@@ -66,15 +67,15 @@ func TestCreateEslintConfigUnnamedParam(t *testing.T) {
 
 func TestCreateEslintConfigNamedParam(t *testing.T) {
 	testConfig(t,
-		ToolConfiguration{
-			PatternsConfiguration: []PatternConfiguration{
-				{
-					PatternId: "consistent-return",
-					ParameterConfigurations: []PatternParameterConfiguration{
-						{
-							Name:  "treatUndefinedAsUnspecified",
-							Value: "false",
-						},
+		[]domain.PatternConfiguration{
+			{
+				PatternDefinition: domain.PatternDefinition{
+					Id: "consistent-return",
+				},
+				Parameters: []domain.ParameterConfiguration{
+					{
+						Name:  "treatUndefinedAsUnspecified",
+						Value: "false",
 					},
 				},
 			},
@@ -90,19 +91,19 @@ func TestCreateEslintConfigNamedParam(t *testing.T) {
 
 func TestCreateEslintConfigUnnamedAndNamedParam(t *testing.T) {
 	testConfig(t,
-		ToolConfiguration{
-			PatternsConfiguration: []PatternConfiguration{
-				{
-					PatternId: "consistent-return",
-					ParameterConfigurations: []PatternParameterConfiguration{
-						{
-							Name:  "treatUndefinedAsUnspecified",
-							Value: "false",
-						},
-						{
-							Name:  "unnamedParam",
-							Value: "foo",
-						},
+		[]domain.PatternConfiguration{
+			{
+				PatternDefinition: domain.PatternDefinition{
+					Id: "consistent-return",
+				},
+				Parameters: []domain.ParameterConfiguration{
+					{
+						Name:  "treatUndefinedAsUnspecified",
+						Value: "false",
+					},
+					{
+						Name:  "unnamedParam",
+						Value: "foo",
 					},
 				},
 			},
@@ -118,10 +119,10 @@ func TestCreateEslintConfigUnnamedAndNamedParam(t *testing.T) {
 
 func TestCreateEslintConfigSupportPlugins(t *testing.T) {
 	testConfig(t,
-		ToolConfiguration{
-			PatternsConfiguration: []PatternConfiguration{
-				{
-					PatternId: "plugin/consistent-return",
+		[]domain.PatternConfiguration{
+			{
+				PatternDefinition: domain.PatternDefinition{
+					Id: "plugin/consistent-return",
 				},
 			},
 		},