Merge pull request #4 from dpaz/origin/master

Add cyclomatic complexity tool

Author: smola

Diff for: cmd/bblfsh-tools/cyclomatic.go

@@ -0,0 +1,11 @@
+package main
+
+import "github.com/bblfsh/tools"
+
+type CyclomaticComp struct {
+	Common
+}
+
+func (c *CyclomaticComp) Execute(args []string) error {
+	return c.execute(args, tools.CyclomaticComplexity{})
+}

Diff for: cmd/bblfsh-tools/main.go

@@ -15,6 +15,7 @@ func main() {
 	parser := flags.NewNamedParser("bblfsh-tools", flags.Default)
 	parser.AddCommand("dummy", "", "Run dummy tool", &Dummy{})
 	parser.AddCommand("tokenizer", "", "Run tokenizer tool", &Tokenizer{})
+	parser.AddCommand("cyclomatic", "", "Run cyclomatic complexity tool", &CyclomaticComp{})
 
 	if _, err := parser.Parse(); err != nil {
 		if flagsErr, ok := err.(*flags.Error); ok {

Diff for: cyclomatic.go

@@ -0,0 +1,78 @@
+package tools
+
+import (
+	"fmt"
+
+	"github.com/bblfsh/sdk/uast"
+)
+
+// CyclomaticComplexity returns the cyclomatic complexity for the node. The cyclomatic complexity
+// is a quantitative measure of the number of linearly independent paths through a program's source code.
+// It was developed by Thomas J. McCabe, Sr. in 1976. For a formal description see:
+// https://en.wikipedia.org/wiki/Cyclomatic_complexity
+// And the original paper: http://www.literateprogramming.com/mccabe.pdf
+
+// This implementation uses PMD implementation as reference and uses the method of
+// counting one + one of the following UAST Roles if present on any children:
+// If | SwitchCase |  For[Each] | [Do]While | TryCatch | Continue | OpBoolean* | Goto
+// Important: since some languages allow for code defined
+// outside function definitions, this won't check that the Node has the role FunctionDeclarationRole
+// so the user should check that if the intended use is calculating the complexity of a function/method.
+// If the children contain more than one function definitions, the value will not be averaged between
+// the total number of function declarations but given as a total.
+//
+// Some practical implementations counting tokens in the code. They sometimes differ; for example
+// some of them count the switch "default" as an incrementor, some consider all return values minus the
+// last, some of them consider "else" (which is wrong IMHO, but not for elifs, remember than the IfElse
+// token in the UAST is really an Else not an "else if", elseifs would have a children If token), some
+// consider throw and finally while others only the catch, etc.
+//
+// Examples:
+// PMD reference implementation: http://pmd.sourceforge.net/pmd-4.3.0/xref/net/sourceforge/pmd/rules/CyclomaticComplexity.html
+// GMetrics: http://gmetrics.sourceforge.net/gmetrics-CyclomaticComplexityMetric.html
+// Go: https://github.com/fzipp/gocyclo/blob/master/gocyclo.go#L214
+// SonarQube (include rules for many languages): https://docs.sonarqube.org/display/SONAR/Metrics+-+Complexity
+//
+// IMPORTANT DISCLAIMER: McCabe definition specifies clearly that boolean operations should increment the
+// count in 1 for every boolean element when the language if the language evaluates conditions in
+// short-circuit.  Unfortunately in the current version of the UAST we don't specify these language invariants
+// and also we still haven't defined how we are going to represent the boolean expressions (which also would
+// need a tree transformation process in the pipeline that we lack) so lacking a better way of detecting for
+// all  languages what symbols or literals are part of a boolean expression we count the boolean operators
+// themselves which should work for short-circuit infix languages but not prefix or infix languages that can
+// evaluate more than two items with a single operator.  (FIXME when both things are solved in the UAST
+// definition and the SDK).
+
+type CyclomaticComplexity struct{}
+
+func (cc CyclomaticComplexity) Exec(n *uast.Node) error {
+	result := cyclomaticComplexity(n)
+	fmt.Println("Cyclomatic Complexity = ", result)
+	return nil
+}
+
+func cyclomaticComplexity(n *uast.Node) int {
+	complexity := 1
+
+	iter := uast.NewOrderPathIter(uast.NewPath(n))
+
+	for {
+		p := iter.Next()
+		if p.IsEmpty() {
+			break
+		}
+		n := p.Node()
+		for _, r := range n.Roles {
+			if addsComplexity(r) {
+				complexity++
+			}
+		}
+	}
+	return complexity
+}
+
+func addsComplexity(r uast.Role) bool {
+	return r == uast.If || r == uast.SwitchCase || r == uast.For || r == uast.ForEach ||
+		r == uast.DoWhile || r == uast.While || r == uast.TryCatch || r == uast.Continue ||
+		r == uast.OpBooleanAnd || r == uast.OpBooleanOr || r == uast.OpBooleanXor
+}

Diff for: cyclomatic_test.go

@@ -0,0 +1,32 @@
+package tools
+
+import (
+	"testing"
+
+	"github.com/bblfsh/sdk/uast"
+	"github.com/stretchr/testify/require"
+)
+
+func TestCyclomaticComplexity(t *testing.T) {
+	require := require.New(t)
+	n := &uast.Node{InternalType: "module",
+		Children: []*uast.Node{
+			{InternalType: "root"}, // 1 (initial)
+			// Prefix is the default so it doesnt need any role
+			{InternalType: "if1", Roles: []uast.Role{uast.If}, Children: []*uast.Node{ // 2 (If)
+				{InternalType: "if1else1", Roles: []uast.Role{uast.IfElse}, Children: []*uast.Node{ // 0
+					{InternalType: "if1else1foreach", Roles: []uast.Role{uast.ForEach}, Children: []*uast.Node{ // 3 (ForEach)
+						{InternalType: "foreach_child1"},                                             // 0
+						{InternalType: "foreach_child2_continue", Roles: []uast.Role{uast.Continue}}, // 4 (Continue)
+					}},
+					{InternalType: "if1else1if", Roles: []uast.Role{uast.If}, Children: []*uast.Node{ // 5 (If)
+						{InternalType: "elseif_child1"},                                // 0
+						{InternalType: "opAnd", Roles: []uast.Role{uast.OpBooleanAnd}}, // 6 (OpBooleanAnd)
+						{InternalType: "elseif_child2"},                                // 0
+					}},
+				}},
+				{InternalType: "break", Roles: []uast.Role{uast.Break}},
+			},
+			}}}
+	require.Equal(cyclomaticComplexity(n), 6)
+}

Diff for: glide.lock

@@ -10,3 +10,9 @@ import:
   version: v1.2.0
 - package: google.golang.org/grpc
   version: v1.3.0
+- package: srcd.works/go-errors.v0
+testImport:
+- package: github.com/stretchr/testify
+  version: v1.1.4
+  subpackages:
+  - require