sproutit-narwhal 0.1.106

data/lib/narwhal/compile.js

@@ -0,0 +1,99 @@
+
+var SYSTEM = require("system");
+var FILE = require("file");
+var PACKAGES = require("packages");
+var UTIL = require("util");
+var TERM = require("term");
+var Bundler = require("./server").Bundler;
+
+exports.ids = function (system, packages) {
+    if (!packages)
+        packages = PACKAGES;
+    if (!system)
+        system = SYSTEM;
+
+    // scan the package order for all possibly relevant
+    // javascript files for the given system
+
+    var files = [];
+    packages.order.forEach(function (info) {
+        var enginePaths = info.engines || 'engines';
+        if (typeof enginePaths == "string")
+            enginePaths = [enginePaths];
+        system.engines.forEach(function (engine) {
+            enginePaths.forEach(function (enginePath) {
+                enginePath = enginePath + '/' + engine;
+                var enginePath = info[enginePath] || enginePath;
+                if (typeof enginePath == "string")
+                    enginePath = [enginePath];
+                enginePath.forEach(function (enginePaths) {
+                    enginePaths = enginePath + '/lib';
+                    var enginePath = info[enginePaths] || enginePaths;
+                    if (typeof enginePath == "string")
+                        enginePath = [enginePath];
+                    enginePath.forEach(function (enginePath) {
+                        enginePath = info.directory.join(enginePath);
+                        enginePath.globPaths("**.js").forEach(function (path) {
+                            files.push([path, enginePath]);
+                        });
+                    });
+                });
+            });
+        });
+        info.lib.forEach(function (lib) {
+            lib.globPaths("**.js").forEach(function (path) {
+                files.push([path, lib]);
+            });
+        });
+    });
+
+    // transform paths into identifiers
+    var ids = UTIL.mapApply(files, function (path, base) {
+        var relative = path.from(base.join(''));
+        var parts = relative.split();
+        parts.pop();
+        parts.push(relative.basename('.js'));
+        var id = parts.join('/');
+        //print(id + ' ' + path + ' ' + base);
+        return id;
+    });
+
+    ids = UTIL.unique(ids);
+
+    return ids;
+};
+
+exports.build = function (location, system, packages) {
+
+    if (!system)
+        system = SYSTEM;
+    system = Object.create(system);
+    system.engine = "browser";
+    system.engines = UTIL.copy(system.engines);
+    system.engines.unshift("browser");
+
+    location = FILE.path(location);
+    var bundler = Bundler(system);
+    exports.ids(system, packages).forEach(function (id) {
+        try {
+            var parts = id.split('/');
+            var basename = parts.pop();
+            var dirname = location.join.apply(location, parts);
+            dirname.mkdirs();
+            var path = dirname.join(basename + '.js');
+            path.write(bundler.bundle([id]));
+            print(path);
+        } catch (exception) {
+            TERM.stream.print("\0red(" + exception + "\0)");
+        }
+    });
+
+};
+
+exports.main = function (system, packages) {
+    exports.build("build", system, packages);
+};
+
+if (require.main == module.id)
+    exports.main();
+

data/lib/narwhal/env.js

@@ -0,0 +1,140 @@
+
+var file = require("file");
+var system = require("system");
+var packages = require("packages");
+var util = require("util");
+var args = require("args");
+
+var parser = exports.parser = new args.Parser();
+
+parser.help(
+    "Constructs an 'eval'-able shell script by augmenting\n" +
+    "current PATH and PATH-like environment variables with\n" +
+    "directories from installed packages in their precedence\n" +
+    "order.  Precedence is determined by a topological sort\n" +
+    "of package dependencies.  Topo-sort guarantees that the\n" +
+    "most dependent packages come first.\n" +
+    "\n" +
+    "    eval $(narwhal -m narwhal/env --path --ldpath)\n" +
+    "    echo $PATH\n"
+);
+
+
+parser.option('--path', 'path')
+    .help("prints a new PATH= based on package/bins")
+    .set(true);
+parser.option('--ldpath', 'ldpath')
+    .help("prints a new LDPATH= based on package/libs")
+    .set(true);
+parser.option('--classpath', 'classpath')
+    .help("prints a new CLASSPATH= based on package/classes and package/jars/*")
+    .set(true);
+parser.option('--custom')
+    .help("prints a new $NAME= based on package/$name")
+    .action(function (options, name, envName, pathName) {
+        util.getset(options, 'custom', []).push([
+            envName,
+            pathName
+        ]);
+    });
+parser.option('--extra')
+    .help("prints a new $NAME= based on package/$name and package/$extra/*")
+    .action(function (options, name, envName, pathName, extraName) {
+        util.getset(options, 'custom', []).push([
+            envName,
+            pathName,
+            extraName
+        ]);
+    });
+
+parser.helpful();
+
+var paths = function (envName, pathName, extraName) {
+
+    // construct a list of paths for each installed package
+    //  based on the default name, or the overridden name
+    //  or names from the package configuration.
+    var paths = Array.prototype.concat.apply(
+        [],
+        packages.order.map(function (info) {
+            var paths = info[pathName] || pathName;
+            if (typeof paths == "string")
+                paths = [paths];
+            return paths.map(function (path) {
+                return info.directory.resolve(path);
+            });
+        })
+    // and add the list of existing values from the
+    //  corresponding environment value (in lower
+    //  precedence, packages will override previous
+    //  values)
+    ).concat(
+        (system.env[envName] || '')
+        .split(":")
+        // filter blank components, or empty env var
+        .filter(function (path) {
+            return path;
+        }).map(function (path) {
+            return new file.Path(path);
+        })
+    // grab only the ones that exist
+    ).filter(function (path) {
+        return path.isDirectory();
+    });
+
+    // grab individual files for the extra directory name
+    if (extraName) {
+        paths = Array.prototype.concat.apply(
+            paths,
+            Array.prototype.concat.apply(
+                [],
+                // as before, find the directories in
+                //  package precedence order, accepting
+                //  overrides from the package configuration
+                packages.order.map(function (info) {
+                    var paths = info[extraName] || extraName;
+                    if (typeof paths == "string")
+                        paths = [paths];
+                    return paths.map(function (path) {
+                        return info.directory.resolve(path);
+                    }).filter(function (path) {
+                        return path.isDirectory();
+                    });
+                })
+            // each individual file within that directory,
+            //  as with *.jar in jars/
+            ).map(function (path) {
+                return path.listPaths();
+            })
+        );
+    }
+    
+    paths = paths.map(function (path) {
+        return path.canonical().toString();
+    });
+
+    return util.unique(paths).join(":");
+};
+
+exports.main = function (system) {
+
+    var options = parser.parse(system.args);
+
+    if (options.path)
+        system.print("PATH=" + paths("PATH", "bin"));
+    if (options.ldpath)
+        system.print("LDPATH=" + paths("LDPATH", "lib"));
+    if (options.classpath)
+        system.print("CLASSPATH=" + paths(
+            "CLASSPATH", "classes",
+            "jars"
+        ));
+    util.forEachApply(options.custom, function (pathName, envName) {
+        system.print(envName + "=" + paths(envName, pathName));
+    });
+
+};
+
+if (require.main == module.id)
+    exports.main(system);
+

data/lib/narwhal/inline.js

@@ -0,0 +1,106 @@
+// this is not a module.  it is a snippet of a script that will be sent by the
+// client/browser module server defined in the narwhal/server module, or some
+// similar mechanism.  this file is simply an anonymous function declaration.
+// the server constructs an inline script to inject anywhere in an HTML page,
+// along with its "path" argument (the base URL from which to download
+// modules).  The function returns a module loader API function/object called
+// "require" that can then be chained with .preload(ids), .when(id),
+// .async(id), or other calls, depending on what services are needed to load
+// this particular page.
+(function (path) {
+
+    // ultimately, we're exporting a "require" API to global scope, and
+    // returning that same object.
+    var require = this.require = function (id) {
+        if (!require.require)
+            throw new Error("require is not yet available");
+        return require.require(id);
+    };
+
+    // the catalog 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.  this is populated by the
+    // register function that is called by injected module and bundle scripts.
+    require.catalog = {};
+    require.requests = [];
+    require.preloads = {};
+
+    // this is an event handler for factory arrivals that will be replaced when
+    // narwhal/client arrives.
+    require.arrive = function (id) {
+        // there's only one module we're particularly interested in at the
+        // moment.  as soon as it comes down, load the client.  this will take
+        // us to the next stage, getting the promise graph and sandbox set up.
+        if (id == "narwhal/client")
+            require.catalog[id].factory(require);
+    };
+
+    // this function gets called by injected scripts with a portion of the
+    // module catalog, which includes factories and dependency lists.
+    require.register = function (entries) {
+        for (var id in entries) {
+            if (Object.prototype.hasOwnProperty.call(entries, id)) {
+                require.catalog[id] = entries[id];
+                // make a note not to preload this module, even if it
+                // was not preloaded in the first place.
+                require.preloads[id] = true;
+                // this function gets redefined at various stages to notice the
+                // arrival of important modules for the bootstrapping process.
+                // 1.) narwhal/client
+                // 2.) ref-send and reactor
+                // 3.) all identifiers
+                require.arrive(id);
+            }
+        }
+    };
+
+    // this function injects script tags for modules or module bundles to
+    // asynchronously load modules that have been wrapped with their metadata
+    // for transport either by a build system or by a server-side component
+    // like the narwhal/server module.
+    require.preload = function (ids) {
+        setTimeout(function () {
+            var length = ids.length;
+            for (var i = 0; i < length; i++) {
+                // don't double preload; this check makes preload idempotent
+                if (require.preloads[ids[i]])
+                    continue;
+                // make a note not to preload this module ever again.
+                require.preloads[ids[i]] = true;
+
+                // prepend instead of append to avoid KB917927
+                // - Kean Tan <http://www.karmagination.com/>
+                var script = document.createElement('script');
+                script.src = path + ids[i] + '.js';
+                document.documentElement.insertBefore(
+                    script,
+                    document.documentElement.firstChild
+                );
+
+            };
+        }, 0);
+        return require;
+    };
+
+    // this is the public API for requesting that a module be loaded as soon as
+    // it's ready (as soon as it and its transitive dependencies have arrived
+    // and been entered in the catalog).  unfortunately, we're not ready to
+    // process requests at this stage, so we add them to a queue that will be
+    // processed later, at which point this function will also be replaced.
+    // all of these later steps occur toward the end of client.js
+    require.async = function (id) {
+        require.requests.push(id);
+        return require;
+    };
+
+    // for convenience, if ever we opt to abolish the global require
+    // variable, being able to call an arbitrary function while
+    // maintaining the require object along the call chain.
+    require.bridge = function (block) {
+        block(require);
+        return require;
+    };
+
+    // return the require object for chaining
+    return require;
+})

data/lib/narwhal/json.js

@@ -0,0 +1,324 @@
+
+var os = require("os");
+var args = require("args");
+var assert = require("test/assert");
+var util = require("util");
+var system = require("system");
+var fs = require("file");
+
+var parser = new args.Parser();
+
+// syntax highlighting for option help
+parser.Option = function () {
+    args.Option.apply(this, arguments);
+    return this;
+};
+parser.Option.prototype = Object.create(args.Option.prototype);
+parser.Option.prototype.help = function (help) {
+    if (/->/.test(help)) {
+        help = help.replace(/\b[a-z]+\b/g, function (all) {
+            return '\0cyan(' + all + '\0)';
+        }).replace(/\b[A-Z]+\b/g, function (all) {
+            return '\0green(' + all + '\0)';
+        }).replace(/"[^"]+"/g, function (all) {
+            return '\0red(' + all + '\0)';
+        }).replace(/_/g, function (all) {
+            return '\0green(\0bold(' + all + '\0)\0)';
+        }).replace(/->|;/g, function (all) {
+            return '\0red(' + all + '\0)';
+        })
+    }
+    return args.Option.prototype.help.call(this, help);
+};
+
+parser.help(
+    'A tool for working with JSON and other data.\n' + 
+    'Options get executed in order, on a register\n' +
+    'or on each value in the register iteratively.'
+);
+
+parser.option('-i', '--file-in', 'name')
+    .help('open(NAME) -> _')
+    .action(function (options, name, fileName) {
+        options._ = fs.open(fileName);
+    });
+
+parser.option('-o', '--file-out', 'name', 'fileOut')
+    .help('write(NAME, _); _ -> _')
+    .action(function (options, name, fileName) {
+        options.out = fs.open(fileName, 'w');
+    });
+
+parser.option('-n', '--read-lines', 'mode')
+    .help('switches to line register mode; _ is each value in the register')
+    .set('lines');
+
+parser.option('-N', '--read-all', 'mode')
+    .help('switches to whole register mode; _ is the whole value')
+    .action(function (options, name) {
+        options.mode = 'all';
+        /*if (options._.read && !Object.hasOwnProperty.call(options._, 'read'))
+            options._ = options._.read();
+            */
+    });
+
+parser.option('-j', '-}', '--json-in', 'jsonIn')
+    .help('json.decode(_) -> _')
+    .action(function (options) {
+        options._ = block(options._, options.mode, function (_) {
+            if (!typeof _ == "string") {
+                system.stderr.print("JSON can only decode strings.");
+                os.exit(-1);
+            }
+            // consume strems before reading
+            _ = read(_);
+            return JSON.decode(_);
+        });
+    });
+
+parser.option('-J', '-{', '--json-out', 'jsonOut')
+    .help('json.encode(_) -> _')
+    .action(function (options) {
+        options._ = collect(options._);
+        options._ = block(options._, options.mode, function (_) {
+            _ = collect(_);
+            return JSON.encode(_, null, options.tabWidth);
+        });
+    });
+
+parser.option('-t', '--tab-width', 'tab-width', 'tabWidth')
+    .help('use pretty print with a given tab width')
+    .set();
+
+parser.option('-T', '--pretty', 'tab-width', 'tabWidth')
+    .help('use pretty print with default tab width of 4')
+    .set(4);
+
+parser.option('-$', '--json-path', 'path')
+    .help('jsonpath.resolve(_, PATH) -> _')
+    .action(function (options, name, path) {
+        options._ = require('jsonpath').resolve(options._, path);
+    });
+
+parser.option('-c', '--array-collect')
+    .help('array(_) -> _')
+    .action(function (options) {
+        options._ = collect(options._);
+    });
+
+parser.option('-]', '-a', '--array-wrap')
+    .help('[array(_)] -> _')
+    .action(function (options) {
+            // TODO convert strams to arrays
+        options._ = [options._];
+    });
+
+parser.option('-[', '-A', '--array-unwrap')
+    .help('concat(_, _, _, ...) -> _')
+    .action(function (options) {
+        options._ = Array.prototype.concat.apply([], options._);
+    });
+
+parser.option('-O', '--array2object', '--a2o')
+    .help('converts [name,value] pairs to {name:value} object')
+    .action(function (options) {
+        options._ = collect(options._)
+        options._ = block(options._, options.mode, function (_) {
+            return util.object(_);
+        });
+    });
+
+parser.option('-X', '--object2array', '--o2a')
+    .help('converts {name:value} object to [name,value] pairs')
+    .action(function (options) {
+        options._ = block(options._, options.mode, function (_) {
+            return util.array(_);
+        });
+    });
+
+parser.option('-d', '--delimiter-in', 'delimiter')
+    .help('split(_, DELIMITER) -> _')
+    .action(function (options, name, delimiter) {
+        // todo switch between regex and literal mode with -E
+        var regex = new RegExp(RegExp.escape(delimiter), 'g');
+        options._ = block(options._, options.mode, function (_) {
+            return ('' + _).split(regex);
+        });
+    });
+
+parser.option('-D', '--delimiter-out', 'delimiter', 'delimiterOut')
+    .help('join(_, DELIMITER) -> _')
+    .action(function (options, name, delimiter) {
+        options._ = block(options._, options.mode, function (_) {
+            return collect(_).join(delimiter);
+        });
+    });
+
+parser.option('-f', '-.', '--array-fields', 'names', 'fields')
+    .help('selects fields from objects or arrays (first is -f 1)')
+    .action(function (options, name, fields) {
+        fields = fields.split(",");
+        options._ = block(options._, options.mode, function (_) {
+            return fields.map(function (field) {
+                if (field == "_")
+                    return _;
+                if ('' + (field >>> 0) === field)
+                    return _[(field >>> 0) - 1];
+                return _[field];
+            });
+        });
+    });
+
+parser.option('-F', '--object-fields', 'names')
+    .help('converts array indexes to object keys')
+    .action(function (options, name, fields) {
+        var fields = fields.split(",");
+        options._ = block(options._, options.mode, function (_) {
+            return util.object(util.zip(fields, _));
+        });
+    });
+
+parser.option('-l', '--lambda', 'names', 'expression')
+    .help('(function (NAMES) EXPRESSION)(_) -> _')
+    .action(function (options, name, names, expression) {
+        var lambda = Function.constructor.apply(
+            null,
+            ['_'].concat(names.split(',')).concat(['return (' + expression + ')'])
+        );
+        options._ = block(options._, options.mode, function (_) {
+            return lambda.apply(null, [_].concat(_));
+        });
+    });
+
+parser.option('-e', '--evaluate', 'expression')
+    .help('eval(EXPRESSION)) -> _')
+    .action(function (options, name, expression) {
+        options._ = block(options._, options.mode, function (_) {
+            global._ = _;
+            return system.evalGlobal(expression);
+        });
+    });
+
+parser.option('-v', '--value', 'expression')
+    .help('eval("("+EXPRESSION+")") -> _')
+    .action(function (options, name, expression) {
+        options._ = block(options._, options.mode, function (_) {
+            global._ = _;
+            return system.evalGlobal('(' + expression + ')');
+        });
+    });
+
+parser.option('-x', '--execute', 'statement')
+    .help('eval(STATEMENT); _ -> _')
+    .action(function (options, name, statement) {
+        options._ = block(options._, options.mode, function (_) {
+            global._ = _;
+            system.evalGlobal(statement);
+            return global._;
+        });
+    });
+
+parser.option('-w', '--where', 'expression')
+    .help('if (EXPRESSION) _ -> _')
+    .action(function (options, name, expression) {
+        var results = [];
+        options._.forEach(function (_) {
+            global._ = _;
+            if (system.evalGlobal(expression))
+                results.push(_);
+        });
+        options._ = results;
+    })
+
+parser.option('-p', '--print-lines', 'print')
+    .help('_.forEach(print); _ -> _')
+    .action(function (options) {
+        block(options._, options.mode, function (_) {
+            if (options.print0)
+                options.out.write('' + _ + '\0');
+            else
+                options.out.print('' + _);
+        });
+        if (options.print0)
+            options.out.flush();
+    });
+
+parser.option('-P', '--print-all', 'print')
+    .help('print(_); _ -> _')
+    .action(function (options) {
+        options._ = collect(options._);
+        if (options.print0)
+            options.out.write('' + options._ + '\0');
+        else
+            options.out.print('' + options._);
+    });
+
+parser.option('-0', '--read0', 'read0')
+    .help('read null terminated strings from streams with -N')
+    .action(function (options) {
+        // trim a final end of line if there is one
+        // (find -print0 writes one)
+        var content = options._.read().replace(/\0(\r\n?|\n)$/, '');
+        options._ = require("io").StringIO(content, "\0");
+    });
+
+parser.option('-z', '--print0', 'print0')
+    .help('print null terminated strings to streams with -p')
+    .set(true);
+
+parser.helpful();
+
+var read = function (_) {
+    if (_.read && !Object.prototype.hasOwnProperty.call(_, 'read')) {
+        return _.read();
+    } else {
+        return _;
+    }
+};
+
+var collect = function (_) {
+    if (
+        !util.no(_) &&
+        _.forEach &&
+        !Object.prototype.hasOwnProperty.call(_, 'forEach') &&
+        typeof _ != "string" // deprecated
+    ) {
+        var result = [];
+        _.forEach(function (_) {
+            result.push(_);
+        });
+        return result;
+    } else {
+        return _;
+    }
+};
+
+var block = function (_, mode, block) {
+    if (mode == "lines") {
+        if (typeof _ == "string") {
+            system.stderr.print("Cannot operate on strings in line mode.");
+            os.exit(-1);
+        }
+        var result = [];
+        _.forEach(function (_) {
+            result.push(block(_));
+        });
+        return result;
+    } else {
+        return block(_);
+    }
+};
+
+exports.main = function (system) {
+    var options = {};
+    options._ = system.stdin;
+    options.mode = "all";
+    options.out = system.stdout;
+    parser.parse(system.args, options);
+    if (typeof options._ == "number")
+        os.exit(options._);
+};
+
+if (require.main == module.id)
+    exports.main(system);
+