08-27-周三_17-09-29

node_modules/dnode/.travis.yml

@@ -0,0 +1,33 @@
+sudo: false
+
+env:
+  - CXX=g++-4.8
+addons:
+  apt:
+    sources:
+      - ubuntu-toolchain-r-test
+    packages:
+      - g++-4.8
+
+language: node_js
+
+node_js:
+  - "0.12"
+  - "0.10"
+  - "0.8"
+  - "iojs"
+  - "4"
+
+install:
+  - PATH="`npm bin`:`npm bin -g`:$PATH"
+  # Node 0.8 comes with a too obsolete npm
+  - if [[ "`node --version`" =~ ^v0\.8\. ]]; then npm install -g npm@1.4.28 ; fi
+  # Install dependencies and build
+  - npm install
+
+script:
+  # Output useful info for debugging
+  - node --version
+  - npm --version
+  # Run tests
+  - npm test

node_modules/dnode/LICENSE

@@ -0,0 +1,4 @@
+Copyright 2010 James Halliday (mail@substack.net)
+
+This project is free software released under the MIT license:
+http://www.opensource.org/licenses/mit-license.php 

node_modules/dnode/browser.js

@@ -0,0 +1,5 @@
+var dnode = require('./lib/dnode');
+
+module.exports = function (cons, opts) {
+    return new dnode(cons, opts);
+};

node_modules/dnode/example/auth/client.js

@@ -0,0 +1,24 @@
+var dnode = require('dnode');
+
+if (process.argv.length < 4) {
+    return console.error('Usage: ./client.js user pass');
+}
+
+var user = process.argv[2];
+var pass = process.argv[3];
+
+var d = dnode.connect(7007);
+d.on('remote', function (remote) {
+    remote.auth(user, pass, function (err, session) {
+        if (err) {
+            console.error(err);
+            return d.end();
+        }
+        
+        session.quote(function (q) {
+            console.log('And now for a quote by ' + q.who + ':\n');
+            console.log(q.quote + '\n');
+            d.end();
+        });
+    });
+});

node_modules/dnode/example/auth/quotes.json

@@ -0,0 +1,18 @@
+[ 
+    {
+        "quote" : "Beauty is a consequential thing, a product of solving problems correctly.",
+        "who" : "Joseph Eshrick"
+    },
+    {
+        "quote" : "If you wish to make an apple pie from scratch, you must first invent the universe.",
+        "who" : "Carl Sagan"
+    },
+    {
+        "quote" : "If you're not allowed to implement new ideas, you stop having them.",
+        "who" : "Paul Graham"
+    },
+    {
+        "quote" : "For a successful technology, reality must take precedence over public relations, for nature cannot be fooled.",
+        "who" : "Richard Feynman"
+    }
+]

node_modules/dnode/example/auth/server.js

@@ -0,0 +1,29 @@
+var dnode = require('dnode');
+var fs = require('fs');
+var net = require('net');
+
+var secretQuotes = require('./quotes.json');
+function randomQuote (cb) {
+    var ix = Math.floor(Math.random() * secretQuotes.length);
+    cb(secretQuotes[ix]);
+}
+
+var server = net.createServer(function (stream) {
+    var d = dnode({ auth : auth });
+    d.pipe(stream).pipe(d);
+    
+    function auth (user, pass, cb) {
+        if (typeof cb !== 'function') return;
+        
+        if (user === 'moo' && pass === 'hax') {
+            console.log('signed in: ' + user);
+            d.on('end', function () {
+                console.log('disconnected: ' + user);
+            });
+            
+            cb(null, { quote : randomQuote });
+        }
+        else cb('ACCESS DENIED')
+    }
+});
+server.listen(7007);

node_modules/dnode/example/shoe/Makefile

@@ -0,0 +1,2 @@
+all:
+	node_modules/.bin/browserify client.js -o static/bundle.js

node_modules/dnode/example/shoe/client.js

@@ -0,0 +1,16 @@
+var domready = require('domready');
+var shoe = require('shoe');
+var dnode = require('../../');
+
+domready(function () {
+    var result = document.getElementById('result');
+    var stream = shoe('/dnode');
+    
+    var d = dnode();
+    d.on('remote', function (remote) {
+        remote.transform('beep', function (s) {
+            result.textContent = 'beep => ' + s;
+        });
+    });
+    d.pipe(stream).pipe(d);
+});

node_modules/dnode/example/shoe/package.json

@@ -0,0 +1,11 @@
+{
+    "name" : "dnode-shoe-example",
+    "version" : "0.0.0",
+    "dependencies" : {
+        "shoe" : "~0.0.0",
+        "ecstatic" : "~0.1.6",
+        "domready" : "~0.2.11",
+        "browserify" : "~1.12.3"
+    },
+    "private" : true
+}

node_modules/dnode/example/shoe/server.js

@@ -0,0 +1,18 @@
+var http = require('http');
+var shoe = require('shoe');
+var ecstatic = require('ecstatic')(__dirname + '/static');
+var dnode = require('../../');
+
+var server = http.createServer(ecstatic);
+server.listen(9999);
+
+var sock = shoe(function (stream) {
+    var d = dnode({
+        transform : function (s, cb) {
+            var res = s.replace(/[aeiou]{2,}/, 'oo').toUpperCase();
+            cb(res);
+        }
+    });
+    d.pipe(stream).pipe(d);
+});
+sock.install(server, '/dnode');

node_modules/dnode/example/shoe/static/index.html

@@ -0,0 +1,2 @@
+<script src="/bundle.js"></script>
+<div id="result"></div>

node_modules/dnode/example/simple/client.js

@@ -0,0 +1,8 @@
+var dnode = require('../../');
+
+dnode.connect(7070, function (remote, conn) {
+    remote.zing(33, function (n) {
+        console.log('n=' + n);
+        conn.end();
+    });
+});

node_modules/dnode/example/simple/server.js

@@ -0,0 +1,6 @@
+var dnode = require('../../');
+
+var server = dnode(function (remote, conn) {
+    this.zing = function (n, cb) { cb(n * 100) };
+});
+server.listen(7070);

node_modules/dnode/example/stream/connect.js

@@ -0,0 +1,13 @@
+var dnode = require('../../');
+var net = require('net');
+
+var d = dnode();
+d.on('remote', function (remote) {
+    remote.transform('beep', function (s) {
+        console.log('beep => ' + s);
+        d.end();
+    });
+});
+
+var c = net.connect(5004);
+c.pipe(d).pipe(c);

node_modules/dnode/example/stream/listen.js

@@ -0,0 +1,13 @@
+var dnode = require('../../');
+var net = require('net');
+
+var server = net.createServer(function (c) {
+    var d = dnode({
+        transform : function (s, cb) {
+            cb(s.replace(/[aeiou]{2,}/, 'oo').toUpperCase())
+        }
+    });
+    c.pipe(d).pipe(c);
+});
+
+server.listen(5004);

node_modules/dnode/index.js

@@ -0,0 +1,137 @@
+var dnode = require('./lib/dnode');
+var parseArgs = require('./lib/parse_args');
+var net = require('net');
+var util = require('util');
+var weak
+
+exports = module.exports = function (cons, opts) {
+    return new D(cons, opts);
+};
+
+exports.connect = function () {
+    var d = new D();
+    return d.connect.apply(d, arguments);
+};
+
+exports.listen = function () {
+    var d = new D();
+    return d.listen.apply(d, arguments);
+};
+
+util.inherits(D, dnode);
+function D (cons, opts) {
+    var self = this;
+    if (!opts) opts = {};
+    
+    if (opts.weak !== false && !opts.proto) {
+        if (!weak) {
+            weak = require("weak")
+        }
+        
+        opts.proto = {};
+        opts.proto.wrap = function (cb, id) {
+            var proto = this;
+            return weak(cb, function () {
+                proto.cull(id);
+            });
+        };
+        opts.proto.unwrap = function (ref, id) {
+            var cb = weak.get(ref);
+            return cb || function () {};
+        };
+    }
+    return dnode.call(self, cons, opts);
+}
+
+D.prototype.connect = function () {
+    var self = this;  
+    var params = parseArgs(arguments);
+    
+    var stream;
+    if (params.path) {
+        stream = net.connect(params.path);
+    }
+    else if (params.port) {
+        stream = net.connect(params.port, params.host);
+    }
+    else {
+        throw new Error('no port or unix path given');
+    }
+    
+    if (params.block) self.on('remote', params.block);
+    
+    stream.on('error', function (err) {
+        if (err && err.code === 'EPIPE') return; // eat EPIPEs
+        self.emit('error', err);
+    });
+    
+    self.id = randomId();
+    self.stream = stream;
+    stream.pipe(self);
+    self.pipe(stream);
+    
+    return self;
+};
+
+dnode.prototype.listen = function () {
+    var self = this;
+    
+    // just copy over the opts and cons, the rest will need to be re-created
+    var cons = self.cons, opts = self.opts;
+    self.cons = function () {};
+    self.end();
+    
+    var params = parseArgs(arguments);
+    
+    var server = net.createServer(function (stream) {
+        var d = new dnode(cons, opts);
+        do { d.id = randomId() }
+        while (server.sessions[d.id]);
+        
+        server.sessions[d.id] = d;
+        d.on('end', function () {
+            delete server.sessions[d.id];
+        });
+        
+        d.on('local', function (ref) {
+            server.emit('local', ref, d);
+        });
+        
+        d.on('remote', function (remote) {
+            server.emit('remote', remote, d);
+        });
+        
+        stream.on('error', function (err) {
+            if (err && err.code === 'EPIPE') return; // eat EPIPEs
+            d.emit('error', err);
+        });
+        
+        d.stream = stream;
+        stream.pipe(d);
+        d.pipe(stream);
+    });
+    
+    server.sessions = {};
+    
+    if (typeof params.port === 'number' && params.port >= 0) {
+        server.listen(params.port, params.host);
+    }
+    else if (params.path) {
+        server.listen(params.path);
+    }
+    else {
+        throw new Error('no port or path provided');
+    }
+    
+    if (params.block) server.on('listening', params.block);
+    
+    return server;
+};
+
+function randomId () {
+    var s = '';
+    for (var i = 0; i < 4; i++) {
+        s += Math.random().toString(16).slice(2);
+    }
+    return s;
+}

node_modules/dnode/lib/dnode.js

@@ -0,0 +1,153 @@
+var protocol = require('dnode-protocol');
+var Stream = require('stream');
+var json = typeof JSON === 'object' ? JSON : require('jsonify');
+
+module.exports = dnode;
+dnode.prototype = {};
+(function () { // browsers etc
+    for (var key in Stream.prototype) {
+        dnode.prototype[key] = Stream.prototype[key];
+    }
+})();
+
+function dnode (cons, opts) {
+    Stream.call(this);
+    var self = this;
+    
+    self.opts = opts || {};
+    
+    self.cons = typeof cons === 'function'
+        ? cons
+        : function () { return cons || {} }
+    ;
+    
+    self.readable = true;
+    self.writable = true;
+    
+    process.nextTick(function () {
+        if (self._ended) return;
+        self.proto = self._createProto();
+        self.proto.start();
+        
+        if (!self._handleQueue) return;
+        for (var i = 0; i < self._handleQueue.length; i++) {
+            self.handle(self._handleQueue[i]);
+        }
+    });
+}
+
+dnode.prototype._createProto = function () {
+    var self = this;
+    var proto = protocol(function (remote) {
+        if (self._ended) return;
+        
+        var ref = self.cons.call(this, remote, self);
+        if (typeof ref !== 'object') ref = this;
+        
+        self.emit('local', ref, self);
+        
+        return ref;
+    }, self.opts.proto);
+    
+    proto.on('remote', function (remote) {
+        self.emit('remote', remote, self);
+        self.emit('ready'); // backwards compatability, deprecated
+    });
+    
+    proto.on('request', function (req) {
+        if (!self.readable) return;
+        
+        if (self.opts.emit === 'object') {
+            self.emit('data', req);
+        }
+        else self.emit('data', json.stringify(req) + '\n');
+    });
+    
+    proto.on('fail', function (err) {
+        // errors that the remote end was responsible for
+        self.emit('fail', err);
+    });
+    
+    proto.on('error', function (err) {
+        // errors that the local code was responsible for
+        self.emit('error', err);
+    });
+    
+    return proto;
+};
+
+dnode.prototype.write = function (buf) {
+    if (this._ended) return;
+    var self = this;
+    var row;
+    
+    if (buf && typeof buf === 'object'
+    && buf.constructor && buf.constructor.name === 'Buffer'
+    && buf.length
+    && typeof buf.slice === 'function') {
+        // treat like a buffer
+        if (!self._bufs) self._bufs = [];
+        
+        // treat like a buffer
+        for (var i = 0, j = 0; i < buf.length; i++) {
+            if (buf[i] === 0x0a) {
+                self._bufs.push(buf.slice(j, i));
+                
+                var line = '';
+                for (var k = 0; k < self._bufs.length; k++) {
+                    line += String(self._bufs[k]);
+                }
+                
+                try { row = json.parse(line) }
+                catch (err) { return self.end() }
+                
+                j = i + 1;
+                
+                self.handle(row);
+                self._bufs = [];
+            }
+        }
+        
+        if (j < buf.length) self._bufs.push(buf.slice(j, buf.length));
+    }
+    else if (buf && typeof buf === 'object') {
+        // .isBuffer() without the Buffer
+        // Use self to pipe JSONStream.parse() streams.
+        self.handle(buf);
+    }
+    else {
+        if (typeof buf !== 'string') buf = String(buf);
+        if (!self._line) self._line = '';
+        
+        for (var i = 0; i < buf.length; i++) {
+            if (buf.charCodeAt(i) === 0x0a) {
+                try { row = json.parse(self._line) }
+                catch (err) { return self.end() }
+                
+                self._line = '';
+                self.handle(row);
+            }
+            else self._line += buf.charAt(i)
+        }
+    }
+};
+
+dnode.prototype.handle = function (row) {
+    if (!this.proto) {
+        if (!this._handleQueue) this._handleQueue = [];
+        this._handleQueue.push(row);
+    }
+    else this.proto.handle(row);
+};
+
+dnode.prototype.end = function () {
+    if (this._ended) return;
+    this._ended = true;
+    this.writable = false;
+    this.readable = false;
+    this.emit('end');
+};
+
+dnode.prototype.destroy = function () {
+    this.end();
+};

node_modules/dnode/lib/parse_args.js

@@ -0,0 +1,35 @@
+module.exports = function (argv) {
+    var params = {};
+    for (var i = 0; i < argv.length; i++) {
+        var arg = argv[i];
+        
+        if (typeof arg === 'string') {
+            if (arg.match(/^\d+$/)) {
+                params.port = parseInt(arg, 10);
+            }
+            else if (arg.match('^/')) {
+                params.path = arg;
+            }
+            else {
+                params.host = arg;
+            }
+        }
+        else if (typeof arg === 'number') {
+            params.port = arg;
+        }
+        else if (typeof arg === 'function') {
+            params.block = arg;
+        }
+        else if (typeof arg === 'object') {
+            for (var key in arg) {
+                if (key === 'port') {
+                    params[key] = parseInt(arg[key], 10)
+                }
+                else params[key] = arg[key]
+            }
+        }
+        // ignore everything else
+    };
+    
+    return params;
+};

node_modules/dnode/package.json

@@ -0,0 +1,123 @@
+{
+  "_args": [
+    [
+      {
+        "name": "dnode",
+        "raw": "dnode@>=1.2.2",
+        "rawSpec": ">=1.2.2",
+        "scope": null,
+        "spec": ">=1.2.2",
+        "type": "range"
+      },
+      "/root/gitbook/node_modules/phantom"
+    ]
+  ],
+  "_from": "dnode@>=1.2.2",
+  "_id": "dnode@1.2.2",
+  "_inCache": true,
+  "_installable": true,
+  "_location": "/dnode",
+  "_nodeVersion": "0.12.7",
+  "_npmUser": {
+    "email": "seethroughtrees+npm@gmail.com",
+    "name": "seethroughtrees"
+  },
+  "_npmVersion": "2.11.3",
+  "_phantomChildren": {},
+  "_requested": {
+    "name": "dnode",
+    "raw": "dnode@>=1.2.2",
+    "rawSpec": ">=1.2.2",
+    "scope": null,
+    "spec": ">=1.2.2",
+    "type": "range"
+  },
+  "_requiredBy": [
+    "/phantom"
+  ],
+  "_resolved": "https://registry.npmjs.org/dnode/-/dnode-1.2.2.tgz",
+  "_shasum": "4ac3cfe26e292b3b39b8258ae7d94edc58132efa",
+  "_shrinkwrap": null,
+  "_spec": "dnode@>=1.2.2",
+  "_where": "/root/gitbook/node_modules/phantom",
+  "author": {
+    "email": "mail@substack.net",
+    "name": "James Halliday",
+    "url": "http://substack.net"
+  },
+  "browserify": "browser.js",
+  "bugs": {
+    "url": "https://github.com/substack/dnode/issues"
+  },
+  "dependencies": {
+    "dnode-protocol": "~0.2.2",
+    "jsonify": "~0.0.0",
+    "weak": "^1.0.0"
+  },
+  "description": "freestyle rpc",
+  "devDependencies": {
+    "tape": "~2.3.2"
+  },
+  "directories": {},
+  "dist": {
+    "integrity": "sha512-OGTysjAH1/hElDKfQb4nS5syzETTc9MWPv1BgAqeKEBpSb+1PBaOxs+n6Uh+Lm1Xh+dwyybDby6t/yP1VFbhag==",
+    "shasum": "4ac3cfe26e292b3b39b8258ae7d94edc58132efa",
+    "signatures": [
+      {
+        "keyid": "SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA",
+        "sig": "MEUCIG1dz8IkT2haAQfnmejvNy+JOhDgprORru2zTJDjIAlJAiEAnFniKP+2kd4sgqOejmWypaBZc6njlImJ3RuMc5dp9Iw="
+      }
+    ],
+    "tarball": "https://registry.npmjs.org/dnode/-/dnode-1.2.2.tgz"
+  },
+  "engine": {
+    "node": ">=0.6.0"
+  },
+  "gitHead": "32e8a7e36f4603672b17fa4b0fbecc05c66022df",
+  "homepage": "https://github.com/substack/dnode#readme",
+  "keywords": [
+    "rpc",
+    "callbacks"
+  ],
+  "main": "./index.js",
+  "maintainers": [
+    {
+      "email": "substack@gmail.com",
+      "name": "substack"
+    },
+    {
+      "email": "seethroughtrees+npm@gmail.com",
+      "name": "seethroughtrees"
+    }
+  ],
+  "name": "dnode",
+  "optionalDependencies": {
+    "weak": "^1.0.0"
+  },
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/substack/dnode.git"
+  },
+  "scripts": {
+    "test": "tape test/*.js test/server/*.js"
+  },
+  "testling": {
+    "browsers": [
+      "ie/6..latest",
+      "chrome/10",
+      "chrome/latest",
+      "chrome/canary",
+      "firefox/10",
+      "firefox/latest",
+      "firefox/nightly",
+      "safari/latest",
+      "opera/11.0..latest",
+      "iphone/6",
+      "ipad/6",
+      "android-browser/latest"
+    ],
+    "files": "test/*.js"
+  },
+  "version": "1.2.2"
+}

node_modules/dnode/perf/memory/client.js

@@ -0,0 +1,12 @@
+var dnode = require('../../');
+var d = dnode();
+
+var d = dnode.connect(7070);
+var ix = 0;
+d.on('remote', function fn (remote) {
+    remote.zing(33, function () {
+        ix++;
+        if (ix % 100 === 0) console.log(ix);
+        fn(remote);
+    });
+});

node_modules/dnode/perf/memory/server.js

@@ -0,0 +1,16 @@
+var dnode = require('../../');
+var net = require('net');
+
+var server = net.createServer(function (stream) {
+    var d = dnode(function (remote) {
+        this.zing = function (n, cb) { cb(n * 100) };
+    });
+    d.pipe(stream).pipe(d);
+});
+server.listen(7070);
+
+setInterval(function () {
+    var mem = process.memoryUsage();
+    var m = mem.heapTotal / 1024 / 1024;
+    console.log(Math.round(m * 100) / 100 + ' MB');
+}, 1000);

node_modules/dnode/readme.markdown

@@ -0,0 +1,293 @@
+# dnode
+
+dnode is an asynchronous rpc system for node.js that lets you
+call remote functions.
+
+You can pass callbacks to remote functions, and the remote end can call
+the functions you passed in with callbacks of its own and so on.
+It's callbacks all the way down!
+
+[![browser support](https://ci.testling.com/substack/dnode.png)](http://ci.testling.com/substack/dnode)
+
+[![build status](https://secure.travis-ci.org/substack/dnode.png)](http://travis-ci.org/substack/dnode)
+
+![dnode: freestyle rpc](http://substack.net/images/dnode.png)
+
+# example
+
+## listen and connect
+
+server:
+
+``` js
+var dnode = require('dnode');
+var server = dnode({
+    transform : function (s, cb) {
+        cb(s.replace(/[aeiou]{2,}/, 'oo').toUpperCase())
+    }
+});
+server.listen(5004);
+```
+
+client:
+
+``` js
+var dnode = require('dnode');
+
+var d = dnode.connect(5004);
+d.on('remote', function (remote) {
+    remote.transform('beep', function (s) {
+        console.log('beep => ' + s);
+        d.end();
+    });
+});
+```
+
+output:
+
+```
+$ node server.js &
+[1] 27574
+$ node client.js
+beep => BOOP
+```
+
+## streaming
+
+The `.connect()` and `.listen()` calls in the previous example are just
+convenience methods for piping to and from readable/writable streams.
+Here's the previous example with the streams set up explicitly:
+
+server:
+
+``` js
+var dnode = require('dnode');
+var net = require('net');
+
+var server = net.createServer(function (c) {
+    var d = dnode({
+        transform : function (s, cb) {
+            cb(s.replace(/[aeiou]{2,}/, 'oo').toUpperCase())
+        }
+    });
+    c.pipe(d).pipe(c);
+});
+
+server.listen(5004);
+```
+
+client:
+
+``` js
+var dnode = require('dnode');
+var net = require('net');
+
+var d = dnode();
+d.on('remote', function (remote) {
+    remote.transform('beep', function (s) {
+        console.log('beep => ' + s);
+        d.end();
+    });
+});
+
+var c = net.connect(5004);
+c.pipe(d).pipe(c);
+```
+
+output:
+
+```
+$ node server.js &
+[1] 27586
+$ node client.js 
+beep => BOOP
+```
+
+## dnode in the browser
+
+Since dnode instances are just readable/writable streams, you can use them with
+any streaming transport, including in the browser!
+
+This example uses the streaming interface provided by
+[shoe](https://github.com/substack/shoe), which is just a thin wrapper on top of
+[sockjs](http://sockjs.org/) that provides websockets with fallbacks.
+
+First whip up a server:
+
+``` js
+var http = require('http');
+var shoe = require('shoe');
+var ecstatic = require('ecstatic')(__dirname + '/static');
+var dnode = require('dnode');
+
+var server = http.createServer(ecstatic);
+server.listen(9999);
+
+var sock = shoe(function (stream) {
+    var d = dnode({
+        transform : function (s, cb) {
+            var res = s.replace(/[aeiou]{2,}/, 'oo').toUpperCase();
+            cb(res);
+        }
+    });
+    d.pipe(stream).pipe(d);
+});
+sock.install(server, '/dnode');
+```
+
+Then write some browser code:
+
+``` js
+var domready = require('domready');
+var shoe = require('shoe');
+var dnode = require('dnode');
+
+domready(function () {
+    var result = document.getElementById('result');
+    var stream = shoe('/dnode');
+    
+    var d = dnode();
+    d.on('remote', function (remote) {
+        remote.transform('beep', function (s) {
+            result.textContent = 'beep => ' + s;
+        });
+    });
+    d.pipe(stream).pipe(d);
+});
+```
+
+Install the dependencies for this example then compile the browser code with
+[browserify](https://github.com/substack/node-browserify):
+
+```
+$ npm install dnode shoe domready ecstatic
+$ npm install -g browserify
+$ browserify client.js -o static/bundle.js
+```
+
+Now drop a script tag into static/index.html:
+
+``` html
+<script src="/bundle.js"></script>
+<div id="result"></div>
+```
+
+and navigate to http://localhost:9999.
+You should see `beep => BOOP` on the page!
+
+Check out the
+[complete shoe example](https://github.com/substack/dnode/tree/master/example/shoe).
+
+# methods
+
+``` js
+var dnode = require('dnode')
+```
+
+## var d = dnode(cons, opts={})
+
+Create a new readable/writable dnode stream object `d`.
+All the usual stream methods are at your disposal: pipe(), write(), end().
+
+If `cons` is a function, it will be called `new cons(remote, d)` to create a new
+instance object. Otherwise its value will be used directly. When `cons` is
+called as a function, the `remote` ref will be an empty unpopulated object.
+
+By default, dnode uses weakmaps to garbage collect unused callbacks
+automatically. This behavior prevents memory leaks in long-running connections.
+
+You can turn weakmaps off by setting `opts.weak = false`.
+
+## d.connect(...)
+
+This method is a shortcut for setting up a pipe between `d` and a new
+`net.connect()` stream.
+
+The host, port, and callback arguments supplied will be inferred by their
+types.
+
+If you pass a callback in as an argument, it will be added as a listener to the
+`'remote'` event.
+
+Returns the `d` object.
+
+## dnode.connect(...)
+
+Shortcut to create a connection without a constructor.
+
+## d.listen(...)
+
+This method is a shortcut for setting up a `net.createServer()` and piping
+network streams to and from new dnode streams.
+
+The host, port, and callback parameters will be inferred from the types of the
+arguments.
+
+Returns a net server object that will also emit `'local'` and `'remote'` events
+from the underlying dnode streams..
+
+## dnode.listen(...)
+
+Shortcut to create a listener without a constructor.
+
+# events
+
+## d.on('remote', cb)
+
+This event fires with `cb(remote, d)` when the remote side of the connection
+has constructed its instance.
+
+## d.on('local', cb)
+
+This event fires right after the constructed instance has been created locally
+but before it gets sent to the remote end so you can modify the ref object.
+
+This event fires with `cb(ref, d)` where `ref` is the local instance object.
+
+## d.on('fail', cb)
+
+This event fires when the remote end causes errors in the protocol layer.
+
+These are non-fatal and can probably be ignored but you could also terminate the
+connection here.
+
+## d.on('error', cb)
+
+This event fires when local code causes errors in its callbacks.
+Not all errors can be caught here since some might be in async functions.
+
+## d.on('end', cb)
+
+This event fires when the input stream finishes.
+
+# install
+
+With [npm](http://npmjs.org) do:
+
+```
+npm install dnode
+```
+
+# protocol
+
+dnode uses a newline-terminated JSON protocol
+[documented in the dnode-protocol project](https://github.com/substack/dnode-protocol/blob/master/doc/protocol.markdown#the-protocol).
+
+# dnode in other languages
+
+These libraries implement the dnode protocol too so you can make RPC calls
+between scripts written in different languages.
+
+* [dnode-perl](http://github.com/substack/dnode-perl)
+* [dnode-ruby](http://github.com/substack/dnode-ruby)
+* [dnode-php](https://github.com/bergie/dnode-php)
+* [dnode-php-sync-client](https://github.com/erasys/dnode-php-sync-client)
+* [dnode-java](https://github.com/aslakhellesoy/dnode-java)
+
+# shameless plug
+
+Want to make sure your crazy javascript-heavy app still works in other
+browsers?
+Give [browserling](http://browserling.com) a spin!
+Browsers in your browser. Powered by dnode.
+

node_modules/dnode/test/_id.js

@@ -0,0 +1,13 @@
+var dnode = require('../');
+var test = require('tape');
+
+test('_id', function (t) {
+    t.plan(1);
+    
+    var server = dnode({ _id : 1337 });
+    var client = dnode();
+    client.on('remote', function (remote, conn) {
+        t.equal(remote._id, 1337);
+    });
+    client.pipe(server).pipe(client);
+});

node_modules/dnode/test/args.js

@@ -0,0 +1,55 @@
+var test = require('tape');
+
+var parseArgs = require('../lib/parse_args');
+
+function argv () { return arguments }
+
+test('args', function (t) {
+    t.deepEqual(
+        parseArgs(argv('moo.com', 555)),
+        { host : 'moo.com', port : 555 }
+    );
+    
+    t.deepEqual(
+        parseArgs(argv('7777')),
+        { port : 7777 }
+    );
+    
+    t.deepEqual(
+        parseArgs(argv({
+            host : 'moosy.moo.com',
+            port : 5050
+        })),
+        { host : 'moosy.moo.com', port : 5050 }
+    );
+    
+    t.deepEqual(
+        parseArgs(argv('meow.cats.com', { port : '1234' })),
+        { host : 'meow.cats.com', port : 1234 }
+    );
+    
+    t.deepEqual(
+        typeof parseArgs(argv('789')).port,
+        'number'
+    );
+    
+    t.deepEqual(
+        parseArgs(argv(
+            { host : 'woof.dogs.com' }, { port : 4050 }
+        )),
+        { host : 'woof.dogs.com', port : 4050 }
+    );
+    
+    t.deepEqual(
+        parseArgs(argv(
+            undefined,
+            { host : 'woof.dogs.com' },
+            undefined,
+            { port : 4050 },
+            undefined
+        )),
+        { host : 'woof.dogs.com', port : 4050 }
+    );
+    
+    t.end();
+});

node_modules/dnode/test/bidirectional.js

@@ -0,0 +1,30 @@
+var dnode = require('../');
+var test = require('tape');
+
+test('bidirectional', function (t) {
+    t.plan(3);
+    
+    var server = dnode(function (client) {
+        this.timesX = function (n,f) {
+            t.equal(n, 3, "timesX's n == 3");
+            
+            client.x(function (x) {
+                t.equal(x, 20, 'client.x == 20');
+                f(n * x);
+            });
+        }; 
+    });
+    
+    var client = dnode({
+        x : function (f) { f(20) }
+    });
+    client.on('remote', function (remote) {
+        remote.timesX(3, function (res) {
+            t.equal(res, 60, 'result of 20 * 3 == 60');
+            client.end();
+            server.end();
+        });
+    });
+    
+    client.pipe(server).pipe(client);
+});

node_modules/dnode/test/broadcast.js

@@ -0,0 +1,69 @@
+var dnode = require('../');
+var EventEmitter = require('events').EventEmitter;
+var test = require('tape');
+
+test('broadcast', function (t) {
+    t.plan(3);
+    
+    var em = new EventEmitter;
+    var server = function () {
+        return dnode(function (client, conn) {
+            conn.on('ready', function () {
+                em.on('message', client.message);
+            });
+            
+            conn.on('end', function () {
+                em.removeListener('message', client.message);
+            });
+            
+            this.message = function (msg) {
+                em.emit('message', client.name + ' says: ' + msg);
+            };
+        });
+    };
+    
+    var recv = { 0 : [], 1 : [], 2 : [] };
+    
+    var client0 = dnode({
+        name : '#0',
+        message : function (msg) { recv[0].push(msg) }
+    });
+    client0.on('remote', function (remote) {
+        setTimeout(function () {
+            remote.message('hello!');
+        }, 25);
+    });
+    client0.pipe(server()).pipe(client0);
+    
+    var client1 = dnode({
+        name : '#1',
+        message : function (msg) { recv[1].push(msg) }
+    });
+    client1.on('remote', function (remote) {
+        setTimeout(function () {
+            remote.message('hey');
+        }, 50);
+    });
+    client1.pipe(server()).pipe(client1);
+    
+    var client2 = dnode({
+        name : '#2',
+        message : function (msg) { recv[2].push(msg) }
+    });
+    client2.on('remote', function (remote) {
+        setTimeout(function () {
+            remote.message('wowsy');
+        }, 75);
+    });
+    client2.pipe(server()).pipe(client2);
+    
+    setTimeout(function () {
+        t.deepEqual(
+            recv[0],
+            [ '#0 says: hello!', '#1 says: hey', '#2 says: wowsy' ],
+            "#0 didn't get the right messages"
+        );
+        t.deepEqual(recv[0], recv[1], "#1 didn't get the messages");
+        t.deepEqual(recv[0], recv[2], "#2 didn't get the messages");
+    }, 150);
+});

node_modules/dnode/test/circular.js

@@ -0,0 +1,33 @@
+var dnode = require('../');
+var test = require('tape');
+
+test('circular refs', function (t) {
+    t.plan(7);
+    
+    var server = dnode({
+        sendObj : function (ref, f) {
+            t.equal(ref.a, 1);
+            t.equal(ref.b, 2);
+            t.deepEqual(ref.c, ref);
+            
+            ref.d = ref.c;
+            
+            f(ref);
+        }
+    });
+    
+    var client = dnode();
+    client.on('remote', function (remote) {
+        var obj = { a : 1, b : 2 };
+        obj.c = obj;
+        
+        remote.sendObj(obj, function (ref) {
+            t.equal(ref.a, 1);
+            t.equal(ref.b, 2);
+            t.deepEqual(ref.c, ref);
+            t.deepEqual(ref.d, ref);
+        });
+    });
+    
+    client.pipe(server).pipe(client);
+});

node_modules/dnode/test/double.js

@@ -0,0 +1,38 @@
+var dnode = require('../');
+var test = require('tape');
+
+test('double', function (t) {
+    t.plan(4);
+    var port = Math.floor(Math.random() * 40000 + 10000);
+    
+    var server = dnode({
+        z : function (f, g, h) {
+            f(10, function (x) {
+                g(10, function (y) {
+                    h(x,y)
+                })
+            })
+        }
+    });
+    
+    var client = dnode();
+    client.on('remote', function (remote) {
+        remote.z(
+            function (x,f) { f(x * 2) },
+            function (x,f) { f(x / 2) },
+            function (x,y) {
+                t.equal(x, 20, 'double, not equal');
+                t.equal(y, 5, 'double, not equal');
+            }
+        );
+        
+        function plusTen(n,f) { f(n + 10) }
+        
+        remote.z(plusTen, plusTen, function (x,y) {
+            t.equal(x, 20, 'double, equal');
+            t.equal(y, 20, 'double, equal');
+        });
+    });
+    
+    client.pipe(server).pipe(client);
+});

node_modules/dnode/test/emit.js

@@ -0,0 +1,61 @@
+var test = require('tape');
+var EventEmitter = require('events').EventEmitter;
+var dnode = require('../');
+
+test('emit events', function (t) {
+    t.plan(1);
+    
+    var subs = [];
+    function publish (name) {
+        var args = [].slice.call(arguments, 1);
+        for (var i = 0; i < subs.length; i++) {
+            subs[i].emit(name, args);
+        }
+    }
+    
+    var server = function () {
+        return dnode(function (remote, conn) {
+            this.subscribe = function (emit) {
+                subs.push({ emit : emit, id : conn.id });
+                
+                conn.on('end', function () {
+                    for (var i = 0; i < subs.length; i++) {
+                        if (subs.id === conn.id) {
+                            subs.splice(i, 1);
+                            break;
+                        }
+                    }
+                });
+            };
+        });
+    };
+    
+    setTimeout(function () {
+        var times = 0;
+        var iv = setInterval(function () {
+            if (++times === 5) {
+                t.deepEqual(xs, ys);
+                return clearInterval(iv);
+            }
+            else publish('data', Math.floor(Math.random() * 100));
+        }, 20);
+    }, 20);
+    
+    var xs = [];
+    var x = dnode();
+    x.on('remote', function (remote) {
+        var em = new EventEmitter;
+        em.on('data', function (n) { xs.push(n) });
+        remote.subscribe(function () { return em.emit.apply(em, arguments) });
+    });
+    x.pipe(server()).pipe(x);
+    
+    var ys = [];
+    var y = dnode();
+    y.on('remote', function (remote) {
+        var em = new EventEmitter;
+        em.on('data', function (n) { ys.push(n) });
+        remote.subscribe(function () { return em.emit.apply(em, arguments) });
+    });
+    y.pipe(server()).pipe(y);
+});

node_modules/dnode/test/middleware.js

@@ -0,0 +1,51 @@
+var dnode = require('../');
+var test = require('tape');
+
+test('middleware', function (t) {
+    t.plan(5);
+    
+    var tf = setTimeout(function () {
+        t.fail('never finished');
+    }, 1000);
+    
+    var tr = setTimeout(function () {
+        t.fail('never ready');
+    }, 1000);
+    
+    var tc = setTimeout(function () {
+        t.fail('connection not ready');
+    }, 1000);
+    
+    var server = dnode(function (client, conn) {
+        var self = this;
+        t.ok(!conn.zing);
+        t.ok(!client.moo);
+        
+        conn.on('remote', function () {
+            clearTimeout(tr);
+            t.ok(conn.zing);
+            t.ok(self.moo);
+        });
+        
+        this.baz = 42;
+    });
+    
+    server.on('local', function (client, conn) {
+        conn.zing = true;
+    });
+    
+    server.on('local', function (client, conn) {
+        client.moo = true;
+        conn.on('remote', function () {
+            clearTimeout(tc);
+        });
+    });
+    
+    var client = dnode();
+    client.on('remote', function (remote, conn) {
+        clearTimeout(tf);
+        t.ok(remote.baz);
+    });
+    
+    server.pipe(client).pipe(server);
+});

node_modules/dnode/test/nested.js

@@ -0,0 +1,48 @@
+var dnode = require('../');
+var test = require('tape');
+var EventEmitter = require('events').EventEmitter;
+
+test('nested', function (t) {
+    t.plan(4);
+    
+    var server1 = function () {
+        return dnode({
+            timesTen : function (n,reply) { reply(n * 10) }
+        });
+    };
+    
+    var server2 = function () {
+        return dnode({
+            timesTwenty : function (n,reply) { reply(n * 20) }
+        });
+    };
+    
+    var moo = new EventEmitter;
+    
+    var client1 = dnode();
+    client1.on('remote', function (remote1, conn1) {
+        var client2 = dnode();
+        client2.on('remote', function (remote2, conn2) {
+            moo.on('hi', function (x) {
+                remote1.timesTen(x, function (res) {
+                    t.equal(res, 5000, 'emitted value times ten');
+                    remote2.timesTwenty(res, function (res2) {
+                        t.equal(res2, 100000, 'result times twenty');
+                    });
+                });
+            });
+            remote2.timesTwenty(5, function (n) {
+                t.equal(n, 100);
+                remote1.timesTen(0.1, function (n) {
+                    t.equal(n, 1);
+                });
+            });
+        });
+        client2.pipe(server2()).pipe(client2);
+    });
+    client1.pipe(server1()).pipe(client1);
+    
+    setTimeout(function() {
+        moo.emit('hi', 500);
+    }, 200);
+});

node_modules/dnode/test/null.js

@@ -0,0 +1,34 @@
+var dnode = require('../');
+var test = require('tape');
+
+test('null', function (t) {
+    t.plan(5);
+    
+    var server = dnode({
+        empty : null,
+        timesTen : function (n, reply) {
+            t.equal(n, 50);
+            reply(n * 10);
+        },
+        moo : function (reply) { reply(100) },
+        sTimesTen : function (n, cb) {
+            t.equal(n, 5);
+            cb(n * 10, null);
+        }
+    });
+    
+    var client = dnode();
+    client.on('remote', function (remote) {
+        remote.moo(function (x) {
+            t.equal(x, 100, 'remote moo == 100');
+        });
+        remote.sTimesTen(5, function (m) {
+            t.equal(m, 50, '5 * 10 == 50');
+            remote.timesTen(m, function (n) {
+                t.equal(n, 500, '50 * 10 == 500');
+            });
+        });
+    });
+    
+    server.pipe(client).pipe(server);
+});

node_modules/dnode/test/obj.js

@@ -0,0 +1,29 @@
+var dnode = require('../');
+var test = require('tape');
+
+test('object ref tests', function (t) {
+    t.plan(8);
+    var obj = { a : 1, b : 2, f : function (n,g) { g(n * 20) } };
+    
+    var server = dnode({
+        getObject : function (f) { f(obj) }
+    });
+    
+    var client = dnode();
+    client.on('remote', function (remote, conn) {
+        remote.getObject(function (rObj) {
+            t.equal(rObj.a, 1);
+            t.equal(rObj.b, 2);
+            t.equal(typeof rObj.f, 'function');
+            rObj.a += 100; rObj.b += 100;
+            t.equal(obj.a, 1);
+            t.equal(obj.b, 2);
+            t.notEqual(obj.f, rObj.g);
+            t.equal(typeof obj.f, 'function');
+            rObj.f(13, function (res) {
+                t.equal(res, 260);
+            });
+        });
+    });
+    client.pipe(server).pipe(client);
+});

node_modules/dnode/test/refs.js

@@ -0,0 +1,19 @@
+var dnode = require('../');
+var test = require('tape');
+
+test('refs', function (t) {
+    t.plan(2);
+    
+    var server = dnode({
+        a : 1,
+        b : 2
+    });
+    
+    var client = dnode();
+    client.on('remote', function (remote) {
+        t.equal(remote.a, 1);
+        t.equal(remote.b, 2);
+    });
+    
+    client.pipe(server).pipe(client);
+});

node_modules/dnode/test/self-referential.js

@@ -0,0 +1,34 @@
+var dnode = require('../')
+var test = require('tape');
+
+test('self-referential', function (t) {
+    t.plan(7);
+    
+    var server = dnode({
+        timesTen : function (n,reply) {
+            t.equal(n.number, 5);
+            reply(n.number * 10);
+        },
+        print : function (n,reply) {
+            t.strictEqual(n[0],1);
+            t.strictEqual(n[1],2);
+            t.strictEqual(n[2],3);
+            t.strictEqual(n[3],n);
+            reply(n);
+        }
+    });
+    
+    var client = dnode();
+    client.on('remote', function (remote) {
+        var args = [1,2,3]
+        args.push(args)
+        
+        remote.print(args, function (m) {
+            t.same(m.slice(0,3), args.slice(0,3));
+            t.equal(m, m[3]);
+            t.equal(args, args[3]);
+        });
+    });
+    
+    client.pipe(server).pipe(client);
+});

node_modules/dnode/test/server/null.js

@@ -0,0 +1,40 @@
+var dnode = require('../../');
+var test = require('tape');
+
+test('null', function (t) {
+    t.plan(7);
+    var port = Math.floor(Math.random() * 40000 + 10000);
+    
+    var server = dnode({
+        empty : null,
+        timesTen : function (n, reply) {
+            t.equal(n, 50);
+            reply(n * 10);
+        },
+        moo : function (reply) { reply(100) },
+        sTimesTen : function (n, cb) {
+            t.equal(n, 5);
+            cb(n * 10, null);
+        },
+    }).listen(port.toString()); // test for stringified ports too why not
+    
+    server.on('listening', function () {
+        dnode.connect(port, function (remote, conn) {
+            t.ok(conn.id);
+            t.equal(conn.stream.remoteAddress, '127.0.0.1');
+            
+            remote.moo(function (x) {
+                t.equal(x, 100, 'remote moo == 100');
+            });
+            remote.sTimesTen(5, function (m) {
+                t.equal(m, 50, '5 * 10 == 50');
+                remote.timesTen(m, function (n) {
+                    t.equal(n, 500, '50 * 10 == 500');
+                    conn.end();
+                    server.close();
+                    t.end();
+                });
+            });
+        });
+    });
+});

node_modules/dnode/test/server/port0.js

@@ -0,0 +1,15 @@
+var dnode = require('../../');
+var test = require('tape');
+
+test('port0', function (t) {
+    t.plan(2);
+    var port = 0;
+
+    var server = dnode().listen(port);
+
+    server.on('listening', function () {
+      t.ok(server.address().port !== port);
+      t.ok(server.address().port > 0);
+      server.close();
+    });
+});

node_modules/dnode/test/server/stream.js

@@ -0,0 +1,33 @@
+var dnode = require('../../');
+var net = require('net');
+var test = require('tape');
+
+test('stream', function (t) {
+    t.plan(2);
+    var port = Math.floor(Math.random() * 40000 + 10000);
+    
+    var server = net.createServer(function (stream) {
+        var d = dnode({
+            meow : function f (g) { g('cats') }
+        });
+        d.on('remote', function (remote) {
+            t.equal(remote.x, 5);
+        });
+        stream.pipe(d).pipe(stream);
+    });
+    server.listen(port);
+    
+    server.on('listening', function () {
+        var d = dnode({ x : 5 });
+        d.on('remote', function (remote) {
+            remote.meow(function (cats) {
+                t.equal(cats, 'cats');
+                server.close();
+                d.end();
+            });
+        });
+        
+        var stream = net.connect(port);
+        d.pipe(stream).pipe(d);
+    });
+});

node_modules/dnode/test/server/tcp.js

@@ -0,0 +1,35 @@
+var dnode = require('../../')
+var test = require('tape');
+var util = require('util');
+
+test('simple', function (t) {
+    t.plan(3);
+    var port = Math.floor(Math.random() * 40000 + 10000);
+    
+    var server = dnode({
+        timesTen : function (n,reply) {
+            t.equal(n.number, 5);
+            reply(n.number * 10);
+        },
+        print : function (n,reply) {
+            reply(util.inspect(n));
+        },
+    }).listen(port);
+    
+    server.on('listening', function () {
+        dnode.connect(port, function (remote, conn) {
+            t.equal(conn.stream.remoteAddress, '127.0.0.1');
+            var args = {
+                number : 5,
+                func : function () {},
+            };
+            
+            remote.timesTen(args, function (m) {
+                t.equal(m, 50, '5 * 10 == 50');
+                conn.end();
+                server.close();
+                t.end();
+            });
+        });
+    });
+});

node_modules/dnode/test/server/unicode.js

@@ -0,0 +1,26 @@
+var dnode = require('../../');
+var test = require('tape');
+
+test('unicode', function (t) {
+    t.plan(2);
+    var port = Math.floor(Math.random() * 40000 + 10000);
+    
+    var server = dnode({
+        unicodes : function (reply) {
+            reply('☔☔☔☁☼☁❄');
+        }
+    }).listen(port);
+    
+    server.on('listening', function () {
+        dnode.connect(port, function (remote, conn) {
+            t.equal(conn.stream.remoteAddress, '127.0.0.1');
+            remote.unicodes(function (str) {
+                t.equal(str, '☔☔☔☁☼☁❄', 'remote unicodes == ☔☔☔☁☼☁❄');
+                
+                conn.end();
+                server.close();
+                t.end();
+            });
+        });
+    });
+});

node_modules/dnode/test/server/unix.js

@@ -0,0 +1,23 @@
+var dnode = require('../../');
+var test = require('tape');
+
+test('unix', function (t) {
+    t.plan(1);
+    
+    var sfile = '/tmp/unix_socket_' + Math.floor(
+        Math.random() * Math.pow(2, 32)
+    ).toString(16);
+    
+    var server = dnode({ f : function (cb) { cb(1337) } }).listen(sfile);
+    
+    server.on('listening', function () {
+        dnode.connect(sfile, function (remote, conn) {
+            remote.f(function (x) {
+                t.equal(x, 1337);
+                server.close();
+                conn.end();
+                t.end();
+            });
+        });
+    });
+});

node_modules/dnode/test/server/zero.js

@@ -0,0 +1,38 @@
+var dnode = require('../../');
+var test = require('tape');
+
+test('listen on port 0', function (t) {
+    t.plan(7);
+    
+    var server = dnode({
+        timesTen : function (n,reply) {
+            t.equal(n, 50);
+            reply(n * 10);
+        },
+        moo : function (reply) { reply(100) },
+        sTimesTen : function (n, cb) {
+            t.equal(n, 5);
+            cb(n * 10);
+        },
+    }).listen(0);
+    
+    server.on('listening', function () {
+        dnode.connect(server.address().port, function (remote, conn) {
+            t.ok(conn.id);
+            t.equal(conn.stream.remoteAddress, '127.0.0.1');
+            
+            remote.moo(function (x) {
+                t.equal(x, 100, 'remote moo == 100');
+            });
+            remote.sTimesTen(5, function (m) {
+                t.equal(m, 50, '5 * 10 == 50');
+                remote.timesTen(m, function (n) {
+                    t.equal(n, 500, '50 * 10 == 500');
+                    conn.end();
+                    server.close();
+                    t.end();
+                });
+            });
+        });
+    });
+});

node_modules/dnode/test/simple.js

@@ -0,0 +1,39 @@
+var dnode = require('../');
+var test = require('tape');
+
+test('simple server and client', function (t) {
+    t.plan(5);
+    
+    var server = dnode({
+        timesTen : function (n,reply) {
+            t.equal(n, 50);
+            reply(n * 10);
+        },
+        moo : function (reply) { reply(100) },
+        sTimesTen : function (n, cb) {
+            t.equal(n, 5);
+            cb(n * 10);
+        }
+    });
+    
+    var client = dnode();
+    client.on('remote', function (remote) {
+        remote.moo(function (x) {
+            t.equal(x, 100, 'remote moo == 100');
+        });
+        remote.sTimesTen(5, function (m) {
+            t.equal(m, 50, '5 * 10 == 50');
+            remote.timesTen(m, function (n) {
+                t.equal(n, 500, '50 * 10 == 500');
+            });
+        });
+    });
+    
+    server.on('end', function () {
+        console.log('server END');
+    });
+    client.on('end', function () {
+        console.log('client END');
+    });
+    server.pipe(client).pipe(server);
+});

node_modules/dnode/test/stream.js

@@ -0,0 +1,22 @@
+var dnode = require('../');
+var test = require('tape');
+
+test('stream', function (t) {
+    t.plan(2);
+    
+    var server = dnode({
+        meow : function f (g) { g('cats') }
+    });
+    server.on('remote', function (remote) {
+        t.equal(remote.x, 5);
+    });
+    
+    var client = dnode({ x : 5 });
+    client.on('remote', function (remote) {
+        remote.meow(function (cats) {
+            t.equal(cats, 'cats');
+        });
+    });
+    
+    client.pipe(server).pipe(client);
+});