Merge pull request #2 from goonnors/master

Calculate CC and compound names

Author: yegor256

.gitignore

@@ -13,3 +13,4 @@ article.pdf
 *.bbl
 *.blg
 *.m
+__pycache__/

Makefile

@@ -20,10 +20,12 @@
 # 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:
 	bundle update
+	python3 -m pip install -r requirements.txt
 
 clean:
 	rm -rf *.tex
@@ -49,9 +51,13 @@ clone:
 uncalc:
 	rm -rf metrics
 
+calc_test:
+	python3 computation/calc_unit_test.py
+	python3 computation/calc_integration_test.py
+
 calc:
 	mkdir -p metrics
-	for r in $$(find clones/ -type directory -depth 2); do \
+	for r in $$(find clones/ -type d -maxdepth 2 ); do \
 	  d="metrics/$${r/clones\/\//}"; \
 		if [ -e "$${d}" ]; then \
 		  echo "Dir with metrics already here: $${d}"; \
@@ -60,9 +66,11 @@ calc:
 		  for f in $$(find $${r} -name '*.java'); do \
 		  	m="metrics/$${f/clones\/\//}.m"; \
 		  	mkdir -p $$(dirname "$${m}"); \
-				echo '1,1' > "$${m}"; \
+				if [ ! -e "$${m}" ]; then \
+					python3 computation/calc.py "$${f}" > "$${m}"; \
+				fi \
 			done; \
-		  echo "$$(find $${d} -type file | wc -l) Java classes analyzed into $${d}"; \
+		  echo "$$(find $${d} -type f | wc -l) Java classes analyzed into $${d}"; \
 		fi; \
 	done
 

computation/calc.py

@@ -0,0 +1,77 @@
+# The MIT License (MIT)
+#
+# Copyright (c) 2020 Yegor Bugayenko
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# 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 == '||'):
+            count = 1
+    elif(isinstance(node, (
+        tree.ForStatement,
+        tree.IfStatement,
+        tree.WhileStatement,
+        tree.DoStatement,
+        tree.TernaryExpression
+    ))):
+        count = 1
+    elif(isinstance(node, tree.SwitchStatementCase)):
+        count = len(node.case)
+    elif(isinstance(node, tree.TryStatement)):
+        count = len(node.catches)
+    return count
+
+"""Check the name for compound inside the methods (i.e. for local variables)
+
+: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)

computation/calc_integration_test.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(os.path.join(fileDir, '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) + ', received ' + str(receivedNames))
+        except Exception as e:
+            sys.exit(str(e) + ': ' + java)
+
+for java in glob(os.path.join(fileDir, '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) + ', received ' + str(receivedCC))
+
+            print('.', end='', flush=True),
+        except Exception as e:
+            sys.exit(str(e) + ': ' + java)
+
+print('\nOK')
+

computation/calc_unit_test.py

@@ -0,0 +1,131 @@
+import os
+import sys
+import unittest
+import javalang
+
+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
+
+class TestCalc(unittest.TestCase):
+    def test_for_statement_count(self):
+        code = """
+            for (int i = 0; i < amounts.length; i++) {
+                result += amounts[i];
+            }
+        """
+        node = self.statement(code)
+        self.assertEqual(branches(node), 1)
+
+    def test_branch_not_count(self):
+        code = "nextKey = new BlockKey(serialNo, System.currentTimeMillis() + 3.0);"
+        node = self.expression(code)
+        self.assertEqual(branches(node), 0)
+
+    def test_if_statement_count(self):
+        code = """
+            if (itr == '\r') {
+                int status = 1;
+            }
+        """
+        node = self.statement(code)
+        self.assertEqual(branches(node), 1)
+
+    def test_while_statement_count(self):
+        code = """
+            while (i < 5) {
+                System.out.println(i);
+                i++;
+            }
+        """
+        node = self.statement(code)
+        self.assertEqual(branches(node), 1)
+
+    def test_do_statement_count(self):
+        code = """
+            do
+                a-- ;
+            while ( a );
+        """
+        node = self.statement(code)
+        self.assertEqual(branches(node), 1)
+
+    def test_switch_statement_count(self):
+        code = """
+            switch ( a )
+            {
+                case 1:
+                return ;
+            }
+        """
+        node = self.statement(code)
+        self.assertEqual(branches(node.cases[0]), 1)
+
+    def test_logic_and_operator_count(self):
+        code = 'if ( a && b ) {}'
+        ifNode = self.statement(code)
+        self.assertEqual(branches(ifNode.children[1]), 1)
+
+    def test_logic_or_operator_count(self):
+        code = 'if ( a || b ) {}'
+        ifNode = self.statement(code)
+        self.assertEqual(branches(ifNode.children[1]), 1)
+
+    def test_logic_operator_not_count(self):
+        code = 'if ( a > b ) {}'
+        ifNode = self.statement(code)
+        self.assertEqual(branches(ifNode.children[1]), 0)
+
+    def test_ternary_operator(self):
+        code = 'value == "uppercase" ? "JOHN" : "john";'
+        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()
+
+    def statement(self, code):
+        return self.parser(code).parse_statement()
+
+    def parser(self, code):
+        return javalang.parser.Parser(
+            javalang.tokenizer.tokenize(code)
+        )
+
+if __name__ == '__main__':
+    unittest.main()

computation/java/cc/Cheating.java

@@ -0,0 +1,10 @@
+class Cheating {
+  public int cc = 1;
+
+  public boolean foo(Account account, int amount) {
+    boolean result = true;
+    result &= account.getBalance() >= amount;
+    result &= !account.isLocked();
+    return result;
+  }
+}

computation/java/cc/DoWhileStatement.java

@@ -0,0 +1,9 @@
+class DoWhileStatement {
+  public int cc = 2;
+
+  void foo( int a ) {
+    do
+      a-- ;
+    while ( a );
+  }
+}

computation/java/cc/ElseIfStatement.java

@@ -0,0 +1,13 @@
+class ElseIfStatement {
+  public int cc = 3;
+
+  public boolean checkWithdrawal() {
+    boolean result = false;
+    if (account.getBalance() >= amount) {
+      result = true;
+    } else if (account.isLocked()) {
+      result = false;
+    }
+    return result;
+  }
+}

computation/java/cc/ForStatement.java

@@ -0,0 +1,11 @@
+public class ForStatement {
+  public int cc = 2;
+
+  public int sum(int[] amounts) {
+    int result = 0;
+    for (int i = 0; i < amounts.length; i++) {
+      result += amounts[i];
+    }
+    return result;
+  }
+}

computation/java/cc/IfStatement.java

@@ -0,0 +1,14 @@
+class IfStatement {
+  public int cc = 3;
+
+  public boolean checkWithdrawal() {
+    boolean result = false;
+    if (account.getBalance() >= amount) {
+      result = true;
+    }
+    if (account.isLocked()) {
+      result = false;
+    }
+    return result;
+  }
+}