spider-src 0.1.5 → 0.1.6

data/lib/spider-src/support/spider/node_modules/spider-script/node_modules/traceur/node_modules/regexpu/node_modules/recast/lib/types.js

@@ -0,0 +1,11 @@
+var types = require("ast-types");
+var def = types.Type.def;
+
+def("File")
+    .bases("Node")
+    .build("program")
+    .field("program", def("Program"));
+
+types.finalize();
+
+module.exports = types;

data/lib/spider-src/support/spider/node_modules/spider-script/node_modules/traceur/node_modules/regexpu/node_modules/recast/lib/util.js

@@ -0,0 +1,141 @@
+var assert = require("assert");
+var getFieldValue = require("./types").getFieldValue;
+var sourceMap = require("source-map");
+var SourceMapConsumer = sourceMap.SourceMapConsumer;
+var SourceMapGenerator = sourceMap.SourceMapGenerator;
+var hasOwn = Object.prototype.hasOwnProperty;
+
+function getUnionOfKeys(obj) {
+    for (var i = 0, key,
+             result = {},
+             objs = arguments,
+             argc = objs.length;
+         i < argc;
+         i += 1)
+    {
+        obj = objs[i];
+        for (key in obj)
+            if (hasOwn.call(obj, key))
+                result[key] = true;
+    }
+    return result;
+}
+exports.getUnionOfKeys = getUnionOfKeys;
+
+exports.assertEquivalent = function(a, b) {
+    if (!deepEquivalent(a, b)) {
+        throw new Error(
+            JSON.stringify(a) + " not equivalent to " +
+            JSON.stringify(b)
+        );
+    }
+};
+
+function deepEquivalent(a, b) {
+    if (a === b)
+        return true;
+
+    if (a instanceof Array)
+        return deepArrEquiv(a, b);
+
+    if (typeof a === "object")
+        return deepObjEquiv(a, b);
+
+    return false;
+}
+exports.deepEquivalent = deepEquivalent;
+
+function deepArrEquiv(a, b) {
+    assert.ok(a instanceof Array);
+    var len = a.length;
+
+    if (!(b instanceof Array &&
+          b.length === len))
+        return false;
+
+    for (var i = 0; i < len; ++i) {
+        if (i in a !== i in b)
+            return false;
+
+        if (!deepEquivalent(a[i], b[i]))
+            return false;
+    }
+
+    return true;
+}
+
+function deepObjEquiv(a, b) {
+    assert.strictEqual(typeof a, "object");
+    if (!a || !b || typeof b !== "object")
+        return false;
+
+    for (var key in getUnionOfKeys(a, b)) {
+        if (key === "loc" ||
+            key === "range" ||
+            key === "comments" ||
+            key === "raw")
+            continue;
+
+        if (!deepEquivalent(getFieldValue(a, key),
+                            getFieldValue(b, key)))
+        {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+function comparePos(pos1, pos2) {
+    return (pos1.line - pos2.line) || (pos1.column - pos2.column);
+}
+exports.comparePos = comparePos;
+
+exports.composeSourceMaps = function(formerMap, latterMap) {
+    if (formerMap) {
+        if (!latterMap) {
+            return formerMap;
+        }
+    } else {
+        return latterMap || null;
+    }
+
+    var smcFormer = new SourceMapConsumer(formerMap);
+    var smcLatter = new SourceMapConsumer(latterMap);
+    var smg = new SourceMapGenerator({
+        file: latterMap.file,
+        sourceRoot: latterMap.sourceRoot
+    });
+
+    var sourcesToContents = {};
+
+    smcLatter.eachMapping(function(mapping) {
+        var origPos = smcFormer.originalPositionFor({
+            line: mapping.originalLine,
+            column: mapping.originalColumn
+        });
+
+        var sourceName = origPos.source;
+
+        smg.addMapping({
+            source: sourceName,
+            original: {
+                line: origPos.line,
+                column: origPos.column
+            },
+            generated: {
+                line: mapping.generatedLine,
+                column: mapping.generatedColumn
+            },
+            name: mapping.name
+        });
+
+        var sourceContent = smcFormer.sourceContentFor(sourceName);
+        if (sourceContent && !hasOwn.call(sourcesToContents, sourceName)) {
+            sourcesToContents[sourceName] = sourceContent;
+            smg.setSourceContent(sourceName, sourceContent);
+        }
+    });
+
+    return smg.toJSON();
+};

data/lib/spider-src/support/spider/node_modules/spider-script/node_modules/traceur/node_modules/regexpu/node_modules/recast/lib/visitor.js

@@ -0,0 +1,123 @@
+var assert = require("assert");
+var Class = require("cls");
+var Node = require("./types").namedTypes.Node;
+var slice = Array.prototype.slice;
+var removeRequests = [];
+
+var Visitor = exports.Visitor = Class.extend({
+    visit: function(node) {
+        var self = this;
+
+        if (!node) {
+            // pass
+
+        } else if (node instanceof Array) {
+            node = self.visitArray(node);
+
+        } else if (Node.check(node)) {
+            var methodName = "visit" + node.type,
+                method = self[methodName] || self.genericVisit;
+            node = method.call(this, node);
+
+        } else if (typeof node === "object") {
+            // Some AST node types contain ad-hoc (non-AST) objects that
+            // may contain nested AST nodes.
+            self.genericVisit(node);
+        }
+
+        return node;
+    },
+
+    visitArray: function(arr, noUpdate) {
+        for (var elem, result, undef,
+                 i = 0, len = arr.length;
+             i < len;
+             i += 1)
+        {
+            if (i in arr)
+                elem = arr[i];
+            else
+                continue;
+
+            var requesters = [];
+            removeRequests.push(requesters);
+
+            // Make sure we don't accidentally reuse a previous result
+            // when this.visit throws an exception.
+            result = undef;
+
+            try {
+                result = this.visit(elem);
+
+            } finally {
+                assert.strictEqual(
+                    removeRequests.pop(),
+                    requesters);
+            }
+
+            if (requesters.length > 0 || (result === null && elem !== null)) {
+                // This hole will be elided by the compaction loop below.
+                delete arr[i];
+            } else if (result !== undef) {
+                arr[i] = result;
+            }
+        }
+
+        // Compact the array to eliminate holes.
+        for (var dst = 0,
+                 src = dst,
+                 // The length of the array might have changed during the
+                 // iteration performed above.
+                 len = arr.length;
+             src < len;
+             src += 1)
+            if (src in arr)
+                arr[dst++] = arr[src];
+        arr.length = dst;
+
+        return arr;
+    },
+
+    remove: function() {
+        var len = removeRequests.length,
+            requesters = removeRequests[len - 1];
+        if (requesters)
+            requesters.push(this);
+    },
+
+    genericVisit: function(node) {
+        var field,
+            oldValue,
+            newValue;
+
+        for (field in node) {
+            if (!node.hasOwnProperty(field))
+                continue;
+
+            oldValue = node[field];
+
+            if (oldValue instanceof Array) {
+                this.visitArray(oldValue);
+
+            } else if (Node.check(oldValue)) {
+                newValue = this.visit(oldValue);
+
+                if (typeof newValue === "undefined") {
+                    // Keep oldValue.
+                } else {
+                    node[field] = newValue;
+                }
+
+            } else if (typeof oldValue === "object") {
+                this.genericVisit(oldValue);
+            }
+        }
+
+        return node;
+    }
+});
+
+require("depd")('require("recast").Visitor').property(
+    Visitor, "extend",
+    'Please use require("recast").visit instead of require("recast").Visitor'
+);

data/lib/spider-src/support/spider/node_modules/spider-script/node_modules/traceur/node_modules/regexpu/node_modules/recast/main.js

@@ -0,0 +1,135 @@
+var types = require("./lib/types");
+var parse = require("./lib/parser").parse;
+var Printer = require("./lib/printer").Printer;
+
+function print(node, options) {
+    return new Printer(options).print(node);
+}
+
+function prettyPrint(node, options) {
+    return new Printer(options).printGenerically(node);
+}
+
+function run(transformer, options) {
+    return runFile(process.argv[2], transformer, options);
+}
+
+function runFile(path, transformer, options) {
+    require("fs").readFile(path, "utf-8", function(err, code) {
+        if (err) {
+            console.error(err);
+            return;
+        }
+
+        runString(code, transformer, options);
+    });
+}
+
+function defaultWriteback(output) {
+    process.stdout.write(output);
+}
+
+function runString(code, transformer, options) {
+    var writeback = options && options.writeback || defaultWriteback;
+    transformer(parse(code, options), function(node) {
+        writeback(print(node, options).code);
+    });
+}
+
+Object.defineProperties(exports, {
+    /**
+     * Parse a string of code into an augmented syntax tree suitable for
+     * arbitrary modification and reprinting.
+     */
+    parse: {
+        enumerable: true,
+        value: parse
+    },
+
+    /**
+     * Traverse and potentially modify an abstract syntax tree using a
+     * convenient visitor syntax:
+     *
+     *   recast.visit(ast, {
+     *     names: [],
+     *     visitIdentifier: function(path) {
+     *       var node = path.value;
+     *       this.visitor.names.push(node.name);
+     *       this.traverse(path);
+     *     }
+     *   });
+     */
+    visit: {
+        enumerable: true,
+        value: types.visit
+    },
+
+    /**
+     * Reprint a modified syntax tree using as much of the original source
+     * code as possible.
+     */
+    print: {
+        enumerable: true,
+        value: print
+    },
+
+    /**
+     * Print without attempting to reuse any original source code.
+     */
+    prettyPrint: {
+        enumerable: false,
+        value: prettyPrint
+    },
+
+    /**
+     * Customized version of require("ast-types").
+     */
+    types: {
+        enumerable: false,
+        value: types
+    },
+
+    /**
+     * Convenient command-line interface (see e.g. example/add-braces).
+     */
+    run: {
+        enumerable: false,
+        value: run
+    },
+
+    /**
+     * Useful utilities for implementing transformer functions.
+     */
+    Syntax: {
+        enumerable: false,
+        get: function getSyntax() {
+            if (getSyntax.cached) {
+                return getSyntax.cached;
+            }
+
+            require("depd")('require("recast").Syntax')(
+                "Please use recast.types.namedTypes instead of recast.Syntax"
+            );
+
+            var def = types.Type.def;
+            var Syntax = {};
+
+            Object.keys(types.namedTypes).forEach(function(name) {
+                if (def(name).buildable)
+                    Syntax[name] = name;
+            });
+
+            // These two types are buildable but do not technically count
+            // as syntax because they are not printable.
+            delete Syntax.SourceLocation;
+            delete Syntax.Position;
+
+            return getSyntax.cached = Syntax;
+        }
+    },
+
+    Visitor: {
+        enumerable: false,
+        value: require("./lib/visitor").Visitor
+    }
+});

data/lib/spider-src/support/spider/node_modules/spider-script/node_modules/traceur/node_modules/regexpu/node_modules/recast/node_modules/.bin/esparse

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+/*
+  Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
+  Copyright (C) 2011 Ariya Hidayat <ariya.hidayat@gmail.com>
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*jslint sloppy:true node:true rhino:true */
+
+var fs, esprima, fname, content, options, syntax;
+
+if (typeof require === 'function') {
+    fs = require('fs');
+    esprima = require('esprima');
+} else if (typeof load === 'function') {
+    try {
+        load('esprima.js');
+    } catch (e) {
+        load('../esprima.js');
+    }
+}
+
+// Shims to Node.js objects when running under Rhino.
+if (typeof console === 'undefined' && typeof process === 'undefined') {
+    console = { log: print };
+    fs = { readFileSync: readFile };
+    process = { argv: arguments, exit: quit };
+    process.argv.unshift('esparse.js');
+    process.argv.unshift('rhino');
+}
+
+function showUsage() {
+    console.log('Usage:');
+    console.log('   esparse [options] file.js');
+    console.log();
+    console.log('Available options:');
+    console.log();
+    console.log('  --comment      Gather all line and block comments in an array');
+    console.log('  --loc          Include line-column location info for each syntax node');
+    console.log('  --range        Include index-based range for each syntax node');
+    console.log('  --raw          Display the raw value of literals');
+    console.log('  --tokens       List all tokens in an array');
+    console.log('  --tolerant     Tolerate errors on a best-effort basis (experimental)');
+    console.log('  -v, --version  Shows program version');
+    console.log();
+    process.exit(1);
+}
+
+if (process.argv.length <= 2) {
+    showUsage();
+}
+
+options = {};
+
+process.argv.splice(2).forEach(function (entry) {
+
+    if (entry === '-h' || entry === '--help') {
+        showUsage();
+    } else if (entry === '-v' || entry === '--version') {
+        console.log('ECMAScript Parser (using Esprima version', esprima.version, ')');
+        console.log();
+        process.exit(0);
+    } else if (entry === '--comment') {
+        options.comment = true;
+    } else if (entry === '--loc') {
+        options.loc = true;
+    } else if (entry === '--range') {
+        options.range = true;
+    } else if (entry === '--raw') {
+        options.raw = true;
+    } else if (entry === '--tokens') {
+        options.tokens = true;
+    } else if (entry === '--tolerant') {
+        options.tolerant = true;
+    } else if (entry.slice(0, 2) === '--') {
+        console.log('Error: unknown option ' + entry + '.');
+        process.exit(1);
+    } else if (typeof fname === 'string') {
+        console.log('Error: more than one input file.');
+        process.exit(1);
+    } else {
+        fname = entry;
+    }
+});
+
+if (typeof fname !== 'string') {
+    console.log('Error: no input file.');
+    process.exit(1);
+}
+
+try {
+    content = fs.readFileSync(fname, 'utf-8');
+    syntax = esprima.parse(content, options);
+    console.log(JSON.stringify(syntax, null, 4));
+} catch (e) {
+    console.log('Error: ' + e.message);
+    process.exit(1);
+}