fix(analysis): fix rloc sometimes being off by one #4092

Author: Nereboss

analysis/analysers/parsers/UnifiedParser/src/main/kotlin/de/maibornwolff/codecharta/analysers/parsers/unified/metriccollectors/AvailableCollectors.kt

@@ -10,5 +10,6 @@ enum class AvailableCollectors(
     JAVASCRIPT(FileExtension.JAVASCRIPT, ::JavascriptCollector),
     KOTLIN(FileExtension.KOTLIN, ::KotlinCollector),
     JAVA(FileExtension.JAVA, ::JavaCollector),
-    CSHARP(FileExtension.CSHARP, ::CSharpCollector)
+    CSHARP(FileExtension.CSHARP, ::CSharpCollector),
+    PYTHON(FileExtension.PYTHON, ::PythonCollector)
 }

analysis/analysers/parsers/UnifiedParser/src/main/kotlin/de/maibornwolff/codecharta/analysers/parsers/unified/metriccollectors/MetricCollector.kt

@@ -18,7 +18,7 @@ abstract class MetricCollector(
 ) {
     private var lastCountedCommentLine = -1
     private var lastCountedCodeLine = -1
-    private var rootNodeType: String = "" //TODO: schauen wie wir für alle kinder vom rootnode berechnen
+    private var rootNodeType: String = ""
 
     // maps a metric to its index for the more performant IntArray and the function how to calculate the metric
     private val metricInfo = mapOf(
@@ -58,7 +58,9 @@ abstract class MetricCollector(
     private fun getRootNode(file: File): TSNode {
         val parser = TSParser()
         parser.setLanguage(treeSitterLanguage)
-        return parser.parseString(null, file.readText()).rootNode
+        val rootNode = parser.parseString(null, file.readText()).rootNode
+        rootNodeType = rootNode.type
+        return rootNode
     }
 
     private val walkTree = DeepRecursiveFunction<Pair<TSTreeCursor, IntArray>, Unit> { (cursor, metrics) ->
@@ -68,9 +70,11 @@ abstract class MetricCollector(
         val startRow = currentNode.startPoint.row
         val endRow = currentNode.endPoint.row
 
-        for ((_, indexAndCalculateMetricForNodeFn) in metricInfo) {
-            val (index, calculateMetricForNodeFn) = indexAndCalculateMetricForNodeFn
-            metrics[index] += calculateMetricForNodeFn(currentNode, nodeType, startRow, endRow)
+        if (nodeType != rootNodeType) {
+            for ((_, indexAndCalculateMetricForNodeFn) in metricInfo) {
+                val (index, calculateMetricForNodeFn) = indexAndCalculateMetricForNodeFn
+                metrics[index] += calculateMetricForNodeFn(currentNode, nodeType, startRow, endRow)
+            }
         }
 
         if (cursor.gotoFirstChild()) {
@@ -134,8 +138,15 @@ abstract class MetricCollector(
     private fun isNestedTypeAllowed(node: TSNode, nodeType: String, nestedTypes: Set<NestedNodeType>): Boolean {
         for (nestedType in nestedTypes) {
             if (nestedType.baseNodeType == nodeType) {
-                val childNode = node.getChildByFieldName(nestedType.childNodeFieldName)
-                if (nestedType.childNodeTypes.contains(childNode.type)) return true
+                if (nestedType.childNodePosition != null &&
+                    nestedType.childNodeCount == node.childCount
+                ) {
+                    val childNode = node.getChild(nestedType.childNodePosition)
+                    if (nestedType.childNodeTypes.contains(childNode.type)) return true
+                } else if (nestedType.childNodeFieldName != null) {
+                    val childNode = node.getChildByFieldName(nestedType.childNodeFieldName)
+                    if (nestedType.childNodeTypes.contains(childNode.type)) return true
+                }
             }
         }
         return false

analysis/analysers/parsers/UnifiedParser/src/main/kotlin/de/maibornwolff/codecharta/analysers/parsers/unified/metriccollectors/PythonCollector.kt

@@ -1,90 +1,9 @@
 package de.maibornwolff.codecharta.analysers.parsers.unified.metriccollectors
 
-import de.maibornwolff.codecharta.analysers.parsers.unified.metricqueries.PythonQueries
-import org.treesitter.TSNode
-import org.treesitter.TSTreeCursor
+import de.maibornwolff.codecharta.analysers.parsers.unified.metricnodetypes.PythonNodeTypes
 import org.treesitter.TreeSitterPython
 
 class PythonCollector : MetricCollector(
     treeSitterLanguage = TreeSitterPython(),
-    queryProvider = PythonQueries()
-) {
-    override fun getRealLinesOfCode(root: TSNode): Int {
-        if (root.childCount == 0) return 0
-
-        rootNodeType = root.type
-        val commentTypes = getParentAndChildNodeTypesFromQuery(queryProvider.commentLinesQuery)
-        return walkTree(TSTreeCursor(root), commentTypes)
-    }
-
-    private fun walkTree(cursor: TSTreeCursor, commentTypes: List<Pair<String, String?>>): Int {
-        var realLinesOfCode = 0
-        val currentNode = cursor.currentNode()
-
-        if (!isCommentNode(currentNode, commentTypes)) {
-            if (currentNode.startPoint.row > lastCountedLine &&
-                currentNode.type != rootNodeType &&
-                !areAllChildrenInLineCommentNodes(currentNode, currentNode.startPoint.row, commentTypes)
-            ) {
-                lastCountedLine = currentNode.startPoint.row
-                realLinesOfCode++
-            }
-
-            if (currentNode.childCount == 0) {
-                if (currentNode.endPoint.row > lastCountedLine) {
-                    realLinesOfCode += currentNode.endPoint.row - currentNode.startPoint.row
-                    lastCountedLine = currentNode.endPoint.row
-                }
-            } else if (currentNode.endPoint.row > currentNode.startPoint.row && cursor.gotoFirstChild()) {
-                realLinesOfCode += walkTree(cursor, commentTypes)
-            }
-        }
-
-        if (cursor.gotoNextSibling()) {
-            realLinesOfCode += walkTree(cursor, commentTypes)
-        } else {
-            cursor.gotoParent()
-        }
-
-        return realLinesOfCode
-    }
-
-    private fun getParentAndChildNodeTypesFromQuery(query: String): List<Pair<String, String?>> {
-        val regex = Regex("""\((.*?)\)\s*@""", RegexOption.MULTILINE)
-        val commentNodeTypes = regex.findAll(query).map { it.groupValues[1] }.toList()
-
-        val parentToChildTypes = commentNodeTypes.mapNotNull {
-            val match = Regex("""(\w+)(?:\s*\((\w+)\))?""").find(it)
-            match?.let { m -> m.groupValues[1] to m.groupValues.getOrNull(2) }
-        }
-        return parentToChildTypes
-    }
-
-    private fun isCommentNode(node: TSNode, commentTypes: List<Pair<String, String?>>): Boolean {
-        for ((parentType, childType) in commentTypes) {
-            if (childType.isNullOrBlank() && node.type == parentType) {
-                return true
-            } else if (node.type == parentType && node.childCount == 1 && node.getChild(0).type == childType) {
-                return true
-            }
-        }
-        return false
-    }
-
-    private fun areAllChildrenInLineCommentNodes(node: TSNode, line: Int, commentTypes: List<Pair<String, String?>>): Boolean {
-        if (node.childCount == 0) return isCommentNode(node, commentTypes)
-
-        val lookAheadCursor = TSTreeCursor(node)
-        if (lookAheadCursor.gotoFirstChild()) {
-            do {
-                val currentNode = lookAheadCursor.currentNode()
-                require(
-                    currentNode.startPoint.row >= line
-                ) { "Malformed tree detected, child node start line comes before parent node start like!" }
-                if (currentNode.startPoint.row > line) return true
-                if (!isCommentNode(currentNode, commentTypes)) return false
-            } while (lookAheadCursor.gotoNextSibling())
-        }
-        return true
-    }
-}
+    queryProvider = PythonNodeTypes()
+)

analysis/analysers/parsers/UnifiedParser/src/main/kotlin/de/maibornwolff/codecharta/analysers/parsers/unified/metricnodetypes/MetricNodeTypes.kt

@@ -21,6 +21,8 @@ class TreeNodeTypes(
 
 class NestedNodeType(
     val baseNodeType: String,
-    val childNodeFieldName: String?,
+    val childNodeFieldName: String? = null,
+    val childNodeCount: Int? = null,
+    val childNodePosition: Int? = null,
     val childNodeTypes: Set<String>
 )

analysis/analysers/parsers/UnifiedParser/src/main/kotlin/de/maibornwolff/codecharta/analysers/parsers/unified/metricnodetypes/PythonNodeTypes.kt

@@ -0,0 +1,43 @@
+package de.maibornwolff.codecharta.analysers.parsers.unified.metricnodetypes
+
+class PythonNodeTypes : MetricNodeTypes {
+    override val complexityNodeTypes = TreeNodeTypes(
+        simpleNodeTypes = setOf(
+            // if
+            "if_statement",
+            "elif_clause",
+            "if_clause",
+            // loop
+            "for_statement",
+            "while_statement",
+            "for_in_clause",
+            // conditional
+            "conditional_expression",
+            "list",
+            // logical binary
+            "boolean_operator",
+            // case label
+            "case_pattern",
+            // catch block
+            "except_clause",
+            // function
+            "function_definition",
+            "lambda"
+        )
+    )
+
+    // in python unassigned strings are used as block comments, meaning an expression that only has string as a child
+    override val commentLineNodeTypes = TreeNodeTypes(
+        simpleNodeTypes = setOf(
+            "comment"
+        ),
+        nestedNodeTypes = setOf(
+            NestedNodeType(
+                baseNodeType = "expression_statement",
+                childNodeCount = 1,
+                childNodePosition = 0,
+                childNodeTypes = setOf("string")
+            )
+        )
+    )
+}