sproutit-narwhal 0.1.106

data/lib/narwhal/json.md

@@ -0,0 +1,178 @@
+
+JA: normal JSON
+    [[1,2,3],[4,5,6]]
+
+JA': abnormal multi-line JSON
+    [[1,2,3],
+    [4,5,6]]
+
+JAR: normal reversed java array
+    [[3,2,1],[6,5,4]]
+
+JOA: deep JSON config file
+    {
+        "values": [
+            [1,2,3],
+            [4,5,6]
+        ]
+    }
+
+JAO: a deep JSON array of objects
+
+    [
+        {"a": 1, "b": 2, "c": 3},
+        {"a": 4, "b": 5, "c": 6}
+    ]
+
+JAS: a JSON array of sums
+
+    [6, 15]
+
+JP: pretty JSON, t = 4
+
+    [
+        [1,2,3],
+        [4,5,6]
+    ]
+
+JL: lines of JSON
+    [1,2,3]
+    [4,5,6]
+
+J0: null-terminated lines of JSON
+
+    [1,2,3]\0[4,5,6]\0
+
+SL: lines of toString
+
+    1,2,3
+    4,5,6
+
+S0: null terminated lines of toString
+
+    1,2,3\04,5,6\0
+
+flat lines of JSON values
+    1
+    2
+    3
+    4
+    5
+    6
+
+flat lines of JSON
+    "2"
+    "3"
+    "4"
+    "5"
+    "6"
+
+UAA: unix records
+
+    1:2:3
+    4:5:6
+
+Cookbook
+========
+
+JOA -> JA: extracting a JSON array form a JSON object with an array
+-N}e{P
+
+    -N  _.read() 
+    -}  JSON.decode(_) 
+    -e  statement(_)        "_.values"
+    -{  JSON.encode(_) 
+    -P  print(_)
+
+JA -> JOA: creating a JSON object with an array from a JSON array
+-N}x{P
+
+    -N  _.read() 
+    -}  JSON.decode(_) 
+    -x  expression(_)       "{values: _}"
+    -{  JSON.encode(_) 
+    -P  print(_)
+
+JAO -> JA: converting objects to arrays
+-N}f{P
+
+    -N  _.read()
+    -}  JSON.decode(_)
+    -f  _.map(select)       "a,b,c"
+    -{  JSON.encode(_)
+    -P  print(_)
+
+JAR -> JA
+-N}
+
+    -N  _.read()
+    -}  JSON.decode(_)
+    -f  _.map(select)       "3,2,1"
+    -{  JSON.encode(_)
+    -P  print(_)
+
+JA -> JAS: calculating the sum of each array
+-N}l{P
+
+    -N  _.read()
+    -}  JSON.decode(_)
+    -l  _.map(lambda)       "a,b,c" "a+b+c"
+    -{  JSON.encode(_)
+    -P  print(_)
+
+JA' -> JA: normalizing an abnormal JSON file
+-N}{P
+
+    -N  _.read()
+    -}  JSON.decode(_) 
+    -{  JSON.encode(_) 
+    -P  print(_)
+
+JL -> J
+-}]{P
+
+    -}  _.map(JSON.decode) 
+    -]  [array(_)] 
+    -{  JSON.encode(_) 
+    -P  print(_)
+
+J -> JL
+-N}{p
+
+    -N  _.read()
+    -}  JSON.decode(_) 
+    -{  _.map(JSON.encode) 
+    -p  _.forEach(print)
+
+J -> SL
+-N}p
+
+    -N  _.read()
+    -}  JSON.decode(_) 
+    -p  _.forEach(print)
+
+SL -> JA
+-ne]{P
+
+    -ne _.map(expression)   "_.split(/,/)"
+    -]  [array(_)]
+    -{  JSON.encode(_)
+    -P  print(_)
+
+UAA -> JA
+-d]{P
+
+    -d  _.map(split)    ":"
+    -]  [array(_)]
+    -{  JSON.encode(_)
+    -P  print(_)
+
+UAA -> JAR
+-d]f{P
+
+    -d  _.map(split)     ":"
+    -]  [array(_)]
+    -f  _.map(select)    "3,2,1"
+    -{  JSON.encode(_)
+    -P  print(_)
+

data/lib/narwhal/repl.js

@@ -0,0 +1,96 @@
+
+var system = require("system");
+
+try { var readline = require("readline").readline; } catch (e) {}
+try { var Narcissus = require("narcissus/parse"); } catch (e) {}
+
+var util = require('util');
+
+var PROMPT_NORMAL       = "js> ",
+    PROMPT_INCOMPLETE   = "  > "
+
+var buffer = "";
+function readln(input) {
+    while (!(/\n/).test(buffer))
+        buffer += input.read(100).toString();
+        
+    var lines = buffer.split("\n"),
+        line = lines.shift();
+
+    buffer = lines.join("\n");
+
+    return line
+}
+
+exports.repl = function() {
+
+    var buffer = "",
+        bufferedLines = [],
+        pendingLines = [];
+        
+    system.stdout.write(PROMPT_NORMAL);
+    system.stdout.flush();
+    
+    while (true) {
+
+        var line = readline ? readline() : system.stdin.readLine();
+        if (!line) {
+            system.stdout.write("\n");
+            system.stdout.flush();
+            break;
+        }
+        
+        line = util.trimEnd(line);
+        var text = pendingLines.join("\n") + "\n" + line;
+        if (line == "" || !incomplete(text)) {
+            
+            pendingLines = [];
+                
+            try {
+                var result = system.evalGlobal(text);
+                var repr = util.repr(result);
+                if (repr.length > 76 || /\n/.test(repr))
+                    repr = String(result);
+                if (!util.no(result)) {
+                    system.stdout.write(repr + '\n');
+                    system.stdout.flush();
+                    global._ = result;
+                }
+            } catch (e) {
+                system.stdout.write("    exception from uncaught JavaScript throw: " + e + "\n");
+            }
+                
+        } else
+            pendingLines.push(line);
+    
+        if (pendingLines.length > 0)
+            system.stdout.write(PROMPT_INCOMPLETE);
+        else
+            system.stdout.write(PROMPT_NORMAL);
+        system.stdout.flush();
+
+    }
+}
+
+function incomplete(text) {
+    if (!Narcissus)
+        return false;
+
+    var incomp = true;
+    try {
+        var t = new Narcissus.Tokenizer(text);
+        var x = new Narcissus.CompilerContext(false);
+        var n = Narcissus.Script(t, x);
+        incomp = !t.done;
+    } catch (e) {
+        if (!t.done) {
+            print(e);
+            return false;
+        }
+    }
+    return incomp;
+}
+
+if (module.id == require.main)
+    exports.repl();
+

data/lib/narwhal/server-test.js

@@ -0,0 +1,6 @@
+var Q = require("ref-send");
+Q.when(require.async("util"), function (util) {
+    print("Hello, World!");
+    print(util.keys({"a": 10, "b": 20}).join(', '));
+    alert(util.upper('hi'));
+});

data/lib/narwhal/server.js

@@ -0,0 +1,270 @@
+
+var SYSTEM = require("system");
+var FILE = require("file");
+var UTIL = require("util");
+var SANDBOX = require("sandbox");
+var JSMIN = require("jsmin");
+var JACKUTILS = require("jack/utils");
+
+var Loader = SANDBOX.Loader;
+var AttenuatedLoader = SANDBOX.AttenuatedLoader;
+var Sandbox = SANDBOX.Sandbox;
+
+var contentType = "application/x-javascript";
+
+exports.Bundler = function (system) {
+    var self = {};
+
+    if (!system)
+        system = SYSTEM;
+    system = Object.create(system);
+    system.engine = "browser";
+    system.engines = UTIL.copy(system.engines);
+    system.engines.unshift("browser");
+    var paths = require.paths.map(function (path) {
+        return String(path);
+    });
+    paths.unshift(FILE.join(system.prefix, "engines", "browser", "lib"));
+
+    var loader = AttenuatedLoader(Loader({"paths": paths}));
+    var sandbox = Sandbox({
+        "loader": loader,
+        "system": system,
+        "modules": {
+            "system": system
+        }
+    });
+
+    sandbox.force("system");
+    sandbox("global");
+    sandbox("packages").main();
+
+    self.depends = function (baseId) {
+        // special case for the sandbox observer
+        //  in inline.js
+        if (baseId == "sandbox")
+            return ["global", "system"];
+        var depends = [];
+        loader.fetch(baseId).replace(
+            // TODO proper recursive descent parser
+            /(?:^|\s+|;)require\s*\(\s*(['"])([^'"]+)\1\s*\)/g,
+            function (all, quote, id) {
+                depends.push(loader.resolve(id, baseId));
+                return all;
+            }
+        );
+        return depends;
+    };
+
+    self.deepDepends = function (id, visited) {
+        var result = [];
+        if (!visited)
+            visited = {};
+        if (UTIL.has(visited, id))
+            return result;
+        visited[id] = true;
+        result.push(id);
+        self.depends(id).forEach(function (id) {
+            result.push.apply(
+                result,
+                self.deepDepends(id, visited)
+            );
+        });
+        return result;
+    };
+
+    self.module = function (id) {
+        return loader.fetch(id);
+    };
+
+    self.bundle = function (ids) {
+        return (
+            "require.register({" +
+            ids.map(function (id) {
+                var depends = JSON.encode(self.depends(id));
+                var factory = (
+                    "function(require,exports,module,system,print){" +
+                        loader.fetch(id) +
+                    "/**/\n}" 
+                );
+                return (
+                    UTIL.enquote(id) + ':' +
+                    "{" +
+                        '"factory":' + factory + "," +
+                        '"depends":' + depends +
+                    "}"
+                );
+            }).join(",") + 
+            "});"
+        );
+    };
+
+    return self;
+};
+
+exports.BundlerApp = function (bundler, options) {
+    options = options || {};
+    var debug = options.debug;
+    return function (env) {
+        var id = env.PATH_INFO.replace(/^\//, '').replace(/\.js$/, '');
+        var content = bundler.bundle([id]);
+        if (!debug)
+            content = JSMIN.encode(content);
+        return {
+            "status": 200,
+            "headers": {"Content-type": contentType},
+            "body": [content]
+        };
+    };
+};
+
+exports.App = function (nextApp, options) {
+    options = options || {};
+    var debug = options.debug;
+    var proxy = options.proxy;
+    var catalog = options.catalog;
+    var noHost = proxy || catalog;
+    if (noHost && options.path)
+        throw new Error("The path option is not applicable when using a proxy or catalog.");
+
+    var bundler = exports.Bundler();
+
+    var path = options.path || '.js/';
+    if (!/\/$/.test(path))
+        path += "/";
+    var re = new RegExp("^/" + RegExp.escape(path));
+    var jsApp = exports.BundlerApp(bundler, options);
+
+    return function (env) {
+        if (!proxy)
+            proxy = '/' + env.SCRIPT_NAME + path;
+        env.script = exports.ClientLoader(
+            env,
+            proxy,
+            bundler,
+            options
+        );
+        if (noHost) {
+            return nextApp(env);
+        } else if (re.test(env.PATH_INFO)) {
+            env = Object.create(env);
+            env.SCRIPT_NAME = env.SCRIPT_NAME + path;
+            env.PATH_INFO = env.PATH_INFO.substring(path.length);
+            return jsApp(env);
+        } else {
+            return nextApp(env);
+        }
+    };
+
+};
+
+var inline = FILE.path(module.path)
+    .resolve("inline.js")
+    .read()
+    .replace(/\s*$/, "");
+
+exports.ClientLoader = function (env, path, bundler, options) {
+    options = options || {};
+    var debug = options.debug;
+    var bundle = options.bundle;
+    var proxy = options.proxy;
+    var catalog = options.catalog;
+
+    // returns a script that loads a program
+    var loader = {};
+
+    var bootstrap = [
+        "narwhal/client",
+        "sandbox",
+        "system",
+        "ref-send",
+        "reactor"
+    ].concat(
+        bundler.deepDepends("global")
+    );
+    var queue = Array.prototype.slice.call(bootstrap);
+
+    var clientSent = false;
+    var client = function () {
+        if (clientSent) {
+            return "require";
+        } else {
+            clientSent = true;
+            var content = inline +
+                ".call(this," + UTIL.repr(path) + ")";
+            if (!debug)
+                content = JSMIN.encode(content);
+            return content;
+        }
+    };
+
+    var flush = function () {
+        var ids = queue.splice(0, queue.length);
+        UTIL.sort(ids, UTIL.by(function (id) {
+            return -bundler.module(id).length;
+        }));
+        return client() +
+            ".preload(" + UTIL.repr(ids) + ")";
+    };
+
+    loader.loader = function () {
+        return flush();
+    };
+
+    // returns a script that loads a bunch of factories
+    loader.preload = function (ids) {
+        ids = Array.prototype.concat.apply([], ids.map(bundler.deepDepends));
+        // enqueue the given module's deep dependencies
+        queue.push.apply(queue, ids);
+        return flush();
+    };
+
+    // returns a script that loads and requires a module
+    loader.require = function (id) {
+        return loader.preload([id]) + ".async(" + UTIL.repr(id) + ")";
+    };
+
+    loader.require.async = function (id) {
+        return flush() + ".async(" + UTIL.repr(id) + ")";
+    };
+    
+    // return a script that *is* a bunch of factories and a loader for them.
+    loader.embed = function (id) {
+        var content = loader.loader() +
+            ".bridge(function(require){" + 
+                bundler.bundle(
+                    queue.splice(0, queue.length)
+                    .concat(bundler.deepDepends(id))
+                ) +
+            "}).async(" + UTIL.repr(id) + ");";
+        if (!debug)
+            content = JSMIN.encode(content);
+        return content;
+    };
+
+    return loader;
+};
+
+exports.main = function () {
+    var app = function (env) {
+        if (/^../.test(env.PATH_INFO))
+            return JACKUTILS.responseForStatus(404, env.PATH_INFO);
+        return {
+            "status": 200,
+            "headers": {"Content-type": "text/html"},
+            "body": [
+                "<html><head><script>" +
+                env.script.require("narwhal/server-test") +
+                "</script></head><body></body></html>"
+            ]
+        };
+    };
+    app = exports.App(app, {"debug": true});
+    app = require("jack").ContentLength(app);
+    exports.app = app;
+    require("jackup").main(["jackup", module.path]);
+};
+
+if (require.main == module.id)
+    exports.main();
+