Merge pull request #897 from uni-bremen-agst/885-static-analyser-framework-checkstyle-support

885 static analyser framework checkstyle support

Closes #885

Author: koschke

Assets/SEE/DataModel/DG/IO/CheckstyleIndexNodeStrategy.cs

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 5ab25e7b3b2faed46958fdec3e51d922

Assets/SEE/DataModel/DG/IO/CheckstyleIndexNodeStrategy.cs.meta

@@ -0,0 +1,117 @@
+using System.Collections.Generic;
+
+namespace SEE.DataModel.DG.IO
+{
+    /// <summary>
+    /// Contains parser configuration and node-indexing helpers for importing external analysis reports.
+    /// Parsing configuration for Checkstyle XML reports.
+    /// </summary>
+    /// <remarks>
+    /// Supported nodes:
+    /// <list type="bullet">
+    /// <item><description><c>&lt;file&gt;</c>: File-level aggregation (counts by severity).</description></item>
+    /// <item><description><c>&lt;error&gt;</c>: Individual violations (line/column + rendered message).</description></item>
+    /// </list>
+    ///
+    /// Key idea:
+    /// Metrics are configured per context (see <see cref="XPathMapping.MetricsByContext"/>),
+    /// so the parser does not need XPath hacks that force irrelevant metrics to evaluate to NaN.
+    /// </remarks>
+    internal sealed class CheckstyleParsingConfig : ParsingConfig
+    {
+        /// <summary>
+        /// Context name for individual Checkstyle violations (<c>&lt;error&gt;</c> nodes).
+        /// </summary>
+        private const string errorContext = "error";
+
+        /// <summary>
+        /// Context name for file-level aggregation (<c>&lt;file&gt;</c> nodes).
+        /// </summary>
+        private const string fileContext = "file";
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CheckstyleParsingConfig"/> class.
+        /// </summary>
+        public CheckstyleParsingConfig()
+        {
+            ToolId = "Checkstyle";
+
+            // Used by CheckstyleIndexNodeStrategy to trim absolute paths down to package/class.
+            SourceRootMarker = "src/main/java/";
+
+            XPathMapping = new XPathMapping
+            {
+                // Parse both file-level and error-level nodes.
+                SearchedNodes = $"//{fileContext}|//{errorContext}",
+
+                // Build a stable "full path" identifier for each node.
+                // For Checkstyle, the report contains absolute file paths in @name.
+                PathBuilders = new Dictionary<string, string>
+                {
+                    [fileContext] = "string(@name)",
+                    [errorContext] = "string(ancestor::file/@name)",
+                },
+
+                // File name extraction (optional for CheckstyleIndexNodeStrategy, but useful for other strategies).
+                // We keep this context-first to avoid tag-name ambiguity.
+                FileName = new Dictionary<string, string>
+                {
+                    // The file element has the file path in @name.
+                    [fileContext] = "string(@name)",
+                    // The error element inherits the file path from its ancestor <file>.
+                    [errorContext] = "string(ancestor::file/@name)",
+                },
+
+                // Location is only meaningful for <error>, but parsing it globally is safe:
+                // for <file> these attributes are missing and are simply ignored.
+                LocationMapping = new Dictionary<string, string>
+                {
+                    ["StartLine"] = "string(@line)",
+                    ["StartColumn"] = "string(@column)",
+                },
+
+                // Context-specific metrics.
+                MetricsByContext = new Dictionary<string, Dictionary<string, string>>
+                {
+                    [fileContext] = new Dictionary<string, string>
+                    {
+                        // Count errors by severity within this file.
+                        // count(error[@severity='warning']) counts all child <error> elements.
+                        ["Aggregated.WarningCount"] = "string(count(error[@severity='warning']))",
+                        ["Aggregated.ErrorCount"] = "string(count(error[@severity='error']))",
+                        ["Aggregated.InfoCount"] = "string(count(error[@severity='info']))",
+
+                        // Total violations for this file.
+                        ["Aggregated.ViolationCount"] = "string(count(error))",
+                    },
+
+                    [errorContext] = new Dictionary<string, string>
+                    {
+                        // A short, human-friendly issue string.
+                        // Using substring(...) with a large length keeps this robust even if message is empty.
+                        ["ContextLevel.Issue"] =
+                            "substring(concat('Line ', @line, ': [', @severity, '] ', @message), 1, 10000)",
+                    },
+                },
+            };
+        }
+
+        /// <summary>
+        /// Creates the parser implementation that can read Checkstyle reports using this configuration.
+        /// </summary>
+        /// <returns>A report parser configured for Checkstyle XML input.</returns>
+        internal override IReportParser CreateParser()
+        {
+            return new XmlReportParser(this);
+        }
+
+        /// <summary>
+        /// Creates the index-node strategy that maps findings to the corresponding graph node identifiers.
+        /// </summary>
+        /// <returns>An index node strategy suitable for Checkstyle file paths.</returns>
+        public override IIndexNodeStrategy CreateIndexNodeStrategy()
+        {
+            return new CheckstyleIndexNodeStrategy(this);
+        }
+    }
+}

Assets/SEE/DataModel/DG/IO/CheckstyleParsingConfig.cs

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: ebed831a38cc0ef438ca848e2657b541

Assets/SEE/DataModel/DG/IO/CheckstyleParsingConfig.cs.meta

@@ -3,22 +3,27 @@
 namespace SEE.DataModel.DG.IO
 {
     /// <summary>
-    /// Represents a single parsed element together with its metrics and optional location data.
+    /// Represents a single parsed report element together with its metrics and optional location data.
     /// </summary>
     public class Finding
     {
         /// <summary>
-        /// Normalized path that can be mapped back to a node in a <see cref="Graph"/>.
+        /// Normalized identifier that can be mapped back to a node in a <see cref="Graph"/>.
         /// </summary>
+        /// <remarks>Preconditions: Should not be null or whitespace if the finding is meant to be applied to a graph.</remarks>
         public string FullPath { get; set; }
 
         /// <summary>
-        /// Name of the source file. Can be empty if <see cref="FullPath"/> contains the file name.
+        /// Name or path of the source file.
         /// </summary>
+        /// <remarks>
+        /// May be empty if <see cref="FullPath"/> already contains the file name or if the report format does not
+        /// expose a file name separately.
+        /// </remarks>
         public string FileName { get; set; }
 
         /// <summary>
-        /// Context or tag name under which the finding was reported (for example, class, method).
+        /// Context or tag name under which the finding was reported (for example, class, method, file).
         /// </summary>
         public string Context { get; set; }
 
@@ -30,7 +35,7 @@ public class Finding
         /// <summary>
         /// Metric values emitted for this finding, keyed by a descriptive string.
         /// </summary>
-        public Dictionary<string, string?> Metrics { get; set; }
-            = new Dictionary<string, string?>();
+        /// <remarks>Preconditions: Never null.</remarks>
+        public Dictionary<string, string> Metrics { get; set; } = new Dictionary<string, string>();
     }
 }

Assets/SEE/DataModel/DG/IO/Finding.cs

@@ -19,7 +19,7 @@ namespace SEE.DataModel.DG.IO
     /// 3. <see cref="FindingPathToMainType"/> resolves to the main type for indexing purposes
     /// 4. <see cref="NodeIdToMainType"/> provides consistent main type resolution from graph nodes
     /// 
-    /// Example implementations: JavaIndexNodeStrategy, CSharpIndexNodeStrategy
+    /// Example implementations:<see cref="JaCoCoIndexNodeStrategy"/> <see cref="CheckstyleIndexNodeStrategy"/>
     /// </remarks>
     public interface IIndexNodeStrategy
     {

Assets/SEE/DataModel/DG/IO/IIndexNodeStrategy.cs

@@ -1,4 +1,5 @@
-using System;
+using SEE.Utils;
+using System;
 using System.Collections.Generic;
 using System.IO;
 
@@ -8,10 +9,9 @@ namespace SEE.DataModel.DG.IO
     /// Strategy for normalizing Java code element identifiers to main type paths.
     /// Handles JaCoCo-specific conventions including package separators, inner classes, and methods.
     /// </summary>
-    public sealed class JavaIndexNodeStrategy : IIndexNodeStrategy
+    public sealed class JaCoCoIndexNodeStrategy : IIndexNodeStrategy
     {
         // JaCoCo and Java conventions
-        private const char JavaPathSeparator = '/';
         private const char NodeIdSeparator = '.';
         private const char InnerClassDelimiter = '$';
         private const char MethodDelimiter = '#';
@@ -29,7 +29,7 @@ public string FindingPathToNodeId(string fullPath)
             }
 
             // 1. replacing path separators
-            fullPath = fullPath.Replace(JavaPathSeparator, NodeIdSeparator);
+            fullPath = fullPath.Replace(Filenames.UnixDirectorySeparator, NodeIdSeparator).Replace(Filenames.WindowsDirectorySeparator, NodeIdSeparator);
 
             bool isMethod = fullPath.IndexOf(MethodDelimiter) > -1;
 
@@ -57,8 +57,8 @@ public string FindingPathToMainType(string fullPath, string fileName)
                 return null;
             }
 
-            // Step 1: Convert path separators: '/' → '.'
-            string normalized = fullPath.Replace(JavaPathSeparator, NodeIdSeparator);
+            // Step 1: Convert path separators: '/' → '.' and '\\' -> '.'
+            string normalized = Filenames.ReplaceDirectorySeparators(fullPath, NodeIdSeparator);
 
             // Step 2: Remove everything from first inner class or method delimiter onwards
             normalized = RemoveInnerTypesAndMethods(normalized);
@@ -86,7 +86,7 @@ public string NodeIdToMainType(Node node)
             }
 
             // For methods: recurse to parent type
-            if (node.Type == "Method")
+            if (node.Type == NodeTypes.Method)
             {
                 return node.Parent != null ? NodeIdToMainType(node.Parent) : null;
             }
@@ -108,10 +108,10 @@ public string NodeIdToMainType(Node node)
         /// </summary>
         private static readonly HashSet<string> TypeNodeTypes = new()
         {
-            "Class",
-            "Interface",
-            "Class_Template",
-            "Interface_Template"
+            NodeTypes.Class,
+            NodeTypes.Interface,
+            NodeTypes.ClassTemplate,
+            NodeTypes.InterfaceTemplate
         };
 
         private static bool IsTypeNode(string nodeType)