sproutit-narwhal 0.1.106

data/engines/rhino/lib/concurrency.js

@@ -0,0 +1,6 @@
+/**
+* Provides some currency help
+*/
+exports.Lock = java.util.concurrent.locks.ReentrantReadWriteLock;
+exports.sync = sync; // already there in Rhino
+exports.ThreadLocal = java.lang.ThreadLocal;

data/engines/rhino/lib/event-queue.js

@@ -0,0 +1,18 @@
+/**
+* Represents the event queue for a vat
+*/
+
+// we could eventually upgrade to PriorityBlockingQueye with FIFOEntry tie breaking
+var queue = new java.util.concurrent.LinkedBlockingQueue();
+
+exports.nextEvent = function(){
+    return queue.take();
+};
+
+exports.enqueue = function(task, priority){
+    queue.put(task); // priority is ignored for now until PriorityBlockingQueue is used
+};
+
+exports.isEmpty = function(){
+    return queue.isEmpty();    
+}

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

@@ -0,0 +1,216 @@
+
+// use the "file" module as the exports object.
+var exports = require('./file');
+
+// File: Rhino
+
+var IO = require("./io").IO;
+var os = require('./os');
+
+var javaRuntime = function () {
+    return Packages.java.lang.Runtime.getRuntime();
+};
+
+var javaPopen = function (command) {
+    return javaRuntime().exec(command);
+};
+
+/* streams */
+
+exports.FileIO = function (path, mode, permissions) {
+    path = JavaPath(path);
+
+    var {
+        read: read,
+        write: write,
+        append: append,
+        update: update
+    } = exports.mode(mode);
+
+    if (update) {
+        throw new Error("Updating IO not yet implemented.");
+    } else if (write || append) {
+        return new IO(null, new Packages.java.io.FileOutputStream(path, append));
+    } else if (read) {
+        return new IO(new Packages.java.io.FileInputStream(path), null);
+    } else {
+        throw new Error("Files must be opened either for read, write, or update mode.");
+    }
+};
+
+/* paths */
+
+exports.cwd = function () {
+    return String(Packages.java.lang.System.getProperty("user.dir"));
+};
+
+var JavaPath = function (path) {
+    return new java.io.File(String(path) || ".");
+};
+
+exports.canonical = function (path) {
+    return String(JavaPath(path).getCanonicalPath());
+};
+
+exports.mtime = function (path) {
+    path = JavaPath(path);
+    var lastModified = path.lastModified();
+    if (lastModified === 0) return undefined;
+    else return new Date(lastModified);
+};
+
+exports.size = function (path) {
+    path = JavaPath(path);
+    return path.length();
+};
+
+exports.stat = function (path) {
+    path = JavaPath(path);
+    return {
+        mtime: exports.mtime(path),
+        size: exports.size(path)
+    }
+};
+
+exports.exists = function (path) {
+    return JavaPath(path).exists();
+};
+
+exports.linkExists = function (path) {
+    return exports.isLink(path) || exports.exists(path);
+};
+
+exports.isDirectory = function (path) {
+    try { return JavaPath(path).isDirectory(); } catch (e) {}
+    return false;
+};
+
+exports.isFile = function (path) {
+    try { return JavaPath(path).isFile(); } catch (e) {}
+    return false;
+};
+
+// XXX not standard
+exports.isAbsolute = function (path) {
+    return new java.io.File(path).isAbsolute();
+};
+
+/* see: http://www.idiom.com/~zilla/Xfiles/javasymlinks.html */
+exports.isLink = function (path) {
+    path = exports.path(path);
+    var canonical = path.canonical().toString();
+    var absolute = path.absolute().toString();
+    return absolute != canonical;
+};
+
+exports.isReadable = function (path) {
+    return JavaPath(path).canRead();
+};
+
+exports.isWritable = function (path) {
+    return JavaPath(path).canWrite();
+};
+
+exports.chmod = function (path, mode) {
+    os.command(['chmod', mode.toString(8), path]);
+};
+
+exports.chown = function (path, owner, group) {
+
+    if (!owner)
+        owner = "";
+    else
+        owner = String(owner);
+
+    if (group)
+        group = String(group);
+
+    if (/:/.test(owner))
+        throw new Error("Invalid owner name");
+    if (/:/.test(group))
+        throw new Error("Invalid group name");
+
+    if (group)
+        owner = owner + ":" + String(group);
+
+    os.command(['chown', owner, path]);
+};
+
+exports.link = function (source, target) {
+    os.command(['ln', source, target]);
+};
+
+exports.symlink = function (source, target) {
+    // XXX this behavior of resolving the source
+    // path from the target path when the source 
+    // path is relative ought to be discussed
+    // on ServerJS
+    if (exports.isRelative(source))
+        source = exports.relative(target, source);
+    os.command(['ln', '-s', source, target]);
+};
+
+exports.rename = function (source, target) {
+    source = exports.path(source);
+    target = source.resolve(target);
+    source = JavaPath(source);
+    target = JavaPath(target);
+    if (!source.renameTo(target))
+        throw new Error("failed to rename " + source + " to " + target);
+};
+
+exports.move = function (source, target) {
+    source = exports.path(source);
+    target = exports.path(target);
+    source = JavaPath(source);
+    target = JavaPath(target);
+    if (!source.renameTo(target))
+        throw new Error("failed to rename " + source + " to " + target);
+};
+
+exports.remove = function (path) {
+    if (!JavaPath(path)['delete']())
+        throw new Error("failed to delete " + path);
+};
+
+exports.mkdir = function (path) {
+    if (!JavaPath(path).mkdir())
+        throw new Error("failed to make directory " + path);
+};
+
+exports.mkdirs = function(path) {
+    JavaPath(path).mkdirs();
+    if (!exports.isDirectory(path))
+        throw new Error("failed to make directories leading to " + path);
+};
+
+exports.rmdir = function(path) {
+    if (!JavaPath(String(path))['delete']())
+        throw new Error("failed to remove the directory " + path);
+};
+
+exports.list = function (path) {
+    path = JavaPath(String(path));
+    var listing = path.list();
+
+    if (!(listing instanceof Array)) {
+        throw new Error("no such directory: " + path);
+    }
+
+    var paths = [];
+    for (var i = 0; i < listing.length; i++) {
+        paths[i] = String(listing[i]);
+    }
+
+    return paths;
+};
+
+exports.touch = function (path, mtime) {
+    if (mtime === undefined || mtime === null)
+        mtime = new Date();
+    path = JavaPath(path);
+    path.createNewFile();
+    if (!path.setLastModified(mtime.getTime()))
+        throw new Error("unable to set mtime of " + path + " to " + mtime);
+};
+

data/engines/rhino/lib/http-client-engine.js

@@ -0,0 +1,90 @@
+var IO = require("io").IO,
+    HashP = require("hashp").HashP;
+
+var engine = exports;
+
+engine.connect = function HttpClient_engine_connect (tx) {
+    if (tx._isConnected) return;
+    
+    var con = java.net.HttpURLConnection(new java.net.URL(tx.url).openConnection());
+    con.setRequestMethod(tx.method.toUpperCase());
+    
+    HashP.forEach(tx.headers, function (h, v) {
+        con.setRequestProperty(h, v);
+    });
+    if (!tx.headers) tx.headers = {};
+    var cl = HashP.get(tx.headers, "Content-Length") || 0;
+    if (cl > 0) {
+        con.setDoOutput(true);
+        var os = null;
+        try {
+            os = con.getOutputStream();
+        } catch (ex) {}
+        if (os) {
+            var writer = new IO(null, con.getOutputStream());
+            tx.body.forEach(function (piece) {
+                writer.write(piece);
+            });
+            writer.close();
+        }
+    }
+    
+    try {
+        con.connect();
+    } catch (ex) {
+        // It would be nice to do something clever and special here,
+        // but I'm not feeling it at the moment.
+        ex.message = [
+            "Could not connect to "+tx.url+". Probably a bad hostname.",
+            ex.message
+        ].join("\n");
+        throw ex;
+    }
+    
+    tx._isConnected = true;
+    var resp = tx._response = {status:200, headers:{}, body:[]};
+    
+    // Call this now to trigger the fetch asynchronously.
+    // This way, if you set up multiple HttpClients, and then call connect()
+    // on all of them, you'll only wait as long as the slowest one, since
+    // the streams will start filling up right away.
+    
+    
+    // now pull everything out.
+    var fields = con.getHeaderFields();
+    var fieldKeys = fields.keySet().toArray();
+    for (var i = 0, l = fieldKeys.length; i < l; i ++ ) {
+        var fieldValue = fields.get(fieldKeys[i]).toArray().join('');
+        var fieldName = fieldKeys[i];
+        if (fieldName === null) {
+            // Something like: HTTP/1.1 200 OK
+            HashP.set(resp, "status", +(/HTTP\/1\.[01] ([0-9]{3})/.exec(fieldValue)[1]));
+            // fieldName = "Status";
+            resp.statusText = fieldValue;
+            continue;
+        }
+        HashP.set(resp.headers, fieldName, fieldValue);
+    }
+
+    // TODO: Restructure using non-blocking IO to support asynchronous interactions.
+    // In that case, you could just have a callback that gets each bytestring.
+    var is = null;
+    try {
+        var is = con.getInputStream();
+    } catch (ex) {
+        return resp;
+    }
+    
+    // TODO: Should the input stream be rewindable?
+    var reader = new IO(con.getInputStream(), null);
+    resp.body = {forEach : function (block) {
+        var buflen = 1024;
+        for (
+            var bytes = reader.read(buflen);
+            bytes.length > 0;
+            bytes = reader.read(buflen)
+        ) block(bytes);
+    }};
+    
+    return resp;
+};

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

@@ -0,0 +1,10 @@
+
+var IO = require('./io').IO;
+
+exports.IO = function (url) {
+    return new IO(
+        new java.net.URL(url).openStream(),
+        null
+    );
+};
+

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

@@ -0,0 +1,347 @@
+// IO: Rhino
+
+var IO = exports.IO = function(inputStream, outputStream) {
+    this.inputStream = inputStream;
+    this.outputStream = outputStream;
+};
+
+IO.prototype.readInto = function(buffer, length, from) {
+    var bytes = buffer._bytes; // java byte array
+
+    var offset = buffer._offset;
+    if (typeof from === "number")
+        offset += from;
+
+    if (length > bytes.length + offset)
+        throw "FIXME: Buffer too small. Throw or truncate?";
+
+    var total = 0,
+        bytesRead = 0;
+
+    while (total < length) {
+        bytesRead = this.inputStream.read(bytes, offset + total, length - total);
+        if (bytesRead < 0)
+            break;
+        total += bytesRead;
+    }
+
+    return total;
+};
+
+IO.prototype.writeInto = function(buffer, from, to) {
+    this.outputStream.write(buffer._bytes, buffer._offset + from, to - from);
+};
+
+IO.prototype.copy = function (output, mode, options) {
+    while (true) {
+        var buffer = this.read(null);
+        if (!buffer.length)
+            break;
+        output.write(buffer);
+    }
+    output.flush();
+    return this;
+};
+
+IO.prototype.flush = function() {
+    this.outputStream.flush();
+    return this;
+};
+
+IO.prototype.close = function() {
+    if (this.inputStream)
+        this.inputStream.close();
+    if (this.outputStream)
+        this.outputStream.close();
+};
+
+IO.prototype.isatty = function () {
+    return false;
+};
+
+exports.TextInputStream = function (raw, lineBuffering, buffering, charset, options) {
+    var stream;
+
+    if (charset === undefined)
+        stream = new Packages.java.io.InputStreamReader(raw.inputStream);
+    else
+        stream = new Packages.java.io.InputStreamReader(raw.inputStream, charset);
+
+    if (buffering === undefined)
+        stream = new Packages.java.io.BufferedReader(stream);
+    else
+        stream = new Packages.java.io.BufferedReader(stream, buffering);
+
+    var self = this;
+
+    self.raw = raw;
+
+    self.readLine = function () {
+        var line = stream.readLine();
+        if (line === null)
+            return '';
+        return String(line) + "\n";
+    };
+
+    self.next = function () {
+        var line = stream.readLine();
+        if (line === null)
+            throw StopIteration;
+        return String(line);
+    };
+
+    self.iterator = function () {
+        return self;
+    };
+
+    self.forEach = function (block, context) {
+        var line;
+        while (true) {
+            try {
+                line = self.next();
+            } catch (exception) {
+                break;
+            }
+            block.call(context, line);
+        }
+    };
+
+    self.input = function () {
+        throw "NYI";
+    };
+
+    self.readLines = function () {
+        var lines = [];
+        do {
+            var line = self.readLine();
+            if (line.length)
+                lines.push(line);
+        } while (line.length);
+        return lines;
+    };
+
+    self.read = function () {
+        return self.readLines().join('');
+    };
+
+    self.readInto = function (buffer) {
+        throw "NYI";
+    };
+
+    self.copy = function (output, mode, options) {
+        do {
+            var line = self.readLine();
+            output.write(line).flush();
+        } while (line.length);
+        return self;
+    };
+
+    self.close = function () {
+        stream.close();
+    };
+
+    return Object.create(self);
+};
+
+exports.TextOutputStream = function (raw, lineBuffering, buffering, charset, options) {
+    var stream;
+
+    if (charset === undefined)
+        stream = new Packages.java.io.OutputStreamWriter(raw.outputStream);
+    else
+        stream = new Packages.java.io.OutputStreamWriter(raw.outputStream, charset);
+
+    if (buffering === undefined)
+        stream = new Packages.java.io.BufferedWriter(stream);
+    else
+        stream = new Packages.java.io.BufferedWriter(stream, buffering);
+
+    var self = this;
+
+    self.raw = raw;
+
+    self.write = function () {
+        stream.write.apply(stream, arguments);
+        return self;
+    };
+
+    self.writeLine = function (line) {
+        self.write(line + "\n"); // todo recordSeparator
+        return self;
+    };
+
+    self.writeLines = function (lines) {
+        lines.forEach(self.writeLine);
+        return self;
+    };
+
+    self.print = function () {
+        self.write(Array.prototype.join.call(arguments, " ") + "\n");
+        self.flush();
+        // todo recordSeparator, fieldSeparator
+        return self;
+    };
+
+    self.flush = function () {
+        stream.flush();
+        return self;
+    };
+
+    self.close = function () {
+        stream.close();
+        return self;
+    };
+
+    return Object.create(self);
+};
+
+exports.TextIOWrapper = function (raw, mode, lineBuffering, buffering, charset, options) {
+    if (mode.update) {
+        return new exports.TextIOStream(raw, lineBuffering, buffering, charset, options);
+    } else if (mode.write || mode.append) {
+        return new exports.TextOutputStream(raw, lineBuffering, buffering, charset, options);
+    } else if (mode.read) {
+        return new exports.TextInputStream(raw, lineBuffering, buffering, charset, options);
+    } else {
+        throw new Error("file must be opened for read, write, or append mode.");
+    }
+}; 
+
+
+/* ByteIO */
+
+// FIXME: this doesn't read/write the same stream
+
+var ByteIO = exports.ByteIO = function(binary) {
+    this.inputStream = binary ? new java.io.ByteArrayInputStream(binary._bytes, binary._offset, binary._length) : null;
+    this.outputStream = new java.io.ByteArrayOutputStream();
+    
+    var stream = (this.inStream, this.outStream);
+    
+    this.length = binary ? binary.length : 0;
+};
+
+ByteIO.prototype = new exports.IO();
+
+ByteIO.prototype.toByteString = function() {
+    var bytes = this.outputStream.toByteArray();
+    var ByteString = require("binary").ByteString;
+    return new ByteString(bytes, 0, bytes.length);
+}
+
+ByteIO.prototype.decodeToString = function(charset) {
+    return String(charset ? this.outputStream.toString(charset) : this.outputStream.toString());
+}
+
+var StringIO = exports.StringIO = function (initial, delimiter) {
+    var buffer = new java.lang.StringBuffer();
+    if (!delimiter)
+        delimiter = "\n";
+    if (initial)
+        buffer.append(initial);
+
+    function length() {
+        return buffer.length();
+    }
+
+    function read(length) {
+        if (arguments.length == 0) { 
+            var result = String(buffer);
+            buffer['delete'](0, buffer.length());
+            return result;
+        } else {
+            if (!length || length < 1)
+                length = 1024;
+            length = Math.min(buffer.length(), length);
+            var result = String(buffer.substring(0, length));
+            buffer['delete'](0, length);
+            return result;
+        }
+    }
+
+    function write(text) {
+        buffer.append(text);
+        return self;
+    }
+
+    function copy(output) {
+        output.write(read()).flush();
+        return self;
+    }
+
+    function next() {
+        if (buffer.length() == 0)
+            throw StopIteration;
+        var pos = buffer.indexOf(delimiter);
+        if (pos == -1)
+            pos = buffer.length();
+        var result = read(pos);
+        read(1);
+        return result;
+    }
+
+    var self = {
+        get length() {
+            return length();
+        },
+        read: read,
+        write: write,
+        copy: copy,
+        close: function () {
+            return self;
+        },
+        flush: function () {
+            return self;
+        },
+        iterator: function () {
+            return self;
+        },
+        forEach: function (block) {
+            while (true) {
+                try {
+                    block.call(this, next());
+                } catch (exception) {
+                    if (exception instanceof StopIteration)
+                        break;
+                    throw exception;
+                }
+            }
+        },
+        readLine: function () {
+            var pos = buffer.indexOf(delimiter);
+            if (pos == -1)
+                pos = buffer.length();
+            return read(pos + 1);
+        },
+        readLines: function () {
+            var lines = [];
+            do {
+                var line = self.readLine();
+                if (line.length)
+                    lines.push(line);
+            } while (line.length);
+            return lines;
+        },
+        next: next,
+        print: function (line) {
+            return write(line + delimiter).flush();
+        },
+        toString: function() {
+            return String(buffer);
+        },
+        substring: function () {
+            var string = String(buffer);
+            return string.substring.apply(string, arguments);
+        },
+        slice: function () {
+            var string = String(buffer);
+            return string.slice.apply(string, arguments);
+        },
+        substr: function () {
+            var string = String(buffer);
+            return string.substr.apply(string, arguments);
+        }
+    };
+    return Object.create(self);
+};
+