fix Codacy issues

Author: alerizzo

cmd/configsetup/codacy_yaml.go

@@ -1,3 +1,5 @@
+// Package configsetup provides helpers to create Codacy configuration
+// files (codacy.yaml and related tool/runtime sections).
 package configsetup
 
 import (
@@ -17,6 +19,8 @@ type RuntimePluginConfig struct {
 	DefaultVersion string `yaml:"default_version"`
 }
 
+// ConfigFileTemplate returns the content of codacy.yaml given the enabled
+// tools. It lists required runtimes and tools with their versions.
 func ConfigFileTemplate(tools []domain.Tool) string {
 	toolsMap := make(map[string]bool)
 	toolVersions := make(map[string]string)
@@ -47,7 +51,7 @@ func ConfigFileTemplate(tools []domain.Tool) string {
 	return sb.String()
 }
 
-// getToolVersion returns the version for a tool, preferring tool.Version over default
+// getToolVersion returns the version for a tool, preferring tool.Version over default.
 func getToolVersion(tool domain.Tool, defaultVersions map[string]string) string {
 	if tool.Version != "" {
 		return tool.Version
@@ -60,9 +64,9 @@ func getToolVersion(tool domain.Tool, defaultVersions map[string]string) string
 	return ""
 }
 
-// addRequiredRuntime adds the runtime requirement for a tool
-func addRequiredRuntime(toolUuid string, neededRuntimes map[string]bool, runtimeDependencies map[string]string) {
-	if meta, ok := domain.SupportedToolsMetadata[toolUuid]; ok {
+// addRequiredRuntime adds the runtime requirement for a tool.
+func addRequiredRuntime(toolUUID string, neededRuntimes map[string]bool, runtimeDependencies map[string]string) {
+    if meta, ok := domain.SupportedToolsMetadata[toolUUID]; ok {
 		if runtime, ok := runtimeDependencies[meta.Name]; ok {
 			if meta.Name == "dartanalyzer" {
 				// For dartanalyzer, default to dart runtime
@@ -74,7 +78,7 @@ func addRequiredRuntime(toolUuid string, neededRuntimes map[string]bool, runtime
 	}
 }
 
-// buildRuntimesSection builds the runtimes section of the configuration
+// buildRuntimesSection builds the runtimes section of the configuration.
 func buildRuntimesSection(sb *strings.Builder, tools []domain.Tool, neededRuntimes map[string]bool, runtimeVersions map[string]string, runtimeDependencies map[string]string) {
 	sb.WriteString("runtimes:\n")
 
@@ -86,7 +90,7 @@ func buildRuntimesSection(sb *strings.Builder, tools []domain.Tool, neededRuntim
 	writeRuntimesList(sb, neededRuntimes, runtimeVersions)
 }
 
-// addAllSupportedRuntimes adds all runtimes needed by supported tools
+// addAllSupportedRuntimes adds all runtimes needed by supported tools.
 func addAllSupportedRuntimes(neededRuntimes map[string]bool, runtimeDependencies map[string]string) {
 	supportedTools, err := plugins.GetSupportedTools()
 	if err != nil {
@@ -105,7 +109,7 @@ func addAllSupportedRuntimes(neededRuntimes map[string]bool, runtimeDependencies
 	}
 }
 
-// writeRuntimesList writes the sorted runtimes list to the string builder
+// writeRuntimesList writes the sorted runtimes list to the string builder.
 func writeRuntimesList(sb *strings.Builder, neededRuntimes map[string]bool, runtimeVersions map[string]string) {
 	var sortedRuntimes []string
 	for runtime := range neededRuntimes {
@@ -118,7 +122,7 @@ func writeRuntimesList(sb *strings.Builder, neededRuntimes map[string]bool, runt
 	}
 }
 
-// buildToolsSection builds the tools section of the configuration
+// buildToolsSection builds the tools section of the configuration.
 func buildToolsSection(sb *strings.Builder, tools []domain.Tool, toolsMap map[string]bool, toolVersions map[string]string, defaultVersions map[string]string) {
 	sb.WriteString("tools:\n")
 
@@ -129,7 +133,7 @@ func buildToolsSection(sb *strings.Builder, tools []domain.Tool, toolsMap map[st
 	}
 }
 
-// writeEnabledTools writes the enabled tools to the string builder
+// writeEnabledTools writes the enabled tools to the string builder.
 func writeEnabledTools(sb *strings.Builder, toolsMap map[string]bool, toolVersions map[string]string) {
 	var sortedTools []string
 	for uuid, meta := range domain.SupportedToolsMetadata {
@@ -150,7 +154,7 @@ func writeEnabledTools(sb *strings.Builder, toolsMap map[string]bool, toolVersio
 	}
 }
 
-// writeAllSupportedTools writes all supported tools to the string builder
+// writeAllSupportedTools writes all supported tools to the string builder.
 func writeAllSupportedTools(sb *strings.Builder, defaultVersions map[string]string) {
 	supportedTools, err := plugins.GetSupportedTools()
 	if err != nil {

cmd/configsetup/config_creators.go

@@ -1,3 +1,5 @@
+// Package configsetup provides helpers to create Codacy configuration
+// and helper files locally.
 package configsetup
 
 import (
@@ -12,6 +14,8 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
+// CreateLanguagesConfigFileLocal writes the languages configuration file to
+// the provided directory using data from the Codacy API.
 func CreateLanguagesConfigFileLocal(toolsConfigDir string) error {
 	// Build tool language configurations from API
 	configTools, err := tools.BuildLanguagesConfigFromAPI()
@@ -33,12 +37,16 @@ func CreateLanguagesConfigFileLocal(toolsConfigDir string) error {
 	return writeConfigFile(filepath.Join(toolsConfigDir, constants.LanguagesConfigFileName), data)
 }
 
+// CreateGitIgnoreFile creates a default .gitignore in the local Codacy
+// directory to avoid committing generated files.
 func CreateGitIgnoreFile() error {
 	gitIgnorePath := filepath.Join(config.Config.LocalCodacyDirectory(), constants.GitIgnoreFileName)
 	content := "# Codacy CLI\ntools-configs/\n.gitignore\ncli-config.yaml\nlogs/\n"
 	return writeConfigFile(gitIgnorePath, []byte(content))
 }
 
+// CreateConfigurationFiles generates project configuration files
+// (codacy.yaml and cli-config.yaml).
 func CreateConfigurationFiles(tools []domain.Tool, cliLocalMode bool, flags domain.InitFlags) error {
 	// Create project config file
 	configContent := ConfigFileTemplate(tools)
@@ -55,11 +63,10 @@ func CreateConfigurationFiles(tools []domain.Tool, cliLocalMode bool, flags doma
 	return nil
 }
 
-// buildCliConfigContent creates the CLI configuration content
+// buildCliConfigContent creates the CLI configuration content.
 func buildCliConfigContent(cliLocalMode bool, initFlags domain.InitFlags) string {
-	if cliLocalMode {
-		return fmt.Sprintf("mode: local")
-	} else {
-		return fmt.Sprintf("mode: remote\nprovider: %s\norganization: %s\nrepository: %s", initFlags.Provider, initFlags.Organization, initFlags.Repository)
-	}
+    if cliLocalMode {
+        return fmt.Sprintf("mode: local")
+    }
+    return fmt.Sprintf("mode: remote\nprovider: %s\norganization: %s\nrepository: %s", initFlags.Provider, initFlags.Organization, initFlags.Repository)
 }

cmd/configsetup/default_config.go

@@ -1,66 +1,77 @@
+// Package configsetup contains defaults and helpers to generate
+// configuration for supported tools.
 package configsetup
 
 import (
-	"fmt"
-	"log"
-	"strings"
-
-	codacyclient "codacy/cli-v2/codacy-client"
-	"codacy/cli-v2/config"
-	"codacy/cli-v2/domain"
-	"codacy/cli-v2/plugins"
-	"codacy/cli-v2/tools"
+    "fmt"
+    "log"
+    "strings"
+
+    codacyclient "codacy/cli-v2/codacy-client"
+    "codacy/cli-v2/config"
+    "codacy/cli-v2/domain"
+    "codacy/cli-v2/plugins"
+    "codacy/cli-v2/tools"
 )
 
-// KeepToolsWithLatestVersion filters the tools to keep only the latest version of each tool family.
+// KeepToolsWithLatestVersion filters the tools to keep only the latest
+// version of each tool family.
 func KeepToolsWithLatestVersion(tools []domain.Tool) (
-	toolsWithLatestVersion []domain.Tool,
-	uuidToName map[string]string,
-	familyToVersions map[string][]string,
+    toolsWithLatestVersion []domain.Tool,
+    uuidToName map[string]string,
+    familyToVersions map[string][]string,
 ) {
-	latestTools := map[string]domain.Tool{}
-	uuidToName = map[string]string{}
-	seen := map[string][]domain.Tool{}
-	familyToVersions = map[string][]string{}
-
-	for _, tool := range tools {
-		meta, ok := domain.SupportedToolsMetadata[tool.Uuid]
-		if !ok {
-			continue
-		}
+    latestTools := map[string]domain.Tool{}
+    uuidToName = map[string]string{}
+    seen := map[string][]domain.Tool{}
 
-		// Track all tools seen per family
-		seen[meta.Name] = append(seen[meta.Name], tool)
+    for _, tool := range tools {
+        processToolForLatest(tool, latestTools, uuidToName, seen)
+    }
 
-		// Pick the best version
-		current, exists := latestTools[meta.Name]
-		if !exists || domain.SupportedToolsMetadata[current.Uuid].Priority > meta.Priority {
-			latestTools[meta.Name] = tool
-			uuidToName[tool.Uuid] = meta.Name
-		}
-	}
+    familyToVersions = buildFamilyVersionMap(seen)
 
-	// Populate final list and version map for logging
-	for family, tools := range seen {
-		var versions []string
-		for _, t := range tools {
-			v := t.Version
-			if v == "" {
-				v = "(unknown)"
-			}
-			versions = append(versions, v)
-		}
-		familyToVersions[family] = versions
-	}
+    for _, tool := range latestTools {
+        toolsWithLatestVersion = append(toolsWithLatestVersion, tool)
+    }
 
-	for _, tool := range latestTools {
-		toolsWithLatestVersion = append(toolsWithLatestVersion, tool)
-	}
+    return
+}
+
+// processToolForLatest updates the latest tool per family and tracking maps.
+func processToolForLatest(tool domain.Tool, latestTools map[string]domain.Tool, uuidToName map[string]string, seen map[string][]domain.Tool) {
+    meta, ok := domain.SupportedToolsMetadata[tool.Uuid]
+    if !ok {
+        return
+    }
+
+    seen[meta.Name] = append(seen[meta.Name], tool)
+
+    current, exists := latestTools[meta.Name]
+    if !exists || domain.SupportedToolsMetadata[current.Uuid].Priority > meta.Priority {
+        latestTools[meta.Name] = tool
+        uuidToName[tool.Uuid] = meta.Name
+    }
+}
 
-	return
+// buildFamilyVersionMap builds a map of tool family to discovered versions.
+func buildFamilyVersionMap(seen map[string][]domain.Tool) map[string][]string {
+    familyToVersions := make(map[string][]string)
+    for family, tools := range seen {
+        var versions []string
+        for _, t := range tools {
+            v := t.Version
+            if v == "" {
+                v = "(unknown)"
+            }
+            versions = append(versions, v)
+        }
+        familyToVersions[family] = versions
+    }
+    return familyToVersions
 }
 
-// BuildDefaultConfigurationFiles creates default configuration files for all tools
+// BuildDefaultConfigurationFiles creates default configuration files for all tools.
 func BuildDefaultConfigurationFiles(toolsConfigDir string, flags domain.InitFlags) error {
 	// Get default tool versions to determine correct UUIDs
 	defaultVersions := plugins.GetToolVersions()
@@ -83,7 +94,7 @@ func BuildDefaultConfigurationFiles(toolsConfigDir string, flags domain.InitFlag
 	return createToolConfigurationsForUUIDs(allUUIDs, toolsConfigDir, flags)
 }
 
-// CreateConfigurationFilesForDiscoveredTools creates tool configuration files for discovered tools
+// CreateConfigurationFilesForDiscoveredTools creates tool configuration files for discovered tools.
 func CreateConfigurationFilesForDiscoveredTools(discoveredToolNames map[string]struct{}, toolsConfigDir string, initFlags domain.InitFlags) error {
 	// Determine CLI mode
 	currentCliMode, err := config.Config.GetCliMode()
@@ -92,18 +103,16 @@ func CreateConfigurationFilesForDiscoveredTools(discoveredToolNames map[string]s
 		currentCliMode = "local" // Default to local
 	}
 
-	if currentCliMode == "remote" && initFlags.ApiToken != "" {
-		// Remote mode - create configurations based on cloud repository settings
-		return createRemoteToolConfigurationsForDiscovered(discoveredToolNames, initFlags)
-	} else {
-		// Local mode - create default configurations for discovered tools
-		return createDefaultConfigurationsForSpecificTools(discoveredToolNames, toolsConfigDir, initFlags)
-	}
+    if currentCliMode == "remote" && initFlags.ApiToken != "" {
+        // Remote mode - create configurations based on cloud repository settings
+        return createRemoteToolConfigurationsForDiscovered(discoveredToolNames, initFlags)
+    }
+    // Local mode - create default configurations for discovered tools
+    return createDefaultConfigurationsForSpecificTools(discoveredToolNames, toolsConfigDir, initFlags)
 }
 
-// createRemoteToolConfigurationsForDiscovered creates tool configurations for remote mode based on cloud settings
+// createRemoteToolConfigurationsForDiscovered creates tool configurations for remote mode based on cloud settings.
 func createRemoteToolConfigurationsForDiscovered(discoveredToolNames map[string]struct{}, initFlags domain.InitFlags) error {
-	
 	// Get repository tools from API
 	apiTools, err := tools.GetRepositoryTools(initFlags)
 	if err != nil {
@@ -136,39 +145,34 @@ func createRemoteToolConfigurationsForDiscovered(discoveredToolNames map[string]
 	return createToolConfigurationFiles(configuredTools, initFlags)
 }
 
-// selectCorrectToolUUID selects the correct UUID for a tool based on its version
+// selectCorrectToolUUID selects the correct UUID for a tool based on its version.
 func selectCorrectToolUUID(toolName string, defaultVersions map[string]string) string {
-	version, hasVersion := defaultVersions[toolName]
-
-	// Special case for PMD: choose PMD7 UUID for version 7.x, PMD UUID for version 6.x
-	if toolName == "pmd" && hasVersion {
-		if strings.HasPrefix(version, "7.") {
-			return domain.PMD7
-		} else {
-			return domain.PMD
-		}
-	}
-
-	// Special case for ESLint: choose ESLint9 UUID for version 9.x, ESLint UUID for older versions
-	if toolName == "eslint" && hasVersion {
-		if strings.HasPrefix(version, "9.") {
-			return domain.ESLint9
-		} else {
-			return domain.ESLint
-		}
-	}
-
-	// For other tools, find the first matching UUID
-	for uuid, meta := range domain.SupportedToolsMetadata {
-		if meta.Name == toolName {
-			return uuid
-		}
-	}
-
-	return ""
+    version := defaultVersions[toolName]
+
+    switch toolName {
+    case "pmd":
+        if strings.HasPrefix(version, "7.") {
+            return domain.PMD7
+        }
+        return domain.PMD
+    case "eslint":
+        if strings.HasPrefix(version, "9.") {
+            return domain.ESLint9
+        }
+        return domain.ESLint
+    }
+
+    // For other tools, find the first matching UUID
+    for uuid, meta := range domain.SupportedToolsMetadata {
+        if meta.Name == toolName {
+            return uuid
+        }
+    }
+
+    return ""
 }
 
-// createDefaultConfigurationsForSpecificTools creates default configurations for specific tools only
+// createDefaultConfigurationsForSpecificTools creates default configurations for specific tools only.
 func createDefaultConfigurationsForSpecificTools(discoveredToolNames map[string]struct{}, toolsConfigDir string, initFlags domain.InitFlags) error {
 	fmt.Printf("Creating default configurations for %d discovered tools...\n", len(discoveredToolNames))