Merge remote-tracking branch 'origin/main' into pylint-config-parser

Author: franciscoovazevedo

README.md

@@ -1,6 +1,7 @@
 # codacy-cli-v2
 
-The `codacy-cli-v2` is a command-line tool for Codacy that supports analyzing code using tools like ESLint and uploading the results in SARIF format to Codacy. It provides two main commands: `analyze` and `upload`.
+The Codacy CLI (version 2) is a command-line tool that supports analyzing code using tools like ESLint and uploading the results in SARIF format to Codacy. 
+The tool is invoked using the `codacy-cli` command, and provides two main commands: analyze and upload.
 
 ### Commands
 
@@ -32,13 +33,13 @@ The `codacy-cli-v2` is a command-line tool for Codacy that supports analyzing co
   tools:
       - [email protected]
 
-- **`codacy-cli-v2 install`**: Command to install the specified node and eslint versions before running analysis.
+- **`codacy-cli install`**: Command to install the specified node and eslint versions before running analysis.
 
 ## Download
 
 ### MacOS (brew)
 
-To install `codacy-cli-v2` using Homebrew:
+To install `codacy-cli` using Homebrew:
 
 ```bash
 brew install codacy/codacy-cli-v2/codacy-cli-v2

cmd/analyze.go

@@ -2,19 +2,23 @@ package cmd
 
 import (
 	"codacy/cli-v2/config"
+	"codacy/cli-v2/plugins"
 	"codacy/cli-v2/tools"
 	"encoding/json"
 	"fmt"
 	"io"
 	"log"
 	"net/http"
 	"os"
+	"path/filepath"
+
+	"codacy/cli-v2/utils"
 
 	"github.com/spf13/cobra"
 )
 
 var outputFile string
-var toolToAnalyze string
+var toolsToAnalyzeParam string
 var autoFix bool
 var outputFormat string
 var sarifPath string
@@ -92,7 +96,7 @@ type Pattern struct {
 
 func init() {
 	analyzeCmd.Flags().StringVarP(&outputFile, "output", "o", "", "Output file for analysis results")
-	analyzeCmd.Flags().StringVarP(&toolToAnalyze, "tool", "t", "", "Which tool to run analysis with")
+	analyzeCmd.Flags().StringVarP(&toolsToAnalyzeParam, "tool", "t", "", "Which tool to run analysis with. If not specified, all configured tools will be run")
 	analyzeCmd.Flags().StringVar(&outputFormat, "format", "", "Output format (use 'sarif' for SARIF format)")
 	analyzeCmd.Flags().BoolVar(&autoFix, "fix", false, "Apply auto fix to your issues when available")
 	rootCmd.AddCommand(analyzeCmd)
@@ -224,35 +228,91 @@ func runPylintAnalysis(workDirectory string, pathsToCheck []string, outputFile s
 
 var analyzeCmd = &cobra.Command{
 	Use:   "analyze",
-	Short: "Runs all linters.",
-	Long:  "Runs all tools for all runtimes.",
+	Short: "Runs all configured linters.",
+	Long:  "Runs all configured tools for code analysis. Use --tool flag to run a specific tool.",
 	Run: func(cmd *cobra.Command, args []string) {
 		workDirectory, err := os.Getwd()
 		if err != nil {
 			log.Fatal(err)
 		}
+		var toolsToRun map[string]*plugins.ToolInfo
 
-		log.Printf("Running %s...\n", toolToAnalyze)
-		if outputFormat == "sarif" {
-			log.Println("Output will be in SARIF format")
+		if toolsToAnalyzeParam != "" {
+			// If a specific tool is specified, only run that tool
+			toolsToRun = map[string]*plugins.ToolInfo{
+				toolsToAnalyzeParam: config.Config.Tools()[toolsToAnalyzeParam],
+			}
+		} else {
+			// Run all configured tools
+			toolsToRun = config.Config.Tools()
 		}
-		if outputFile != "" {
-			log.Println("Output will be available at", outputFile)
+
+		if len(toolsToRun) == 0 {
+			log.Fatal("No tools configured. Please run 'codacy-cli init' and 'codacy-cli install' first")
 		}
 
-		switch toolToAnalyze {
-		case "eslint":
-			runEslintAnalysis(workDirectory, args, autoFix, outputFile, outputFormat)
-		case "trivy":
-			runTrivyAnalysis(workDirectory, args, outputFile, outputFormat)
-		case "pmd":
-			runPmdAnalysis(workDirectory, args, outputFile, outputFormat)
-		case "pylint":
-			runPylintAnalysis(workDirectory, args, outputFile, outputFormat)
-		case "":
-			log.Fatal("You need to specify a tool to run analysis with, e.g., '--tool eslint'")
-		default:
-			log.Fatal("Trying to run unsupported tool: ", toolToAnalyze)
+		log.Println("Running all configured tools...")
+
+		if outputFormat == "sarif" {
+			// Create temporary directory for individual tool outputs
+			tmpDir, err := os.MkdirTemp("", "codacy-analysis-*")
+			if err != nil {
+				log.Fatalf("Failed to create temporary directory: %v", err)
+			}
+			defer os.RemoveAll(tmpDir)
+
+			var sarifOutputs []string
+			for toolName := range toolsToRun {
+				log.Printf("Running %s...\n", toolName)
+				tmpFile := filepath.Join(tmpDir, fmt.Sprintf("%s.sarif", toolName))
+				runTool(workDirectory, toolName, args, tmpFile)
+				sarifOutputs = append(sarifOutputs, tmpFile)
+			}
+
+			// create output file tmp file
+			tmpOutputFile := filepath.Join(tmpDir, "merged.sarif")
+
+			// Merge all SARIF outputs
+			if err := utils.MergeSarifOutputs(sarifOutputs, tmpOutputFile); err != nil {
+				log.Fatalf("Failed to merge SARIF outputs: %v", err)
+			}
+
+			if outputFile != "" {
+				// copy tmpOutputFile to outputFile
+				content, err := os.ReadFile(tmpOutputFile)
+				if err != nil {
+					log.Fatalf("Failed to read merged SARIF output: %v", err)
+				}
+				os.WriteFile(outputFile, content, utils.DefaultRW)
+			} else {
+				// println the output file content
+				content, err := os.ReadFile(tmpOutputFile)
+				if err != nil {
+					log.Fatalf("Failed to read merged SARIF output: %v", err)
+				}
+				fmt.Println(string(content))
+			}
+		} else {
+			// Run tools without merging outputs
+			for toolName := range toolsToRun {
+				log.Printf("Running %s...\n", toolName)
+				runTool(workDirectory, toolName, args, outputFile)
+			}
 		}
 	},
 }
+
+func runTool(workDirectory string, toolName string, args []string, outputFile string) {
+	switch toolName {
+	case "eslint":
+		runEslintAnalysis(workDirectory, args, autoFix, outputFile, outputFormat)
+	case "trivy":
+		runTrivyAnalysis(workDirectory, args, outputFile, outputFormat)
+	case "pmd":
+		runPmdAnalysis(workDirectory, args, outputFile, outputFormat)
+	case "pylint":
+		runPylintAnalysis(workDirectory, args, outputFile, outputFormat)
+	default:
+		log.Printf("Warning: Unsupported tool: %s\n", toolName)
+	}
+}

cmd/init.go

@@ -32,9 +32,9 @@ var initFlags InitFlags
 
 func init() {
 	initCmd.Flags().StringVar(&initFlags.apiToken, "api-token", "", "optional codacy api token, if defined configurations will be fetched from codacy")
-	initCmd.Flags().StringVar(&initFlags.provider, "provider", "", "optional provider (gh/bb/gl), if defined configurations will be fetched from codacy")
-	initCmd.Flags().StringVar(&initFlags.organization, "organization", "", "optional remote organization name, if defined configurations will be fetched from codacy")
-	initCmd.Flags().StringVar(&initFlags.repository, "repository", "", "optional remote repository name, if defined configurations will be fetched from codacy")
+	initCmd.Flags().StringVar(&initFlags.provider, "provider", "", "provider (gh/bb/gl) to fetch configurations from codacy, required when api-token is provided")
+	initCmd.Flags().StringVar(&initFlags.organization, "organization", "", "remote organization name to fetch configurations from codacy, required when api-token is provided")
+	initCmd.Flags().StringVar(&initFlags.repository, "repository", "", "remote repository name to fetch configurations from codacy, required when api-token is provided")
 	rootCmd.AddCommand(initCmd)
 }
 
@@ -339,19 +339,20 @@ func createDefaultPylintConfigFile() error {
 
 func createPMDConfigFile(config []domain.PatternConfiguration, toolsConfigDir string) error {
 	pmdConfigurationString := tools.CreatePmdConfig(config)
-	return os.WriteFile(filepath.Join(toolsConfigDir, "pmd-ruleset.xml"), []byte(pmdConfigurationString), utils.DefaultRW)
+	return os.WriteFile(filepath.Join(toolsConfigDir, "pmd-ruleset.xml"), []byte(pmdConfigurationString), utils.DefaultFilePerms)
 }
 
 func createDefaultPMDConfigFile(toolsConfigDir string) error {
 	content := tools.CreatePmdConfig([]domain.PatternConfiguration{})
-	return os.WriteFile(filepath.Join(toolsConfigDir, "pmd-ruleset.xml"), []byte(content), utils.DefaultRW)
+	return os.WriteFile(filepath.Join(toolsConfigDir, "pmd-ruleset.xml"), []byte(content), utils.DefaultFilePerms)
 }
 
 // createTrivyConfigFile creates a trivy.yaml configuration file based on the API configuration
 func createTrivyConfigFile(config []domain.PatternConfiguration, toolsConfigDir string) error {
 	trivyConfigurationString := tools.CreateTrivyConfig(config)
 
-	return os.WriteFile(filepath.Join(toolsConfigDir, "trivy.yaml"), []byte(trivyConfigurationString), utils.DefaultRW)
+	// Write to file
+	return os.WriteFile(filepath.Join(toolsConfigDir, "trivy.yaml"), []byte(trivyConfigurationString), utils.DefaultFilePerms)
 }
 
 // createDefaultTrivyConfigFile creates a default trivy.yaml configuration file
@@ -361,7 +362,7 @@ func createDefaultTrivyConfigFile(toolsConfigDir string) error {
 	content := tools.CreateTrivyConfig(emptyConfig)
 
 	// Write to file
-	return os.WriteFile(filepath.Join(toolsConfigDir, "trivy.yaml"), []byte(content), utils.DefaultRW)
+	return os.WriteFile(filepath.Join(toolsConfigDir, "trivy.yaml"), []byte(content), utils.DefaultFilePerms)
 }
 
 // createDefaultEslintConfigFile creates a default eslint.config.mjs configuration file
@@ -371,7 +372,7 @@ func createDefaultEslintConfigFile(toolsConfigDir string) error {
 	content := tools.CreateEslintConfig(emptyConfig)
 
 	// Write to file
-	return os.WriteFile(filepath.Join(toolsConfigDir, "eslint.config.mjs"), []byte(content), utils.DefaultRW)
+	return os.WriteFile(filepath.Join(toolsConfigDir, "eslint.config.mjs"), []byte(content), utils.DefaultFilePerms)
 }
 
 const (

cmd/root.go

@@ -3,15 +3,17 @@ package cmd
 import (
 	"fmt"
 	"os"
+	"path/filepath"
 
 	"github.com/fatih/color"
 	"github.com/spf13/cobra"
 )
 
 var rootCmd = &cobra.Command{
-	Use:   "codacy-cli",
-	Short: "Codacy CLI - A command line interface for Codacy",
-	Long:  ``,
+	Use:     "codacy-cli",
+	Short:   "Codacy CLI - A command line interface for Codacy",
+	Long:    "",
+	Example: getExampleText(),
 	Run: func(cmd *cobra.Command, args []string) {
 		// Check if .codacy directory exists
 		if _, err := os.Stat(".codacy"); os.IsNotExist(err) {
@@ -52,4 +54,61 @@ func showWelcomeMessage() {
 	fmt.Println()
 	fmt.Println("Or run without a token to use local configuration:")
 	fmt.Println("  codacy-cli init")
+	fmt.Println()
+	fmt.Println("For more information about available commands, run:")
+	fmt.Println("  codacy-cli --help")
+}
+
+func getExampleText() string {
+	return color.New(color.FgCyan).Sprint("Initialize a project:") + "\n" +
+		color.New(color.FgGreen).Sprint("  codacy-cli init") + "\n\n" +
+		color.New(color.FgCyan).Sprint("Install required tools:") + "\n" +
+		color.New(color.FgGreen).Sprint("  codacy-cli install") + "\n\n" +
+		color.New(color.FgCyan).Sprint("Run analysis with ESLint:") + "\n" +
+		color.New(color.FgGreen).Sprint("  codacy-cli analyze --tool eslint") + "\n\n" +
+		color.New(color.FgCyan).Sprint("Run analysis and output in SARIF format:") + "\n" +
+		color.New(color.FgGreen).Sprint("  codacy-cli analyze --tool eslint --format sarif") + "\n\n" +
+		color.New(color.FgCyan).Sprint("Upload results to Codacy:") + "\n" +
+		color.New(color.FgGreen).Sprint("  codacy-cli upload -s results.sarif -c <commit-uuid> -t <project-token>")
+}
+
+func init() {
+	// Add global flags here
+	rootCmd.PersistentFlags().StringP("config", "c", filepath.Join(".codacy", "codacy.yaml"), "config file")
+
+	// Customize help template
+	rootCmd.SetUsageTemplate(`
+` + color.New(color.FgCyan).Sprint("Usage:") + `
+  {{.UseLine}}{{if .HasAvailableSubCommands}}
+  {{.CommandPath}} [command]{{end}}{{if gt (len .Aliases) 0}}
+
+` + color.New(color.FgCyan).Sprint("Aliases:") + `
+  {{.NameAndAliases}}{{end}}{{if .HasExample}}
+
+` + color.New(color.FgCyan).Sprint("Examples:") + `
+{{.Example}}{{end}}{{if .HasAvailableSubCommands}}
+
+` + color.New(color.FgCyan).Sprint("Available Commands:") + `{{range .Commands}}{{if (or .IsAvailableCommand (eq .Name "help"))}}
+  ` + "{{$cmd := .Name}}" + color.New(color.FgGreen).Sprintf("{{rpad .Name .NamePadding}}") + ` {{.Short}}{{end}}{{end}}{{end}}{{if .HasAvailableLocalFlags}}
+
+` + color.New(color.FgCyan).Sprint("Flags:") + `
+{{.LocalFlags.FlagUsages | trimTrailingWhitespaces}}{{end}}{{if .HasAvailableInheritedFlags}}
+
+` + color.New(color.FgCyan).Sprint("Global Flags:") + `
+{{.InheritedFlags.FlagUsages | trimTrailingWhitespaces}}{{end}}{{if .HasHelpSubCommands}}
+
+` + color.New(color.FgCyan).Sprint("Additional help topics:") + `{{range .Commands}}{{if .IsAdditionalHelpTopicCommand}}
+  {{rpad .CommandPath .CommandPathPadding}} {{.Short}}{{end}}{{end}}{{end}}{{if .HasAvailableSubCommands}}
+
+Use "{{.CommandPath}} [command] --help" for more information about a command.{{end}}
+
+` + color.New(color.FgCyan).Sprint("Configuration Example") + ` (.codacy/codacy.yaml):
+  runtimes:
+    - [email protected]
+  tools:
+    - [email protected]
+
+` + color.New(color.FgCyan).Sprint("For more information and examples, visit:") + `
+https://github.com/codacy/codacy-cli-v2
+`)
 }

config/config.go

@@ -7,6 +7,7 @@ import (
 	"path/filepath"
 
 	"codacy/cli-v2/plugins"
+	"codacy/cli-v2/utils"
 )
 
 type ConfigType struct {
@@ -109,22 +110,22 @@ func (c *ConfigType) setupCodacyPaths() {
 }
 
 func (c *ConfigType) CreateCodacyDirs() error {
-	if err := os.MkdirAll(c.globalCacheDirectory, 0777); err != nil {
+	if err := os.MkdirAll(c.globalCacheDirectory, utils.DefaultDirPerms); err != nil {
 		return fmt.Errorf("failed to create codacy directory: %w", err)
 	}
 
-	if err := os.MkdirAll(c.runtimesDirectory, 0777); err != nil {
+	if err := os.MkdirAll(c.runtimesDirectory, utils.DefaultDirPerms); err != nil {
 		return fmt.Errorf("failed to create runtimes directory: %w", err)
 	}
 
-	if err := os.MkdirAll(c.toolsDirectory, 0777); err != nil {
+	if err := os.MkdirAll(c.toolsDirectory, utils.DefaultDirPerms); err != nil {
 		return fmt.Errorf("failed to create tools directory: %w", err)
 	}
 	return nil
 }
 
 func (c *ConfigType) CreateLocalCodacyDir() error {
-	if err := os.MkdirAll(c.localCodacyDirectory, 0777); err != nil {
+	if err := os.MkdirAll(c.localCodacyDirectory, utils.DefaultDirPerms); err != nil {
 		return fmt.Errorf("failed to create local codacy directory: %w", err)
 	}
 	return nil

config/runtimes-installer_test.go

@@ -2,6 +2,7 @@ package config
 
 import (
 	"codacy/cli-v2/plugins"
+	"codacy/cli-v2/utils"
 	"os"
 	"path/filepath"
 	"testing"
@@ -26,7 +27,7 @@ func TestIsRuntimeInstalled(t *testing.T) {
 	assert.False(t, isRuntimeInstalled(runtimeInfoNoBinaries))
 
 	// Create the install directory
-	err = os.MkdirAll(runtimeInfoNoBinaries.InstallDir, 0755)
+	err = os.MkdirAll(runtimeInfoNoBinaries.InstallDir, utils.DefaultDirPerms)
 	assert.NoError(t, err)
 
 	// Test when the install directory exists
@@ -52,4 +53,4 @@ func TestIsRuntimeInstalled(t *testing.T) {
 
 	// Test when the binary exists
 	assert.True(t, isRuntimeInstalled(runtimeInfoWithBinaries))
-}
+}