pmd configuration

Author: zhamborova

.codacy/codacy.yaml

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

cmd/init.go

@@ -55,15 +55,22 @@ var initCmd = &cobra.Command{
 }
 
 func createConfigurationFile(tools []tools.Tool) error {
+	configPath := config.Config.ProjectConfigFile()
+	fmt.Printf("Creating config file at: %s\n", configPath) // Debug log
 
-	configFile, err := os.Create(config.Config.ProjectConfigFile())
-	defer configFile.Close()
+	configFile, err := os.Create(configPath)
 	if err != nil {
+		fmt.Printf("Error creating file: %v\n", err) // Debug log
 		log.Fatal(err)
 	}
+	defer configFile.Close()
 
-	_, err = configFile.WriteString(configFileTemplate(tools))
+	content := configFileTemplate(tools)
+	fmt.Printf("Writing config content:\n%s\n", content) // Debug log
+
+	_, err = configFile.WriteString(content)
 	if err != nil {
+		fmt.Printf("Error writing content: %v\n", err) // Debug log
 		log.Fatal(err)
 	}
 
@@ -76,6 +83,7 @@ func configFileTemplate(tools []tools.Tool) string {
 	eslintVersion := "9.3.0"
 	trivyVersion := "0.59.1" // Latest stable version
 	pylintVersion := "3.3.6"
+	pmdVersion := "7.12.0"
 
 	for _, tool := range tools {
 		if tool.Uuid == "f8b29663-2cb2-498d-b923-a10c6a8c05cd" {
@@ -87,16 +95,21 @@ func configFileTemplate(tools []tools.Tool) string {
 		if tool.Uuid == "31677b6d-4ae0-4f56-8041-606a8d7a8e61" {
 			pylintVersion = tool.Version
 		}
+		if tool.Uuid == "9ed24812-b6ee-4a58-9004-0ed183c45b8f" {
+			pmdVersion = tool.Version
+		}
 	}
 
+	//todo correct java version
 	return fmt.Sprintf(`runtimes:
     - [email protected]
     - [email protected]
 tools:
     - eslint@%s
     - trivy@%s
     - pylint@%s
-`, eslintVersion, trivyVersion, pylintVersion)
+    - pmd@%s
+`, eslintVersion, trivyVersion, pylintVersion, pmdVersion)
 }
 
 func buildRepositoryConfigurationFiles(token string) error {
@@ -181,6 +194,22 @@ func buildRepositoryConfigurationFiles(token string) error {
 		fmt.Println("Default Trivy configuration created")
 	}
 
+	// Add PMD configuration handling
+	pmdApiConfiguration := extractPMDConfiguration(apiToolConfigurations)
+	if pmdApiConfiguration != nil {
+		err = createPMDConfigFile(*pmdApiConfiguration)
+		if err != nil {
+			log.Fatal(err)
+		}
+		fmt.Println("PMD configuration created based on Codacy settings")
+	} else {
+		err = createDefaultPMDConfigFile()
+		if err != nil {
+			log.Fatal(err)
+		}
+		fmt.Println("Default PMD configuration created")
+	}
+
 	return nil
 }
 
@@ -239,6 +268,29 @@ func extractTrivyConfiguration(toolConfigurations []CodacyToolConfiguration) *Co
 	return nil
 }
 
+// Add PMD-specific functions
+func extractPMDConfiguration(toolConfigurations []CodacyToolConfiguration) *CodacyToolConfiguration {
+	const PMDUUID = "9ed24812-b6ee-4a58-9004-0ed183c45b8f"
+	for _, toolConfiguration := range toolConfigurations {
+		if toolConfiguration.Uuid == PMDUUID {
+			return &toolConfiguration
+		}
+	}
+	return nil
+}
+
+func createPMDConfigFile(config CodacyToolConfiguration) error {
+	pmdDomainConfiguration := convertAPIToolConfigurationToDomain(config)
+	pmdConfigurationString := tools.CreatePmdConfig(pmdDomainConfiguration)
+	return os.WriteFile("pmd-ruleset.xml", []byte(pmdConfigurationString), 0644)
+}
+
+func createDefaultPMDConfigFile() error {
+	emptyConfig := tools.ToolConfiguration{}
+	content := tools.CreatePmdConfig(emptyConfig)
+	return os.WriteFile("pmd-ruleset.xml", []byte(content), 0644)
+}
+
 type CodacyToolConfiguration struct {
 	Uuid      string                 `json:"uuid"`
 	IsEnabled bool                   `json:"isEnabled"`

plugins/tools/pmd/default-ruleset.xml

@@ -7,4 +7,17 @@ download:
     default: .zip
 binaries:
   - name: pmd
-    path: pmd-bin-{{.Version}}/bin/pmd
+    path: pmd-bin-{{.Version}}/bin/pmd
+runtime: java
+runtime_binaries:
+  package_manager: java
+  execution: java
+default_rules:
+  - category: java/codestyle
+    rule: AtLeastOneConstructor
+  - category: java/design
+    rule: UnusedPrivateField
+  - category: java/codestyle
+    rule: ShortVariable
+  - category: java/documentation
+    rule: CommentRequired

plugins/tools/pmd/plugin.yaml

@@ -0,0 +1,73 @@
+package tools
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+func CreatePmdConfig(configuration ToolConfiguration) string {
+	// If no patterns provided, return the default ruleset from file
+	if len(configuration.PatternsConfiguration) == 0 {
+		defaultRulesetPath := filepath.Join("plugins", "tools", "pmd", "default-ruleset.xml")
+		defaultRuleset, err := os.ReadFile(defaultRulesetPath)
+		if err != nil {
+			log.Printf("Failed to read default PMD ruleset: %v", err)
+			return "" // Or handle error as needed
+		}
+		return string(defaultRuleset)
+	}
+
+	var contentBuilder strings.Builder
+
+	// Write XML header and ruleset opening with correct name
+	contentBuilder.WriteString("<?xml version=\"1.0\"?>\n")
+	contentBuilder.WriteString("<ruleset name=\"Codacy PMD Ruleset\"\n")
+	contentBuilder.WriteString("    xmlns=\"http://pmd.sourceforge.net/ruleset/2.0.0\"\n")
+	contentBuilder.WriteString("    xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n")
+	contentBuilder.WriteString("    xsi:schemaLocation=\"http://pmd.sourceforge.net/ruleset/2.0.0 https://pmd.sourceforge.io/ruleset_2_0_0.xsd\">\n\n")
+
+	// Process patterns from configuration
+	for _, pattern := range configuration.PatternsConfiguration {
+		// Check if pattern is enabled
+		patternEnabled := true
+		var properties []string
+
+		for _, param := range pattern.ParamenterConfigurations {
+			if param.Name == "enabled" && param.Value == "false" {
+				patternEnabled = false
+				break
+			} else if param.Name != "enabled" {
+				// Store non-enabled parameters for properties
+				properties = append(properties, fmt.Sprintf("            <property name=\"%s\" value=\"%s\"/>", param.Name, param.Value))
+			}
+		}
+
+		if patternEnabled {
+			// Convert pattern ID to correct PMD path format
+			// e.g., "java/codestyle/AtLeastOneConstructor" -> "category/java/codestyle.xml/AtLeastOneConstructor"
+			parts := strings.Split(pattern.PatternId, "/")
+			if len(parts) >= 2 {
+				category := parts[len(parts)-2]
+				rule := parts[len(parts)-1]
+				contentBuilder.WriteString(fmt.Sprintf("    <rule ref=\"category/java/%s.xml/%s\"", category, rule))
+
+				// Add properties if any exist
+				if len(properties) > 0 {
+					contentBuilder.WriteString(">\n        <properties>\n")
+					for _, prop := range properties {
+						contentBuilder.WriteString(prop + "\n")
+					}
+					contentBuilder.WriteString("        </properties>\n    </rule>\n")
+				} else {
+					contentBuilder.WriteString("/>\n")
+				}
+			}
+		}
+	}
+
+	contentBuilder.WriteString("</ruleset>")
+	return contentBuilder.String()
+}

tools/pmdConfigCreator.go

@@ -0,0 +1,152 @@
+package tools
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCreatePmdConfig(t *testing.T) {
+	// Setup test configuration with patterns
+	config := ToolConfiguration{
+		PatternsConfiguration: []PatternConfiguration{
+			{
+				PatternId: "java/codestyle/AtLeastOneConstructor",
+				ParamenterConfigurations: []PatternParameterConfiguration{
+					{
+						Name:  "enabled",
+						Value: "true",
+					},
+				},
+			},
+			{
+				PatternId: "java/design/UnusedPrivateField",
+				ParamenterConfigurations: []PatternParameterConfiguration{
+					{
+						Name:  "enabled",
+						Value: "true",
+					},
+				},
+			},
+			{
+				PatternId: "java/codestyle/ShortVariable",
+				ParamenterConfigurations: []PatternParameterConfiguration{
+					{
+						Name:  "enabled",
+						Value: "true",
+					},
+				},
+			},
+			{
+				PatternId: "java/documentation/CommentRequired",
+				ParamenterConfigurations: []PatternParameterConfiguration{
+					{
+						Name:  "enabled",
+						Value: "true",
+					},
+				},
+			},
+			{
+				PatternId: "java/design/LoosePackageCoupling",
+				ParamenterConfigurations: []PatternParameterConfiguration{
+					{
+						Name:  "enabled",
+						Value: "true",
+					},
+					{
+						Name:  "packages",
+						Value: "java.util,java.io",
+					},
+				},
+			},
+		},
+	}
+
+	// Generate PMD config
+	pmdConfigurationString := CreatePmdConfig(config)
+
+	// Compare with expected config from test file
+	expectedConfigFile := filepath.Join("testdata", "repositories", "pmd", "expected-ruleset.xml")
+	expectedConfigBytes, err := os.ReadFile(expectedConfigFile)
+	if err != nil {
+		t.Fatalf("Failed to read expected config file: %v", err)
+	}
+	expectedConfig := strings.TrimSpace(string(expectedConfigBytes))
+
+	assert.Equal(t, expectedConfig, pmdConfigurationString)
+}
+
+func TestCreatePmdConfigWithDisabledRules(t *testing.T) {
+	// Test configuration with disabled rules
+	config := ToolConfiguration{
+		PatternsConfiguration: []PatternConfiguration{
+			{
+				PatternId: "java/codestyle/AtLeastOneConstructor",
+				ParamenterConfigurations: []PatternParameterConfiguration{
+					{
+						Name:  "enabled",
+						Value: "false",
+					},
+				},
+			},
+		},
+	}
+
+	obtainedConfig := CreatePmdConfig(config)
+
+	// Verify disabled rules are not included
+	assert.NotContains(t, obtainedConfig, "AtLeastOneConstructor",
+		"Disabled rule should not appear in config")
+}
+
+func TestCreatePmdConfigEmpty(t *testing.T) {
+	// Save current working directory
+	cwd, err := os.Getwd()
+	if err != nil {
+		t.Fatalf("Failed to get current directory: %v", err)
+	}
+
+	// Create a temporary test directory structure
+	tmpDir := t.TempDir()
+	err = os.MkdirAll(filepath.Join(tmpDir, "plugins", "tools", "pmd"), 0755)
+	if err != nil {
+		t.Fatalf("Failed to create test directory structure: %v", err)
+	}
+
+	// Copy the default ruleset to the test location
+	defaultRuleset := `<?xml version="1.0"?>
+<ruleset name="Codacy PMD Ruleset"
+    xmlns="http://pmd.sourceforge.net/ruleset/2.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://pmd.sourceforge.net/ruleset/2.0.0 https://pmd.sourceforge.io/ruleset_2_0_0.xsd">
+    <!-- Default rules here -->
+</ruleset>`
+
+	err = os.WriteFile(filepath.Join(tmpDir, "plugins", "tools", "pmd", "default-ruleset.xml"), []byte(defaultRuleset), 0644)
+	if err != nil {
+		t.Fatalf("Failed to write test ruleset: %v", err)
+	}
+
+	// Change to temp directory for test
+	err = os.Chdir(tmpDir)
+	if err != nil {
+		t.Fatalf("Failed to change directory: %v", err)
+	}
+	// Restore working directory after test
+	defer os.Chdir(cwd)
+
+	// Run the test
+	config := ToolConfiguration{
+		PatternsConfiguration: []PatternConfiguration{},
+	}
+
+	obtainedConfig := CreatePmdConfig(config)
+
+	// Verify the output contains basic XML structure
+	assert.Contains(t, obtainedConfig, "<?xml version=\"1.0\"?>")
+	assert.Contains(t, obtainedConfig, "<ruleset")
+	assert.Contains(t, obtainedConfig, "</ruleset>")
+}