[PLUTO-1431] Revive config

Author: zhamborova

.codacy/codacy.yaml

@@ -1,16 +1,15 @@
 runtimes:
     - dart@3.7.2
+    - go@1.22.3
     - java@17.0.10
     - node@22.2.0
     - python@3.11.11
-    - go@1.22.3
 tools:
-    - codacy-enigma-cli@0.0.1-main.8.49310c3
     - dartanalyzer@3.7.2
     - eslint@8.57.0
     - lizard@1.17.19
     - pmd@6.55.0
     - pylint@3.3.6
+    - revive@1.7.0
     - semgrep@1.78.0
     - trivy@0.59.1
-    - revive@1.7.0

cmd/configsetup/setup.go

@@ -15,6 +15,7 @@ import (
 	"codacy/cli-v2/tools"
 	"codacy/cli-v2/tools/lizard"
 	"codacy/cli-v2/tools/pylint"
+	reviveTool "codacy/cli-v2/tools/revive"
 	"codacy/cli-v2/utils"
 )
 
@@ -374,6 +375,11 @@ func createToolFileConfigurations(tool domain.Tool, patternConfiguration []domai
 			return fmt.Errorf("failed to create Lizard config: %v", err)
 		}
 		fmt.Println("Lizard configuration created based on Codacy settings")
+	case domain.Revive:
+		if err := createReviveConfigFile(patternConfiguration, toolsConfigDir); err != nil {
+			return fmt.Errorf("failed to write revive config: %v", err)
+		}
+		fmt.Println("Revive configuration created based on Codacy settings")
 	}
 	return nil
 }
@@ -466,6 +472,11 @@ func createLizardConfigFile(toolsConfigDir string, patternConfiguration []domain
 	return nil
 }
 
+func createReviveConfigFile(config []domain.PatternConfiguration, toolsConfigDir string) error {
+	reviveConfigurationString := reviveTool.GenerateReviveConfig(config)
+	return os.WriteFile(filepath.Join(toolsConfigDir, "revive.toml"), []byte(reviveConfigurationString), utils.DefaultFilePerms)
+}
+
 // buildDefaultConfigurationFiles creates default configuration files for all tools
 func BuildDefaultConfigurationFiles(toolsConfigDir string, flags domain.InitFlags) error {
 	for uuid := range domain.SupportedToolsMetadata {
@@ -502,6 +513,10 @@ func BuildDefaultConfigurationFiles(toolsConfigDir string, flags domain.InitFlag
 			if err := createLizardConfigFile(toolsConfigDir, patternsConfig); err != nil {
 				return fmt.Errorf("failed to create default Lizard configuration: %w", err)
 			}
+		case domain.Revive:
+			if err := createReviveConfigFile(patternsConfig, toolsConfigDir); err != nil {
+				return fmt.Errorf("failed to create default Revive configuration: %w", err)
+			}
 		case domain.PMD7, domain.ESLint9:
 			continue
 		}

domain/tool.go

@@ -27,6 +27,7 @@ const (
 	DartAnalyzer string = "d203d615-6cf1-41f9-be5f-e2f660f7850f"
 	Semgrep      string = "6792c561-236d-41b7-ba5e-9d6bee0d548b"
 	Lizard       string = "76348462-84b3-409a-90d3-955e90abfb87"
+	Revive       string = "bd81d1f4-1406-402d-9181-1274ee09f1aa"
 )
 
 type ToolInfo struct {
@@ -45,4 +46,5 @@ var SupportedToolsMetadata = map[string]ToolInfo{
 	DartAnalyzer: {Name: "dartanalyzer", Priority: 0},
 	Lizard:       {Name: "lizard", Priority: 0},
 	Semgrep:      {Name: "semgrep", Priority: 0},
+	Revive:       {Name: "revive", Priority: 0},
 }

plugins/tools/revive/plugin.yaml

@@ -12,10 +12,8 @@ binaries:
   - name: revive
     path: revive
 formatters:
-  - name: stylish
-    flag: "-formatter stylish"
-  - name: json
-    flag: "-formatter json"
+  - name: sarif
+    flag: "-formatter sarif"
 output_options:
   file_flag: "-o"
 analysis_options:

tools/revive/reviveConfigCreator.go

@@ -0,0 +1,50 @@
+package tools
+
+import (
+	"fmt"
+	"strings"
+
+	"codacy/cli-v2/domain"
+)
+
+// GenerateReviveConfig generates a TOML config for revive based on enabled patterns and their parameters
+func GenerateReviveConfig(patterns []domain.PatternConfiguration) string {
+	var sb strings.Builder
+	sb.WriteString("[revive]\n")
+	sb.WriteString("ignoreGeneratedHeader = true\n")
+	sb.WriteString("severity = \"warning\"\n")
+	sb.WriteString("confidence = 0.8\n")
+	sb.WriteString("errorCode = 0\n")
+	sb.WriteString("warningCode = 0\n\n")
+
+	enabledRules := make([]string, 0)
+	for _, pattern := range patterns {
+		if pattern.Enabled {
+			ruleName := strings.TrimPrefix(pattern.PatternDefinition.Id, "Revive_")
+			enabledRules = append(enabledRules, fmt.Sprintf("\"%s\"", ruleName))
+		}
+	}
+	if len(enabledRules) > 0 {
+		sb.WriteString(fmt.Sprintf("rules = [%s]\n\n", strings.Join(enabledRules, ", ")))
+	}
+
+	for _, pattern := range patterns {
+		if pattern.Enabled {
+			ruleName := strings.TrimPrefix(pattern.PatternDefinition.Id, "Revive_")
+			sb.WriteString(fmt.Sprintf("[rule.%s]\n", ruleName))
+			if len(pattern.Parameters) > 0 {
+				sb.WriteString("arguments = [")
+				args := make([]string, 0)
+				for _, param := range pattern.Parameters {
+					// TOML: string values should be quoted
+					args = append(args, fmt.Sprintf("\"%s\"", param.Value))
+				}
+				sb.WriteString(strings.Join(args, ", "))
+				sb.WriteString("]\n")
+			}
+			sb.WriteString("\n")
+		}
+	}
+
+	return sb.String()
+}

tools/revive/reviveRunner.go

@@ -5,22 +5,25 @@ import (
 	"log"
 	"os"
 	"os/exec"
+
+	"codacy/cli-v2/config"
+	parenttools "codacy/cli-v2/tools"
 )
 
 // RunRevive executes revive analysis on the specified files or directory
 func RunRevive(workDirectory string, binary string, files []string, outputFile string, outputFormat string) error {
 	cmdArgs := []string{}
 
+	// Check if a config file exists in the expected location and use it if present
+	if configFile, exists := parenttools.ConfigFileExists(config.Config, "revive.toml"); exists {
+		cmdArgs = append(cmdArgs, "-config", configFile)
+	}
+
 	// Add output format if specified
 	if outputFormat != "" {
 		cmdArgs = append(cmdArgs, "-formatter", outputFormat)
 	}
 
-	// Add output file if specified
-	if outputFile != "" {
-		cmdArgs = append(cmdArgs, "-o", outputFile)
-	}
-
 	// Add files to analyze - if no files specified, analyze current directory
 	if len(files) > 0 {
 		cmdArgs = append(cmdArgs, files...)
@@ -30,9 +33,20 @@ func RunRevive(workDirectory string, binary string, files []string, outputFile s
 
 	cmd := exec.Command(binary, cmdArgs...)
 	cmd.Dir = workDirectory
-	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
 
+	// Handle output file redirection
+	if outputFile != "" {
+		outputWriter, err := os.Create(outputFile)
+		if err != nil {
+			return fmt.Errorf("failed to create output file: %w", err)
+		}
+		defer outputWriter.Close()
+		cmd.Stdout = outputWriter
+	} else {
+		cmd.Stdout = os.Stdout
+	}
+
 	if err := cmd.Run(); err != nil {
 		if _, ok := err.(*exec.ExitError); !ok {
 			log.Printf("[REVIVE] Error running revive: %v", err)