rapydscript-ns 0.8.0

package/tools/msgfmt.js

@@ -0,0 +1,187 @@
+/* vim:fileencoding=utf-8
+ * 
+ * Copyright (C) 2015 Kovid Goyal <kovid at kovidgoyal.net>
+ *
+ * Distributed under terms of the BSD license
+ */
+"use strict";  /*jshint node:true */
+
+function unesc(string) {
+    return string.replace(/\\"/g, '"').replace(/\\n/g, '\n').replace(/\\r/g, '\r').replace(/\\t/g, '\t').replace(/\\\\/g, '\\');
+}
+
+function parse(data, on_error) {
+    // Parse a PO file using a state machine (does not work for POT files). Also only extracts data useful
+    // for JSON output.
+    var plural_forms = null;
+    var lines = data.split('\n');
+    var entries = [];
+    var current_entry = create_entry();
+    var lnum = 0;
+    var nplurals = null;
+    var language = null;
+
+    function fatal() {
+        var msg = Array.prototype.slice.call(arguments).join(' ');
+        if (on_error) { on_error(msg); return; }
+        console.error(msg);
+        process.exit(1);
+    }
+
+    function create_entry() {
+        return {msgid: null, fuzzy: false, msgstr:[], msgid_plural:null, lnum:null};
+    }
+
+    function parse_header() {
+        var raw = current_entry.msgstr[0];
+        if (raw === undefined) fatal('Header has no msgstr');
+        raw.split('\n').forEach(function(line) {
+            if (line.startsWith('Plural-Forms:')) {
+                plural_forms = line.slice('Plural-Forms:'.length).trim();
+                var match = /^nplurals\s*=\s*(\d+)\s*;/.exec(plural_forms);
+                if (!match || match[1] === undefined) fatal('Invalid Plural-Forms header:', plural_forms);
+                nplurals = parseInt(match[1]);
+            } 
+            else if (line.startsWith('Language:')) {
+                language = line.slice('Language:'.length).trim();
+            }
+        });
+    }
+
+    function commit_entry() {
+        if (current_entry.msgid) {
+            if (current_entry.msgid_plural !== null) {
+                if (nplurals === null) fatal('Plural-Forms header missing');
+                for (var i = 0; i < nplurals; i++) {
+                    if (current_entry.msgstr[i] === undefined) fatal('Missing plural form for entry at line number:', lnum);
+                }
+            }
+            entries.push(current_entry);
+        } else if (current_entry.msgid === '') parse_header();
+        current_entry = create_entry();
+    }
+
+    function read_string(line) {
+        line = line.trim();
+        if (!line || line[0] !== '"' || line[line.length - 1] !== '"') {
+            fatal('Expecting a string at line number:', lnum);
+        }
+        return unesc(line.slice(1, -1));
+    }
+
+    function continuation(line, lines, append, after) {
+        if (line[0] === '"') append(read_string(line));
+        else {
+            state = after;
+            after(line, lines);
+        }
+    }
+
+    function start(line, lines) {
+        if (line[0] === '#') {
+            if (line[1] === ',') {
+                line.slice(2).trimLeft().split(',').forEach(function(flag) {
+                    if (flag.trim().toLowerCase() === 'fuzzy') current_entry.fuzzy = true;
+                });
+            }
+        } else if (line.startsWith('msgid ')) {
+            current_entry.msgid = read_string(line.slice('msgid '.length));
+            current_entry.lnum = lnum;
+            state = function(line, lines) { 
+                continuation(line, lines, function(x) { current_entry.msgid += x; }, after_msgid);
+            };
+        } else {
+            fatal('Expecting msgid at line number:', lnum);
+        }
+    }
+
+    function after_msgid(line, lines) {
+        if (line.startsWith('msgid_plural ')) {
+            current_entry.msgid_plural = read_string(line.slice('msgid_plural '.length));
+            state = function(line, lines) { 
+                continuation(line, lines, function(x) { current_entry.msgid_plural += x; }, msgstr);
+            };
+        } 
+        
+        else if (line.startsWith('msgstr ') || line.startsWith('msgstr[')) {
+            state = msgstr;
+            msgstr(line, lines);
+        } 
+        
+        else fatal('Expecting either msgstr or msgid_plural at line number:', lnum);
+
+    }
+
+    function msgstr(line, lines) {
+        if (line.startsWith('msgstr ')) {
+            if (current_entry.msgid_plural !== null) fatal('Expecting msgstr[0] at line number:', lnum);
+            current_entry.msgstr.push(read_string(line.slice('msgstr '.length)));
+            state = function(line, lines) { 
+                continuation(line, lines, function(x) { current_entry.msgstr[current_entry.msgstr.length - 1] += x; }, msgstr);
+            };
+        } 
+
+        else if (line[0] === '#' || line.startsWith('msgid ')) {
+            if (!current_entry.msgstr.length) fatal('Expecting msgstr at line number:', lnum);
+            commit_entry();
+            state = start;
+            start(line, lines);
+        }
+
+        else if (line.startsWith('msgstr[')) {
+            if (current_entry.msgid_plural === null) fatal('Expecting non-plural msgstr at line number:', lnum);
+            var pnum = /^msgstr\[(\d+)\] /.exec(line);
+            if (!pnum || pnum[1] === undefined) fatal('Malformed msgstr at line number:', lnum);
+            var idx = parseInt(pnum[1]);
+            current_entry.msgstr[idx] = read_string(line.slice(pnum[0].length));
+            state = function(line, lines) { 
+                continuation(line, lines, function(x) { current_entry.msgstr[idx] += x; }, msgstr);
+            };
+        }
+
+        else fatal('Expecting msgstr or msgid at line number:', lnum);
+    }
+
+    var state = start;
+
+    while (lines.length) {
+        var line = lines.shift().trim();
+        lnum += 1;
+        if (!line) continue;
+        state(line, lines);
+    }
+    commit_entry();
+    if (language === null) fatal('No language specified in the header of this po file');
+    return {entries:entries, plural_forms:plural_forms, nplurals:nplurals, language:language};
+}
+
+function read_stdin(cont) {
+    var chunks = [];
+    process.stdin.setEncoding('utf8');
+
+    process.stdin.on('readable', function () { 
+        var chunk = process.stdin.read();
+        if (chunk) chunks.push(chunk); 
+    });
+
+    process.stdin.on('end', function() { cont(chunks.join('')); });
+}
+
+function serialize_catalog(catalog, options) {
+    if (!options.use_fuzzy) catalog.entries = catalog.entries.filter(function(e) { return !e.fuzzy; });
+    var entries = {};
+    catalog.entries.forEach(function (entry) {
+        entries[entry.msgid] = entry.msgstr;
+    });
+    return JSON.stringify({'plural_forms':catalog.plural_forms, 'entries':entries, 'language':catalog.language});
+}
+
+module.exports.cli = function(argv, base_path, src_path, lib_path) {
+    read_stdin(function process(data) {
+        var catalog = parse(data);
+        console.log(serialize_catalog(catalog, argv));
+    });
+};
+
+module.exports.parse = parse;
+module.exports.build = function(data, options) { return serialize_catalog(parse(data), options); };

package/tools/repl.js

@@ -0,0 +1,223 @@
+/*
+ * repl.js
+ * Copyright (C) 2015 Kovid Goyal <kovid at kovidgoyal.net>
+ *
+ * Distributed under terms of the BSD license.
+ */
+"use strict";  /*jshint node:true */
+
+var fs = require('fs');
+var path = require('path');
+var vm = require('vm');
+var util = require('util');
+var utils = require('./utils');
+var completelib = require('./completer');
+var colored = utils.safe_colored;
+var RapydScript = (typeof create_rapydscript_compiler === 'function') ? create_rapydscript_compiler() : require('./compiler').create_compiler();
+var has_prop = Object.prototype.hasOwnProperty.call.bind(Object.prototype.hasOwnProperty);
+
+function strip_exports(js) { return js.replace(/^export ((?:async )?function |let )/gm, '$1'); }
+
+function create_ctx(baselib, show_js, console) {
+    var ctx = vm.createContext({'console':console, 'show_js': !!show_js, 'RapydScript':RapydScript, 'require':require});
+	vm.runInContext(baselib, ctx, {'filename':'baselib-plain-pretty.js'});
+    vm.runInContext('var __name__ = "__repl__";', ctx);
+    return ctx;
+}
+
+
+var homedir = process.env[(process.platform == 'win32') ? 'USERPROFILE' : 'HOME'];
+var cachedir = expanduser(process.env.XDG_CACHE_HOME || '~/.cache');
+
+function expanduser(x) {
+  if (!x) return x;
+  if (x === '~') return homedir;
+  if (x.slice(0, 2) != '~/') return x;
+  return path.join(homedir, x.slice(2));
+}
+
+function repl_defaults(options) {
+    options = options || {};
+    if (!options.input) options.input = process.stdin;
+    if (!options.output) options.output = process.stdout;
+    if (options.show_js === undefined) options.show_js = true;
+    if (!options.ps1) options.ps1 = '>>> ';
+    if (!options.ps2) options.ps2 = '... ';
+    if (!options.console) options.console = console;
+    if (!options.readline) options.readline = require('readline');
+    if (options.terminal === undefined) options.terminal = options.output.isTTY;
+    if (options.histfile === undefined) options.histfile = path.join(cachedir, 'rapydscript-repl.history');
+        
+    options.colored = (options.terminal) ? colored : (function (string) { return string; });
+    options.historySize = options.history_size || 1000;
+    return options;
+}
+
+function read_history(options) {
+    if (options.histfile) {
+        try {
+            return fs.readFileSync(options.histfile, 'utf-8').split('\n');
+        } catch (e) { return []; }
+    }
+}
+
+function write_history(options, history) {
+    if (options.histfile) {
+        history = history.join('\n');
+        try {
+            return fs.writeFileSync(options.histfile, history, 'utf-8');
+        } catch (e) {}
+    }
+}
+
+
+module.exports = function(options) {
+    options = repl_defaults(options);
+    options.completer = completer;
+    var rl = options.readline.createInterface(options);
+	var ps1 = options.colored(options.ps1, 'green');
+	var ps2 = options.colored(options.ps2, 'yellow');
+	var ctx = create_ctx(print_ast(RapydScript.parse('(def ():\n yield 1\n)'), true), options.show_js, options.console);
+    var buffer = [];
+    var more = false;
+    var LINE_CONTINUATION_CHARS = ':\\';
+    var toplevel;
+    var import_dirs = utils.get_import_dirs();
+    var find_completions = completelib(RapydScript, options);
+
+    options.console.log(options.colored('Welcome to the RapydScript REPL! Press Ctrl+C then Ctrl+D to quit.', 'green', true));
+    if (options.show_js)
+        options.console.log(options.colored('Use show_js=False to stop the REPL from showing the compiled JavaScript.', 'green', true));
+    else
+        options.console.log(options.colored('Use show_js=True to have the REPL show the compiled JavaScript before executing it.', 'green', true));
+    options.console.log();
+
+    function print_ast(ast, keep_baselib) {
+        var output_options = {omit_baselib:!keep_baselib, write_name:false, private_scope:false, beautify:true, keep_docstrings:true};
+        if (keep_baselib) output_options.baselib_plain = fs.readFileSync(path.join(options.lib_path, 'baselib-plain-pretty.js'), 'utf-8');
+        var output = new RapydScript.OutputStream(output_options);
+        ast.print(output);
+        return output.get();
+    }
+
+
+    function resetbuffer() { buffer = []; }
+
+    function completer(line) {
+        return find_completions(line, ctx);
+    }
+
+    function prompt() {
+        var lw = '';
+        if (more && buffer.length) {
+            var prev_line = buffer[buffer.length - 1];
+            if (prev_line.trimRight().substr(prev_line.length - 1) == ':') lw = '    ';
+            prev_line = prev_line.match(/^\s+/);
+            if (prev_line) lw += prev_line;
+        }
+        rl.setPrompt((more) ? ps2 : ps1);
+        if (rl.sync_prompt) rl.prompt(lw);
+        else {
+            rl.prompt();
+            if (lw) rl.write(lw);
+        }
+    }
+
+    function runjs(js) {
+        var result;
+        if (vm.runInContext('show_js', ctx)) {
+            options.console.log(options.colored('---------- Compiled JavaScript ---------', 'green', true));
+            options.console.log(js);
+            options.console.log(options.colored('---------- Running JavaScript ---------', 'green', true));
+        }
+        try {
+            // Despite what the docs say node does not actually output any errors by itself
+            // so, in case this bug is fixed later, we turn it off explicitly.
+            result = vm.runInContext(strip_exports(js), ctx, {'filename':'<repl>', 'displayErrors':false});
+        } catch(e) {
+            if (e.stack) options.console.error(e.stack);
+            else options.console.error(e.toString());
+        }
+
+        if (result !== undefined) {
+            options.console.log(util.inspect(result, {'colors':options.terminal}));
+        }
+    }
+
+    function compile_source(source) {
+        var classes = (toplevel) ? toplevel.classes : undefined;
+        var scoped_flags = (toplevel) ? toplevel.scoped_flags: undefined;
+        try {
+            toplevel = RapydScript.parse(source, {
+                'filename':'<repl>',
+                'basedir': process.cwd(),
+                'libdir': options.imp_path,
+                'import_dirs': import_dirs,
+                'classes': classes,
+                'scoped_flags': scoped_flags,
+            });
+        } catch(e) {
+            if (e.is_eof && e.line == buffer.length && e.col > 0) return true;
+            if (e.message && e.line !== undefined) options.console.log(e.line + ':' + e.col + ':' + e.message);
+            else options.console.log(e.stack || e.toString());
+            return false;
+        }
+        var output = print_ast(toplevel);
+        if (classes) {
+            var exports = {};
+            toplevel.exports.forEach(function (name) { exports[name] = true; });
+            Object.getOwnPropertyNames(classes).forEach(function (name) {
+                if (!has_prop(exports, name) && !has_prop(toplevel.classes, name))
+                    toplevel.classes[name] = classes[name];
+            });
+        }
+        scoped_flags = toplevel.scoped_flags;
+        runjs(output);
+        return false;
+    }
+
+    function push(line) {
+        buffer.push(line);
+        var ll = line.trimRight();
+        if (ll && LINE_CONTINUATION_CHARS.indexOf(ll.substr(ll.length - 1)) > -1)
+            return true;
+        var source = buffer.join('\n');
+        if (!source.trim()) { resetbuffer(); return false; }
+        var incomplete = compile_source(source);
+        if (!incomplete) resetbuffer();
+        return incomplete;
+    }
+
+	rl.on('line', function(line) {
+        if (more) {
+            // We are in a block 
+            var line_is_empty = !line.trimLeft();
+            if (line_is_empty && buffer.length && !buffer[buffer.length - 1].trimLeft()) {
+                // We have two empty lines, evaluate the block
+                more = push(line.trimLeft());
+            } else buffer.push(line);
+        } else more = push(line);  // Not in a block, evaluate line
+		prompt();
+	})
+	
+	.on('close', function() {
+		options.console.log('Bye!');
+        if (rl.history) write_history(options, rl.history);
+		process.exit(0);
+	})
+
+	.on('SIGINT', function() {
+        rl.clearLine();
+		options.console.log('Keyboard Interrupt');
+        resetbuffer();
+        more = false;
+		prompt();
+	})
+
+	.on('SIGCONT', function() {
+		prompt();
+	});
+
+    rl.history = read_history(options);
+	prompt();
+};

package/tools/self.js

@@ -0,0 +1,162 @@
+/*
+ * self.js
+ * Copyright (C) 2015 Kovid Goyal <kovid at kovidgoyal.net>
+ *
+ * Distributed under terms of the BSD license.
+ */
+"use strict";  /*jshint node:true */
+
+var path = require('path');
+var crypto = require('crypto');
+var fs = require('fs');
+var vm = require('vm');
+var zlib = require('zlib');
+
+function compile_baselib(RapydScript, src_path) {
+    var items = fs.readdirSync(src_path).filter(function(name) {
+        return name.slice(0, 'baselib-'.length) === 'baselib-' && name.slice(-4) == '.pyj';
+    });
+    var ans = {'pretty': '', 'ugly': ''};
+
+    items.sort().forEach(function(fname) {
+        var name = fname.slice('baselib-'.length, -4), ast;
+        var raw = fs.readFileSync(path.join(src_path, fname), 'utf-8');
+        try {
+            ast = RapydScript.parse(raw, {filename:fname, basedir:src_path});
+        } catch (e) {
+            if (!(e instanceof RapydScript.SyntaxError)) throw e;
+            console.error(e.toString());
+            process.exit(1);
+        }
+        [true, false].forEach(function (beautify) {
+            var output = new RapydScript.OutputStream({
+                beautify: beautify, write_name: false, private_scope:false, omit_baselib: true,  
+            });
+            ast.print(output);
+            ans[(beautify) ? 'pretty' : 'ugly'] += output.get();
+        });
+    });
+    return ans;
+}
+
+function check_for_changes(base_path, src_path, signatures) {
+    // Check if any of the files involved in the build process have changed,
+    // as compared to the saved sha1 hashes from the last build
+    var saved_hashes = {}, hashes = {}, sources = {};
+    var compiler_changed = false, compiler_hash, source_hash;
+    try {
+        saved_hashes = JSON.parse(fs.readFileSync(signatures, 'utf-8'));
+    } catch (e) {
+        if (e.code != 'ENOENT') throw (e);
+    }
+
+    var src_file_names = [];
+
+    function process_dir(p) {
+        fs.readdirSync(p).forEach(function(name) {
+            var fp = path.join(p, name);
+            if (name.substr(-4) === '.pyj') src_file_names.push(path.relative(src_path, fp));
+            else if (name != 'lib' && fs.statSync(fp).isDirectory()) process_dir(fp);
+        });
+    }
+    process_dir(src_path);
+
+    compiler_hash = crypto.createHash('sha1');
+    source_hash = crypto.createHash('sha1');
+    src_file_names.forEach(function(fname) {
+        var src = path.join(src_path, fname);
+        sources[src] = fs.readFileSync(src, 'utf-8');
+        compiler_hash.update(sources[src]);
+        source_hash.update(sources[src]);
+        var h = crypto.createHash('sha1');
+        h.update(sources[src]);
+        hashes[fname.split('.')[0]] = h.digest('hex');
+    });
+    var compiler_files = [module.filename, path.join(base_path, 'tools', 'compiler.js')];
+    compiler_files.forEach(function(fpath) { 
+        compiler_hash.update(fs.readFileSync(fpath, 'utf-8'));
+    });
+    hashes['#compiler#'] = compiler_hash.digest('hex');
+    hashes['#compiled_with#'] = saved_hashes['#compiler#'] || 'unknown';
+    source_hash = source_hash.digest('hex');
+    if (hashes['#compiler#'] != saved_hashes['#compiler#']) {
+        console.log('There are changes to the source files of the compiler, rebuiliding');
+        compiler_changed = true;
+    } else if (hashes['#compiled_with#'] != saved_hashes['#compiled_with#']) {
+        console.log('Re-building compiler with updated version of itself');
+        compiler_changed = true;
+    }
+
+    return [source_hash, compiler_changed, sources, hashes];
+}
+
+
+function compile(src_path, lib_path, sources, source_hash, profile) {
+    var file = path.join(src_path, 'compiler.pyj');
+    var t1 = new Date().getTime();
+    var RapydScript = require('./compiler').create_compiler();
+    var output_options, profiler, cpu_profile;
+    var compiled_baselib = compile_baselib(RapydScript, src_path);
+    var out_path = path.join(path.dirname(lib_path), 'dev');
+    try {
+        fs.mkdirSync(out_path);
+    } catch (e) {
+        if (e.code != 'EEXIST') throw e;
+    }
+    output_options = {'beautify': true, 'baselib_plain': compiled_baselib.pretty};
+
+    var raw = sources[file], toplevel;
+
+	function parse_file(code, file) {
+		return RapydScript.parse(code, {
+			filename: file,
+			basedir: path.dirname(file),
+			libdir: path.join(src_path, 'lib'),
+		});
+	}
+
+    try {
+        if (profile) {
+            profiler = require('v8-profiler');
+            profiler.startProfiling();
+        }
+        toplevel = parse_file(raw, file);
+        if (profile) {
+            cpu_profile = profiler.stopProfiling();
+            fs.writeFileSync('self.cpuprofile', JSON.stringify(cpu_profile), 'utf-8');
+        }
+    } catch (e) {
+        if (!(e instanceof RapydScript.SyntaxError)) throw e;
+        console.error(e.toString());
+        process.exit(1);
+    }
+    var output = new RapydScript.OutputStream(output_options);
+    toplevel.print(output);
+    output = output.get().replace('__COMPILER_VERSION__', source_hash);
+    fs.writeFileSync(path.join(out_path, 'compiler.js'), output, "utf8");
+    fs.writeFileSync(path.join(out_path, 'baselib-plain-pretty.js'), compiled_baselib.pretty, 'utf-8');
+    fs.writeFileSync(path.join(out_path, 'baselib-plain-ugly.js'), compiled_baselib.ugly, 'utf-8');
+    console.log('Compiler built in', (new Date().getTime() - t1)/1000, 'seconds\n');
+    return output;
+}
+
+function run_single_compile(base_path, src_path, lib_path, profile) {
+    var out_path = path.join(path.dirname(lib_path), 'dev');
+    var signatures = path.join(out_path, 'signatures.json');
+    var temp = check_for_changes(base_path, src_path, signatures);
+    var source_hash = temp[0], compiler_changed = temp[1], sources = temp[2], hashes = temp[3];
+    
+    if (compiler_changed) {
+        compile(src_path, lib_path, sources, source_hash, profile);
+        fs.writeFileSync(signatures, JSON.stringify(hashes, null, 4));
+    } else console.log('Compiler is built with the up-to-date version of itself');
+    return compiler_changed;
+}
+
+module.exports = function compile_self(base_path, src_path, lib_path, complete, profile) {
+    var changed;
+    do {
+        changed = run_single_compile(base_path, src_path, lib_path, profile);
+        lib_path = path.join(path.dirname(lib_path), 'dev');
+    } while (changed && complete);
+};

package/tools/test.js

@@ -0,0 +1,118 @@
+/*
+ * test.js
+ * Copyright (C) 2015 Kovid Goyal <kovid at kovidgoyal.net>
+ *
+ * Distributed under terms of the BSD license.
+ */
+"use strict";  /*jshint node:true */
+var path = require('path');
+var fs = require('fs');
+var RapydScript = require('./compiler').create_compiler();
+var utils = require('./utils');
+var colored = utils.safe_colored;
+
+module.exports = function(argv, base_path, src_path, lib_path) {
+    // run all tests and exit
+    var assert = require("assert");
+    var os = require('os');
+    var failures = [];
+    var vm = require('vm');
+    var compiler_dir = path.join(base_path, 'dev');
+    if (!utils.path_exists(path.join(compiler_dir, 'compiler.js'))) compiler_dir = path.join(base_path, 'release');
+    var test_dir = path.join(base_path, 'test');
+	var baselib = fs.readFileSync(path.join(lib_path, 'baselib-plain-pretty.js'), 'utf-8');
+    var files;
+    var deep_eq = assert.deepEqual;
+    assert.deepEqual = function(a, b, message) {
+        // Compare array objects that have extra properties as simple arrays
+        if (Array.isArray(a) && Array.isArray(b)) {
+            if (a === b) return;
+            if (a.length !== b.length) throw new assert.AssertionError({actual:a, expected:b, operator:'deepEqual', stackStartFunction:assert.deepEqual});
+            for(var i=0; i < a.length; i++) assert.deepEqual(a[i], b[i], message);
+        } else if (a !== undefined && a !== null && typeof a.__eq__ === 'function') {
+            if (!a.__eq__(b)) throw new assert.AssertionError({actual:a, expected:b, operator:'deepEqual', stackStartFunction:assert.deepEqual});
+        } else return deep_eq(a, b, message);
+    };
+
+    if (argv.files.length) {
+        files = [];
+		argv.files.forEach(function(fname) { files.push(fname + '.pyj'); });
+	} else {
+        files = fs.readdirSync(test_dir).filter(function(name){
+            return /^[^_].*\.pyj$/.test(name);
+        });
+	}
+    files.forEach(function(file){
+        var ast;
+        var filepath = path.join(test_dir, file);
+        var failed = false;
+        try {
+            ast = RapydScript.parse(fs.readFileSync(filepath, "utf-8"), {
+                filename: file,
+                toplevel: ast,
+                basedir: test_dir,
+                libdir: path.join(src_path, 'lib'),
+            });
+            if (ast.imports && Object.keys(ast.imports).length) {
+                RapydScript.tree_shake(ast, {
+                    parse: RapydScript.parse,
+                    import_dirs: [],
+                    basedir: test_dir,
+                    libdir: path.join(src_path, 'lib'),
+                });
+            }
+        } catch(e) {
+            failures.push(file);
+            failed = true;
+            console.log(colored(file, 'red') + ': ' + e + "\n\n");
+            return;
+        }
+
+        var js_version = 5;
+        while (js_version < 7) {
+            // generate output
+            var output = new RapydScript.OutputStream({
+                baselib_plain: baselib,
+                beautify: true,
+                js_version: js_version,
+                keep_docstrings: true,
+            });
+            ast.print(output);
+
+            // test that output performs correct JS operations
+            var jsfile = path.join(os.tmpdir(), file + '-es' + js_version + '.js');
+            var code = output.toString();
+            try {
+                vm.runInNewContext(code, {
+                    'assrt':assert, 
+                    '__name__': jsfile,
+                    'require':require, 
+                    'fs':fs,
+                    'RapydScript':RapydScript, 
+                    'console':console,
+                    'compiler_dir': compiler_dir,
+                    'test_path':test_dir,
+                    'Buffer': Buffer,
+                }, {'filename':jsfile});
+            } catch (e) {
+                failures.push(file);
+                failed = true;
+                fs.writeFileSync(jsfile, code);
+                console.error('Failed running: ' + colored(jsfile, 'red'));
+                if (e.stack) 
+                    console.error(colored(file, 'red') + ":\n" + e.stack + "\n\n");
+                else 
+                    console.error(colored(file, 'red') + ": " + e + "\n\n");
+                js_version = 1000;
+            }
+            js_version++;
+        }
+		if (!failed) console.log(colored(file, 'green') + ": test completed successfully\n");
+        else { console.log(colored(file, 'red') + ":\ttest failed\n"); }
+    });
+    if (failures.length) {
+        console.log(colored('There were ' + failures.length + ' test failure(s):', 'red'));
+        console.log.apply(console, failures);
+    } else console.log(colored('All tests passed!', 'green'));
+    process.exit((failures.length) ? 1 : 0);
+};