Refine CCMetric

Author: rultor

aibolit/config.py

@@ -23,6 +23,7 @@
 from aibolit.metrics.NumberMethods.NumberMethods import NumberMethods as M8
 from aibolit.metrics.RFC.rfc import RFC as M9
 from aibolit.metrics.fanout.FanOut import FanOut as M10
+from aibolit.metrics.cc.main import CCMetric as M11
 from aibolit.patterns.array_as_argument.array_as_argument import ArrayAsArgument as P22
 from aibolit.patterns.assert_in_code.assert_in_code import AssertInCode as P1
 from aibolit.patterns.assign_null_finder.assign_null_finder import NullAssignment as P28
@@ -228,6 +229,7 @@ def get_patterns_config() -> PatternsConfig:
                 {'name': 'Number of methods', 'code': 'M8', 'make': M8},
                 {'name': 'Responce for class', 'code': 'M9', 'make': M9},
                 {'name': 'Fan out', 'code': 'M10', 'make': M10},
+                {'name': 'Cyclomatic Complexity', 'code': 'M11', 'make': M11},
             ],
             'target': {
 

aibolit/metrics/cc/README.md

@@ -1,17 +1,14 @@
-To run:
-1. Install java
-2. Install Maven `sudo apt install maven`
-3. Install Python 3.6 or higher
-4. Install dependencies: `pip3 install -r requirements.txt`
-5. Execute: `python3 run.py ../input/Complicated.java`, where:
-  * first parameter is path to current folder run.py
-  * second parameter is path to analyzed java file.
+# Cyclomatic Complexity metric for Java code analysis.
 
 Usage:
-```
-from main import CCMetric
-input = `myfile.java`
-showlog = True
-metric = CCMetric(input)
-print(metric.value(showlog))
+
+```python
+from aibolit.metrics.cc.main import CCMetric
+from aibolit.ast_framework import AST
+from aibolit.utils.ast_builder import build_ast
+
+ast = AST.build_from_javalang(build_ast('MyClass.java'))
+metric = CCMetric()
+complexity = metric.value(ast)
+print(f"Total cyclomatic complexity: {complexity}")
 ```

aibolit/metrics/cc/cyclical.xml

@@ -1,80 +1,72 @@
 # SPDX-FileCopyrightText: Copyright (c) 2019-2025 Aibolit
 # SPDX-License-Identifier: MIT
 
-import os
-import shutil
-import subprocess
-import tempfile
-import uuid
+from aibolit.ast_framework import AST, ASTNode, ASTNodeType
 
-from bs4 import BeautifulSoup
 
+class CCMetric:
+    """
+    Calculates cyclomatic complexity by counting
+    decision points in all methods and constructors:
 
-class CCMetric():
-    """Main Cyclical Complexity class."""
+    - Base complexity: 1 per method/constructor
+    - Decision points: if, while, for, do-while,
+                       switch cases, catch, throw,
+                       ternary, break, continue
+    - Boolean operators (&&, ||) add additional complexity paths
+    """
 
-    input = ''
+    def value(self, ast: AST) -> int:
+        return sum(
+            self._method_complexity(ast, node)
+            for node in ast.get_proxy_nodes(
+                ASTNodeType.METHOD_DECLARATION, ASTNodeType.CONSTRUCTOR_DECLARATION
+            )
+        )
 
-    def __init__(self, input):
-        self.input = input
+    def _method_complexity(self, ast: AST, method: ASTNode) -> int:
+        method_ast = ast.get_subtree(method)
+        return 1 + sum(self._node_complexity(ast, node) for node in method_ast.get_proxy_nodes())
 
-    def value(self, showoutput=False):
-        """Run Cyclical Complexity analaysis"""
+    def _node_complexity(self, ast: AST, node: ASTNode) -> int:
+        if node.node_type in _SIMPLE_NODES:
+            return 1
+        elif node.node_type in _CONDITION_NODES:
+            return self._condition_complexity(ast, node)
+        elif node.node_type == ASTNodeType.FOR_STATEMENT:
+            return self._for_statement_complexity(ast, node)
+        return 0
 
-        if len(self.input) == 0:
-            raise ValueError('Empty file for analysis')
-        try:
-            root = os.path.join(tempfile.gettempdir(), uuid.uuid4().hex)
-            dirName = os.path.join(root, 'src/main/java')
-            os.makedirs(dirName)
-            if os.path.isdir(self.input):
-                shutil.copytree(self.input, os.path.join(dirName, self.input))
-            elif os.path.isfile(self.input):
-                pos1 = self.input.rfind('/')
-                os.makedirs(dirName + '/' + self.input[0:pos1])
-                shutil.copyfile(self.input, os.path.join(dirName, self.input))
-            else:
-                raise Exception('File ' + self.input + ' does not exist')
-            tmppath = os.path.dirname(os.path.realpath(__file__))
-            shutil.copyfile(os.path.join(tmppath, 'pom.xml'), root + '/pom.xml')
-            shutil.copyfile(os.path.join(tmppath, 'cyclical.xml'), root + '/cyclical.xml')
-            if showoutput:
-                subprocess.run(['mvn', 'pmd:pmd'], cwd=root, check=False)
-            else:
-                subprocess.run(['mvn', 'pmd:pmd'], cwd=root,
-                               stdout=subprocess.DEVNULL,
-                               stderr=subprocess.DEVNULL, check=False)
-            if os.path.isfile(root + '/target/pmd.xml'):
-                res = self.__parseFile(root)
-                return res
-            raise Exception('File ' + self.input + ' analyze failed')
-        finally:
-            shutil.rmtree(root)
+    def _condition_complexity(self, ast: AST, node: ASTNode) -> int:
+        return 1 + self._expression_complexity(ast, node.condition)
 
-    def __parseFile(self, root):
-        result = {'data': [], 'errors': []}
-        content = []
-        with open(root + '/target/pmd.xml', 'r', encoding='utf-8') as file:
-            content = file.read()
-            soup = BeautifulSoup(content, 'lxml')
-            files = soup.find_all('file')
-            for file in files:
-                out = file.violation.string
-                name = file['name']
-                pos1 = name.find(root + '/src/main/java/')
-                pos1 = pos1 + len(root + '/src/main/java/')
-                name = name[pos1:]
-                pos1 = out.find('has a total cyclomatic complexity')
-                pos1 = out.find('of ', pos1)
-                pos1 = pos1 + 3
-                pos2 = out.find('(', pos1)
-                complexity = int(out[pos1:pos2 - 1])
-                result['data'].append({'file': name, 'complexity': complexity})
-            errors = soup.find_all('error')
-            for error in errors:
-                name = error['filename']
-                pos1 = name.find(root + '/src/main/java/')
-                pos1 = pos1 + len(root + '/src/main/java/')
-                name = name[pos1:]
-                raise Exception(error['msg'])
-        return result
+    def _for_statement_complexity(self, ast: AST, node: ASTNode) -> int:
+        if hasattr(node.control, 'condition'):
+            return self._condition_complexity(ast, node.control)
+        return 1
+
+    def _expression_complexity(self, ast: AST, expression: ASTNode | None) -> int:
+        if expression is None:
+            return 0
+        expression_ast = ast.get_subtree(expression)
+        return sum(
+            1
+            for node in expression_ast.get_proxy_nodes(ASTNodeType.BINARY_OPERATION)
+            if node.operator in ('&&', '||')
+        )
+
+
+_SIMPLE_NODES = (
+    ASTNodeType.BREAK_STATEMENT,
+    ASTNodeType.CATCH_CLAUSE,
+    ASTNodeType.CONTINUE_STATEMENT,
+    ASTNodeType.SWITCH_STATEMENT_CASE,
+    ASTNodeType.THROW_STATEMENT,
+)
+
+_CONDITION_NODES = (
+    ASTNodeType.IF_STATEMENT,
+    ASTNodeType.WHILE_STATEMENT,
+    ASTNodeType.DO_STATEMENT,
+    ASTNodeType.TERNARY_EXPRESSION,
+)