From 278f68d48800aa52a0d46b5f71545f507e55a04a Mon Sep 17 00:00:00 2001 From: Joao Machado <13315199+machadoit@users.noreply.github.com> Date: Mon, 7 Apr 2025 18:27:59 +0200 Subject: [PATCH 1/2] fix: Only pass configuration file if created, otherwise fallback to native tool PLUTO-1383 Still needs updates on PMD --- tools/eslintRunner.go | 8 ++++---- tools/pmdRunner.go | 1 + tools/pylintRunner.go | 7 ++++--- tools/runnerUtils.go | 27 +++++++++++++++++++++++++++ tools/runnerUtils_test.go | 36 ++++++++++++++++++++++++++++++++++++ tools/trivyRunner.go | 9 ++++----- 6 files changed, 76 insertions(+), 12 deletions(-) create mode 100644 tools/runnerUtils.go create mode 100644 tools/runnerUtils_test.go diff --git a/tools/eslintRunner.go b/tools/eslintRunner.go index 3ae58b0b..d17ac6b8 100644 --- a/tools/eslintRunner.go +++ b/tools/eslintRunner.go @@ -1,7 +1,6 @@ package tools import ( - "codacy/cli-v2/config" "os" "os/exec" "path/filepath" @@ -20,9 +19,10 @@ func RunEslint(repositoryToAnalyseDirectory string, eslintInstallationDirectory // https://eslint.org/docs/v8.x/use/configure/configuration-files-new cmd.Env = append(cmd.Env, "ESLINT_USE_FLAT_CONFIG=true") - // Add config file from tools-configs directory - configFile := filepath.Join(config.Config.ToolsConfigDirectory(), "eslint.config.mjs") - cmd.Args = append(cmd.Args, "-c", configFile) + // Add config file from tools-configs directory if it exists + if configFile, exists := ConfigFileExists(repositoryToAnalyseDirectory, "eslint.config.mjs"); exists { + cmd.Args = append(cmd.Args, "-c", configFile) + } if autoFix { cmd.Args = append(cmd.Args, "--fix") diff --git a/tools/pmdRunner.go b/tools/pmdRunner.go index 173094d0..e4c56615 100644 --- a/tools/pmdRunner.go +++ b/tools/pmdRunner.go @@ -25,6 +25,7 @@ func RunPmd(repositoryToAnalyseDirectory string, pmdBinary string, pathsToCheck // 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") cmd.Args = append(cmd.Args, "-R", configFile) } else { diff --git a/tools/pylintRunner.go b/tools/pylintRunner.go index 40e1d8be..2b554353 100644 --- a/tools/pylintRunner.go +++ b/tools/pylintRunner.go @@ -19,9 +19,10 @@ func RunPylint(workDirectory string, toolInfo *plugins.ToolInfo, files []string, // Always use JSON output format since we'll convert to SARIF if needed args = append(args, "--output-format=json") - // Use the configuration file from .codacy/tools-configs/pylintrc - configPath := filepath.Join(workDirectory, ".codacy", "tools-configs", "pylint.rc") - args = append(args, fmt.Sprintf("--rcfile=%s", configPath)) + // Check if a config file exists in the expected location and use it if present + if configFile, exists := ConfigFileExists(workDirectory, "pylint.rc"); exists { + args = append(args, fmt.Sprintf("--rcfile=%s", configFile)) + } // Create a temporary file for JSON output if we need to convert to SARIF var tempFile string diff --git a/tools/runnerUtils.go b/tools/runnerUtils.go new file mode 100644 index 00000000..448b3920 --- /dev/null +++ b/tools/runnerUtils.go @@ -0,0 +1,27 @@ +package tools + +import ( + "os" + "path/filepath" +) + +// ConfigFileExists checks if a specific configuration file exists in the .codacy/tools-configs/ directory +// of the specified repository. +// +// Parameters: +// - repositoryDir: The repository directory path +// - 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) + + if _, err := os.Stat(configFilePath); err == nil { + return configFile, true + } + + return "", false +} diff --git a/tools/runnerUtils_test.go b/tools/runnerUtils_test.go new file mode 100644 index 00000000..f26631f0 --- /dev/null +++ b/tools/runnerUtils_test.go @@ -0,0 +1,36 @@ +package tools + +import ( + "os" + "path/filepath" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestConfigFileExists(t *testing.T) { + // Create a test directory structure + tempDir := t.TempDir() + + // Create .codacy/tools-configs directory + configDir := filepath.Join(tempDir, ".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) + 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, + "Config path should be correctly formed relative path") + + // Test case 2: Config file doesn't exist + configPath, exists = ConfigFileExists(tempDir, "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") +} diff --git a/tools/trivyRunner.go b/tools/trivyRunner.go index b3636087..645d70f8 100644 --- a/tools/trivyRunner.go +++ b/tools/trivyRunner.go @@ -1,19 +1,18 @@ package tools import ( - "codacy/cli-v2/config" "os" "os/exec" - "path/filepath" ) // RunTrivy executes Trivy vulnerability scanner with the specified options func RunTrivy(repositoryToAnalyseDirectory string, trivyBinary string, pathsToCheck []string, outputFile string, outputFormat string) error { cmd := exec.Command(trivyBinary, "fs") - // Add config file from tools-configs directory - configFile := filepath.Join(config.Config.ToolsConfigDirectory(), "trivy.yaml") - cmd.Args = append(cmd.Args, "--config", configFile) + // Add config file from tools-configs directory if it exists + if configFile, exists := ConfigFileExists(repositoryToAnalyseDirectory, "trivy.yaml"); exists { + cmd.Args = append(cmd.Args, "--config", configFile) + } // Add format options if outputFile != "" { From cbca7b29f39089ca8b23d9e20497a83e106c88ce Mon Sep 17 00:00:00 2001 From: Joao Machado <13315199+machadoit@users.noreply.github.com> Date: Wed, 9 Apr 2025 18:05:46 +0200 Subject: [PATCH 2/2] 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 --- cmd/analyze.go | 2 +- cmd/init.go | 4 +- config/config.go | 49 ++++++++-- tools/eslintRunner.go | 3 +- tools/pmdRunner.go | 11 +-- tools/pmdRunner_test.go | 12 ++- tools/pylintRunner.go | 3 +- tools/runnerUtils.go | 19 ++-- tools/runnerUtils_test.go | 94 ++++++++++++++++--- .../pmd/{pmd-ruleset.xml => ruleset.xml} | 0 tools/trivyRunner.go | 3 +- 11 files changed, 154 insertions(+), 46 deletions(-) rename tools/testdata/repositories/pmd/{pmd-ruleset.xml => ruleset.xml} (100%) diff --git a/cmd/analyze.go b/cmd/analyze.go index 0fd36faf..56dbe9f2 100644 --- a/cmd/analyze.go +++ b/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) } diff --git a/cmd/init.go b/cmd/init.go index 1e34a96e..31ab57f7 100644 --- a/cmd/init.go +++ b/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) } diff --git a/config/config.go b/config/config.go index 24239296..74f91f11 100644 --- a/config/config.go +++ b/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 diff --git a/tools/eslintRunner.go b/tools/eslintRunner.go index d17ac6b8..4000a5e3 100644 --- a/tools/eslintRunner.go +++ b/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) } diff --git a/tools/pmdRunner.go b/tools/pmdRunner.go index e4c56615..901d09d5 100644 --- a/tools/pmdRunner.go +++ b/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) diff --git a/tools/pmdRunner_test.go b/tools/pmdRunner_test.go index 453bfe11..30bea013 100644 --- a/tools/pmdRunner_test.go +++ b/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/pmd@6.55.0/pmd-bin-6.55.0/bin/run.sh") + pmdBinary := filepath.Join(globalCache, "tools/pmd@6.55.0/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) } diff --git a/tools/pylintRunner.go b/tools/pylintRunner.go index 2b554353..5d907837 100644 --- a/tools/pylintRunner.go +++ b/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)) } diff --git a/tools/runnerUtils.go b/tools/runnerUtils.go index 448b3920..46e37986 100644 --- a/tools/runnerUtils.go +++ b/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 diff --git a/tools/runnerUtils_test.go b/tools/runnerUtils_test.go index f26631f0..706548ea 100644 --- a/tools/runnerUtils_test.go +++ b/tools/runnerUtils_test.go @@ -1,6 +1,7 @@ package tools import ( + "codacy/cli-v2/config" "os" "path/filepath" "testing" @@ -8,29 +9,100 @@ import ( "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") } diff --git a/tools/testdata/repositories/pmd/pmd-ruleset.xml b/tools/testdata/repositories/pmd/ruleset.xml similarity index 100% rename from tools/testdata/repositories/pmd/pmd-ruleset.xml rename to tools/testdata/repositories/pmd/ruleset.xml diff --git a/tools/trivyRunner.go b/tools/trivyRunner.go index 645d70f8..8e8e3522 100644 --- a/tools/trivyRunner.go +++ b/tools/trivyRunner.go @@ -1,6 +1,7 @@ package tools import ( + "codacy/cli-v2/config" "os" "os/exec" ) @@ -10,7 +11,7 @@ func RunTrivy(repositoryToAnalyseDirectory string, trivyBinary string, pathsToCh cmd := exec.Command(trivyBinary, "fs") // Add config file from tools-configs directory if it exists - if configFile, exists := ConfigFileExists(repositoryToAnalyseDirectory, "trivy.yaml"); exists { + if configFile, exists := ConfigFileExists(config.Config, "trivy.yaml"); exists { cmd.Args = append(cmd.Args, "--config", configFile) }