sproutit-narwhal 0.1.106

data/engines/rhino/lib/md5-engine.js

@@ -0,0 +1,40 @@
+
+var binary = require("./binary");
+
+var JString = Packages.java.lang.String,
+    JInteger = Packages.java.lang.Integer,
+    JStringBuffer = Packages.java.lang.StringBuffer,
+    JMessageDigest = Packages.java.security.MessageDigest;
+
+exports.hash = function (str) {
+    var jstr = new JString(str);
+    var algorithm = JMessageDigest.getInstance("MD5");
+    algorithm.reset();
+    algorithm.update(jstr.getBytes());
+    var bytes = algorithm.digest();
+    return binary.ByteString(bytes);
+};
+
+// deprecated
+// 
+
+var MD5 = exports.MD5 = {};
+
+MD5.hexdigest = function(str) {
+    system.log.warn('hexdigest is depreacted, use md5.hash().toString(16)');
+    var jstr = new JString(str);
+    var algorithm = JMessageDigest.getInstance("MD5");
+    
+    algorithm.reset();
+    algorithm.update(jstr.getBytes());
+
+    var messageDigest = algorithm.digest();
+    
+    var hexString = new JStringBuffer();
+    for (var i = 0; i < messageDigest.length; i++) {
+        hexString.append(JInteger.toHexString(0xFF & messageDigest[i]));
+    }
+
+    return String(hexString.toString());
+};
+

data/engines/rhino/lib/os-engine.js

@@ -0,0 +1,150 @@
+
+var io = require('io');
+
+var cLib;
+var getCLib = function () {
+    var jna = Packages.com.sun.jna;
+    cLib = jna.NativeLibrary.getInstance(
+        jna.Platform.isWindows() ? "msvcrt" : "c"
+    );
+    getCLib = function () {
+        return cLib;
+    };
+    return cLib;
+};
+
+exports.exit = function (status) {
+    Packages.java.lang.System.exit(status << 0);
+};
+
+exports.sleep = function (seconds) {
+    Packages.java.lang.Thread.sleep((seconds * 1000) >>> 0);
+};
+
+exports.fork = function () {
+};
+
+exports.exec = function () {
+};
+
+var cSystem;
+var getCSystem = function () {
+    cSystem = getCLib().getFunction("system");
+    getCSystem = function () {
+        return cSystem;
+    };
+    return cSystem;
+};
+
+exports.system = function (command) {
+    if (Array.isArray(command)) {
+        command = command.map(function (arg) {
+            return require("os").enquote(arg);
+        }).join(" ");
+    }
+    return getCSystem().invokeInt([command]) >> 8;
+};
+
+exports.dup = function () {
+};
+
+exports.dup2 = function () {
+};
+
+exports.setsid = function () {
+};
+
+exports.getpid = function () {
+};
+
+var javaRuntime = function () {
+    return Packages.java.lang.Runtime.getRuntime();
+};
+
+var javaPopen = function (command) {
+    return javaRuntime().exec(command);
+};
+
+exports.popen = function (command, options) {
+    // todo options: "b", {charset, shell}
+    if (!options)
+        options = {};
+    if (typeof command == "string")
+        command = ["sh", "-c", command];
+
+    var process = javaPopen(command);
+
+    var stdin = new io.TextOutputStream(new io.IO(null, process.getOutputStream()));
+    var stdout = new io.TextInputStream(new io.IO(process.getInputStream()));
+    var stderr = new io.TextInputStream(new io.IO(process.getErrorStream()));
+
+    return {
+        wait: function () {
+            return process.waitFor();
+        },
+        stdin: stdin,
+        stdout: stdout,
+        stderr: stderr,
+        communicate: function (input, output, errput) {
+
+            if (typeof stdin == "string")
+                stdin = new io.StringIO(input);
+            else if (!stdin)
+                stdin = new io.StringIO();
+
+            if (typeof input == "string")
+                input = new io.StringIO(input);
+            else if (!input)
+                input = new io.StringIO();
+            if (!output)
+                output = new io.StringIO();
+            if (!errput)
+                errput = new io.StringIO();
+
+            var inThread = new JavaAdapter(Packages.java.lang.Thread, {
+                "run": function () {
+                    input.copy(stdin);
+                    stdin.close();
+                }
+            });
+
+            var outThread = new JavaAdapter(Packages.java.lang.Thread, {
+                "run": function () {
+                    stdout.copy(output);
+                    stdout.close();
+                }
+            });
+
+            var errThread = new JavaAdapter(Packages.java.lang.Thread, {
+                "run": function () {
+                    stderr.copy(errput);
+                    stderr.close();
+                }
+            });
+
+            inThread.setDaemon(true);
+            inThread.start();
+            errThread.setDaemon(true);
+            errThread.start();
+            outThread.setDaemon(true);
+            outThread.start();
+
+            inThread.join();
+            outThread.join();
+            errThread.join();
+
+            var status = process.waitFor();
+            stdin.close();
+            stdout.close();
+            stderr.close();
+
+            return {
+                status: status,
+                stdin: input,
+                stdout: output,
+                stderr: errput
+            };
+        }
+    }
+};
+

data/engines/rhino/lib/packages-engine.js

@@ -0,0 +1,71 @@
+
+var fs = require('./file');
+var system = require('./system');
+
+/*** analyze
+*/
+exports.analyze = function (analysis, sortedPackages) {
+    var javaPaths = analysis.javaPaths = []
+    sortedPackages.forEach(function (packageData) {
+        /* migration */
+        if (packageData.jars)
+            packageData.java = packageData.jars;
+        /* /migration */
+        if (typeof packageData.java == 'string')
+            packageData.java = [packageData.java];
+        if (!packageData.java)
+            packageData.java = [];
+        for (var i = 0; i < packageData.java.length; i++)
+            packageData.java[i] = packageData.directory.resolve(packageData.java[i]);
+        /* new approach */
+        var jarsDirectory = packageData.directory.join('jars');
+        if (jarsDirectory.isDirectory()) {
+            jarsDirectory.listPaths().forEach(function (jarDirectory) {
+                packageData.java.push(jarDirectory);
+            });
+        }
+        javaPaths.unshift.apply(javaPaths, packageData.java);
+    });
+};
+
+/*** synthesize
+*/
+exports.synthesize = function (analysis) {
+    exports.addJavaPaths(analysis.javaPaths);
+};
+
+var loader = Packages.java.lang.ClassLoader.getSystemClassLoader();
+// so that replacing Packages does not implicitly dispose of the
+//  only means of creating new Packages objects.
+
+/*** addJavaPaths
+*/
+exports.addJavaPaths = function addJavaPaths(javaPaths) {
+    if (!javaPaths || javaPaths.length === 0)
+        return;
+    // after reinstalling Packages once, the Packages object
+    // is no longer a Packages constructor function.
+    // If that's the case, abandone hope.
+    if (typeof Packages == "object" || system.appEngine)
+        return;
+        
+    /* set up jar loader */
+    var urls = Packages.java.lang.reflect.Array.newInstance(java.net.URL, javaPaths.length);
+    for (var i = 0; i < javaPaths.length; i++) {
+        urls[i] = new Packages.java.net.URL('file://' + javaPaths[i]);
+    };
+    loader = new Packages.java.net.URLClassLoader(urls, loader);
+
+    try {
+        /* intall jar loader */
+        //Packages.java.lang.Thread.currentThread().setContextClassLoader(loader);
+        var context = Packages.org.mozilla.javascript.Context.getCurrentContext();
+        context.setApplicationClassLoader(loader);
+        // must explicitly be made global when each module has it's own scope
+        global.Packages = new Packages(loader);
+        installed = true;
+    } catch (e) {
+        print("warning: couldn't install jar loader: " + e);
+    }
+};
+

data/engines/rhino/lib/sandbox-engine.js

@@ -0,0 +1,70 @@
+
+/* shared, sealed global context */
+
+var blacklist = [
+    'Packages',
+    'java',
+    'javax',
+    'org',
+    'net',
+    'com',
+    'edu',
+    'JavaAdapter',
+    'JavaImporter',
+    'getClass'
+];
+
+var whitelist = [
+    'Array',
+    'Boolean',
+    'Date',
+    'Error',
+    'EvalError',
+    'Function',
+    'Math',
+    'Number',
+    'Object',
+    'RangeError',
+    'ReferenceError',
+    'InternalError',
+    'RegExp',
+    'String',
+    'SyntaxError',
+    'TypeError',
+    'URIError',
+    'Infinity',
+    'NaN',
+    'undefined',
+    'decodeURI',
+    'decodeURIComponent',
+    'encodeURI',
+    'encodeURIComponent',
+    'eval',
+    'isFinite',
+    'isNaN',
+    'parseFloat',
+    'parseInt'
+];
+
+var context = new Packages.org.mozilla.javascript.Context();
+var global = context.initStandardObjects(null, true);
+for (var i = 0; i < blacklist.length; i++)
+    delete global[blacklist[i]];
+seal(global);
+
+
+/* create module factories */
+
+exports.evaluate = function (text, id) {
+    // verify that the script is a program by compiling it as such
+    context.compileString(text, id, 1, null);
+    // return a module factory function instead though.
+    return context.compileFunction(
+        global,
+        "function(require,exports,module,system,print){"+text+"}",
+        id,
+        1,
+        null
+    );
+};
+

data/engines/rhino/lib/system.js

@@ -0,0 +1,38 @@
+
+var io = require("./io");
+
+exports.print = function () {
+    exports.stdout.write(Array.prototype.join.call(arguments, ' ') + "\n").flush();
+};
+
+exports.stdin  = new io.TextInputStream(new io.IO(Packages.java.lang.System['in'], null));
+exports.stdout = new io.TextOutputStream(new io.IO(null, Packages.java.lang.System.out));
+exports.stderr = new io.TextOutputStream(new io.IO(null, Packages.java.lang.System.err));
+
+exports.args = global.arguments || [];
+exports.originalArgs = exports.args.slice(0);
+
+exports.env = {};
+
+var env = Packages.java.lang.System.getenv(),
+    keyIterator = env.keySet().iterator();
+while (keyIterator.hasNext()) {
+    var key = keyIterator.next();
+    exports.env[String(key)] = String(env.get(key));
+}
+
+var securityManager = Packages.java.lang.System.getSecurityManager()
+if (securityManager) {
+    var securityManagerName = securityManager.getClass().getName();
+    if (/^com.google.app(engine|hosting)./.test(securityManagerName))
+        exports.appEngine = true;
+    if (/^com.google.apphosting\./.test(securityManagerName))
+        exports.appEngineHosting = true;
+}
+
+exports.fs = require('./file');
+
+// default logger
+var Logger = require("./logger").Logger;
+exports.log = new Logger(exports.stderr);
+

data/engines/rhino/lib/worker-engine.js

@@ -0,0 +1,23 @@
+exports.createEnvironment = function(){
+    var workerQueue, 
+        workerGlobal = new org.mozilla.javascript.tools.shell.Global();
+    javaWorkerGlobal = new org.mozilla.javascript.NativeJavaObject(global, workerGlobal, null);
+    javaWorkerGlobal.init(org.mozilla.javascript.tools.shell.Main.shellContextFactory);
+    workerGlobal.NARWHAL_HOME = system.prefix;
+    workerGlobal.NARWHAL_ENGINE_HOME = system.enginePrefix;
+    // get the path to the bootstrap.js file
+    var bootstrapPath = system.enginePrefix + "/bootstrap.js";
+    org.mozilla.javascript.tools.shell.Main.processFile(
+        org.mozilla.javascript.Context.enter(), 
+        workerGlobal,
+        bootstrapPath);
+    return workerGlobal;
+};
+
+exports.spawn = function(functionToRun, threadName){
+    (new java.lang.Thread(functionToRun, threadName)).start();
+};
+
+exports.defaultErrorReporter = function(e){
+    print((e.rhinoException && e.rhinoException.printStackTrace()) || (e.name + ": " + e.message));
+};

data/engines/rhino/lib/zip.js

@@ -0,0 +1,78 @@
+
+var io = require('io');
+
+var javaZip = Packages.java.util.zip;
+var JavaZipFile = javaZip.ZipFile;
+var JavaZipEntry = javaZip.ZipEntry;
+
+exports.unzip = function (source, target) {
+    if (!target)
+        target = system.fs.path(source).absolute().dirname();
+    target = system.fs.path(target);
+    return new exports.Unzip(source).forEach(function (entry) {
+        var targetPath = target.join(entry.getName());
+        if (entry.isDirectory())
+            return;
+        targetPath.dirname().mkdirs();
+        targetPath.write(entry.read('b'), 'b');
+    });
+};
+
+exports.Unzip = function (path) {
+    this._javaZipFile = JavaZipFile(path);
+};
+
+exports.Unzip.prototype.iterator = function () {
+    var self = this;
+    var enumeration = this._javaZipFile.entries();
+    return {
+        next: function () {
+            if (!enumeration.hasMoreElements())
+                throw new StopIteration();
+            return new exports.Entry(
+                self._javaZipFile,
+                enumeration.nextElement()
+            );
+        }
+    };
+};
+
+exports.Unzip.prototype.forEach = function (block, context) {
+    var iterator = this.iterator();
+    var next;
+    while (true) {
+        try {
+            next = iterator.next();
+        } catch (exception) {
+            break;
+        }
+        block.call(context, next);
+    }
+};
+
+exports.Entry = function (javaZipFile, javaZipEntry) {
+    this._javaZipFile = javaZipFile;
+    this._javaZipEntry = javaZipEntry;
+};
+
+exports.Entry.prototype.getName = function () {
+    return String(this._javaZipEntry.getName());
+};
+
+exports.Entry.prototype.isDirectory = function () {
+    return Boolean(this._javaZipEntry.isDirectory());
+};
+
+exports.Entry.prototype.open = function (mode, options) {
+    // TODO mode and options negotiation
+    return new io.IO(this._javaZipFile.getInputStream(this._javaZipEntry));
+};
+
+exports.Entry.prototype.read = function () {
+    return this.open().read();
+};
+
+exports.Entry.prototype.copy = function (output, mode, options) {
+    return this.open().copy(output);
+};
+