Complexity

In this workshop, you’ll be implementing simple algorithms for checking basic properties of code complexity.

Two design patterns are of importance here:

A Builder pattern, which is used to build up state and then finally emit.
A Visitor pattern, which is used to abstract the process of visiting a data structure such as abstract syntax tree (AST). The only input you have to provide is what action to perform at each node.

Esprima

Instead of building a scanner and parser by hand like we demonstrated previously. We will use an existing library, esprima, to parse code and create a static analyzer for basic code complexity metrics.

Video

If you have not already watched this video, you can get more background about Esprima here: Watch 5:00-14:30,28:00-34:00.

Interactive AST

Use the demo page to see what a code snippet looks like, in order to help you navigate the data structure.

For example, the following snippet:

function functionName( node )
{
	if( node.id )
	{
		return node.id.name;
	}
	return "anon function @" + node.loc.start.line;
}

Will appear as following, and:

Can be interacted with here.

Workshop

The repository contains a stub that parses a javascript file and visits each function.

Run the program and print all the tokens in an ast.
```
   npm install
   node analysis.js
```
Do a simple calculation
- ParameterCount: The number of parameters for functions
- PackageComplexity: The number of imports used by code.
Statements inside a function.
- SimpleCyclomaticComplexity: The number of if statements/loops + 1. For live example of a code complexity calculator, see jscomplexity.
Using multiple visitors.
- MaxConditions: The max number of conditions in one statement.
- MaxNestingDepth: The max depth of scopes (nested ifs, loops, etc) – this one is hard, only expect a few to get to do finish this one.