feat: adding new probes to improve short identifiers detection

src/Analysis.js

@@ -110,7 +110,8 @@ export default class Analysis {
     }
 
     const identifiersLengthArr = this.identifiersName
-      .filter((value) => value.type !== "property" && typeof value.name === "string").map((value) => value.name.length);
+      .filter((value) => value.type !== "property" && typeof value.name === "string")
+      .map((value) => value.name.length);
 
     const [idsLengthAvg, stringScore] = [sum(identifiersLengthArr), sum(this.literalScores)];
     if (!isMinified && identifiersLengthArr.length > 5 && idsLengthAvg <= 1.5) {

src/probes/index.js

@@ -13,6 +13,8 @@ import isAssignmentExpression from "./isAssignmentExpression.js";
 import isObjectExpression from "./isObjectExpression.js";
 import isUnaryExpression from "./isUnaryExpression.js";
 import isWeakCrypto from "./isWeakCrypto.js";
+import isClassDeclaration from "./isClassDeclaration.js";
+import isMethodDefinition from "./isMethodDefinition.js";
 
 // CONSTANTS
 const kListOfProbes = [
@@ -29,7 +31,9 @@ const kListOfProbes = [
   isArrayExpression,
   isFunctionDeclaration,
   isUnaryExpression,
-  isWeakCrypto
+  isWeakCrypto,
+  isClassDeclaration,
+  isMethodDefinition
 ];
 
 const kSymBreak = Symbol.for("breakWalk");

src/probes/isClassDeclaration.js

@@ -0,0 +1,25 @@
+// Import Internal Dependencies
+import { extractNode } from "../utils.js";
+
+// CONSTANTS
+const kIdExtractor = extractNode("Identifier");
+
+function validateNode(node) {
+  return [
+    node.type === "ClassDeclaration"
+  ];
+}
+
+function main(node, options) {
+  const { analysis } = options;
+
+  kIdExtractor(
+    ({ name }) => analysis.identifiersName.push({ name, type: "class" }),
+    [node.id, node.superClass]
+  );
+}
+
+export default {
+  name: "isClassDeclaration",
+  validateNode, main, breakOnMatch: false
+};

src/probes/isMethodDefinition.js

@@ -0,0 +1,25 @@
+// Import Internal Dependencies
+import { extractNode } from "../utils.js";
+
+// CONSTANTS
+const kIdExtractor = extractNode("Identifier");
+
+function validateNode(node) {
+  return [
+    node.type === "MethodDefinition"
+  ];
+}
+
+function main(node, options) {
+  const { analysis } = options;
+
+  kIdExtractor(
+    ({ name }) => analysis.identifiersName.push({ name, type: "method" }),
+    [node.key]
+  );
+}
+
+export default {
+  name: "isMethodDefinition",
+  validateNode, main, breakOnMatch: false
+};

src/utils.js

@@ -30,3 +30,15 @@ export function toArrayLocation(location = rootLocation()) {
     [end.line || 0, end.column || 0]
   ];
 }
+
+export function extractNode(expectedType) {
+  return (callback, nodes) => {
+    const finalNodes = Array.isArray(nodes) ? nodes : [nodes];
+
+    for (const node of finalNodes) {
+      if (notNullOrUndefined(node) && node.type === expectedType) {
+        callback(node);
+      }
+    }
+  };
+}

test/probes/isClassDeclaration.spec.js

@@ -0,0 +1,43 @@
+// Require Internal Dependencies
+import { getSastAnalysis, parseScript } from "../utils/index.js";
+import isClassDeclaration from "../../src/probes/isClassDeclaration.js";
+
+// Require Third-party dependencies
+import test from "tape";
+
+test("should detect two identifiers (class name and superClass name A.K.A extends)", (tape) => {
+  const str = "class File extends Blob {}";
+  const ast = parseScript(str);
+  const analysis = getSastAnalysis(str, ast.body, isClassDeclaration);
+
+  tape.deepEqual(analysis.identifiersName, [
+    { name: "File", type: "class" },
+    { name: "Blob", type: "class" }
+  ]);
+
+  tape.end();
+});
+
+test("should detect one identifier because there is no superClass (extension)", (tape) => {
+  const str = "class File {}";
+  const ast = parseScript(str);
+  const analysis = getSastAnalysis(str, ast.body, isClassDeclaration);
+
+  tape.deepEqual(analysis.identifiersName, [
+    { name: "File", type: "class" }
+  ]);
+
+  tape.end();
+});
+
+test("should detect one identifier because superClass is not an Identifier but a CallExpression", (tape) => {
+  const str = "class File extends (foo()) {}";
+  const ast = parseScript(str);
+  const analysis = getSastAnalysis(str, ast.body, isClassDeclaration);
+
+  tape.deepEqual(analysis.identifiersName, [
+    { name: "File", type: "class" }
+  ]);
+
+  tape.end();
+});

test/probes/isMethodDefinition.spec.js

@@ -0,0 +1,38 @@
+// Require Internal Dependencies
+import { getSastAnalysis, parseScript } from "../utils/index.js";
+import isMethodDefinition from "../../src/probes/isMethodDefinition.js";
+
+// Require Third-party dependencies
+import test from "tape";
+
+test("should detect two identifiers (constructor and one method definition)", (tape) => {
+  const str = `class File {
+    constructor() {}
+    foo() {}
+  }`;
+  const ast = parseScript(str);
+  const analysis = getSastAnalysis(str, ast.body, isMethodDefinition);
+
+  tape.deepEqual(analysis.identifiersName, [
+    { name: "constructor", type: "method" },
+    { name: "foo", type: "method" }
+  ]);
+
+  tape.end();
+});
+
+test("should detect two identifiers (getter and setter)", (tape) => {
+  const str = `class File {
+    get foo() {}
+    set bar(value) {}
+  }`;
+  const ast = parseScript(str);
+  const analysis = getSastAnalysis(str, ast.body, isMethodDefinition);
+
+  tape.deepEqual(analysis.identifiersName, [
+    { name: "foo", type: "method" },
+    { name: "bar", type: "method" }
+  ]);
+
+  tape.end();
+});