sproutit-narwhal 0.1.106

data/engines/default/lib/object.js

@@ -0,0 +1,69 @@
+
+if (!Object.keys) {
+    Object.keys = function (object) {
+        var keys = [];
+        for (var name in object) {
+            if (Object.prototype.hasOwnProperty.call(object, name)) {
+                keys.push(name);
+            }
+        }
+        return keys;
+    };
+}
+
+if (!Object.defineProperty)
+    Object.defineProperty = function(object, property, descriptor) {
+        var has = Object.prototype.hasOwnProperty;
+        if (typeof descriptor == "object") {
+            if (has.call(descriptor, "value")) {
+                if (!object.__lookupGetter__(property) && !object.__lookupSetter__(property))
+                    // data property defined and no pre-existing accessors
+                    object[property] = descriptor.value;
+                if ((has.call(descriptor, "get") || has.call(descriptor, "set")))
+                    // descriptor has a value property but accessor already exists
+                    throw new TypeError("Object doesn't support this action");
+            }
+            if ( // can't implement these features; allow false but not true
+                !(has.call(descriptor, "writable") ? descriptor.writable : true) ||
+                !(has.call(descriptor, "enumerable") ? descriptor.enumerable : true) ||
+                !(has.call(descriptor, "configurable") ? descriptor.configurable : true)
+            )
+                throw new RangeError(
+                    "This implementation of Object.defineProperty does not " +
+                    "support configurable, enumerable, or writable."
+                );
+            else if (typeof descriptor.get == "function")
+                object.__defineGetter__(property, descriptor.get);
+            if (typeof descriptor.set == "function")
+                object.__defineSetter__(property, descriptor.set);
+        }
+        return object;
+    };
+
+if (!Object.defineProperties) {
+    Object.defineProperties = function(object, properties) {
+        for (var property in properties) {
+            if (Object.prototype.hasOwnProperty.call(properties, property))
+                Object.defineProperty(object, property, properties[property]);
+        }
+        return object;
+    };
+}
+
+if (!Object.create) {
+    Object.create = function(prototype, properties) {
+        function Type() {};
+        Type.prototype = prototype;
+        var object = new Type();
+        if (typeof properties !== "undefined")
+            Object.defineProperties(object, properties);
+        return object;
+    };
+}
+
+if (!Object.freeze) {
+    Object.freeze = function (object) {
+        return object;
+    };
+}
+

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

@@ -0,0 +1,3 @@
+exports.exit = function(status) {
+    throw new Error("Exiting with status="+status);
+}

data/engines/default/lib/reactor.js

@@ -0,0 +1,12 @@
+
+var tasks = [];
+
+require('unload').when(function () {
+    while (tasks.length)
+        tasks.shift()();
+});
+
+exports.enqueue = function (task) {
+    tasks.push(task);
+};
+

data/engines/default/lib/string.js

@@ -0,0 +1,84 @@
+// String additions
+
+String.prototype.squeeze = function() {
+    var set = arguments.length > 0 ? "["+Array.prototype.join.call(arguments, '')+"]" : ".|\\n",
+        regex = new RegExp("("+set+")\\1+", "g");
+    
+    return this.replace(regex, "$1");
+};
+
+String.prototype.chomp = function(separator) {
+    var extra = separator ? separator + "|" : "";
+    return this.replace(new RegExp("("+extra+"\\r|\\n|\\r\\n)*$"), "");
+};
+
+// Check if the string starts with the given prefix string.
+String.prototype.begins = function(str) {
+    return this.indexOf(str) === 0;
+};
+
+// Check if the string ends with the given postfix string.
+String.prototype.ends = function(str) {
+    var offset = this.length - str.length;
+    return offset >= 0 && this.lastIndexOf(str) === offset;
+};
+
+// Trim the string, left/right.
+//
+// Faster version: http://blog.stevenlevithan.com/archives/faster-trim-javascript
+//
+// function trim (str) {
+// var str = str.replace(/^\s\s*/, ''),
+// ws = /\s/,
+// i = str.length;
+// while (ws.test(str.charAt(--i)));
+// return str.slice(0, i + 1);
+// }
+//Trim the string, left.
+var trimBeginExpression = /^\s\s*/g;
+String.prototype.trimBegin = function() {
+    return this.replace(trimBeginExpression, "");
+};
+
+// Trim the string, right.
+var trimEndExpression = /\s\s*$/g;
+String.prototype.trimEnd = function() {
+    return this.replace(trimEndExpression, "");
+};
+
+String.prototype.trim = function() {
+    return this.replace(trimBeginExpression, "").replace(trimEndExpression, "");
+};
+
+/* binary */
+
+// https://wiki.mozilla.org/ServerJS/Binary/B
+if (!String.prototype.toByteString)
+    String.prototype.toByteString = function(charset) {
+        // RHINO bug: it thinks "this" is a Java string (?!)
+        var binary = require("binary");
+        return new binary.ByteString(String(this), charset);
+    };
+
+// https://wiki.mozilla.org/ServerJS/Binary/B
+if (!String.prototype.toByteArray)
+    String.prototype.toByteArray = function(charset) {
+        // RHINO bug: it thinks "this" is a Java string (?!)
+        var binary = require("binary");
+        return new binary.ByteArray(String(this), charset);
+    };
+
+// https://wiki.mozilla.org/ServerJS/Binary/B
+if (!String.prototype.charCodes)
+    String.prototype.charCodes = function() {
+        return Array.prototype.map.call(this, function (c) {
+            return c.charCodeAt();
+        });
+    };
+
+// https://wiki.mozilla.org/ServerJS/Binary/B
+if (!String.prototype.fromCharCodes)
+    String.fromCharCodes = function (codes) {
+        return codes.map(String.fromCharCode).join('');
+    };
+

data/engines/default/lib/system.js

@@ -0,0 +1,20 @@
+
+var IO = require("./io").IO;
+
+exports.print = function () {
+    exports.stdout.write(Array.prototype.join.call(arguments, ' ') + "\n").flush();
+};
+
+exports.stdin  = new IO(function(){}, null);
+exports.stdout = new IO(null, function(string) { exports.print(String(string).replace(/\n$/,"")); });
+exports.stderr = new IO(null, function(string) { exports.print(String(string).replace(/\n$/,"")); });
+
+exports.args = global.arguments || [];
+
+exports.env = {};
+
+exports.fs = require('./file');
+
+// default logger
+var Logger = require("logger").Logger;
+exports.log = new Logger(exports.stdout);

data/engines/default/lib/worker.js

@@ -0,0 +1,133 @@
+var queue = require("event-queue");
+var workerEngine = require("worker-engine");
+
+var Worker = exports.Worker = function(scriptName){
+    var worker;
+    createWorker(scriptName, function(workerQueue, workerGlobal){
+        worker = createPort(workerQueue, workerGlobal, null, workerGlobal);
+        createPort(queue, worker, workerGlobal, global);
+        return worker;
+    });
+    return worker;
+};
+
+function createPort(queue, target, port, global){
+    target.onmessage = true; // give it something to feature detect off of
+    port = port || {
+            // allows for sending a message with a direct object reference.
+            // this is not part of CommonJS, and must be used with great care.
+            __enqueue__: function(eventName, args){
+                queue.enqueue(function(){
+                    if(typeof target[eventName] == "function"){
+                        target[eventName].apply(target, args);
+                    }
+                });
+            }
+        };
+    port.postMessage = function(message){
+        queue.enqueue(function(){
+            var event = {
+                //when is supposed to be the target, and when the ports? The spec is confusing
+                target: target,
+                ports: [target],
+                // this can be optimized to be much faster
+                data: typeof message == "string" ? message : 
+                    global.JSON.parse(JSON.stringify(message)),
+            }
+            if(typeof target.onmessage == "function"){
+                target.onmessage(event);
+            }
+        });
+    };
+    port.isIdle= function(){
+        return queue.isEmpty();
+    };
+    return port;
+}
+function createWorker(scriptName, setup, workerName){
+    var workerQueue, 
+        workerGlobal = workerEngine.createEnvironment();
+    
+    // add the module lookup paths from our environment
+    var paths = workerGlobal.require.paths;
+    paths.splice(0, paths.length);
+    paths.push.apply(paths, require.paths);
+    
+    // get the event queue
+    workerQueue = workerGlobal.require("event-queue");
+    
+    // calback for dedicated and shared workers to do their thing
+    var worker = setup(workerQueue, workerGlobal);
+    
+    // there must be one and only one shared worker map amongst all workers
+    workerGlobal.require("system").__sharedWorkers__ = system.__sharedWorkers__;
+
+    workerEngine.spawn(function(){
+        workerGlobal.require(scriptName);
+        // enter the event loop
+        while(true){
+            try{
+                workerQueue.nextEvent()();
+                if(workerQueue.isEmpty()){
+                    // fire onidle events when empty, this allows to do effective worker pooling
+                    queue.enqueue(function(){
+                       if(worker && worker.onidle){
+                           worker.onidle();
+                       }
+                    });
+                }
+            }catch(e){
+                workerQueue.enqueue(function(){
+                    if(typeof workerGlobal.onerror === "function"){
+                        // trigger the onerror event in the worker if an error occurs
+                        try{
+                            workerGlobal.onerror(e);
+                        }
+                        catch(e){
+                            // don't want an error here to go into an infinite loop!
+                            workerEngine.defaultErrorReporter(e);
+                        }
+                    }
+                    else{
+                        workerEngine.defaultErrorReporter(e);
+                    }
+                });
+            
+            
+            }
+        }
+    }, workerName || scriptName);
+};
+
+if(!system.__sharedWorkers__){
+    system.__sharedWorkers__ = {};
+}
+
+exports.SharedWorker = function(scriptName, workerName){
+    workerName = workerName || scriptName;
+    var shared = system.__sharedWorkers__[workerName];
+    if(!shared){
+        var shared = {};
+        createWorker(scriptName, function(queue, global){
+            shared.queue = queue;
+            shared.global = global;
+            global.onconnect = true;
+        }, workerName);
+        system.__sharedWorkers__[workerName] = shared;
+    }
+    var port = {};
+    
+    var returnPort = createPort(queue, port, null, global);
+    
+    createPort(shared.queue, returnPort, port, shared.global);
+    shared.queue.enqueue(function(){
+        if(typeof shared.global.onconnect == "function"){
+            shared.global.onconnect({
+                port: returnPort
+            });
+        }
+    });
+    shared.num = shared.num || Math.random();
+    return {port: port};
+}
+

data/engines/jsc/README.md

@@ -0,0 +1,18 @@
+Narwhal JavaScriptCore / JSCocoa Platform
+=========================================
+
+Setup
+-----
+
+    git clone git://github.com/tlrobinson/narwhal.git narwhal
+    cd narwhal/engines
+    git clone git://github.com/tlrobinson/narwhal-jsc.git jsc
+    cd jsc
+    make
+    cd ../..
+    NARWHAL_ENGINE=jsc bin/narwhal
+
+Notes
+-----
+
+* Only builds on Mac OS X and JSCocoa support is currently broken, but both of these things can be fixed with improved Makefiles (or Jakefiles)

data/engines/jsc/bootstrap.js

@@ -0,0 +1,53 @@
+(function (evalGlobal, global) {
+    var debug = true;
+
+    var prefix = ENV['NARWHAL_HOME'];
+    var enginePrefix = ENV['NARWHAL_ENGINE_HOME'];
+
+    var _isFile = isFile, _read = read, _print = print;
+    delete read, isFile, print;
+    
+    function NativeLoader() {
+        var loader = {};
+        var factories = {};
+        
+        loader.reload = function(topId, path) {
+            factories[topId] = requireNative(topId, path);
+        }
+        
+        loader.load = function(topId, path) {
+            if (!factories.hasOwnProperty(topId))
+                loader.reload(topId, path);
+            return factories[topId];
+        }
+        
+        return loader;
+    };
+
+    var narwhal = eval(_read(prefix + "/narwhal.js"));
+    
+    narwhal({
+        global: global,
+        evalGlobal: evalGlobal,
+        engine: 'jsc',
+        engines: ['jsc', 'c', 'default'],
+        prefix: prefix,
+        prefixes: [enginePrefix, prefix],
+        debug: debug,
+        print: function (string) { _print(String(string)); },
+        evaluate: function (text) {
+            return eval("(function(require,exports,module,system,print){" + text + "/**/\n})");
+        },
+        fs: {
+            read: function(path) { return _read(path); },
+            isFile: function(path) { return _isFile(path); }
+        },
+        loaders: [[".dylib", NativeLoader()]],
+        os : "darwin",
+        debug: ENV['NARWHAL_DEBUG'],
+        verbose: ENV['NARWHAL_VERBOSE']
+    });
+
+})(function () {
+    return eval(arguments[0]);
+}, this);

data/engines/jsc/deps/http-parser/LICENSE

@@ -0,0 +1,77 @@
+Copyright 2009, Ryan Lienhart Dahl. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.
+
+http_parser is based on Zed Shaw's Mongrel. Mongrel's license is as follows.
+
+---- 8< ---- 8< ---- 8< ---- 8< ---- 8< ---- 8< ---- 8< ---- 8< ----
+Mongrel Web Server (Mongrel) is copyrighted free software by Zed A. Shaw
+<zedshaw at zedshaw dot com> and contributors. You can redistribute it
+and/or modify it under either the terms of the GPL2 or the conditions below:
+
+1. You may make and give away verbatim copies of the source form of the
+   software without restriction, provided that you duplicate all of the
+   original copyright notices and associated disclaimers.
+
+2. You may modify your copy of the software in any way, provided that
+   you do at least ONE of the following:
+
+     a) place your modifications in the Public Domain or otherwise make them
+     Freely Available, such as by posting said modifications to Usenet or an
+     equivalent medium, or by allowing the author to include your
+     modifications in the software.
+
+     b) use the modified software only within your corporation or
+        organization.
+
+     c) rename any non-standard executables so the names do not conflict with
+     standard executables, which must also be provided.
+
+     d) make other distribution arrangements with the author.
+
+3. You may distribute the software in object code or executable
+   form, provided that you do at least ONE of the following:
+
+     a) distribute the executables and library files of the software,
+     together with instructions (in the manual page or equivalent) on where
+     to get the original distribution.
+
+     b) accompany the distribution with the machine-readable source of the
+     software.
+
+     c) give non-standard executables non-standard names, with
+        instructions on where to get the original software distribution.
+
+     d) make other distribution arrangements with the author.
+
+4. You may modify and include the part of the software into any other
+   software (possibly commercial).  But some files in the distribution
+   are not written by the author, so that they are not under this terms.
+
+5. The scripts and library files supplied as input to or produced as
+   output from the software do not automatically fall under the
+   copyright of the software, but belong to whomever generated them,
+   and may be sold commercially, and may be aggregated with this
+   software.
+
+6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+   IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+   PURPOSE.
+---- 8< ---- 8< ---- 8< ---- 8< ---- 8< ---- 8< ---- 8< ---- 8< ----