fix JSDoc namings, fix spacing,

separate preprocessing functionality in stages,
change method of view, pure and constant removal,
start the algorithm to detect unbracketed singleton statements nesting
and calculate offset properly, remove unnecessary functions,
modifier removal result: https://www.diffchecker.com/IbYzRM8Y

lib/preprocessor.js

@@ -1,92 +1,109 @@
 const SolExplore = require('sol-explore');
 const SolidityParser = require('solidity-parser-sc');
 
-const crRegex = /[\r\n ]+$/g;
 /**
- * Splices enclosing brackets into `contract` around `expression`;
+ * Parses the AST tree to remove pure, constant and view modifiers
- * @param  {String} contract solidity source
+ * @param  {Object} ast      AST tree
- * @param  {Object} node     AST node to bracket
+ * @param  {String} contract solidity code
  * @return {String} contract
  */
-function blockWrap(contract, expression) {
+function removeViewPureConst(ast, contract) {
-  return contract.slice(0, expression.start) + '{' + contract.slice(expression.start, expression.end) + '}' + contract.slice(expression.end);
+  SolExplore.traverse(ast, {
-}
+    enter(node, parent) {
-
+      if (node.type === 'FunctionDeclaration' && node.modifiers) {
-
+        // We want to remove constant / pure / view from functions
-/**
+        for (let i = 0; i < node.modifiers.length; i++) {
- * Captures carriage returns at modifiers we'll remove. These need to be re-injected into the
+          if (['pure', 'constant', 'view'].indexOf(node.modifiers[i].name) > -1) {
- * source to keep line report alignments accurate.
+            contract = contract.slice(0, node.modifiers[i].start) +
- * @param  {String} contract solidity source
+              ' '.repeat(node.modifiers[i].end - node.modifiers[i].start) +
- * @param  {Object} modifier AST node
+              contract.slice(node.modifiers[i].end);
- * @return {String} whitespace around the modifier
+          }
- */
+        }
-function getModifierWhitespace(contract,  modifier){
+      }
-  const source = contract.slice(modifier.start, modifier.end);
+    },
-  const whitespace = source.match(crRegex) || [];
+  });
-  return whitespace.join('');
+  return contract;
 }
 
 /**
- * Locates unbracketed singleton statements attached to if, else, for and while statements
+ * Parses the AST tree to locate unbracketed singleton statements attached to if, else, for and while statements
- * and brackets them. Instrumenter needs to inject events at these locations and having
+ * and brackets them
- * them pre-bracketed simplifies the process. Each time a modification is made the contract
+ * @param  {Object} ast      AST tree product of SolidityParser
- * is passed back to the parser and re-walked because all the starts and ends get shifted.
- *
- * Also removes pure and view modifiers.
- *
  * @param  {String} contract solidity code
  * @return {String} contract
  */
-module.exports.run = function r(contract) {
+function bracketUnbStatements(ast, contract) {
-  let keepRunning = true;
+  const brkList = [];
-
-  while (keepRunning) {
-    try {
-      const ast = SolidityParser.parse(contract);
-      keepRunning = false;
   SolExplore.traverse(ast, {
     enter(node, parent) { // eslint-disable-line no-loop-func
       // If consequents
       if (node.type === 'IfStatement' && node.consequent.type !== 'BlockStatement') {
-            contract = blockWrap(contract, node.consequent);
+        brkList.push({
-            keepRunning = true;
+          start: node.consequent.start, end: node.consequent.end,
-            this.stopTraversal();
+        });
         // If alternates
       } else if (
         node.type === 'IfStatement' &&
         node.alternate &&
         node.alternate.type !== 'BlockStatement') {
-            contract = blockWrap(contract, node.alternate);
+        brkList.push({
-            keepRunning = true;
+          start: node.alternate.start, end: node.alternate.end,
-            this.stopTraversal();
+        });
         // Loops
       } else if (
         (node.type === 'ForStatement' || node.type === 'WhileStatement') &&
         node.body.type !== 'BlockStatement') {
-            contract = blockWrap(contract, node.body);
+        brkList.push({
-            keepRunning = true;
+          start: node.body.start, end: node.body.end,
-            this.stopTraversal();
+        });
-          } else if (node.type === 'FunctionDeclaration' && node.modifiers) {
-            // We want to remove constant / pure / view from functions
-            for (let i = 0; i < node.modifiers.length; i++) {
-              if (['pure', 'constant', 'view'].indexOf(node.modifiers[i].name) > -1) {
-                let whitespace = getModifierWhitespace(contract, node.modifiers[i]);
-
-                contract = contract.slice(0, node.modifiers[i].start) +
-                           whitespace +
-                           contract.slice(node.modifiers[i].end);
-
-                keepRunning = true;
-                this.stopTraversal();
       }
+    },
+  });
+  brkList.sort((a, b) => {
+    if (a.start < b.start) {
+      return -1;
     }
+    if (a.start > b.start) {
+      return 1;
     }
-        },
+    return 0;
   });
+  for (let i = 0; i < brkList.length; i++) {
+    let check = null;
+    if (i > 0 && i < brkList.length - 1) {
+      check =
+        brkList[i].end >= brkList[i + 1].end ||
+        brkList[i].end <= brkList[i - 1].end;
+      if (i > 1) {
+        check = check || brkList[i].end <= brkList[i - 2].end;
+      }
+    } else if (i === 0) {
+      check = brkList[i].end >= brkList[i + 1].end;
+    } else if (i === brkList.length - 1) {
+      check = brkList[i].end <= brkList[i - 1].end;
+    }
+    brkList[i].nested = check;
+  }
+  return contract;
+}
+
+/**
+ * Locates unbracketed singleton statements attached to if, else, for and while statements
+ * and brackets them. Instrumenter needs to inject events at these locations and having
+ * them pre-bracketed simplifies the process. The process is broken down to 3 stages:
+ *   1. Parse the contract to get the AST tree
+ *   2. Remove all the view, pure and constant modifiers
+ *   3. Bracket all related unbracketed singleton statements
+ * @param  {String} contract solidity code
+ * @return {String} contract
+ */
+module.exports.run = function r(contract) {
+  try {
+    const ast = SolidityParser.parse(contract);
+    contract = removeViewPureConst(ast, contract);
+    contract = bracketUnbStatements(ast, contract);
   } catch (err) {
     contract = err;
-      keepRunning = false;
-    }
   }
   return contract;
 };