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.

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.

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.

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.

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

1. Run the program and print all the tokens in an ast.

      npm install
      node analysis.js
   

2. Do a simple calculation

   • ParameterCount: The number of parameters for functions
   • PackageComplexity: The number of imports used by code.

3. Statements inside a function.

   • SimpleCyclomaticComplexity: The number of if statements/loops + 1. For live example of a code complexity calculator, see jscomplexity.

4. 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.