Fix code cleanup

Author: Bassem Dghaidi

index.js

@@ -1,74 +1,108 @@
+/**
+ * Compares a set of match rules contained with an object to determine if
+ * the latter conforms to the matching rules
+ *
+ * @param {*} payload Object to test
+ * @param {*} pattern Object containing the matching rules
+ * @param {*} callback Function to call when the traversal and matching is complete
+ */
 const match = (payload, pattern, callback) => {
-    let result = { match: true, total: 0, matches: {}, groups: {}};
-    let node = result.matches;
+  const result = { match: true, total: 0, matches: {}, groups: {} }
+  const node = result.matches
 
-    const tester = (payload, pattern, current_node) => {
-
-        Object.entries(pattern).forEach(([key, value]) => {
-            if(!(key in payload)){
-                result.match = false;
-                return;
-            }
-
-            if(value instanceof RegExp){
-                const matcher = payload[key].match(value) || [];
-                if (matcher.length > 0) {
-                    result.groups =  {...result.groups, ...matcher.groups};
-                    current_node[key] = payload[key];
-                    result.total += 1;
-                } else {
-                    result.match = false;
-                }
-            } else if (value instanceof Array) {
-                current_node[key] = [];
-                value.forEach((element, index) => {
-                    if(element instanceof RegExp){
-                        const matcher = payload[key][index].match(element) || [];
-                        if (matcher.length > 0) {
-                            result.groups = { ...result.groups, ...matcher.groups};
-                            current_node[key] = payload[key];
-                            result.total += 1;
-                        } else {
-                            result.match = false;
-                        }
-                    } else if (element instanceof Object) {
-                        current_node[key][index] = {};
-                        tester(payload[key][index], element, current_node[key][index]);
-                    } else if (payload[key].includes(element)) {
-                        current_node[key][index] = element;
-                        result.total += 1;
-                    } else {
-                        result.match = false;
-                    }
-                });
-            } else if (value instanceof Function) {
-                if (!value(payload[key])){
-                    result.match = false;
-                } else {
-                    current_node[key] = payload[key];
-                    result.total += 1;
-                }
-            } else if (value instanceof Object) {
-                current_node[key] = {};
-                tester(payload[key], value, current_node[key]);
+  /**
+   * Recursive functions that will traverse the tree
+   * @param {*} payload Object to test
+   * @param {*} pattern Object containing the matching rules
+   * @param {*} currentNode Contains the nested objects
+   */
+  const tester = (payload, pattern, currentNode) => {
+    /**
+     * Loop over the elements of the testing object
+     */
+    Object.entries(pattern).forEach(([key, value]) => {
+      if (!(key in payload)) {
+        result.match = false
+        return
+      }
+      /**
+       * Level 1 depth RegExp handling
+       * executes a regular match then concatenates the matches
+       * with the result object
+       */
+      if (value instanceof RegExp) {
+        const matcher = payload[key].match(value) || []
+        if (matcher.length > 0) {
+          result.groups = { ...result.groups, ...matcher.groups }
+          currentNode[key] = payload[key]
+          result.total += 1
+        } else {
+          result.match = false
+        }
+      /**
+       * Level 1 depth array handling
+       */
+      } else if (value instanceof Array) {
+        currentNode[key] = []
+        value.forEach((element, index) => {
+          /**
+           * Level N depth RegExp handling
+           */
+          if (element instanceof RegExp) {
+            const matcher = payload[key][index].match(element) || []
+            if (matcher.length > 0) {
+              result.groups = { ...result.groups, ...matcher.groups }
+              currentNode[key] = payload[key]
+              result.total += 1
             } else {
-                if (payload[key] != value){
-                    result.match = false;
-                } else {
-                    current_node[key] = payload[key];
-                    result.total += 1;
-                }
+              result.match = false
             }
+          /**
+           * Level N depth Object and Array handling
+           */
+          } else if (element instanceof Object) {
+            currentNode[key][index] = {}
+            tester(payload[key][index], element, currentNode[key][index])
+          } else if (payload[key].includes(element)) {
+            currentNode[key][index] = element
+            result.total += 1
+          } else {
+            result.match = false
+          }
         })
-    }
+      /**
+       * Level 1 depth tester functions handling
+       */
+      } else if (value instanceof Function) {
+        if (!value(payload[key])) {
+          result.match = false
+        } else {
+          currentNode[key] = payload[key]
+          result.total += 1
+        }
+      } else if (value instanceof Object) {
+        currentNode[key] = {}
+        tester(payload[key], value, currentNode[key])
+      } else {
+        if (payload[key] !== value) {
+          result.match = false
+        } else {
+          currentNode[key] = payload[key]
+          result.total += 1
+        }
+      }
+    })
+  }
 
-    tester(payload, pattern, node);
+  // Invoke the tester method - execution starts here
+  tester(payload, pattern, node)
 
-    if(callback && result.match){
-        callback(result);
-    }
+  // Invoke callback
+  if (callback && result.match) {
+    callback(result)
+  }
 
-    return result;
+  return result
 }
 
-module.exports = match;
+module.exports = match