sproutit-narwhal 0.1.106

data/lib/printf.js

@@ -0,0 +1,169 @@
+
+/** provides printf and sprintf.
+
+    This code is unrestricted: you are free to use it however you like.
+
+    The functions should work as expected, performing left or right alignment,
+    truncating strings, outputting numbers with a required precision etc.
+
+    For complex cases, these functions follow the Perl implementations of
+    (s)printf, allowing arguments to be passed out-of-order, and to set the
+    precision or length of the output based on arguments instead of fixed
+    numbers.
+
+    See http://perldoc.perl.org/functions/sprintf.html for more information.
+
+    Implemented:
+     - zero and space-padding
+     - right and left-alignment,
+     - base X prefix (binary, octal and hex)
+     - positive number prefix
+     - (minimum) width
+     - precision / truncation / maximum width
+     - out of order arguments
+
+    Not implemented (yet):
+     - vector flag
+     - size (bytes, words, long-words etc.)
+
+    Will not implement:
+     - %n or %p (no pointers in JavaScript)
+
+    by Ash Searle, 2007-04-27
+    Integrated into Chiron by Kris Kowal, 2007-10-19
+    Integrated into Narwhal by Kris Kowal, 2009-07-27
+
+*/
+
+exports.printf = function () {
+    print(exports.sprintf.apply(null, arguments));
+};
+
+exports.fprintf = function () {
+    var args = Array.prototype.slice.call(arguments);
+    var stream = args.shift();
+    stream.print(exports.sprintf.apply(null, args));
+};
+
+exports.sprintf = function () {
+
+    var a = arguments, i = 1, format = a[0];
+    return format.replace(regex, function ($0, valueIndex, flags, minWidth, precision, type) {
+        if ($0 == '%%') return '%';
+
+        // parse flags
+        var leftJustify    = flags.indexOf('-') > -1,
+            positivePrefix = (flags.match(/[ +]/g) || ['']).pop(),
+            zeroPad        = flags.indexOf('0') > -1,
+            prefixBaseX    = flags.indexOf('#') > -1;
+
+        // parameters may be null, undefined, empty-string or real valued
+        // we want to ignore null, undefined and empty-string values
+
+        if (!minWidth)
+            minWidth = 0;
+        else if (minWidth == '*')
+            minWidth = +a[i++];
+        else if (minWidth.charAt(0) == '*')
+            minWidth = +a[minWidth.slice(1, -1)];
+        else
+            minWidth = +minWidth;
+
+        // Note: undocumented perl feature:
+        if (minWidth < 0) {
+            minWidth = -minWidth;
+            leftJustify = true;
+        }
+
+        if (!isFinite(minWidth))
+            throw new Error('sprintf: (minimum-)width must be finite');
+
+        if (!precision)
+            precision = 'fFeE'.indexOf(type) > -1 ? 6 : (type == 'd' ? 0 : void(0));
+        else if (precision == '*')
+            precision = +a[i++];
+        else if (precision.charAt(0) == '*')
+            precision = +a[precision.slice(1, -1)];
+        else
+            precision = +precision;
+
+        // grab value using valueIndex if required?
+        var value = valueIndex ? a[valueIndex] : a[i++];
+
+        switch (type) {
+            case 's': return formatString(String(value), leftJustify, minWidth, precision, zeroPad);
+            case 'c': return formatString(String.fromCharCode(+value), leftJustify, minWidth, precision, zeroPad);
+            case 'b': return formatBaseX(value, 2, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
+            case 'o': return formatBaseX(value, 8, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
+            case 'x': return formatBaseX(value, 16, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
+            case 'X': return formatBaseX(value, 16, prefixBaseX, leftJustify, minWidth, precision, zeroPad).toUpperCase();
+            case 'u': return formatBaseX(value, 10, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
+            case 'i':
+            case 'd': {
+                      var number = parseInt(+value);
+                      var prefix = number < 0 ? '-' : positivePrefix;
+                      value = prefix + pad(String(Math.abs(number)), precision, '0', false);
+                      return justify(value, prefix, leftJustify, minWidth, zeroPad);
+            }
+            case 'e':
+            case 'E':
+            case 'f':
+            case 'F':
+            case 'g':
+            case 'G': {
+                      var number = +value;
+                      var prefix = number < 0 ? '-' : positivePrefix;
+                      var method = ['toExponential', 'toFixed', 'toPrecision']['efg'.indexOf(type.toLowerCase())];
+                      var textTransform = ['toString', 'toUpperCase']['eEfFgG'.indexOf(type) % 2];
+                      value = prefix + Math.abs(number)[method](precision);
+                      return justify(value, prefix, leftJustify, minWidth, zeroPad)[textTransform]();
+            }
+            default: return $0;
+        }
+    });
+}
+
+var pad = function (str, len, chr, leftJustify) {
+    var padding = (str.length >= len) ? '' : Array(1 + len - str.length >>> 0).join(chr);
+    return leftJustify ? str + padding : padding + str;
+};
+
+var justify = function (value, prefix, leftJustify, minWidth, zeroPad) {
+    var diff = minWidth - value.length;
+    if (diff > 0) {
+        if (leftJustify || !zeroPad) {
+            value = pad(value, minWidth, ' ', leftJustify);
+        } else {
+            value = value.slice(0, prefix.length) + pad('', diff, '0', true) + value.slice(prefix.length);
+        }
+    }
+    return value;
+};
+
+var formatBaseX = function (value, base, prefix, leftJustify, minWidth, precision, zeroPad) {
+    // Note: casts negative numbers to positive ones
+    var number = value >>> 0;
+    prefix = prefix && number && {'2': '0b', '8': '0', '16': '0x'}[base] || '';
+    value = prefix + pad(number.toString(base), precision || 0, '0', false);
+    return justify(value, prefix, leftJustify, minWidth, zeroPad);
+};
+
+var formatString = function (value, leftJustify, minWidth, precision, zeroPad) {
+    if (precision != null) {
+        value = value.slice(0, precision);
+    }
+    return justify(value, '', leftJustify, minWidth, zeroPad);
+};
+
+var regex = /%(?:%|(?:(\d+)\$)?([-+#0 ]*)([1-9][0-9]*|\*(?:[0-9]+\$)?)?(?:\.([0-9]+|\*(?:[0-9]+\$)?))?([csduoxefgXEGbi]))/g;
+
+/*
+    References
+    ==========
+
+    http://www.webtoolkit.info/javascript-sprintf.html
+    An alternate implementation, if this one does not perform well
+    in practice.
+
+*/
+

data/lib/promise.js

@@ -0,0 +1,352 @@
+// this is based on the CommonJS spec for promises: 
+// http://wiki.commonjs.org/wiki/Promises
+
+// A typical usage:
+// A default Promise constructor can be used to create a self-resolving promise:
+// var Promise = require("promise").Promise;
+//    var promise = new Promise();
+// asyncOperation(function(){
+//    Promise.resolve("succesful result");
+// });
+//    promise -> given to the consumer
+//  
+//    A consumer can use the promise
+//    promise.then(function(result){
+//        ... when the action is complete this is executed ...
+//   },
+//   function(error){
+//        ... executed when the promise fails
+//  });
+//
+// Alternately, a provider can create a deferred and resolve it when it completes an action. 
+// The deferred object provides a separation of consumer and producer to protect
+// promises from being fulfilled by untrusted code.
+// var defer = require("promise").defer;
+//    var deferred = defer();
+// asyncOperation(function(){
+//    deferred.resolve("succesful result");
+// });
+//    deferred.promise -> given to the consumer
+//  
+//    Another way that a consumer can use the promise (using promise.then is also allowed)
+// var when = require("promise").when;
+// when(promise,function(result){
+//        ... when the action is complete this is executed ...
+//   },
+//   function(error){
+//        ... executed when the promise fails
+//  });
+try{
+    var queue = require("event-queue");
+}
+catch(e){
+    // squelch the error, and only complain if the queue is needed
+}
+
+/**
+ * Default constructor that creates a self-resolving Promise. Not all promise implementations
+ * need to use this constructor.
+ */
+var Promise = exports.Promise = function(canceller){
+    // make a deferred and copy everything to its promise so it can be self-resolving
+    var deferred = new Deferred();
+    var promise = deferred.promise;
+    for(var i in deferred){
+        promise[i] = deferred[i];
+    }
+    if(canceller){
+        promise.cancel = function(){
+            var error = canceller();
+            if(!(error instanceof Error)){
+                error = new Error(error);
+            }
+            promise.reject(error);
+        }
+    }
+    return promise;
+};
+
+/**
+ * Promise implementations must provide a "then" function.
+ */
+Promise.prototype.then = function(resolvedCallback, errorCallback, progressCallback){
+    throw new TypeError("The Promise base class is abstract, this function must be implemented by the Promise implementation");
+};
+
+/**
+ * If an implementation of a promise supports a concurrency model that allows
+ * execution to block until the promise is resolved, the wait function may be 
+ * added. 
+ */
+/**
+ * If an implementation of a promise can be cancelled, it may add this function
+ */
+ // Promise.prototype.cancel = function(){
+ // };
+
+Promise.prototype.get = function(propertyName){
+    return this.then(function(value){
+        return value[propertyName];
+    });
+};
+
+Promise.prototype.put = function(propertyName, value){
+    return this.then(function(object){
+        return object[propertyName] = value;
+    });
+};
+
+Promise.prototype.call = function(functionName /*, args */){
+    return this.then(function(value){
+        return value[propertyName].apply(value, Array.prototype.slice.call(arguments, 1));
+    });
+};
+
+// if an error is not handled within 5 seconds then it should be reported
+var errorHandledTimeout = 5000; 
+function DeferredPromise(){
+}
+DeferredPromise.prototype = Promise.prototype; 
+// A deferred provides an API for creating and resolveing a promise.
+exports.defer = function(canceller){
+    return new Deferred(canceller);
+} 
+function Deferred(){
+    var result, finished, isError, waiting = [], handled, errorTimeout;
+    var promise = this.promise = new DeferredPromise();
+    
+    function notifyAll(value){
+        if(queue){
+            // if we have an event queue, we will enqueue it
+            queue.enqueue(doNotify);    
+        }
+        else{
+            doNotify();
+        }
+        
+        function doNotify(){
+            if(finished){
+                throw new Error("This deferred has already been resolved");                
+            }
+            result = value;
+            finished = true;
+            for(var i = 0; i < waiting.length; i++){
+                notify(waiting[i]);    
+            }
+        }
+    }
+    function notify(listener){
+        var func = (isError ? listener.error : listener.resolved);
+        try{
+            if(func){
+                handled = true;
+                if(typeof errorTimeout == "number"){
+                    clearTimeout(errorTimeout);
+                }
+                var newResult = func(result);
+            }
+            if(newResult && typeof newResult.then === "function"){
+                newResult.then(function(result){
+                        listener.deferred.resolve(result);
+                    },
+                    function(error){
+                        listener.deferred.reject(error);
+                    });
+            }
+            else{
+                listener.deferred.resolve(newResult === undefined ? result : newResult);
+            }
+        }
+        catch(e){
+            listener.deferred.reject(e);
+        } 
+    }
+    // calling resolve will resolve the promise
+    this.resolve = function(value){
+        notifyAll(value);
+    };
+    // calling error will indicate that the promise failed
+    var errback = this.reject = function(error){
+        isError = true;
+        notifyAll(error);
+        if(typeof setTimeout != "undefined" && !handled){
+            errorTimeout = setTimeout(function(){
+                throw error;
+            }, errorHandledTimeout);
+        }
+    }
+    // call progress to provide updates on the progress on the completion of the promise
+    this.progress = function(update){
+        for(var i = 0; i < waiting.length; i++){
+            var progress = waiting[i].progress;
+            progress && progress(update);    
+        }
+    }
+    // provide the implementation of the promise
+    promise.then = function(resolvedCallback, errorCallback, progressCallback){
+        var returnDeferred = new Deferred();
+        var listener = {resolved: resolvedCallback, error: errorCallback, progress: progressCallback, deferred: returnDeferred}; 
+        if(finished){
+            notify(listener);
+        }
+        else{
+            waiting.push(listener);
+        }
+        return returnDeferred.promise;
+    };
+};
+
+function perform(value, async, sync, promiseNotNeeded){
+    try{
+        if(value && typeof value.then === "function"){
+            value = async(value);
+        }
+        else{
+            value = sync(value);
+        }
+        if(value && typeof value.then === "function"){
+            return value;
+        }
+        if(promiseNotNeeded){
+            return value;
+        }
+        var deferred = new Deferred();
+        deferred.resolve(value);
+        return deferred.promise;
+    }catch(e){
+        if(promiseNotNeeded){
+            throw e;
+        }
+        var deferred = new Deferred();
+        deferred.reject(e);
+        return deferred.promise;
+    }
+    
+}
+/**
+ * Promise manager to make it easier to consume promises
+ */
+ 
+/**
+ * Registers an observer on a promise.
+ * @param value     promise or value to observe
+ * @param resolvedCallback function to be called with the resolved value
+ * @param rejectCallback  function to be called with the rejection reason
+ * @param progressCallback  function to be called when progress is made
+ * @return promise for the return value from the invoked callback
+ */
+exports.when = function(value, resolvedCallback, rejectCallback, progressCallback){
+    return perform(value, function(value){
+        return value.then(resolvedCallback, rejectCallback, progressCallback);
+    },
+    function(value){
+        return resolvedCallback(value);
+    });
+};
+/**
+ * Registers an observer on a promise.
+ * @param value     promise or value to observe
+ * @param resolvedCallback function to be called with the resolved value
+ * @param rejectCallback  function to be called with the rejection reason
+ * @param progressCallback  function to be called when progress is made
+ * @return promise for the return value from the invoked callback or the value if it
+ * is a non-promise value
+ */
+exports.whenPreservingType = function(value, resolvedCallback, rejectCallback, progressCallback){
+    return perform(value, function(value){
+        return value.then(resolvedCallback, rejectCallback, progressCallback);
+    },
+    function(value){
+        return resolvedCallback(value);
+    }, true);
+};
+
+/**
+ * Gets the value of a property in a future turn.
+ * @param target    promise or value for target object
+ * @param property      name of property to get
+ * @return promise for the property value
+ */
+exports.get = function(target, property){
+    return perform(target, function(target){
+        return target.get(property);
+    },
+    function(target){
+        return target[property]
+    });
+};
+
+/**
+ * Invokes a method in a future turn.
+ * @param target    promise or value for target object
+ * @param methodName      name of method to invoke
+ * @param args      array of invocation arguments
+ * @return promise for the return value
+ */
+exports.post = function(target, methodName, args){
+    return perform(target, function(target){
+        return target.call(property, args);
+    },
+    function(target){
+        return target[methodName].apply(target, args);
+    });
+};
+
+/**
+ * Sets the value of a property in a future turn.
+ * @param target    promise or value for target object
+ * @param property      name of property to set
+ * @param value     new value of property
+ * @return promise for the return value
+ */
+exports.put = function(target, property, value){
+    return perform(target, function(target){
+        return target.put(property, value);
+    },
+    function(target){
+        return target[property] = value;
+    });
+};
+
+
+/**
+ * Waits for the given promise to finish, blocking (and executing other events)
+ * if necessary to wait for the promise to finish. If target is not a promise
+ * it will return the target immediately. If the promise results in an reject,
+ * that reject will be thrown.
+ * @param target   promise or value to wait for.
+ * @return the value of the promise;
+ */
+exports.wait = function(target){
+    if(!queue){
+        throw new Error("Can not wait, the event-queue module is not available");
+    }
+    if(target && typeof target.then === "function"){
+        var isFinished, isError, result;        
+        target.then(function(value){
+            isFinished = true;
+            result = value;
+        },
+        function(error){
+            isFinished = true;
+            isError = true;
+            result = error;
+        });
+        while(!isFinished){
+            try{
+                queue.nextEvent()();
+            }catch(e){
+                print(e);
+            }
+        }
+        if(isError){
+            throw result;
+        }
+        return result;
+    }
+    else{
+        return target;
+    }
+};
+
+