@dacely/toildefender 0.1.0

package/estest.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var assert = require("assert");
+
+var _ = require("lodash");
+
+const EXPRESSIONS = [
+    "Identifier"
+];
+
+const COMPOUND_STATEMENTS = [
+    "BlockStatement",
+    "WithStatement",
+    "IfStatement",
+    "SwitchStatement",
+    "TryStatement",
+    "WhileStatement",
+    "DoWhileStatement",
+    "ForStatement",
+    "ForInStatement"
+];
+
+exports.isNode = function (x) {
+    return x != null && typeof x.type == "string";
+};
+
+exports.isStatement = function (x) {
+    assert.ok(exports.isNode(x));
+    
+    return x.type == "Program" || _.endsWith(x.type, "Statement") || _.endsWith(x.type, "Declaration");
+};
+
+exports.isCompoundStatement = function (x) {
+    assert.ok(exports.isNode(x));
+    
+    return _.includes(COMPOUND_STATEMENTS.indexOf, x.type);
+};
+
+exports.isExpression = function (x) {
+    assert.ok(exports.isNode(x));
+    
+    return _.includes(EXPRESSIONS, x.type) || _.endsWith(x.type, "Expression");
+};
+
+exports.isFunction = function (x) {
+    assert.ok(exports.isNode(x));
+    
+    return _.startsWith(x.type, "Function");
+};

package/esutils.js

@@ -0,0 +1,107 @@
+"use strict";
+
+var assert = require("assert");
+
+var estest = require("./estest");
+var traverser = require("./traverser");
+
+module.exports = function (logger) {
+    
+    this.setParents = function (node) {
+        assert.ok(estest.isNode(node));
+        
+        traverser.visitChildrenEx(node, (child, key) => {
+            Object.defineProperty(child, "veilmark$parent", {
+                value: node,
+                configurable: true
+            });
+            return child;
+        });
+    };
+
+    this.setParentsRecursive = function (node) {
+        assert.ok(estest.isNode(node));
+        
+        traverser.visitChildrenEx(node, (child, key) => {
+            Object.defineProperty(child, "veilmark$parent", {
+                value: node,
+                configurable: true
+            });
+            this.setParentsRecursive(child);
+            return child;
+        });
+    };
+
+    this.insertIntoScope = function (scope, node, idx) {
+        assert.ok(estest.isNode(node));
+        
+        idx = idx || 0;
+
+        if (scope.block.body.type == "Program" || scope.block.body.type == "BlockStatement") {
+            scope.block.body.body.splice(idx, 0, node);
+            
+            Object.defineProperty(node, "veilmark$parent", {
+                value: scope.block.body,
+                configurable: true
+            });
+        } else if (scope.block.type == "Program" || scope.block.type == "BlockStatement") {
+            scope.block.body.splice(idx, 0, node);
+            
+            Object.defineProperty(node, "veilmark$parent", {
+                value: scope.block,
+                configurable: true
+            });
+        } else {
+            throw new Error("Cannot insert into scope.block of type " + scope.block.type);
+        }
+    };
+    
+    this.replaceNode = function (root, child, replacement) {
+        assert.ok(estest.isNode(root));
+        assert.ok(estest.isNode(child));
+        assert.ok(estest.isNode(replacement));
+        assert.equal(estest.isStatement(child), estest.isStatement(replacement), `Replacee ${child.type} is not of the same type as replacement ${replacement.type}`);
+        assert.equal(estest.isExpression(child), estest.isExpression(replacement), `Replacee ${child.type} is not of the same type as replacement ${replacement.type}`);
+        
+        var _this = this;
+        root = this.getParent(child) || root;
+        traverser.traverseEx(root, [], function (node, stack) {
+            if (node == child) {
+                this.abort();
+                Object.defineProperty(replacement, "veilmark$parent", {
+                    value: child.veilmark$parent,
+                    configurable: true
+                });
+                _this.setParents(replacement);
+                return replacement;
+            } else {
+                return node;
+            }
+        });
+    };
+
+    this.getParent = function (node) {
+        assert.ok(estest.isNode(node));
+        
+        var parent = node.veilmark$parent;
+        var legit = false;
+        if (parent) {
+            traverser.visitChildren(parent, child => {
+                if (node == child) {
+                    legit = true;
+                }
+                return child;
+            });
+        }
+        if (legit) {
+            return parent;
+        } else if (parent) {
+            logger.debug("Child has wrong parent");
+            return null;
+        } else {
+            logger.debug("Child has no parent");
+            return null;
+        }
+    };
+
+};

package/logger.js

@@ -0,0 +1,28 @@
+
+module.exports = function (adapter) {
+    
+    adapter = adapter || function (level, args) {
+        console.log(level + ": " + JSON.stringify(args));
+    };
+    
+    this.log = function () {
+        adapter("log", Array.prototype.slice.call(arguments));
+    };
+    
+    this.error = function () {
+        adapter("error", Array.prototype.slice.call(arguments));
+    };
+    
+    this.warn = function () {
+        adapter("warn", Array.prototype.slice.call(arguments));
+    };
+    
+    this.info = function () {
+        adapter("info", Array.prototype.slice.call(arguments));
+    };
+    
+    this.debug = function () {
+        adapter("debug", Array.prototype.slice.call(arguments));
+    };
+    
+};