module.exports = function (config) {
config = config || {}
var udid = require('udid')(config.name || 'rumours')
//run on local by default for now...
//but later, it will be rumours.nearform.com or whatever...
var host = config.host || window.location.protocol + '//' + window.location.host
var tmpId = shasum(JSON.stringify([udid, config, host]))
if(connections[tmpId]) return connections[tmpId]
config.name = config.name || 'rumours'
config.prefix = config.prefix || '/rumours'
var schema = config.schema || require('./schema')
var remote = Remote(schema, udid)
var r = reconnect(reloader(function (stream) {
//this will load the default schema into the bundle,
//should do this a different way, to avoid that when using custom schemas.
stream.pipe(remote.createRemoteStream()).pipe(stream)
}, config)).connect(host + config.prefix)
connections[tmpId] = r
r.open = remote.open
r.view = remote.view
r._remote = remote
r.id = udid
return r
}
var shoe = require('shoe')
var ecstatic = require('ecstatic')
var http = require('http')
var join = require('path').join
var reloader = require('client-reloader')
var rText = require('../')()
rText.push('open in multiple tabs and start editing!')
var PORT = 3000
shoe(reloader(function (stream) {
console.log('connection')
//echo server
stream.pipe(rText.createStream()).pipe(stream)
stream.pipe(process.stderr, {end: false})
})).install(http.createServer(
ecstatic(join(__dirname, 'static'))
).listen(PORT, function () {
console.log( 'listening on', PORT)
}), '/shoe')
var RText = require('..')
var reconnect = require('reconnect')
var reloader = require('client-reloader')
var ta = document.getElementById('ta')
var m = M = require('./model')()
var rText = (m._redit || m).wrap(ta)
m.on('_update', function (update) {
console.log(update)
})
reconnect(reloader(function (stream) {
stream.pipe(m.createStream()).pipe(stream)
})).connect('/shoe')
var Rumours = module.exports = function (config) {
config = config || {}
var udid = require('udid')(config.name || 'rumours')
var loadDb = require('./db')(config)
//inject arbitary authorization about who can access what db here...
var auth = config.auth || function (meta, cb) {
console.log('connection', meta.db)
return cb(null, meta.db)
}
var sh = shoe(reloader(function (stream) {
var ts = through().pause(), s
function error(err) {
if(err) {
console.error(err)
ts.end(); ts.resume()
if(s) s.end()
stream.end()
}
}
auth(stream.meta, function (err, name) {
if(err) return error(err)
var db = loadDb(name, function (err) {
if(err) return error(err)
ts.resume()
})
ts.pipe(s = db.scuttlebutt.createRemoteStream()).pipe(stream)
})
stream.pipe(ts)
}, {version: config.version}))
var install = sh.install
sh.install = function (server) {
install.call(sh, server, config.prefix || '/rumours')
return server
}
sh.openDb = function (name, cb) {
return loadDb(name, cb)
}
var crud = CRUD(sh)
for(var k in crud)
sh[k] = crud[k]
sh.REST = function (req, res, next) {
//TODO replace this with ./crud.js
if(req.method.toLowerCase() !== 'get') return next()
var url = req.url.substring(1).split('/')
if(url.shift() !== 'db') return next()
var db = url.shift()
//add more features
auth({db: db, headers: req.headers}, function (err, name) {
if(err) return next(err)
loadDb(name, function (err, db) {
db.scuttlebutt.open(url.join('!'), function (err, sb) {
if(err) return next(err)
res.writeHead(200, {'Content-type': 'application/json'})
res.end(JSON.stringify(sb.toJSON()) + '\n')
console.log(sb)
//sb.dispose()
sb.on('update', function () {
console.log(sb)
})
})
})
})
}
return sh
}
reconnect(reloader(function (stream) {
// We create a new instance of MuxDemux() for each connection.
var mdm = MuxDemux()
// Ensure we don't miss messages while we get setup.
mdm.pause();
// We create the read/write stream to interface with rText().
var rtStream = rText.createStream();
$textArea.autogrow();
$text.append($textArea);
// We connect our shoe stream directly our muxer/demuxer.
// This allows the muxer to encode anything written to any virtual connection
// multiplexed through the one stream and the demuxer to decode anything coming
// back from the server.
stream.pipe(mdm).pipe(stream);
// Create an individual channel on the main read/write stream.
var mxdTitleStream = mdm.createStream(title)
mxdTitleStream.on('data', updateMarkdown);
// Ensure we don't miss messages while we get setup.
mdm.resume();
// Pipe anything sent on this channel into the rtext stream and pipe anything
// coming back from that stream back across the virtual connection.
mxdTitleStream.pipe(rtStream).pipe(mxdTitleStream)
})).connect('/shoe/');
window.$ = require('jquery');
// Make sure everything is included in the bundle
require('buffer-browserify');
var reconnect = require('reconnect');
var reloader = require('client-reloader');
var domready = require('domready');
var client = require('../shared/client');
var game = require('../shared/state');
var UI = require('./ui');
var ui;
reconnect({ maxDelay: 3e3 }, reloader(function(stream) {
client(stream);
})).connect('/shoe');
domready(function() {
ui = exports.ui = new UI($(document.body), game);
});
exports.game = game;
app.use(ecstatic('public', { handleError: false }));
var server = http.createServer(app);
var sock = shoe(reloader(function(stream) {
var gameId, entitiesId;
stream.on('data', function(data) {
data = JSON.parse(data);
// console.dir({ gameId: gameId, entitiesId: entitiesId, data: data });
if(data[0] == gameId && data[1] == 'data') {
data = JSON.parse(data[2]);
if(/*data[0] == entitiesId &&*/ data[1] == 'data') {
console.dir(data);
debugger;
}
if(data[1] == 'new' && data[2].meta == 'entities')
entitiesId = data[0];
}
if(data[1] == 'new' && data[2].meta == 'game')
gameId = data[0];
});
clients(stream);
}));
sock.install(server, '/shoe');
server.listen(process.env.VMC_APP_PORT || process.env.PORT || 3000, function(err) {