sproutit-narwhal 0.1.106

data/lib/mime.js

@@ -0,0 +1,166 @@
+/**
+    This module provides basic functions for handling mime-types. It can
+    handle matching mime-types against a list of media-ranges. See section
+    14.1 of the HTTP specification [RFC 2616] for a complete explanation.
+    
+      <http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1>
+    
+    A port to JavaScript of Joe Gregorio's MIME-Type Parser:
+    
+      <http://code.google.com/p/mimeparse/>
+    
+    Ported by J. Chris Anderson <jchris@apache.org>, targeting the Spidermonkey runtime.
+    
+    To run the tests, open mimeparse-js-test.html in a browser.
+    Ported from version 0.1.2.
+    Comments are mostly excerpted from the original.
+*/
+
+var util = require("util");
+
+/*** parseMimeType
+    Carves up a mime-type and returns an Array of the
+    [type, subtype, params] where "params" is a Hash of all
+    the parameters for the media range.
+
+    For example, the media range "application/xhtml;q=0.5" would
+    get parsed into::
+
+        ["application", "xhtml", { "q" : "0.5" }]
+*/
+exports.parseMimeType = function (mimeType) {
+    var fullType, typeParts, params = {}, parts = mimeType.split(';');
+    for (var i=0; i < parts.length; i++) {
+        var p = parts[i].split('=');
+        if (p.length == 2) {
+            params[util.trim(p[0])] = util.trim(p[1]);
+        }
+    };
+    fullType = parts[0].replace(/^\s+/, '').replace(/\s+$/, '');
+    if (fullType == '*') fullType = '*/*';
+    typeParts = fullType.split('/');
+    return [typeParts[0], typeParts[1], params];
+};
+
+/*** parseMediaRange
+    Carves up a media range and returns an Array of the
+    [type, subtype, params] where "params" is a Object with
+    all the parameters for the media range.
+    
+    For example, the media range "application/*;q=0.5" would
+    get parsed into::
+    
+        ["application", "*", { "q" : "0.5" }]
+    
+    In addition this function also guarantees that there
+    is a value for "q" in the params dictionary, filling it
+    in with a proper default if necessary.
+*/
+exports.parseMediaRange = function (range) {
+    var q, parsedType = exports.parseMimeType(range);
+    if (!parsedType[2]['q']) {
+        parsedType[2]['q'] = '1';
+    } else {
+        q = parseFloat(parsedType[2]['q']);
+        if (isNaN(q)) {
+            parsedType[2]['q'] = '1';
+        } else if (q > 1 || q < 0) {
+            parsedType[2]['q'] = '1';
+        }
+    }
+    return parsedType;
+};
+
+/*** fitnessAndQualityParsed
+    Find the best match for a given mime-type against
+    a list of media_ranges that have already been
+    parsed by parseMediaRange(). Returns an array of
+    the fitness value and the value of the 'q' quality
+    parameter of the best match, or (-1, 0) if no match
+    was found. Just as for qualityParsed(), 'parsed_ranges'
+    must be a list of parsed media ranges.
+*/
+exports.fitnessAndQualityParsed = function (mimeType, parsedRanges) {
+    var bestFitness = -1, bestFitQ = 0, target = exports.parseMediaRange(mimeType);
+    var targetType = target[0], targetSubtype = target[1], targetParams = target[2];
+
+    for (var i=0; i < parsedRanges.length; i++) {
+        var parsed = parsedRanges[i];
+        var type = parsed[0], subtype = parsed[1], params = parsed[2];
+        if ((type == targetType || type == "*" || targetType == "*") &&
+            (subtype == targetSubtype || subtype == "*" || targetSubtype == "*")) {
+            var matchCount = 0;
+            for (param in targetParams) {
+                if (param != 'q' && params[param] && params[param] == targetParams[param]) {
+                    matchCount += 1;
+                }
+            }
+
+            var fitness = (type == targetType) ? 100 : 0;
+            fitness += (subtype == targetSubtype) ? 10 : 0;
+            fitness += matchCount;
+
+            if (fitness > bestFitness) {
+                bestFitness = fitness;
+                bestFitQ = params["q"];
+            }
+        }
+    };
+    return [bestFitness, parseFloat(bestFitQ)];
+};
+
+/*** qualityParsed
+    Find the best match for a given mime-type against
+    a list of media_ranges that have already been
+    parsed by parseMediaRange(). Returns the
+    'q' quality parameter of the best match, 0 if no
+    match was found. This function bahaves the same as quality()
+    except that 'parsedRanges' must be a list of
+    parsed media ranges.
+*/
+exports.qualityParsed = function (mimeType, parsedRanges) {
+    return exports.fitnessAndQualityParsed(mimeType, parsedRanges)[1];
+};
+
+/*** quality
+    Returns the quality 'q' of a mime-type when compared
+    against the media-ranges in ranges. For example::
+
+        >>> Mimeparse.quality('text/html','text/*;q=0.3, text/html;q=0.7, text/html;level=1, text/html;level=2;q=0.4, *\/*;q=0.5')
+        0.7
+*/
+exports.quality = function (mimeType, ranges) {
+    return exports.qualityParsed(mimeType, parseRanges(ranges));
+};
+
+/*** bestMatch
+    Takes a list of supported mime-types and finds the best
+    match for all the media-ranges listed in header. The value of
+    header must be a string that conforms to the format of the
+    HTTP Accept: header. The value of 'supported' is a list of
+    mime-types::
+    
+        >>> bestMatch(['application/xbel+xml', 'text/xml'], 'text/*;q=0.5,*\/*; q=0.1')
+        'text/xml'
+*/
+exports.bestMatch = function (supported, header) {
+    var parsedHeader = parseRanges(header);
+    var weighted = [];
+    for (var i=0; i < supported.length; i++) {
+        weighted.push([
+            exports.fitnessAndQualityParsed(supported[i], parsedHeader),
+            supported[i]
+        ])
+    };
+    weighted.sort();
+    return weighted[weighted.length-1][0][1] ? weighted[weighted.length-1][1] : '';
+};
+
+function parseRanges(ranges) {
+    var parsedRanges = [], rangeParts = ranges.split(",");
+    for (var i=0; i < rangeParts.length; i++) {
+        parsedRanges.push(exports.parseMediaRange(rangeParts[i]));
+    };
+    return parsedRanges;
+};
+

data/lib/narwhal.js

@@ -0,0 +1,102 @@
+
+var args = require("args");
+
+var parser = exports.parser = new args.Parser();
+
+parser.arg('script').optional();
+
+parser.help(
+    'Runs the Narwhal JavaScript interpreter.\n' + 
+    'If no script is specified, runs interactively.'
+);
+
+parser.option('-e', '-c', '--command', 'command')
+    .help("evaluate command")
+    .todo("eval", "command")
+    .halt();
+
+parser.option('-m', '--module', 'main')
+    .help("run a library module as a script")
+    .set()
+    .halt();
+
+parser.option('-i', '--interactive', 'interactive')
+    .help('enter interactive mode after running scripts')
+    .set(true)
+    .hidden();
+
+var modulesGroup = parser.group('modules');
+
+modulesGroup.option('-r', '--require', 'module')
+    .help("pre-load a module")
+    .todo("require", "module");
+
+modulesGroup.option('-I', '--include', 'lib')
+    .help("add a library")
+    .todo("include", "lib");
+
+modulesGroup.option('-p', '--package', 'prefix', 'prefixes')
+    .help("add a package")
+    .push();
+
+modulesGroup.option('-P', '--no-packages', 'noPackages')
+    .help("don't load packages")
+    .set(true);
+
+modulesGroup.option('-:', '--path', 'delimiter')
+    .help("prints an augmented PATH with all package bins/")
+    .todo("path", "delimiter");
+
+parser.option('-E', '--no-use-env', 'useEnv')
+    .help('ignore environment variables like JS_PATH, NARWHAL_PATH')
+    .def(true)
+    .set(false)
+    .hidden();
+
+parser.option('-d', '--debug', 'debug')
+    .help('set debug mode, system.debug = true')
+    .inc();
+
+parser.option('-v', '--verbose', 'verbose')
+    .help("verbose mode: trace 'require' calls.")
+    .set(true);
+
+parser.option('-x', '--shebang', 'shebang')
+    .help('skip every line before the Unix #!shebang for non-Unix shebangs')
+    .set(true)
+    .hidden();
+
+parser.option('-u', '--unbuffered')
+    .help('unbuffered stdin and stdout; no auto-flush on lines')
+    .set(true)
+    .hidden();
+
+parser.option('-l', '--log', 'level')
+    .help('set the log level')
+    .choices({'critical': 0, 'error': 1, 'warn': 2, 'info': 3, 'debug': 4});
+
+parser.option('-V', '--version')
+    .help("print Narwhal version number and exit.")
+    .action(function () {
+        this.print("Narwhal Version 0.");
+        this.exit();
+    });
+
+parser.option('-O', 'optimize').inc().hidden();
+
+parser.option('--narwhal')
+    .def('left')
+    .choices(['left', 'right'])
+    .action(function (options, name, value) {
+        this.print(exports[value.toUpperCase()]);
+    })
+    .halt()
+    .hidden();
+
+parser.helpful();
+
+// and now for something completely different
+
+exports.LEFT = "                                                     ,\n                                                  ,f\n                                               ,t,\n                                            ,:L.\n                                           tL,\n                        :EDDEKL         :Lt\n                      DDDDLGKKKK    ,,tD\n                   ,GDDfi.itLKKEKL tEi\n                 DDEEf,,tfLLDEEDL,D\n              .GEDEf,itLLfDLDLDDfD\n            DDEDLf,,fLLGLLDLDti:DL\n          DGDDGL,tttLDLDLfttttiLD\n         GDDLLt,fLLLDLLtLi,ttfLG\n        GGDGt,tLLLDfftii,i,ttLf\n       DGLLtttftftttf,,tttitLt\n      DEtftttLffttttii ttfLfj\n    .DLtittftLftt,,i,,itLfLj\n    DGL;t,tftiti,,,,,,tLLLt\n   DGGttttttii,,,,,:,tttDG\n  ,DLtjtiitii,,:,:,,t ,tG:\n  DDjttttt,ii,,,,:::t:ttL\n ;GLjtttti,i,,, ,,LG,,ft\n DDLttftttti;,,ifDLDtiit\n EGLjtjftt,,,ifLt  DLt,:\n DGfffijittfftt   .DLLt\n:DGfjffftfLft      EEDf\n:EGfftjjLLj         EED\n:DGfLfjLGG          ;E,\n GGfffLLL\n DGffLDf\n DGLfGL.\n fGLfGL\n  DGLDL\n  EGGGG\n   DLGG\n   EGLL\n    ELG\n    EEDKDGEE\n    jKEKKKK\n    EEKKKK\n    DEE\n  .EEKG\n   Lf";
+exports.RIGHT = ",\nf,\n  ,t,\n    .L:,\n      ,Lt\n         tL:         LKEDDE:\n            Dt,,    KKKKGLDDDD\n              iEt LKEKKLti.ifDDG,\n                 D,LDEEDLLft,,fEEDD\n                  DfDDLDLDfLLti,fEDEG.\n                  LD:itDLDLLGLLf,,fLDEDD\n                   DLittttfLDLDLttt,LGDDGD\n                    GLftt,iLtLLDLLLf,tLLDDG\n                     fLtt,i,iitffDLLLt,tGDGG\n                      tLtittt,,ftttftftttLLGD\n                       jfLftt iittttffLtttftED\n                        jLfLti,,i,,ttfLtfttitLD.\n                         tLLLt,,,,,,ititft,t;LGD\n                          GDttt,:,,,,,iittttttGGD\n                          :Gt, t,,:,:,,iitiitjtLD,\n                           Ltt:t:::,,,,ii,tttttjDD\n                            tf,,GL,, ,,,i,ittttjLG;\n                            tiitDLDfi,,;ittttfttLDD\n                            :,tLD  tLfi,,,ttfjtjLGE\n                             tLLD.   ttffttijifffGD\n                             fDEE      tfLftfffjfGD:\n                             DEE         jLLjjtffGE:\n                             ,E;          GGLjfLfGD:\n                                           LLLfffGG\n                                            fDLffGD\n                                            .LGfLGD\n                                             LGfLGf\n                                             LDLGD\n                                             GGGGE\n                                             GGLD\n                                             LLGE\n                                             GLE\n                                        EEGDKDEE\n                                         KKKKEKj\n                                          KKKKEE\n                                             EED\n                                             GKEE.\n                                               fL\n";
+

data/lib/narwhal/client.js

@@ -0,0 +1,261 @@
+
+// the catalog, inherited from inline.js, is a lookup table of top level module
+// identifiers to catalog entries.  catalog entries include a module factory
+// function and an array of top level identifiers of each dependency.
+var catalog = require.catalog;
+// the requests, is an array of the top-level identifiers sent to
+// require.request before the mechanisms to fulfill those requests were set up.
+// a "request" is like "require" or "require.async" except it just asks that a
+// module be required whenever its transitive dependencies are ready to be
+// loaded.
+var requests = require.requests;
+// a lookup table of module top level identifiers to 
+//  module exports objects.  these are constructed by calling
+//  the module factory with (require, exports, ...).
+var modules = {};
+// a lookup table of the top level identifier of any module that has ever been
+// mentioned, either by having been registered, or having been noted in a
+// module's dependency array, to a corresponding promise that will be
+// fullfilled when that module and its transitive dependencies have all been
+// registered, and thus can be loaded synchronously.
+var readys = {};
+// a lookup table of the top level identifier of any module that has ever been
+// mentioned in the dependency array of another catalog entry to a promise that
+// will be fulfilled when that module is registered.  registrations come in
+// asynchronously through script injection.
+var arrivals = {};
+// this will eventually be the ref-send promise module.
+var Q;
+// this will eventually be the sandbox function, the requirer.
+var sandbox;
+
+require.arrive = function (id) {
+    if (catalog['reactor'] && catalog['ref-send'])
+        boot();
+};
+
+// gets a promise that will be fulfilled when the module corresponding to the
+// given identifier and its transitive dependencies have all been registered,
+// which means that it's safe to call require(id).  this function uses the
+// readys lookup table as a memo, constructing promises on demand, and
+// immediately fullfilling them if conditions warrant.
+var getReady = function (id) {
+    require.preload([id]); // idempotent
+    if (!readys[id])
+        readys[id] = Q.defer();
+    if (modules[id])
+        readys[id].resolve(catalog[id]);
+    return readys[id];
+};
+
+// gets a promise that will be fulfilled when the module corresponding to the
+// given identifier has been registered, which means that any module depending
+// on this module may be ready.
+var getArrival = function (id) {
+    require.preload([id]); // idempotent
+    if (!arrivals[id])
+        arrivals[id] = Q.defer();
+    if (catalog[id])
+        arrivals[id].resolve(catalog[id]);
+    return arrivals[id];
+};
+
+// require.arrive is called by the require.register function defined in
+// inline.js whenever a catalog entry arrives through script injection.  the
+// require.arrive function starts off as a stub that does nothing, since there
+// is nothing it can do until the promise and reactor modules arrive.  we
+// replace the original arrival method that notices when these modules are
+// ready and initiates the boot process.
+require.arrive = function (id) {
+    if (catalog.reactor && catalog['ref-send'])
+        boot();
+};
+
+// check whether reactor and promise have already arrived
+require.arrive();
+
+// use the promise and reactor modules to move on to the next phase of the boot
+// process, which is the creation of a module loader sandbox with normalized
+// globals, primordials, and a system module.  after we have all that set up,
+// we can begin watching for the arrival of the requested program module(s).
+function boot() {
+
+    // create a stub module loader that can load the promise and reactor
+    // modules.  we have to construct them manually and in the proper order in
+    // the absense of a full loader.
+    var subRequire = function (id) {return modules[id];};
+    modules.reactor = {};
+    catalog.reactor.factory(subRequire, modules.reactor);
+    Q = modules['ref-send'] = {};
+    catalog['ref-send'].factory(subRequire, modules['ref-send']);
+
+    // a signal that the sandbox has been hooked up and
+    // modules may be required.
+    var ready = Q.defer();
+
+    // global public API for asynchronously requiring a module, that will be
+    // fulfilled with the module's exports whenever it can be loaded, which
+    // entails registration of that module's transitive dependencies.
+    require.async = function (id) {
+        var q = Q.defer();
+        Q.when(ready.promise, function () {
+            Q.when(getReady(id).promise, function () {
+                q.resolve(sandbox(id));
+            }, function () {
+                q.reject();
+            });
+        }, function () {
+            q.reject();
+        });
+        return q.promise;
+    };
+
+    // global public API: a shortcut for attaching callbacks to a promise to be
+    // fulfilled when a requested module is ready to be loaded.
+    require.when = function (id, fulfilled, rejected) {
+        return Q.when(getReady(id).promise, fulfilled, rejected);
+    };
+
+    // we are now ready to make promises about the arrival and readiness of
+    // modules.  this is the third replacement of the require.arrive event
+    // handler called by require.register whenever it gets executed by an
+    // injected script.  this version will create a graph of promises that will
+    // collectively determine when each module is ready.
+    require.arrive = function (id) {
+        var depends = catalog[id].depends;
+        var length = depends.length;
+
+        // the module has arrived, but it won't be ready until all of its
+        // dependencies are ready.  this promise will be fulfilled when all the
+        // dependencies are ready, and in turn will fulfill this module's ready
+        // promise.  a module with no dependencies is the basis, so this
+        // promise will need to be fulfilled immediately in that case.
+        var a = Q.defer();
+        Q.when(a.promise, function () {
+            getReady(id).resolve(catalog[id]);
+        });
+
+        // create a chain of promises that will be ultimately fulfilled when
+        // EVERY dependency is ready.
+        for (var i = 0; i < length; i++) {
+            var depend = depends[i];
+            // trap the previous promise and the dependency name in an
+            // enclosure.
+            a = (function (a, depend) {
+                var b = Q.defer();
+                // the new promise is that the previous promise has been
+                // fulfilled and this dependency is ready.  this is a logical
+                // AND promise.
+                Q.when(getReady(depend).promise, function () {
+                    return Q.when(b.promise, function () {
+                        a.resolve(true);
+                    });
+                })
+                return b;
+            })(a, depend);
+        }
+
+        // if there are no dependencies, this resolves the original promise and
+        // in turn marks this module as ready.  if there are dependencies, this
+        // half fulfills second operand of the last AND junction among the
+        // dependencies, which starts the ball rolling.
+        a.resolve(true);
+
+        // oh, by the way, signal the arrival of this module, so some of my
+        // dependees can get ready.
+        getArrival(id).resolve(catalog[id]);
+    };
+
+    // process arrivals that have already occurred.  the catalog already
+    // contains several entries for modules that arrived, but they have not
+    // been properly processed with the promise system.
+    for (var id in catalog) {
+        if (Object.prototype.hasOwnProperty.call(catalog, id)) {
+            var entry = catalog[id];
+            require.arrive(id);
+        }
+    }
+
+    // now that we can use promises to observe when modules are ready
+    // to load, we can move on to the next phase: installing a module
+    // loader and kicking off the requested programs.
+
+    // this is another logical AND of promises.  when the "sandbox", "global",
+    // and "system" modules with all of their transitive dependencies are ready
+    // to be loaded, we proceed.
+    Q.when(getReady("sandbox").promise, function () {
+    return Q.when(getReady("global").promise, function () {
+    return Q.when(getReady("system").promise, function () {
+
+        // the sandbox module needs a semi-functional system object
+        var system = {};
+        system.print = function () {
+            if (typeof console != "undefined") {
+                console.log(Array.prototype.join.call(arguments, ' '));
+            }
+        };
+        system.fs = {
+            normal: function (path) {
+                return path;
+            }
+        };
+        system.engine = "browser";
+        system.engines = ["browser"];
+
+        // the loader is relatively simple since it doesn't need to do
+        // any searching or extension resolving.
+        var loader = {};
+        loader.reload = function (id) {
+            if (!catalog[id])
+                throw new Error(id + " has not been preloaded.");
+            return catalog[id].factory;
+        };
+        loader.load = function (id) {
+            return loader.reload(id);
+        };
+
+        // load the sandbox module manually.
+        var SANDBOX = {};
+        loader.load('sandbox')(
+            function () {return system},
+            SANDBOX,
+            {},
+            system,
+            system.print
+        );
+        sandbox = SANDBOX.Sandbox({loader: loader});
+        // patch the loader with the sandbox module's general purpose resolve
+        // function.
+        loader.resolve = SANDBOX.resolve;
+
+        sandbox.async = require.async;
+
+        // apply the system module to the existing system object
+        sandbox.force("system");
+        // patch the primordials to approach something near ES5 compliance
+        sandbox("global");
+
+        // up to this point, the require(id) function defined in inline.js
+        // defers to require.require(id), if it is defined.  otherwise it
+        // throws an error.  now, we have a sandbox, so we can return modules.
+        require.require = sandbox;
+
+        // notify any requested module programs that they may
+        // require modules.
+        ready.resolve(true);
+
+        // we now have all of the plumbing to request, register, load, and
+        // require modules.  we have a backlog of module's to request (these
+        // were deferred by the require.request function defined in inline.js).
+        // with our new require.request method, complete those requests.
+        var length = requests.length;
+        for (var i = 0; i < length; i++) {
+            var id = requests[i];
+            require.async(id);
+        }
+
+    // because lisp wasn't bad enough
+    });});});
+
+}
+