@dacely/toildefender 0.1.0 → 0.1.2

package/processors/methods.js

@@ -1,332 +1,332 @@
-"use strict";
-
-const METHODS_INJECT = `
-function veilmark$mergeArguments(a, b) {
-    return Array.prototype.slice.call(a).concat(Array.prototype.slice.call(b));
-}
-
-function veilmark$bind() {
-    var fn = arguments[0], prepend = Array.prototype.slice.call(arguments, 1);
-    var wrapper = function() {
-        return fn.apply(this, prepend.concat(Array.prototype.slice.call(arguments)));
-    };
-    wrapper.prototype = fn.prototype;
-    return wrapper;
-}
-
-function veilmark$sliceArguments(args, num) {
-    return Array.prototype.slice.call(args, num);
-}
-
-function veilmark$toObject(schema, values) {
-    var obj = {};
-    if (values === undefined) {
-        for (var legacy = 0; legacy < schema.length; legacy += 2) {
-            obj[schema[legacy]] = schema[legacy + 1];
-        }
-        return obj;
-    }
-    var cursor = 2;
-    var salt = schema[0];
-    var count = schema[1];
-    for (var i = 0; i < count; i += 1) {
-        var len = schema[cursor++] ^ ((salt + i * 131) & 65535);
-        var key = "";
-        for (var j = 0; j < len; j += 1) {
-            key += String.fromCharCode(schema[cursor++] ^ ((salt + i * 257 + j * 17) & 65535));
-        }
-        obj[key] = values[i];
-    }
-    return obj;
-}
-
-function veilmark$decodeString(arr) {
-    return arr.map(function(x) { return String.fromCharCode(x & ~0 >>> 16) + String.fromCharCode(x >> 16); }).join("");
-}
-
-function veilmark$fromCharCodes() {
-    return String.fromCharCode.apply(null, arguments);
-}
-
-`;
-
-var assert = require("assert");
-var fs = require("fs");
-
-var _ = require("lodash");
-var escope = require("escope");
-var esprima = require("esprima");
-
-var estest = require("../estest");
-var traverser = require("../traverser");
-var utils = require("../utils");
-
-const ANON_METHOD_ID = "veilmark$anonymousMethodId";
-
-/**
- * Wrap function with veilmark$bind.
- * @param {Identifier} Function identifier
- * @returns {Node} Wrapped function
- */
-function createMethodStub(id) {
-    assert.equal(id.type, "Identifier");
-    
-    return {
-        type: "CallExpression",
-        callee: { type: "Identifier", name: "veilmark$bind" },
-        arguments: [
-            id
-        ]
-    };
-}
-
-function anonymousMethodName(node) {
-    assert.equal(node.type, "FunctionExpression");
-
-    if (!node[ANON_METHOD_ID]) {
-        Object.defineProperty(node, ANON_METHOD_ID, {
-            configurable: false,
-            enumerable: false,
-            value: `veilmark$anon$${utils.hash(node)}`
-        });
-    }
-
-    return node[ANON_METHOD_ID];
-}
-
-/**
- * Get index of argument in function.
- * @param {Function} method Function
- * @param {Identifier} identifier} Argument identifier
- * @returns {number} Index of argument
- */
-function getArgumentIndex(method, identifier) {
-    assert.ok(estest.isFunction(method));
-    assert.equal(identifier.type, "Identifier");
-    
-    return _.findIndex(method.params, x => x.name == identifier.name);
-}
-
-function rawArgumentsIdentifier() {
-    return {
-        type: "Identifier",
-        name: "arguments",
-        veilmark$rawArguments: true
-    };
-}
-
-module.exports = class Methods {
-
-    constructor (logger) {
-        this.logger = logger;
-    }
-    
-    /**
-     * Adds helper methods to the beginning of the app.
-     * @param {Node} Root node
-     */
-    addCustomBind (ast) {
-        assert.ok(estest.isNode(ast));
-        
-        var code = esprima.parse(METHODS_INJECT);
-        code.type = "BlockStatement";
-        ast.body.splice(0, 0, code);
-    }
-    
-    /**
-     * Checks whether a method refers to the "arguments" array.
-     * @param {Function} method
-     * @param {ScopeManager} scopeManager
-     * @returns {boolean}
-     */
-    methodRefersToArguments (method, scopeManager) {
-        assert.ok(estest.isFunction(method));
-        assert.ok(scopeManager);
-        
-        return scopeManager
-        .acquire(method)
-        .references
-        .some(reference => !utils.isResolvedReference(reference) && reference.identifier.name == "arguments");
-    }
-    
-    /**
-     * Inserts code to copy/slice arguments from the arguments array like
-     * function () { ... }
-     * to
-     * function () { var veilmark$arguments = veilmark$sliceArguments(arguments, 1); ... }
-     * @param {Function} method
-     * @param {number} num Number of arguments to be sliced off. 0 if none.
-     */
-    removeFirstArguments (method, num) {
-        assert.ok(estest.isFunction(method));
-        assert.equal(typeof num, "number");
-        
-        method.body.body.splice(0, 0, {
-            type: "VariableDeclaration",
-            kind: "var",
-            declarations: [
-                {
-                    type: "VariableDeclarator",
-                    id: { type: "Identifier", name: "veilmark$arguments" },
-                    init: rawArgumentsIdentifier()
-                },
-                {
-                    type: "VariableDeclarator",
-                    id: { type: "Identifier", name: "veilmark$bareArguments" },
-                    init: num > 0 ? {
-                        type: "CallExpression",
-                        callee: { type: "Identifier", name: "veilmark$sliceArguments" },
-                        arguments: [
-                            rawArgumentsIdentifier(),
-                            { type: "Literal", value: num, veilmark$removeFirstArguments: true }
-                        ]
-                    } : rawArgumentsIdentifier()
-                }
-            ],
-            veilmark$reassigningArguments: true,
-            veilmark$followsSlicingArguments: num > 0
-        });
-    }
-
-    /**
-     * Lists all methods.
-     * @param {Node} ast Root node
-     * @returns {string[]} Method names
-     */
-    listMethods (ast) {
-        assert.ok(estest.isNode(ast));
-        
-        var methods = [];
-        
-        traverser.traverse(ast, [], (node, stack) => {
-            if (node.type == "FunctionDeclaration") { // Statement
-                methods.push(node.id.name);
-            } else if (node.type == "FunctionExpression") { // Expression
-                methods.push(anonymousMethodName(node));
-            }
-            
-            return node;
-        });
-        
-        return methods;
-    }
-
-    /**
-     * Extracts all methods from the AST.
-     * @param {Node} ast Root node
-     * @returns {Function[]}
-     */
-    extractMethods (ast) {
-        assert.ok(estest.isNode(ast));
-        
-        var methods = [];
-        
-        traverser.traverse(ast, [], (node, stack) => {
-            if (node.type == "FunctionDeclaration") { // Statement
-                methods.push(node);
-                return { type: "ExpressionStatement", expression: createMethodStub(node.id) }; // This is not ideal
-            } else if (node.type == "FunctionExpression") { // Expression
-                var id = anonymousMethodName(node);
-                // Merge into old object instead of creating a new one to preserve object references
-                methods.push(_.assign(node, {
-                    type: "FunctionDeclaration",
-                    id: { type: "Identifier", name: id }
-                }));
-                return createMethodStub({ type: "Identifier", name: id });
-            }
-            
-            return node;
-        });
-        
-        return methods;
-    }
-
-    /**
-     * Replaces direct argument references with arguments references like
-     * function (a) { return a; }
-     * to
-     * function (a) { return veilmark$arguments[0]; }
-     * @param {Function} method Function whose body will be transformed
-     * @param {boolean} useReassignedVariable Use veilmark$arguments instead of arguments
-     * @returns {Function} Function from method parameter
-     */
-    replaceArgumentReferences (method, useReassignedVariable) {
-        assert.ok(estest.isFunction(method));
-        
-        traverser.traverse(method.body, [], (node, stack) => {
-            if (node.type == "Identifier") {
-                var nestedFunction = stack.some(frame => estest.isFunction(frame.node));
-                if (useReassignedVariable && node.name == "arguments" && !node.veilmark$rawArguments && !nestedFunction) {
-                    return { type: "Identifier", name: "veilmark$bareArguments" };
-                }
-                var index = getArgumentIndex(method, node);
-                if (index != -1) {
-                    return {
-                        type: "MemberExpression",
-                        object: { type: "Identifier", name: useReassignedVariable ? "veilmark$arguments" : "arguments" },
-                        property: { type: "Literal", value: index },
-                        computed: true
-                    };
-                }
-            }
-            
-            return node;
-        });
-        
-        method.params = [];
-        
-        return method;
-    }
-
-    /**
-     * Replaces function calls with main calls like
-     * test()
-     * to
-     * veilmark$bind(main, 1234)()
-     * @param {Node} ast Root node
-     * @param {Object[]} methodEntryExitPoints Method entry point table
-     * @param {number} methodEntryExitPoints[].entry Entry point
-     */
-    replaceFunctionCalls (ast, methodEntryExitPoints) {
-        assert.ok(estest.isNode(ast));
-        assert.equal(typeof methodEntryExitPoints, "object");
-        
-        traverser.traverse(ast, [], (node, stack) => {
-            if (node.type == "Identifier" && methodEntryExitPoints[node.name] && methodEntryExitPoints[node.name].entry) {
-                return {
-                    type: "CallExpression",
-                    callee: { type: "Identifier", name: "veilmark$bind" },
-                    arguments: [
-                        { type: "Identifier", name: "main" },
-                        { type: "Identifier", name: methodEntryExitPoints[node.name].entry }
-                    ]
-                };
-            }
-            return node;
-        });
-    }
-
-    /**
-     * Bumps all arguments indices like
-     * veilmark$arguments[0]
-     * to
-     * veilmark$arguments[1]
-     * @param {Function} method Function whose body will be transformed
-     * @param {number} inc Number to be added to all argument indices
-     */
-    bumpArgumentsIndices (method, inc) {
-        assert.ok(estest.isFunction(method));
-        assert.equal(typeof inc, "number");
-        
-        traverser.traverse(method.body, [], (node, stack) => {
-            if (node.type == "MemberExpression" && node.object.type == "Identifier" && node.object.name == "veilmark$arguments") {
-                node.property.value += inc;
-            }
-            if (node.veilmark$removeFirstArguments) {
-                node.value += inc;
-            }
-            return node;
-        });
-    }
-    
-};
+"use strict";
+
+const METHODS_INJECT = `
+function veilmark$mergeArguments(a, b) {
+    return Array.prototype.slice.call(a).concat(Array.prototype.slice.call(b));
+}
+
+function veilmark$bind() {
+    var fn = arguments[0], prepend = Array.prototype.slice.call(arguments, 1);
+    var wrapper = function() {
+        return fn.apply(this, prepend.concat(Array.prototype.slice.call(arguments)));
+    };
+    wrapper.prototype = fn.prototype;
+    return wrapper;
+}
+
+function veilmark$sliceArguments(args, num) {
+    return Array.prototype.slice.call(args, num);
+}
+
+function veilmark$toObject(schema, values) {
+    var obj = {};
+    if (values === undefined) {
+        for (var legacy = 0; legacy < schema.length; legacy += 2) {
+            obj[schema[legacy]] = schema[legacy + 1];
+        }
+        return obj;
+    }
+    var cursor = 2;
+    var salt = schema[0];
+    var count = schema[1];
+    for (var i = 0; i < count; i += 1) {
+        var len = schema[cursor++] ^ ((salt + i * 131) & 65535);
+        var key = "";
+        for (var j = 0; j < len; j += 1) {
+            key += String.fromCharCode(schema[cursor++] ^ ((salt + i * 257 + j * 17) & 65535));
+        }
+        obj[key] = values[i];
+    }
+    return obj;
+}
+
+function veilmark$decodeString(arr) {
+    return arr.map(function(x) { return String.fromCharCode(x & ~0 >>> 16) + String.fromCharCode(x >> 16); }).join("");
+}
+
+function veilmark$fromCharCodes() {
+    return String.fromCharCode.apply(null, arguments);
+}
+
+`;
+
+var assert = require("assert");
+var fs = require("fs");
+
+var _ = require("lodash");
+var escope = require("escope");
+var esprima = require("esprima");
+
+var estest = require("../estest");
+var traverser = require("../traverser");
+var utils = require("../utils");
+
+const ANON_METHOD_ID = "veilmark$anonymousMethodId";
+
+/**
+ * Wrap function with veilmark$bind.
+ * @param {Identifier} Function identifier
+ * @returns {Node} Wrapped function
+ */
+function createMethodStub(id) {
+    assert.equal(id.type, "Identifier");
+    
+    return {
+        type: "CallExpression",
+        callee: { type: "Identifier", name: "veilmark$bind" },
+        arguments: [
+            id
+        ]
+    };
+}
+
+function anonymousMethodName(node) {
+    assert.equal(node.type, "FunctionExpression");
+
+    if (!node[ANON_METHOD_ID]) {
+        Object.defineProperty(node, ANON_METHOD_ID, {
+            configurable: false,
+            enumerable: false,
+            value: `veilmark$anon$${utils.hash(node)}`
+        });
+    }
+
+    return node[ANON_METHOD_ID];
+}
+
+/**
+ * Get index of argument in function.
+ * @param {Function} method Function
+ * @param {Identifier} identifier} Argument identifier
+ * @returns {number} Index of argument
+ */
+function getArgumentIndex(method, identifier) {
+    assert.ok(estest.isFunction(method));
+    assert.equal(identifier.type, "Identifier");
+    
+    return _.findIndex(method.params, x => x.name == identifier.name);
+}
+
+function rawArgumentsIdentifier() {
+    return {
+        type: "Identifier",
+        name: "arguments",
+        veilmark$rawArguments: true
+    };
+}
+
+module.exports = class Methods {
+
+    constructor (logger) {
+        this.logger = logger;
+    }
+    
+    /**
+     * Adds helper methods to the beginning of the app.
+     * @param {Node} Root node
+     */
+    addCustomBind (ast) {
+        assert.ok(estest.isNode(ast));
+        
+        var code = esprima.parse(METHODS_INJECT);
+        code.type = "BlockStatement";
+        ast.body.splice(0, 0, code);
+    }
+    
+    /**
+     * Checks whether a method refers to the "arguments" array.
+     * @param {Function} method
+     * @param {ScopeManager} scopeManager
+     * @returns {boolean}
+     */
+    methodRefersToArguments (method, scopeManager) {
+        assert.ok(estest.isFunction(method));
+        assert.ok(scopeManager);
+        
+        return scopeManager
+        .acquire(method)
+        .references
+        .some(reference => !utils.isResolvedReference(reference) && reference.identifier.name == "arguments");
+    }
+    
+    /**
+     * Inserts code to copy/slice arguments from the arguments array like
+     * function () { ... }
+     * to
+     * function () { var veilmark$arguments = veilmark$sliceArguments(arguments, 1); ... }
+     * @param {Function} method
+     * @param {number} num Number of arguments to be sliced off. 0 if none.
+     */
+    removeFirstArguments (method, num) {
+        assert.ok(estest.isFunction(method));
+        assert.equal(typeof num, "number");
+        
+        method.body.body.splice(0, 0, {
+            type: "VariableDeclaration",
+            kind: "var",
+            declarations: [
+                {
+                    type: "VariableDeclarator",
+                    id: { type: "Identifier", name: "veilmark$arguments" },
+                    init: rawArgumentsIdentifier()
+                },
+                {
+                    type: "VariableDeclarator",
+                    id: { type: "Identifier", name: "veilmark$bareArguments" },
+                    init: num > 0 ? {
+                        type: "CallExpression",
+                        callee: { type: "Identifier", name: "veilmark$sliceArguments" },
+                        arguments: [
+                            rawArgumentsIdentifier(),
+                            { type: "Literal", value: num, veilmark$removeFirstArguments: true }
+                        ]
+                    } : rawArgumentsIdentifier()
+                }
+            ],
+            veilmark$reassigningArguments: true,
+            veilmark$followsSlicingArguments: num > 0
+        });
+    }
+
+    /**
+     * Lists all methods.
+     * @param {Node} ast Root node
+     * @returns {string[]} Method names
+     */
+    listMethods (ast) {
+        assert.ok(estest.isNode(ast));
+        
+        var methods = [];
+        
+        traverser.traverse(ast, [], (node, stack) => {
+            if (node.type == "FunctionDeclaration") { // Statement
+                methods.push(node.id.name);
+            } else if (node.type == "FunctionExpression") { // Expression
+                methods.push(anonymousMethodName(node));
+            }
+            
+            return node;
+        });
+        
+        return methods;
+    }
+
+    /**
+     * Extracts all methods from the AST.
+     * @param {Node} ast Root node
+     * @returns {Function[]}
+     */
+    extractMethods (ast) {
+        assert.ok(estest.isNode(ast));
+        
+        var methods = [];
+        
+        traverser.traverse(ast, [], (node, stack) => {
+            if (node.type == "FunctionDeclaration") { // Statement
+                methods.push(node);
+                return { type: "ExpressionStatement", expression: createMethodStub(node.id) }; // This is not ideal
+            } else if (node.type == "FunctionExpression") { // Expression
+                var id = anonymousMethodName(node);
+                // Merge into old object instead of creating a new one to preserve object references
+                methods.push(_.assign(node, {
+                    type: "FunctionDeclaration",
+                    id: { type: "Identifier", name: id }
+                }));
+                return createMethodStub({ type: "Identifier", name: id });
+            }
+            
+            return node;
+        });
+        
+        return methods;
+    }
+
+    /**
+     * Replaces direct argument references with arguments references like
+     * function (a) { return a; }
+     * to
+     * function (a) { return veilmark$arguments[0]; }
+     * @param {Function} method Function whose body will be transformed
+     * @param {boolean} useReassignedVariable Use veilmark$arguments instead of arguments
+     * @returns {Function} Function from method parameter
+     */
+    replaceArgumentReferences (method, useReassignedVariable) {
+        assert.ok(estest.isFunction(method));
+        
+        traverser.traverse(method.body, [], (node, stack) => {
+            if (node.type == "Identifier") {
+                var nestedFunction = stack.some(frame => estest.isFunction(frame.node));
+                if (useReassignedVariable && node.name == "arguments" && !node.veilmark$rawArguments && !nestedFunction) {
+                    return { type: "Identifier", name: "veilmark$bareArguments" };
+                }
+                var index = getArgumentIndex(method, node);
+                if (index != -1) {
+                    return {
+                        type: "MemberExpression",
+                        object: { type: "Identifier", name: useReassignedVariable ? "veilmark$arguments" : "arguments" },
+                        property: { type: "Literal", value: index },
+                        computed: true
+                    };
+                }
+            }
+            
+            return node;
+        });
+        
+        method.params = [];
+        
+        return method;
+    }
+
+    /**
+     * Replaces function calls with main calls like
+     * test()
+     * to
+     * veilmark$bind(main, 1234)()
+     * @param {Node} ast Root node
+     * @param {Object[]} methodEntryExitPoints Method entry point table
+     * @param {number} methodEntryExitPoints[].entry Entry point
+     */
+    replaceFunctionCalls (ast, methodEntryExitPoints) {
+        assert.ok(estest.isNode(ast));
+        assert.equal(typeof methodEntryExitPoints, "object");
+        
+        traverser.traverse(ast, [], (node, stack) => {
+            if (node.type == "Identifier" && methodEntryExitPoints[node.name] && methodEntryExitPoints[node.name].entry) {
+                return {
+                    type: "CallExpression",
+                    callee: { type: "Identifier", name: "veilmark$bind" },
+                    arguments: [
+                        { type: "Identifier", name: "main" },
+                        { type: "Identifier", name: methodEntryExitPoints[node.name].entry }
+                    ]
+                };
+            }
+            return node;
+        });
+    }
+
+    /**
+     * Bumps all arguments indices like
+     * veilmark$arguments[0]
+     * to
+     * veilmark$arguments[1]
+     * @param {Function} method Function whose body will be transformed
+     * @param {number} inc Number to be added to all argument indices
+     */
+    bumpArgumentsIndices (method, inc) {
+        assert.ok(estest.isFunction(method));
+        assert.equal(typeof inc, "number");
+        
+        traverser.traverse(method.body, [], (node, stack) => {
+            if (node.type == "MemberExpression" && node.object.type == "Identifier" && node.object.name == "veilmark$arguments") {
+                node.property.value += inc;
+            }
+            if (node.veilmark$removeFirstArguments) {
+                node.value += inc;
+            }
+            return node;
+        });
+    }
+    
+};