fix: Check for configuration files both generated or existing PLUTO-1383

If a config file is generated (exists inside the .codacy) then rely on it
It also updates PMD to receive the configuration to be able to test it

Author: machadoit

cmd/analyze.go

@@ -211,7 +211,7 @@ func runPmdAnalysis(workDirectory string, pathsToCheck []string, outputFile stri
 	pmd := config.Config.Tools()["pmd"]
 	pmdBinary := pmd.Binaries["pmd"]
 
-	err := tools.RunPmd(workDirectory, pmdBinary, pathsToCheck, outputFile, outputFormat, "")
+	err := tools.RunPmd(workDirectory, pmdBinary, pathsToCheck, outputFile, outputFormat, config.Config)
 	if err != nil {
 		log.Fatalf("Error running PMD: %v", err)
 	}

cmd/init.go

@@ -327,12 +327,12 @@ func createToolFileConfigurations(tool tools.Tool, patternConfiguration []domain
 
 func createPMDConfigFile(config []domain.PatternConfiguration, toolsConfigDir string) error {
 	pmdConfigurationString := tools.CreatePmdConfig(config)
-	return os.WriteFile(filepath.Join(toolsConfigDir, "pmd-ruleset.xml"), []byte(pmdConfigurationString), utils.DefaultFilePerms)
+	return os.WriteFile(filepath.Join(toolsConfigDir, "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.DefaultFilePerms)
+	return os.WriteFile(filepath.Join(toolsConfigDir, "ruleset.xml"), []byte(content), utils.DefaultFilePerms)
 
 }
 

config/config.go

@@ -11,7 +11,8 @@ import (
 )
 
 type ConfigType struct {
-	homePath             string
+	repositoryDirectory string
+
 	globalCacheDirectory string
 	runtimesDirectory    string
 	toolsDirectory       string
@@ -24,8 +25,8 @@ type ConfigType struct {
 	tools    map[string]*plugins.ToolInfo
 }
 
-func (c *ConfigType) HomePath() string {
-	return c.homePath
+func (c *ConfigType) RepositoryDirectory() string {
+	return c.repositoryDirectory
 }
 
 func (c *ConfigType) CodacyDirectory() string {
@@ -98,15 +99,42 @@ func (c *ConfigType) ToolsConfigDirectory() string {
 	return c.toolsConfigDirectory
 }
 
-func (c *ConfigType) setupCodacyPaths() {
-	c.globalCacheDirectory = filepath.Join(c.homePath, ".cache", "codacy")
+func NewConfigType(repositoryDirectory string, repositoryCache string, globalCache string) *ConfigType {
+	c := &ConfigType{}
+
+	c.repositoryDirectory = repositoryDirectory
+	c.localCodacyDirectory = repositoryCache
+	c.globalCacheDirectory = globalCache
+
 	c.runtimesDirectory = filepath.Join(c.globalCacheDirectory, "runtimes")
 	c.toolsDirectory = filepath.Join(c.globalCacheDirectory, "tools")
-	c.localCodacyDirectory = ".codacy"
 	c.toolsConfigDirectory = filepath.Join(c.localCodacyDirectory, "tools-configs")
 
 	c.projectConfigFile = filepath.Join(c.localCodacyDirectory, "codacy.yaml")
 	c.cliConfigFile = filepath.Join(c.localCodacyDirectory, "cli-config.yaml")
+
+	c.runtimes = make(map[string]*plugins.RuntimeInfo)
+	c.tools = make(map[string]*plugins.ToolInfo)
+	return c
+}
+
+// TODO: Consider not having a global config and instead pass the config object around
+func setupGlobalConfig(repositoryDirectory string, repositoryCache string, globalCache string) {
+	newConfig := NewConfigType(repositoryDirectory, repositoryCache, globalCache)
+
+	Config.repositoryDirectory = newConfig.repositoryDirectory
+	Config.localCodacyDirectory = newConfig.localCodacyDirectory
+	Config.globalCacheDirectory = newConfig.globalCacheDirectory
+
+	Config.runtimesDirectory = newConfig.runtimesDirectory
+	Config.toolsDirectory = newConfig.toolsDirectory
+	Config.toolsConfigDirectory = newConfig.toolsConfigDirectory
+
+	Config.projectConfigFile = newConfig.projectConfigFile
+	Config.cliConfigFile = newConfig.cliConfigFile
+
+	Config.runtimes = newConfig.runtimes
+	Config.tools = newConfig.tools
 }
 
 func (c *ConfigType) CreateCodacyDirs() error {
@@ -136,11 +164,12 @@ func Init() {
 	if err != nil {
 		log.Fatal(err)
 	}
-	Config.homePath = homePath
+	// Repository directory is the current working directory
+	repositoryDirectory := ""
+	repositoryCache := ".codacy"
+	globalCache := filepath.Join(homePath, ".cache", "codacy")
 
-	Config.setupCodacyPaths()
-	Config.runtimes = make(map[string]*plugins.RuntimeInfo)
-	Config.tools = make(map[string]*plugins.ToolInfo)
+	setupGlobalConfig(repositoryDirectory, repositoryCache, globalCache)
 }
 
 // IsRuntimeInstalled checks if a runtime is already installed

tools/eslintRunner.go

@@ -1,6 +1,7 @@
 package tools
 
 import (
+	"codacy/cli-v2/config"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -20,7 +21,7 @@ func RunEslint(repositoryToAnalyseDirectory string, eslintInstallationDirectory
 	cmd.Env = append(cmd.Env, "ESLINT_USE_FLAT_CONFIG=true")
 
 	// Add config file from tools-configs directory if it exists
-	if configFile, exists := ConfigFileExists(repositoryToAnalyseDirectory, "eslint.config.mjs"); exists {
+	if configFile, exists := ConfigFileExists(config.Config, "eslint.config.mjs"); exists {
 		cmd.Args = append(cmd.Args, "-c", configFile)
 	}
 

tools/pmdRunner.go

@@ -4,7 +4,6 @@ import (
 	"codacy/cli-v2/config"
 	"os"
 	"os/exec"
-	"path/filepath"
 	"strings"
 )
 
@@ -20,16 +19,12 @@ import (
 //
 // Returns:
 //   - error: nil if analysis succeeds or violations found, error otherwise
-func RunPmd(repositoryToAnalyseDirectory string, pmdBinary string, pathsToCheck []string, outputFile string, outputFormat string, rulesetFile string) error {
+func RunPmd(repositoryToAnalyseDirectory string, pmdBinary string, pathsToCheck []string, outputFile string, outputFormat string, config config.ConfigType) error {
 	cmd := exec.Command(pmdBinary, "pmd")
 
-	// Add config file from tools-configs directory if not specified
-	if rulesetFile == "" {
-		// TODO: Check if the config file exists before using it
-		configFile := filepath.Join(config.Config.ToolsConfigDirectory(), "pmd-ruleset.xml")
+	// Add config file from tools-configs directory if it exists
+	if configFile, exists := ConfigFileExists(config, "ruleset.xml"); exists {
 		cmd.Args = append(cmd.Args, "-R", configFile)
-	} else {
-		cmd.Args = append(cmd.Args, "-R", rulesetFile)
 	}
 
 	// Add source directories (comma-separated list for PMD)

tools/pmdRunner_test.go

@@ -1,6 +1,7 @@
 package tools
 
 import (
+	"codacy/cli-v2/config"
 	"encoding/json"
 	"log"
 	"os"
@@ -51,19 +52,24 @@ func TestRunPmdToFile(t *testing.T) {
 
 	// Use the correct path relative to tools directory
 	testDirectory := filepath.Join(currentDirectory, "testdata", "repositories", "pmd")
+	repositoryCache := filepath.Join(testDirectory, ".codacy")
+	globalCache := filepath.Join(homeDirectory, ".cache/codacy")
+
 	tempResultFile := filepath.Join(os.TempDir(), "pmd.sarif")
 	defer os.Remove(tempResultFile)
 
+	config := *config.NewConfigType(testDirectory, repositoryCache, globalCache)
+
 	// Use absolute paths
 	repositoryToAnalyze := testDirectory
 	// Use the standard ruleset file for testing the PMD runner functionality
-	rulesetFile := filepath.Join(testDirectory, "pmd-ruleset.xml")
+	//rulesetFile := filepath.Join(testDirectory, "ruleset.xml")
 
 	// Use the same path as defined in plugin.yaml
-	pmdBinary := filepath.Join(homeDirectory, ".cache/codacy/tools/[email protected]/pmd-bin-6.55.0/bin/run.sh")
+	pmdBinary := filepath.Join(globalCache, "tools/[email protected]/pmd-bin-6.55.0/bin/run.sh")
 
 	// Run PMD
-	err = RunPmd(repositoryToAnalyze, pmdBinary, nil, tempResultFile, "sarif", rulesetFile)
+	err = RunPmd(repositoryToAnalyze, pmdBinary, nil, tempResultFile, "sarif", config)
 	if err != nil {
 		t.Fatalf("Failed to run pmd: %v", err)
 	}

tools/pylintRunner.go

@@ -1,6 +1,7 @@
 package tools
 
 import (
+	"codacy/cli-v2/config"
 	"codacy/cli-v2/plugins"
 	"codacy/cli-v2/utils"
 	"fmt"
@@ -20,7 +21,7 @@ func RunPylint(workDirectory string, toolInfo *plugins.ToolInfo, files []string,
 	args = append(args, "--output-format=json")
 
 	// Check if a config file exists in the expected location and use it if present
-	if configFile, exists := ConfigFileExists(workDirectory, "pylint.rc"); exists {
+	if configFile, exists := ConfigFileExists(config.Config, "pylint.rc"); exists {
 		args = append(args, fmt.Sprintf("--rcfile=%s", configFile))
 	}
 

tools/runnerUtils.go

@@ -1,26 +1,29 @@
 package tools
 
 import (
+	"codacy/cli-v2/config"
 	"os"
 	"path/filepath"
 )
 
-// ConfigFileExists checks if a specific configuration file exists in the .codacy/tools-configs/ directory
-// of the specified repository.
+// ConfigFileExists checks if a specific configuration file exists in the .codacy/tools-configs/
+// or on the root of the repository directory.
 //
 // Parameters:
-//   - repositoryDir: The repository directory path
+//   - conf: The configuration object containing the tools config directory
 //   - fileName: The configuration file name to check for
 //
 // Returns:
 //   - string: The relative path to the configuration file (for cmd args)
 //   - bool: True if the file exists, false otherwise
-func ConfigFileExists(repositoryDir string, fileName string) (string, bool) {
-	configFile := filepath.Join(".codacy", "tools-configs", fileName)
-	configFilePath := filepath.Join(repositoryDir, configFile)
+func ConfigFileExists(conf config.ConfigType, fileName string) (string, bool) {
+	generatedConfigFile := filepath.Join(conf.ToolsConfigDirectory(), fileName)
+	existingConfigFile := filepath.Join(conf.RepositoryDirectory(), fileName)
 
-	if _, err := os.Stat(configFilePath); err == nil {
-		return configFile, true
+	if _, err := os.Stat(generatedConfigFile); err == nil {
+		return generatedConfigFile, true
+	} else if _, err := os.Stat(existingConfigFile); err == nil {
+		return existingConfigFile, true
 	}
 
 	return "", false

tools/runnerUtils_test.go

@@ -1,36 +1,108 @@
 package tools
 
 import (
+	"codacy/cli-v2/config"
 	"os"
 	"path/filepath"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 )
 
-func TestConfigFileExists(t *testing.T) {
+func TestConfigFileExistsInToolsConfigDirectory(t *testing.T) {
 	// Create a test directory structure
 	tempDir := t.TempDir()
+	repoDir := filepath.Join(tempDir, "src")
+	repositoryCache := filepath.Join(repoDir, ".codacy")
+
+	// Create configuration
+	config := *config.NewConfigType(repoDir, repositoryCache, "unused-global-cache")
 
 	// Create .codacy/tools-configs directory
-	configDir := filepath.Join(tempDir, ".codacy", "tools-configs")
+	configDir := filepath.Join(repoDir, ".codacy", "tools-configs")
+	err := os.MkdirAll(configDir, 0755)
+	assert.NoError(t, err, "Failed to create test directory structure")
+
+	// Create a test config file on the configDir
+	generatedConfigFile := filepath.Join(configDir, "generated-config.yaml")
+	err = os.WriteFile(generatedConfigFile, []byte("test content"), 0644)
+	assert.NoError(t, err, "Failed to create test config file")
 
+	// Test case: Config file exists in tools config directory
+	configPath, exists := ConfigFileExists(config, "generated-config.yaml")
+	assert.True(t, exists, "Config file should exist in tools config directory")
+	assert.Equal(t, filepath.Join(config.ToolsConfigDirectory(), "generated-config.yaml"), configPath,
+		"Config path should be correctly formed relative path")
+}
+
+func TestConfigFileExistsInRepositoryDirectory(t *testing.T) {
+	// Create a test directory structure
+	tempDir := t.TempDir()
+	repoDir := filepath.Join(tempDir, "src")
+	repositoryCache := filepath.Join(repoDir, ".codacy")
+
+	// Create configuration
+	config := *config.NewConfigType(repoDir, repositoryCache, "unused-global-cache")
+
+	// Create .codacy/tools-configs directory
+	configDir := filepath.Join(repoDir, ".codacy", "tools-configs")
 	err := os.MkdirAll(configDir, 0755)
 	assert.NoError(t, err, "Failed to create test directory structure")
 
-	// Create a test config file
-	testConfigFile := filepath.Join(configDir, "test-config.yaml")
-	err = os.WriteFile(testConfigFile, []byte("test content"), 0644)
+	// Create a test config file on the repository directory
+	existingConfigFile := filepath.Join(repoDir, "existing-config.yaml")
+	err = os.WriteFile(existingConfigFile, []byte("test content"), 0644)
 	assert.NoError(t, err, "Failed to create test config file")
 
-	// Test case 1: Config file exists
-	configPath, exists := ConfigFileExists(tempDir, "test-config.yaml")
-	assert.True(t, exists, "Config file should exist")
-	assert.Equal(t, filepath.Join(".codacy", "tools-configs", "test-config.yaml"), configPath,
+	// Test case: The existing config file gets picked up
+	configPath, exists := ConfigFileExists(config, "existing-config.yaml")
+	assert.True(t, exists, "Config file should exist in tools config directory")
+	assert.Equal(t, filepath.Join(config.RepositoryDirectory(), "existing-config.yaml"), configPath,
 		"Config path should be correctly formed relative path")
+}
+
+func TestConfigFilePrefersToolsConfigDirectory(t *testing.T) {
+	// Create a test directory structure
+	tempDir := t.TempDir()
+	repoDir := filepath.Join(tempDir, "src")
+	repositoryCache := filepath.Join(repoDir, ".codacy")
+
+	// Create configuration
+	config := *config.NewConfigType(repoDir, repositoryCache, "unused-global-cache")
+
+	// Create .codacy/tools-configs directory
+	configDir := filepath.Join(repoDir, ".codacy", "tools-configs")
+	err := os.MkdirAll(configDir, 0755)
+	assert.NoError(t, err, "Failed to create test directory structure")
+
+	// Create a test config file in both locations
+	generatedConfigFile := filepath.Join(configDir, "some-config.yaml")
+	existingConfigFile := filepath.Join(repoDir, "some-config.yaml")
+
+	err = os.WriteFile(generatedConfigFile, []byte("tools config content"), 0644)
+	assert.NoError(t, err, "Failed to create test config file in tools config directory")
+
+	err = os.WriteFile(existingConfigFile, []byte("repository config content"), 0644)
+	assert.NoError(t, err, "Failed to create test config file in repository directory")
+
+	// Test case: Config file in tools config directory is preferred
+	configPath, exists := ConfigFileExists(config, "some-config.yaml")
+	assert.True(t, exists, "Config file should exist")
+	assert.Equal(t, filepath.Join(config.ToolsConfigDirectory(), "some-config.yaml"), configPath,
+		"Config path should prefer tools config directory")
+}
+
+func TestConfigFileDoesNotExist(t *testing.T) {
+	// Create a test directory structure
+	tempDir := t.TempDir()
+	repoDir := filepath.Join(tempDir, "src")
+	repositoryCache := filepath.Join(repoDir, ".codacy")
+
+	// Create configuration
+	config := *config.NewConfigType(repoDir, repositoryCache, "unused-global-cache")
 
-	// Test case 2: Config file doesn't exist
-	configPath, exists = ConfigFileExists(tempDir, "non-existent-config.yaml")
+	// Test case: Config file does not exist
+	configPath, exists := ConfigFileExists(config, "non-existent-config.yaml")
 	assert.False(t, exists, "Config file should not exist")
 	assert.Equal(t, "", configPath, "Config path should be empty for non-existent file")
 }