check compound names

Author: Albert Allagulov

Makefile

@@ -20,6 +20,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+SHELL := /bin/bash
 all: install search clone calc summary draw article
 
 install:
@@ -62,9 +63,8 @@ calc:
 		  	m="metrics/$${f/clones\/\//}.m"; \
 		  	mkdir -p $$(dirname "$${m}"); \
 				if [ ! -e "$${m}" ]; then \
-					python3 calc.py "$${f}"; \
+					python3 computation/calc.py "$${f}" > "$${m}"; \
 				fi \
-				# echo '1,1' > "$${m}"; \
 			done; \
 		  echo "$$(find $${d} -type f | wc -l) Java classes analyzed into $${d}"; \
 		fi; \

calc/calc_integration_test.py

@@ -21,34 +21,57 @@
 # SOFTWARE.
 
 import sys
+import re
 from javalang import tree, parse
 
+"""Determines the number of branches for a node
+according to the Extended Cyclomatic Complexity metric.
+Binary operations (&&, ||) and each case statement are taken into account.
+
+:param node: class provided by the parser and targeted to Java 8 spec
+:returns: number
+"""
 def branches(node):
+    count = 0
     if (isinstance(node, tree.BinaryOperation)):
         if(node.operator == '&&' or node.operator == '||'):
-            return 1
-
-    if(isinstance(node, (
+            count = 1
+    elif(isinstance(node, (
         tree.ForStatement,
         tree.IfStatement,
         tree.WhileStatement,
         tree.DoStatement,
         tree.TernaryExpression
     ))):
-        return 1
+        count = 1
+    elif(isinstance(node, tree.SwitchStatementCase)):
+        count = len(node.case)
+    elif(isinstance(node, tree.TryStatement)):
+        count = len(node.catches)
+    return count
 
-    if(isinstance(node, tree.SwitchStatementCase)):
-        return len(node.case)
+"""Check the name for compound inside the methods (i.e. for local variables)
 
-    return 0
+:param node: class provided by the parser and targeted to Java 8 spec
+:returns: boolean
+"""
+def compound(node):
+    flag = False
+    if (isinstance(node, tree.LocalVariableDeclaration)):
+        name = node.declarators[0].name
+        flag = len(re.findall(r'(?:[a-z][A-Z]+)|(?:[_])', name)) != 0
+    return flag
 
 
 java = sys.argv[1]
 with open(java, encoding='utf-8') as f:
     try:
         cc = 1
+        names = 0
         ast = parse.parse(f.read())
         for path, node in ast:
             cc += branches(node)
+            names += int(compound(node))
+        print(str(cc) + ',' +  str(names))
     except Exception as e:
         sys.exit(str(e) + ': ' + java)

calc/calc.py renamed to computation/calc.py

@@ -0,0 +1,61 @@
+import os
+import sys
+import unittest
+import javalang
+from glob import glob
+import re
+
+try:
+    from unittest.mock import patch
+except ImportError:
+    from mock import patch
+
+fileDir = os.path.dirname(os.path.realpath('__file__'))
+testargs = ["", os.path.join(fileDir, 'java/cc/SwitchCaseStatement.java')]
+with patch.object(sys, 'argv', testargs):
+    from calc import branches, compound
+
+def cc(tree):
+    var = next(tree.filter(javalang.tree.VariableDeclarator))[1]
+    if (var.name != 'cc'):
+        raise ValueError('file not tested')
+    return int(var.initializer.value)
+
+def names(ast):
+    comment = next(ast.filter(javalang.tree.Documented))[1]
+    return int(re.search(r'[\d]+', comment.documentation).group(0))
+
+for java in glob('java/names/*.java'):
+    with open(java, encoding='utf-8') as f:
+        try:
+            ast = javalang.parse.parse(f.read())
+            receivedNames = 0
+            expectedNames = names(ast)
+
+            for path, node in ast:
+                receivedNames += compound(node)
+
+            if (receivedNames != expectedNames):
+                raise Exception('\nTest failed. Expected ' + str(expectedNames) + ', receivedNames ' + str(receivedNames))
+        except Exception as e:
+            sys.exit(str(e) + ': ' + java)
+
+for java in glob('java/cc/*.java'):
+    with open(java, encoding='utf-8') as f:
+        try:
+            ast = javalang.parse.parse(f.read())
+            receivedCC = 1
+            expectedCC = cc(ast)
+
+            for path, node in ast:
+                receivedCC += branches(node)
+
+            if (receivedCC != expectedCC):
+                raise Exception('\nTest failed. Expected ' + str(expectedCC) + ', receivedCC ' + str(receivedCC))
+
+            print('.', end='', flush=True),
+        except Exception as e:
+            sys.exit(str(e) + ': ' + java)
+
+print(' OK')
+

computation/calc_integration_test.py

@@ -11,7 +11,7 @@
 fileDir = os.path.dirname(os.path.realpath('__file__'))
 testargs = ["", os.path.join(fileDir, 'java/cc/SwitchCaseStatement.java')]
 with patch.object(sys, 'argv', testargs):
-    from calc import branches
+    from calc import branches, compound
 
 class TestCalc(unittest.TestCase):
     def test_for_statement_count(self):
@@ -87,6 +87,35 @@ def test_ternary_operator(self):
         node = self.expression(code);
         self.assertEqual(branches(node), 1)
 
+    def test_catch_statements(self):
+        code = """
+            try {
+                Throwable t = new Exception();
+                throw t;
+            } catch (RuntimeException e) {
+                System.err.println("catch RuntimeException");
+            } catch (Exception e) {
+                System.err.println("catch Exception");
+            } catch (Throwable e) {
+                System.err.println("catch Throwable");
+            }
+            System.err.println("next statement");
+        """
+        node = self.statement(code)
+        self.assertEqual(branches(node), 3)
+
+    def test_compound_with_camel_and_snake_cases(self):
+        for s in ['camelCase', 'CamelCase', 'camelCASE', 'snake_case', 'snake_CASE', 'SNAKE_CASE', 'SNAKE_case']:
+            code = "int %s = 0;" % (s)
+            node = self.parser(code).parse_local_variable_declaration_statement()
+            self.assertEqual(compound(node), 1)
+
+    def test_compound_without_camel_and_snake_cases(self):
+        for s in ['camelcase, CAMELCASE, Camelcase']:
+            code = "int %s = 0;" % (s)
+            node = self.parser(code).parse_local_variable_declaration_statement()
+            self.assertEqual(compound(node), 0)
+
     def expression(self, code):
         return self.parser(code).parse_expression()