snowball 0.1.21 → 0.1.22

data/node_modules/browserify/node_modules/syntax-error/node_modules/esprima/test/compare.js

@@ -0,0 +1,270 @@
+/*
+  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 browser: true */
+
+function runBenchmarks() {
+    'use strict';
+
+    var index = 0,
+        totalSize = 0,
+        totalTime = {},
+        fixture;
+
+    fixture = [
+        'esprima jquery-1.7.1',
+        'parsejs jquery-1.7.1',
+        'zeparser jquery-1.7.1',
+        'narcissus jquery-1.7.1',
+
+        'esprima prototype-1.7.0.0',
+        'parsejs prototype-1.7.0.0',
+        'zeparser prototype-1.7.0.0',
+        'narcissus prototype-1.7.0.0',
+
+        'esprima mootools-1.4.1',
+        'parsejs mootools-1.4.1',
+        'zeparser mootools-1.4.1',
+        'narcissus mootools-1.4.1',
+
+        'esprima ext-core-3.1.0',
+        'parsejs ext-core-3.1.0',
+        'zeparser ext-core-3.1.0',
+        'narcissus ext-core-3.1.0'
+    ];
+
+    function id(i) {
+        return document.getElementById(i);
+    }
+
+    function kb(bytes) {
+        return (bytes / 1024).toFixed(1);
+    }
+
+    function setText(id, str) {
+        var el = document.getElementById(id);
+        if (typeof el.innerText === 'string') {
+            el.innerText = str;
+        } else {
+            el.textContent = str;
+        }
+    }
+
+    function ready() {
+        setText('status', 'Ready.');
+        id('run').disabled = false;
+        id('run').style.visibility = 'visible';
+    }
+
+    function load(tst, callback) {
+        var xhr = new XMLHttpRequest(),
+            src = '3rdparty/' + tst + '.js';
+
+        // Already available? Don't reload from server.
+        if (window.data && window.data.hasOwnProperty(tst)) {
+            callback.apply();
+        }
+
+        try {
+            xhr.timeout = 30000;
+            xhr.open('GET', src, true);
+            setText('status', 'Please wait. Loading ' + src);
+
+            xhr.ontimeout = function () {
+                setText('status', 'Please wait. Error: time out while loading ' + src + ' ');
+                callback.apply();
+            };
+
+            xhr.onreadystatechange = function () {
+                var success = false,
+                    size = 0;
+
+                if (this.readyState === XMLHttpRequest.DONE) {
+                    if (this.status === 200) {
+                        window.data = window.data || {};
+                        window.data[tst] = this.responseText;
+                        size = this.responseText.length;
+                        totalSize += size;
+                        success = true;
+                    }
+                }
+
+                if (success) {
+                    setText(tst + '-size', kb(size));
+                } else {
+                    setText('status', 'Please wait. Error loading ' + src);
+                    setText(tst + '-size', 'Error');
+                }
+
+                callback.apply();
+            };
+
+            xhr.send(null);
+        } catch (e) {
+            setText('status', 'Please wait. Error loading ' + src);
+            callback.apply();
+        }
+    }
+
+
+    function loadTests() {
+        var sources = fixture.slice();
+
+        function loadNextTest() {
+            var tst;
+
+            if (sources.length > 0) {
+                tst = sources[0].split(' ');
+                tst = tst[1];
+                sources.splice(0, 1);
+                window.setTimeout(function () {
+                    load(tst, loadNextTest);
+                }, 100);
+            } else {
+                setText('total-size', kb(totalSize));
+                ready();
+            }
+        }
+
+        id('run').style.visibility = 'hidden';
+        loadNextTest();
+    }
+
+    function runBenchmark() {
+        var test, source, parser, fn, benchmark;
+
+        function formatTime(t) {
+            return (t === 0) ? 'N/A' : (1000 * t).toFixed(1) + ' ms';
+        }
+
+        if (index >= fixture.length) {
+            setText('total-size', kb(totalSize));
+            setText('esprima-time', formatTime(totalTime.esprima));
+            setText('parsejs-time', formatTime(totalTime.parsejs));
+            setText('zeparser-time', formatTime(totalTime.zeparser));
+            setText('narcissus-time', formatTime(totalTime.narcissus));
+            ready();
+            return;
+        }
+
+        test = fixture[index].split(' ');
+        parser = test[0];
+        test = test[1];
+
+        source = window.data[test];
+        setText(parser + '-' + test, 'Running...');
+
+        // Force the result to be held in this array, thus defeating any
+        // possible "dead core elimination" optimization.
+        window.tree = [];
+
+        switch (parser) {
+        case 'esprima':
+            fn = function () {
+                var syntax = window.esprima.parse(source);
+                window.tree.push(syntax.body.length);
+            };
+            break;
+        case 'narcissus':
+            fn = function () {
+                var syntax = window.Narcissus.parser.parse(source);
+                window.tree.push(syntax.children.length);
+            };
+            break;
+        case 'parsejs':
+            fn = function () {
+                var syntax = window.parseJS.parse(source);
+                window.tree.push(syntax.length);
+            };
+            break;
+        case 'zeparser':
+            fn = function () {
+                var syntax = window.ZeParser.parse(source, false);
+                window.tree.push(syntax.length);
+            };
+            break;
+        default:
+            throw 'Unknown parser type ' + parser;
+        }
+
+        benchmark = new window.Benchmark(test, fn, {
+            'onComplete': function () {
+                setText(parser + '-' + this.name, formatTime(this.stats.mean));
+                totalSize += source.length;
+                totalTime[parser] += this.stats.mean;
+            }
+        });
+
+        window.setTimeout(function () {
+            benchmark.run();
+            index += 1;
+            window.setTimeout(runBenchmark, 211);
+        }, 211);
+    }
+
+    id('run').onclick = function () {
+
+        var test;
+
+        for (index = 0; index < fixture.length; index += 1) {
+            test = fixture[index].split(' ').join('-');
+            setText(test, '');
+        }
+
+        setText('status', 'Please wait. Running benchmarks...');
+        id('run').style.visibility = 'hidden';
+
+        index = 0;
+        totalTime = {
+            'esprima': 0,
+            'narcissus': 0,
+            'parsejs': 0,
+            'zeparser': 0
+        };
+
+        for (test in totalTime) {
+            if (totalTime.hasOwnProperty(test)) {
+                setText(test + '-time', '');
+            }
+        }
+
+        if (typeof window.Narcissus !== 'object') {
+            window.Narcissus = {
+                parser: {
+                    parse: function (code) {
+                        throw new Error('Narcissus is not available!');
+                    }
+                }
+            };
+        }
+
+        runBenchmark();
+    };
+
+    setText('benchmarkjs-version', ' version ' + window.Benchmark.version);
+    setText('version', window.esprima.version);
+
+    loadTests();
+}
+/* vim: set sw=4 ts=4 et tw=80 : */

data/node_modules/browserify/node_modules/syntax-error/node_modules/esprima/test/compat.html

@@ -0,0 +1,40 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>Esprima: Compatibility Tests</title>
+<link rel="stylesheet" type="text/css" href="../assets/style.css"/>
+<script src="../esprima.js"></script>
+<script src="../assets/json2.js"></script>
+<script id="reflect" src="reflect.js"></script>
+<script src="compat.js"></script>
+</head>
+<body>
+<div class="container">
+
+<div class="topbar">
+<ul class="nav">
+<li><a href="../index.html">&larr; Home</a></li>
+<li><a href="http://github.com/ariya/esprima">Code</a></li>
+<li><a href="http://wiki.esprima.org">Documentation</a></li>
+<li><a href="http://issues.esprima.org">Issues</a></li>
+</ul>
+</div>
+
+<h1>Compatibility <small>keeps everyone happy</small></h1>
+<p>Esprima version <span id="version"></span>.</p>
+<p>The following tests are to ensure that the syntax tree is compatible to
+that produced by Mozilla SpiderMonkey
+<a href="https://developer.mozilla.org/en/SpiderMonkey/Parser_API">Parser reflection</a>.</p>
+<p id="status">Please wait...</p>
+<div id="report"></div>
+<div class="footer"><strong>Esprima</strong> is created by
+<a href="http://ariya.ofilabs.com/about" target="_blank">Ariya Hidayat</a>. Follow <a href="http://twitter.com/ariyahidayat">@ariyahidayat</a> on Twitter.
+</div>
+</div>
+<script>
+/*jslint browser:true*/
+window.onload = window.runTests;
+</script>
+</body>
+</html>

data/node_modules/browserify/node_modules/syntax-error/node_modules/esprima/test/compat.js

@@ -0,0 +1,239 @@
+/*
+  Copyright (C) 2012 Joost-Wim Boekesteijn <joost-wim@boekesteijn.nl>
+  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 node: true */
+/*global document: true, window:true, esprima: true, testReflect: true */
+
+var runTests;
+
+function getContext(esprima, reportCase, reportFailure) {
+    'use strict';
+
+    var Reflect, Pattern;
+
+    // Maps Mozilla Reflect object to our Esprima parser.
+    Reflect = {
+        parse: function (code) {
+            var result;
+
+            reportCase(code);
+
+            try {
+                result = esprima.parse(code);
+            } catch (error) {
+                result = error;
+            }
+
+            return result;
+        }
+    };
+
+    // This is used by Reflect test suite to match a syntax tree.
+    Pattern = function (obj) {
+        var pattern;
+
+        // Poor man's deep object cloning.
+        pattern = JSON.parse(JSON.stringify(obj));
+
+        // Special handling for regular expression literal since we need to
+        // convert it to a string literal, otherwise it will be decoded
+        // as object "{}" and the regular expression would be lost.
+        if (obj.type && obj.type === 'Literal') {
+            if (obj.value instanceof RegExp) {
+                pattern = {
+                    type: obj.type,
+                    value: obj.value.toString()
+                };
+            }
+        }
+
+        // Special handling for branch statement because SpiderMonkey
+        // prefers to put the 'alternate' property before 'consequent'.
+        if (obj.type && obj.type === 'IfStatement') {
+            pattern = {
+                type: pattern.type,
+                test: pattern.test,
+                consequent: pattern.consequent,
+                alternate: pattern.alternate
+            };
+        }
+
+        // Special handling for do while statement because SpiderMonkey
+        // prefers to put the 'test' property before 'body'.
+        if (obj.type && obj.type === 'DoWhileStatement') {
+            pattern = {
+                type: pattern.type,
+                body: pattern.body,
+                test: pattern.test
+            };
+        }
+
+        function adjustRegexLiteralAndRaw(key, value) {
+            if (key === 'value' && value instanceof RegExp) {
+                value = value.toString();
+            } else if (key === 'raw' && typeof value === "string") {
+                // Ignore Esprima-specific 'raw' property.
+                return undefined;
+            }
+            return value;
+        }
+
+        if (obj.type && (obj.type === 'Program')) {
+            pattern.assert = function (tree) {
+                var actual, expected;
+                actual = JSON.stringify(tree, adjustRegexLiteralAndRaw, 4);
+                expected = JSON.stringify(obj, null, 4);
+
+                if (expected !== actual) {
+                    reportFailure(expected, actual);
+                }
+            };
+        }
+
+        return pattern;
+    };
+
+    return {
+        Reflect: Reflect,
+        Pattern: Pattern
+    };
+}
+
+if (typeof window !== 'undefined') {
+    // Run all tests in a browser environment.
+    runTests = function () {
+        'use strict';
+
+        var total = 0,
+            failures = 0;
+
+        function setText(el, str) {
+            if (typeof el.innerText === 'string') {
+                el.innerText = str;
+            } else {
+                el.textContent = str;
+            }
+        }
+
+        function reportCase(code) {
+            var report, e;
+            report = document.getElementById('report');
+            e = document.createElement('pre');
+            e.setAttribute('class', 'code');
+            setText(e, code);
+            report.appendChild(e);
+            total += 1;
+        }
+
+        function reportFailure(expected, actual) {
+            var report, e;
+
+            failures += 1;
+
+            report = document.getElementById('report');
+
+            e = document.createElement('p');
+            setText(e, 'Expected');
+            report.appendChild(e);
+
+            e = document.createElement('pre');
+            e.setAttribute('class', 'expected');
+            setText(e, expected);
+            report.appendChild(e);
+
+            e = document.createElement('p');
+            setText(e, 'Actual');
+            report.appendChild(e);
+
+            e = document.createElement('pre');
+            e.setAttribute('class', 'actual');
+            setText(e, actual);
+            report.appendChild(e);
+        }
+
+        setText(document.getElementById('version'), esprima.version);
+
+        window.setTimeout(function () {
+            var tick, context = getContext(esprima, reportCase, reportFailure);
+
+            tick = new Date();
+            testReflect(context.Reflect, context.Pattern);
+            tick = (new Date()) - tick;
+
+            if (failures > 0) {
+                setText(document.getElementById('status'), total + ' tests. ' +
+                    'Failures: ' + failures + '. ' + tick + ' ms');
+            } else {
+                setText(document.getElementById('status'), total + ' tests. ' +
+                    'No failure. ' + tick + ' ms');
+            }
+        }, 513);
+    };
+} else {
+    (function (global) {
+        'use strict';
+        var esprima = require('../esprima'),
+            tick,
+            total = 0,
+            failures = [],
+            header,
+            current,
+            context;
+
+        function reportCase(code) {
+            total += 1;
+            current = code;
+        }
+
+        function reportFailure(expected, actual) {
+            failures.push({
+                source: current,
+                expected: expected.toString(),
+                actual: actual.toString()
+            });
+        }
+
+        context = getContext(esprima, reportCase, reportFailure);
+
+        tick = new Date();
+        require('./reflect').testReflect(context.Reflect, context.Pattern);
+        tick = (new Date()) - tick;
+
+        header = total + ' tests. ' + failures.length + ' failures. ' +
+            tick + ' ms';
+        if (failures.length) {
+            console.error(header);
+            failures.forEach(function (failure) {
+                console.error(failure.source + ': Expected\n    ' +
+                    failure.expected.split('\n').join('\n    ') +
+                    '\nto match\n    ' + failure.actual);
+            });
+        } else {
+            console.log(header);
+        }
+        process.exit(failures.length === 0 ? 0 : 1);
+    }(this));
+}
+/* vim: set sw=4 ts=4 et tw=80 : */