[PLUTO-1392] Add Lizard tool (#101)

* [PLUTO-1392] Add Lizard tool (#101)

Author: zhamborova

.codacy/codacy.yaml

@@ -9,3 +9,4 @@ tools:
     - [email protected]
     - [email protected]
     - [email protected]
+    - [email protected]

cmd/analyze.go

@@ -2,8 +2,10 @@ package cmd
 
 import (
 	"codacy/cli-v2/config"
+	"codacy/cli-v2/domain"
 	"codacy/cli-v2/plugins"
 	"codacy/cli-v2/tools"
+	"codacy/cli-v2/tools/lizard"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -329,26 +331,39 @@ func runEslintAnalysis(workDirectory string, pathsToCheck []string, autoFix bool
 
 func runTrivyAnalysis(workDirectory string, pathsToCheck []string, outputFile string, outputFormat string) error {
 	trivy := config.Config.Tools()["trivy"]
+	if trivy == nil {
+		log.Fatal("Trivy tool configuration not found")
+	}
 	trivyBinary := trivy.Binaries["trivy"]
 
 	return tools.RunTrivy(workDirectory, trivyBinary, pathsToCheck, outputFile, outputFormat)
 }
 
 func runPmdAnalysis(workDirectory string, pathsToCheck []string, outputFile string, outputFormat string) error {
 	pmd := config.Config.Tools()["pmd"]
+	if pmd == nil {
+		log.Fatal("Pmd tool configuration not found")
+	}
 	pmdBinary := pmd.Binaries["pmd"]
 
 	return tools.RunPmd(workDirectory, pmdBinary, pathsToCheck, outputFile, outputFormat, config.Config)
 }
 
 func runPylintAnalysis(workDirectory string, pathsToCheck []string, outputFile string, outputFormat string) error {
 	pylint := config.Config.Tools()["pylint"]
+	if pylint == nil {
+		log.Fatal("Pylint tool configuration not found")
+	}
+	pylintBinary := pylint.Binaries["python"]
 
-	return tools.RunPylint(workDirectory, pylint, pathsToCheck, outputFile, outputFormat)
+	return tools.RunPylint(workDirectory, pylintBinary, pathsToCheck, outputFile, outputFormat)
 }
 
 func runDartAnalyzer(workDirectory string, pathsToCheck []string, outputFile string, outputFormat string) error {
 	dartanalyzer := config.Config.Tools()["dartanalyzer"]
+	if dartanalyzer == nil {
+		log.Fatal("Dart analyzer tool configuration not found")
+	}
 	return tools.RunDartAnalyzer(workDirectory, dartanalyzer.InstallDir, dartanalyzer.Binaries["dart"], pathsToCheck, outputFile, outputFormat)
 }
 
@@ -357,8 +372,43 @@ func runSemgrepAnalysis(workDirectory string, pathsToCheck []string, outputFile
 	if semgrep == nil {
 		log.Fatal("Semgrep tool configuration not found")
 	}
+	semgrepBinary := semgrep.Binaries["python"]
+
+	return tools.RunSemgrep(workDirectory, semgrepBinary, pathsToCheck, outputFile, outputFormat)
+}
+
+func runLizardAnalysis(workDirectory string, pathsToCheck []string, outputFile string, outputFormat string) error {
+	lizardTool := config.Config.Tools()["lizard"]
+
+	if lizardTool == nil {
+		log.Fatal("Lizard plugin configuration not found")
+	}
+
+	lizardBinary := lizardTool.Binaries["python"]
+
+	configFile, exists := tools.ConfigFileExists(config.Config, "lizard.yaml")
+	var patterns []domain.PatternDefinition
+	var err error
+
+	//this logic is here because I want to pass the config to the runner which is good for:
+	//Separation of concerns, runner will simply run the tool now
+	//Easier testing, since config is now passed
+	//Avoiding fetching the default patterns in tests (unless we want to maintain codacy directory with the configs)
+	if exists {
+		// Configuration exists, read from file
+		patterns, err = lizard.ReadConfig(configFile)
+		if err != nil {
+			return fmt.Errorf("error reading config file: %v", err)
+		}
+	} else {
+		fmt.Println("No configuration file found for Lizard, using default patterns, run init with repository token to get a custom configuration")
+		patterns, err = tools.FetchDefaultEnabledPatterns(Lizard)
+		if err != nil {
+			return fmt.Errorf("failed to fetch default patterns: %v", err)
+		}
+	}
 
-	return tools.RunSemgrep(workDirectory, semgrep, pathsToCheck, outputFile, outputFormat)
+	return lizard.RunLizard(workDirectory, lizardBinary, pathsToCheck, outputFile, outputFormat, patterns)
 }
 
 var analyzeCmd = &cobra.Command{
@@ -380,6 +430,7 @@ var analyzeCmd = &cobra.Command{
 		} else {
 			// Run all configured tools
 			toolsToRun = config.Config.Tools()
+			log.Println("Running all configured tools...")
 		}
 
 		if len(toolsToRun) == 0 {
@@ -463,6 +514,8 @@ func runTool(workDirectory string, toolName string, args []string, outputFile st
 		return runSemgrepAnalysis(workDirectory, args, outputFile, outputFormat)
 	case "dartanalyzer":
 		return runDartAnalyzer(workDirectory, args, outputFile, outputFormat)
+	case "lizard":
+		return runLizardAnalysis(workDirectory, args, outputFile, outputFormat)
 	default:
 		return fmt.Errorf("unsupported tool: %s", toolName)
 	}

cmd/init.go

@@ -4,6 +4,7 @@ import (
 	"codacy/cli-v2/config"
 	"codacy/cli-v2/domain"
 	"codacy/cli-v2/tools"
+	"codacy/cli-v2/tools/lizard"
 	"codacy/cli-v2/tools/pylint"
 	"codacy/cli-v2/utils"
 	"encoding/json"
@@ -65,6 +66,10 @@ var initCmd = &cobra.Command{
 			if err != nil {
 				log.Fatal(err)
 			}
+			// Create default configuration files
+			if err := buildDefaultConfigurationFiles(toolsConfigDir); err != nil {
+				log.Fatal(err)
+			}
 		} else {
 			err := buildRepositoryConfigurationFiles(initFlags.apiToken)
 			if err != nil {
@@ -140,6 +145,7 @@ func configFileTemplate(tools []tools.Tool) string {
 	needsNode := false
 	needsPython := false
 	needsDart := false
+
 	// Default versions
 	defaultVersions := map[string]string{
 		ESLint:       "9.3.0",
@@ -148,6 +154,7 @@ func configFileTemplate(tools []tools.Tool) string {
 		PMD:          "6.55.0",
 		DartAnalyzer: "3.7.2",
 		Semgrep:      "1.78.0",
+		Lizard:       "1.17.19",
 	}
 
 	// Build map of enabled tools with their versions
@@ -162,7 +169,7 @@ func configFileTemplate(tools []tools.Tool) string {
 		// Check if tool needs a runtime
 		if tool.Uuid == ESLint {
 			needsNode = true
-		} else if tool.Uuid == PyLint {
+		} else if tool.Uuid == PyLint || tool.Uuid == Lizard {
 			needsPython = true
 		} else if tool.Uuid == DartAnalyzer {
 			needsDart = true
@@ -203,6 +210,7 @@ func configFileTemplate(tools []tools.Tool) string {
 			PMD:          "pmd",
 			DartAnalyzer: "dartanalyzer",
 			Semgrep:      "semgrep",
+			Lizard:       "lizard",
 		}
 
 		for uuid, name := range uuidToName {
@@ -218,6 +226,7 @@ func configFileTemplate(tools []tools.Tool) string {
 		sb.WriteString(fmt.Sprintf("    - pmd@%s\n", defaultVersions[PMD]))
 		sb.WriteString(fmt.Sprintf("    - dartanalyzer@%s\n", defaultVersions[DartAnalyzer]))
 		sb.WriteString(fmt.Sprintf("    - semgrep@%s\n", defaultVersions[Semgrep]))
+		sb.WriteString(fmt.Sprintf("    - lizard@%s\n", defaultVersions[Lizard]))
 	}
 
 	return sb.String()
@@ -422,6 +431,8 @@ func createToolFileConfigurations(tool tools.Tool, patternConfiguration []domain
 				return fmt.Errorf("failed to create Semgrep config: %v", err)
 			}
 		}
+	case Lizard:
+		createLizardConfigFile(toolsConfigDir, patternConfiguration)
 	}
 	return nil
 }
@@ -434,7 +445,6 @@ func createPMDConfigFile(config []domain.PatternConfiguration, toolsConfigDir st
 func createDefaultPMDConfigFile(toolsConfigDir string) error {
 	content := tools.CreatePmdConfig([]domain.PatternConfiguration{})
 	return os.WriteFile(filepath.Join(toolsConfigDir, "ruleset.xml"), []byte(content), utils.DefaultFilePerms)
-
 }
 
 func createPylintConfigFile(config []domain.PatternConfiguration, toolsConfigDir string) error {
@@ -527,11 +537,55 @@ func cleanConfigDirectory(toolsConfigDir string) error {
 	return nil
 }
 
+func createLizardConfigFile(toolsConfigDir string, patternConfiguration []domain.PatternConfiguration) error {
+	var patterns []domain.PatternDefinition
+
+	if len(patternConfiguration) == 0 {
+		fmt.Println("Using default Lizard configuration")
+		var err error
+		patterns, err = tools.FetchDefaultEnabledPatterns(Lizard)
+		if err != nil {
+			return err
+		}
+	} else {
+		patterns = make([]domain.PatternDefinition, len(patternConfiguration))
+		for i, pattern := range patternConfiguration {
+			patterns[i] = pattern.PatternDefinition
+		}
+
+		fmt.Println("Lizard configuration created based on Codacy settings")
+	}
+
+	content, err := lizard.CreateLizardConfig(patterns)
+	if err != nil {
+		return fmt.Errorf("failed to create Lizard configuration: %w", err)
+	}
+
+	return os.WriteFile(filepath.Join(toolsConfigDir, "lizard.yaml"), []byte(content), utils.DefaultFilePerms)
+}
+
+// buildDefaultConfigurationFiles creates default configuration files for all tools
+func buildDefaultConfigurationFiles(toolsConfigDir string) error {
+	// Create default Lizard configuration
+	if err := createLizardConfigFile(toolsConfigDir, []domain.PatternConfiguration{}); err != nil {
+		return fmt.Errorf("failed to create default Lizard configuration: %w", err)
+	}
+
+	// Add other default tool configurations here as needed
+	// For example:
+	// if err := createDefaultEslintConfigFile(toolsConfigDir); err != nil {
+	//     return fmt.Errorf("failed to create default ESLint configuration: %w", err)
+	// }
+
+	return nil
+}
+
 const (
 	ESLint       string = "f8b29663-2cb2-498d-b923-a10c6a8c05cd"
 	Trivy        string = "2fd7fbe0-33f9-4ab3-ab73-e9b62404e2cb"
 	PMD          string = "9ed24812-b6ee-4a58-9004-0ed183c45b8f"
 	PyLint       string = "31677b6d-4ae0-4f56-8041-606a8d7a8e61"
 	DartAnalyzer string = "d203d615-6cf1-41f9-be5f-e2f660f7850f"
 	Semgrep      string = "6792c561-236d-41b7-ba5e-9d6bee0d548b"
+	Lizard       string = "76348462-84b3-409a-90d3-955e90abfb87"
 )

domain/patternConfiguration.go

@@ -1,8 +1,9 @@
 package domain
 
 type ParameterConfiguration struct {
-	Name  string `json:"name"`
-	Value string `json:"value"`
+	Name    string `json:"name"`
+	Value   string `json:"value,omitempty"`
+	Default string `json:"default,omitempty"`
 }
 
 type PatternDefinition struct {

plugins/tool-utils_test.go

@@ -168,6 +168,7 @@ func TestGetSupportedTools(t *testing.T) {
 				"trivy",
 				"dartanalyzer",
 				"semgrep",
+				"lizard",
 			},
 			expectedError: false,
 		},

plugins/tools/lizard/plugin.yaml

@@ -0,0 +1,13 @@
+name: lizard
+description: Lizard code complexity analyzer
+runtime: python
+runtime_binaries:
+  package_manager: python3
+  execution: python3
+binaries:
+  - name: python
+    path: "venv/bin/python3"
+output_options:
+  file_flag: "-o"
+analysis_options:
+  default_path: "."