Feature/pmd

.codacy/codacy.yaml

@@ -4,4 +4,5 @@ runtimes:
 tools:
     - [email protected]
     - [email protected]
+    - [email protected]
     - [email protected]

.cursor/rules/cursor.mdc

@@ -0,0 +1,22 @@
+---
+description: 
+globs: 
+alwaysApply: true
+---
+
+# Your rule content
+
+## Code Style Guidelines
+- **Imports**: Standard lib first, external packages second, internal last
+- **Naming**: PascalCase for exported (public), camelCase for unexported (private)
+- **Error handling**: Return errors as last value, check with `if err != nil`
+- **Testing**: Use testify/assert package for assertions
+- **Package organization**: Keep related functionality in dedicated packages
+- **Documentation**: Document all exported functions, types, and packages
+- **Commit messages**: Start with verb, be concise and descriptive
+
+## Project Structure
+- `cmd/`: CLI command implementations
+- `config/`: Configuration handling
+- `tools/`: Tool-specific implementations
+- `utils/`: Utility functions

cmd/analyze.go

@@ -20,6 +20,7 @@ var outputFormat string
 var sarifPath string
 var commitUuid string
 var projectToken string
+var pmdRulesetFile string
 
 type Sarif struct {
 	Runs []struct {
@@ -95,6 +96,7 @@ func init() {
 	analyzeCmd.Flags().StringVarP(&toolToAnalyze, "tool", "t", "", "Which tool to run analysis with")
 	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")
+	analyzeCmd.Flags().StringVar(&pmdRulesetFile, "rulesets", "", "Path to PMD ruleset file")
 	rootCmd.AddCommand(analyzeCmd)
 }
 
@@ -203,6 +205,16 @@ func runTrivyAnalysis(workDirectory string, pathsToCheck []string, outputFile st
 	}
 }
 
+func runPmdAnalysis(workDirectory string, pathsToCheck []string, outputFile string, outputFormat string) {
+	pmd := config.Config.Tools()["pmd"]
+	pmdBinary := pmd.Binaries["pmd"]
+
+	err := tools.RunPmd(workDirectory, pmdBinary, pathsToCheck, outputFile, outputFormat, pmdRulesetFile)
+	if err != nil {
+		log.Fatalf("Error running PMD: %v", err)
+	}
+}
+
 func runPylintAnalysis(workDirectory string, pathsToCheck []string, outputFile string, outputFormat string) {
 	pylint := config.Config.Tools()["pylint"]
 
@@ -235,6 +247,8 @@ var analyzeCmd = &cobra.Command{
 			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 "":

plugins/tool-utils.go

@@ -174,7 +174,23 @@ func ProcessTools(configs []ToolConfig, toolDir string) (map[string]*ToolInfo, e
 
 		// Process binary paths
 		for _, binary := range pluginConfig.Binaries {
-			binaryPath := path.Join(installDir, binary.Path)
+			// Process template variables in binary path
+			tmpl, err := template.New("binary_path").Parse(binary.Path)
+			if err != nil {
+				return nil, fmt.Errorf("error parsing binary path template for %s: %w", config.Name, err)
+			}
+
+			var buf bytes.Buffer
+			err = tmpl.Execute(&buf, struct {
+				Version string
+			}{
+				Version: config.Version,
+			})
+			if err != nil {
+				return nil, fmt.Errorf("error executing binary path template for %s: %w", config.Name, err)
+			}
+
+			binaryPath := filepath.Join(installDir, buf.String())
 			info.Binaries[binary.Name] = binaryPath
 		}
 

plugins/tools/pmd/plugin.yaml

@@ -0,0 +1,10 @@
+name: pmd
+description: PMD - An extensible cross-language static code analyzer
+download:
+  url_template: https://github.com/pmd/pmd/releases/download/pmd_releases%2F{{.Version}}/pmd-dist-{{.Version}}-bin.zip
+  file_name_template: pmd-dist-{{.Version}}-bin.zip
+  extension:
+    default: .zip
+binaries:
+  - name: pmd
+    path: pmd-bin-{{.Version}}/bin/pmd

tools/pmdRunner.go

@@ -0,0 +1,42 @@
+package tools
+
+import (
+	"os"
+	"os/exec"
+)
+
+// RunPmd executes PMD static code analyzer with the specified options
+func RunPmd(repositoryToAnalyseDirectory string, pmdBinary string, pathsToCheck []string, outputFile string, outputFormat string, rulesetFile string) error {
+	cmd := exec.Command(pmdBinary, "check")
+
+	// Add ruleset file if provided
+	if rulesetFile != "" {
+		cmd.Args = append(cmd.Args, "--rulesets", rulesetFile)
+	}
+
+	// Add format options
+	if outputFormat == "sarif" {
+		cmd.Args = append(cmd.Args, "--format", "sarif")
+	}
+
+	if outputFile != "" {
+		cmd.Args = append(cmd.Args, "--report-file", outputFile)
+	}
+
+	// Add directory to scan
+	cmd.Args = append(cmd.Args, "--dir", repositoryToAnalyseDirectory)
+
+	cmd.Dir = repositoryToAnalyseDirectory
+	cmd.Stderr = os.Stderr
+	cmd.Stdout = os.Stdout
+
+	err := cmd.Run()
+	if err != nil {
+		if exitErr, ok := err.(*exec.ExitError); ok && exitErr.ExitCode() == 4 {
+			// Exit status 4 means violations were found, which is not an error
+			return nil
+		}
+		return err
+	}
+	return nil
+}

tools/pmdRunner_test.go

@@ -0,0 +1,64 @@
+package tools
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRunPmdToFile(t *testing.T) {
+	homeDirectory, err := os.UserHomeDir()
+	if err != nil {
+		log.Fatal(err.Error())
+	}
+	currentDirectory, err := os.Getwd()
+	if err != nil {
+		log.Fatal(err.Error())
+	}
+
+	// Get absolute paths for test files
+	testDirectory := filepath.Join(currentDirectory, "testdata/repositories/pmd")
+	tempResultFile := filepath.Join(os.TempDir(), "pmd.sarif")
+	defer os.Remove(tempResultFile)
+
+	// Use absolute paths for repository and ruleset
+	repositoryToAnalyze := testDirectory
+	rulesetFile := filepath.Join(testDirectory, "pmd-ruleset.xml")
+
+	pmdBinary := filepath.Join(homeDirectory, ".cache/codacy/tools/[email protected]/pmd-bin-7.12.0/bin/pmd")
+
+	err = RunPmd(repositoryToAnalyze, pmdBinary, nil, tempResultFile, "sarif", rulesetFile)
+	// PMD returns exit status 4 when violations are found, which is expected in our test
+	if err != nil {
+		if exitErr, ok := err.(*exec.ExitError); ok && exitErr.ExitCode() != 4 {
+			t.Fatalf("Failed to run PMD: %v", err)
+		}
+	}
+
+	// Check if the output file was created
+	obtainedSarifBytes, err := os.ReadFile(tempResultFile)
+	if err != nil {
+		t.Fatalf("Failed to read output file: %v", err)
+	}
+	obtainedSarif := string(obtainedSarifBytes)
+	filePrefix := "file://" + currentDirectory + "/"
+	fmt.Println(filePrefix)
+	actualSarif := strings.ReplaceAll(obtainedSarif, filePrefix, "")
+	actualSarif = strings.TrimSpace(actualSarif)
+
+	// Read the expected SARIF
+	expectedSarifFile := filepath.Join(testDirectory, "expected.sarif")
+	expectedSarifBytes, err := os.ReadFile(expectedSarifFile)
+	if err != nil {
+		log.Fatal(err)
+	}
+	expectedSarif := strings.TrimSpace(string(expectedSarifBytes))
+
+	assert.Equal(t, expectedSarif, actualSarif, "output did not match expected")
+}

tools/testdata/repositories/pmd/RulesBreaker.java

@@ -0,0 +1,20 @@
+
+/**
+ * This class demonstrates various PMD rule violations.
+ * It is used for testing PMD's rule detection capabilities.
+ * 
+ * @author Codacy Test Team
+ * @version 1.0
+ */
+
+package tools.testdata.repositories.pmd;
+
+/**
+ * A class that demonstrates PMD rule violations.
+ */
+public class RulesBreaker {
+
+    // Breaking naming convention rules
+    private int x;
+
+}