@dacely/toildefender 0.1.0 → 0.1.1

package/estest.js

@@ -1,49 +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");
-};
+"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

@@ -1,107 +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;
-        }
-    };
-
-};
+"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

@@ -1,28 +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));
-    };
-    
-};
+
+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));
+    };
+    
+};