fix: clean up

Author: offgriddev

README.md

@@ -0,0 +1,17 @@
+# Cyclomatic JS
+
+Cyclomatic Complexity was developed by a Computer Scientist at IBM named Thomas McCabe in an article called ["A Complexity Measurement"](https://ieeexplore.ieee.org/document/1702388). The approach uses Graph Theory to creates a representation of the number of linear paths possible through the execution of an algorithm. It will produce a simple integer value as an assessment. For example, the following code has an objective Complexity of 2:
+
+```javascript
+function main(a) {
+  if (a > 0) {
+    return "is positive"
+  }
+
+  return "is negative"
+}
+```
+
+As code grows, and I'm sure we've all seen it, algorithms can take on a life of their own and grow to contain numerous linear paths that all have to be maintained and amount to the cognitive overhead of a given algorithm. 
+
+This library provides any JS library the ability to analyze the Cyclomatic Complexity of their functions with a dependency solely on the [abstract-syntax-tree](https://www.npmjs.com/package/abstract-syntax-tree)

default-export-example.js

@@ -1,6 +1,6 @@
 {
   "name": "forecast-action-js",
-  "version": "1.0.0",
+  "version": "0.0.0",
   "main": "index.js",
   "type": "module",
   "license": "MIT",

example.cjs

@@ -55,9 +55,7 @@ const typesAddingComplexity = [
   "ForInStatement",
   "ForOfStatement",
   "ForStatement",
-  "SwitchStatement",
   "BinaryExpression",
-  //  "SwitchCase",
   "WhileStatement",
   "ConditionalExpression",
 ];
@@ -67,6 +65,10 @@ function increasesComplexity(node) {
     return [true, 1];
   }
 
+  if (node.type === "SwitchCase" && node.consequent?.length > 0) {
+    return [true, 1];
+  }
+
   if (
     node.type === "LogicalExpression" &&
     (node.operator === "||" || node.operator === "&&" || node.operator === "??")
@@ -82,10 +84,11 @@ const resolveBody = {
   TryStatement: (node) => [node?.block?.body, node.handler.body.body],
   TryStatementHandler: (node) => [],
   LogicalExpression: (node) => [[node.left], [node.right]],
-  ForStatement: (node) => [],
-  ForOfStatement: (node) => [],
-  ForInStatement: (node) => [],
-  SwitchStatement: (node) => [],
+  ForStatement: (node) => [node.body],
+  ForOfStatement: (node) => [node.body],
+  ForInStatement: (node) => [node.body],
+  SwitchStatement: (node) => [node.cases],
+  SwitchCase: (node) => [node.body],
   WhileStatement: (node) => [],
   BinaryExpression: (node) => [],
   IfStatement: (node) => [
@@ -110,15 +113,14 @@ function determineLogicalComplexity(bodyInput) {
     for (const node of body) {
       if (node.type === "ExportNamedDeclaration") {
         complexity = 1; // reset clock on each function
-        console.log(node);
-        console.log(`export name: ${node.id.lk}`);
         if (node.declaration.type === "FunctionDeclaration") {
           processNodes([node.declaration.body]);
         } else {
           findDeclarations(node.declaration);
         }
       }
       const resolvedBody = resolveBody[node.type];
+      console.log(node)
       if (!resolvedBody) continue;
       const [shouldIncrease] = increasesComplexity(node);
       if (shouldIncrease) {
@@ -149,46 +151,14 @@ function determineLogicalComplexity(bodyInput) {
     }
   }
   processNodes(bodyInput);
-  // if (node.type === "SwitchCase" || node.type === "SwitchStatement") {
-  //   console.log(JSON.stringify(node, undefined, 2));
-  // }
-
-  // if (node.handler?.type === "CatchClause") {
-  //   complexity++;
-  //   determineLogicalComplexity(node.handler.body.body, complexity);
-  // }
-
-  // if (node.type === "TryStatement") {
-  //   determineLogicalComplexity(node.block.body, complexity);
-  //   determineLogicalComplexity([node.handler?.body?.body]);
-  // }
-
-  // if (node.type === "LogicalExpression") {
-  //   determineLogicalComplexity([node.left], complexity);
-  //   determineLogicalComplexity([node.right], complexity);
-
-  //   if (node.operator === "||" || node.operator === "&&") {
-  //     complexity++;
-  //   }
-  // }
 
-  // if (node.type === "IfStatement") {
-  //   determineLogicalComplexity([node.test], complexity);
-  //   // consequent and alternate are BlockStatement nodes
-  //   determineLogicalComplexity(node.consequent.body, complexity);
-  //   if (node?.alternate?.body) {
-  //     complexity++;
-  //     determineLogicalComplexity(node.alternate.body, complexity);
-  //   }
-  // }
   return complexity;
 }
 
 function calculateComplexity(tree) {
   const complexity = determineLogicalComplexity(tree.body);
   console.log(complexity);
 }
-console.log(process.argv[2]);
 const file = await readFile(process.argv[2], "utf-8");
 const tree = ast.parse(file);
 calculateComplexity(tree);