Mirroristas/gun
2
0
Fork 0
mirror of https://github.com/amark/gun.git synced 2025-03-30 15:08:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

ONE BIG MASSIVE UPDATE

Browse Source
This commit is contained in:
Mark Nadal 2015-05-29 16:01:00 -07:00
parent 2f59cb0ade
commit e89c19cdd8
26 changed files with 5319 additions and 796 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1259
_gun.js Normal file
View File

File diff suppressed because it is too large Load Diff

10
examples/angular/index.html
View File

@ -53,10 +53,10 @@
var gun = Gun(location.origin + '/gun');
angular.module('admin', []).controller('editor', function($scope){
$scope.data = {};
$scope.$data = gun.load('example/angular/data').blank(function(){
$scope.$data = gun.get('example/angular/data')/*.not(function(){
console.log("Initializing Data!");
this.set({});
}).on(function(data){
this.put({});
})*/.on(function(data){
Gun.obj.map(data, function(val, field){
if(val === $scope.data[field]){ return }
$scope.data[field] = val;
@ -64,13 +64,13 @@
$scope.$apply();
});
$scope.add = function(){
$scope.$data.path($scope.field).set( $scope.data[$scope.field] = 'value' );
$scope.$data.path($scope.field).put( $scope.data[$scope.field] = 'value' );
$scope.field = '';
};
}).directive('gun', function(){
return function(scope, elem){
elem.on('keyup', function(){
scope.$data.path(scope.key).set( scope.data[scope.key] = elem.text() );
scope.$data.path(scope.key).put( scope.data[scope.key] = elem.text() );
});
};
});

4
examples/hello-world.js
View File

@ -6,11 +6,11 @@ var gun = Gun({
bucket: '' // The bucket you want to save into
}
});
gun.set({ hello: 'world' }).key('my/first/data');
gun.put({ hello: 'world' }).key('my/first/data');
var http = require('http');
http.createServer(function(req, res){
gun.load('my/first/data', function(err, data){
gun.get('my/first/data', function(err, data){
res.writeHead(200, {'Content-Type': 'application/json'});
res.end(JSON.stringify(data));
});

2
examples/package.json
View File

@ -8,7 +8,7 @@
}
, "dependencies": {
"express": "~>4.9.0",
"gun": "0.1.5"
"gun": "file:../"
}
, "scripts": {
"start": "node express.js",

9
examples/todo/index.html
View File

@ -9,8 +9,9 @@
<script>
// by Forrest Tait! Edited by Mark Nadal.
function ready(){
Gun.log.verbose = true;
var $ = document.querySelector.bind(document);
var gun = Gun(location.origin + '/gun').load('example/todo/data').set({});
var gun = Gun(location.origin + '/gun').get('example/todo/data');
gun.on(function renderToDo(val){
var todoHTML = '';
for(key in val) {
@ -22,12 +23,12 @@
});
$("#addToDo").onsubmit = function(){
var id = randomId();
gun.path(id).set(($("#todoItem").value||'').toString().replace(/\</ig, '&lt;'));
gun.path(id).put(($("#todoItem").value||'').toString().replace(/\</ig, '&lt;'));
$("#todoItem").value = "";
return false;
};
window.removeToDo = function(id){
gun.path(id).set(null);
gun.path(id).put(null);
}
}
function randomId(){
@ -35,4 +36,4 @@
}
</script>
</body>
</html>
</html>

962
gun.js
View File

File diff suppressed because it is too large Load Diff

449
lib/api.js Normal file
View File

@ -0,0 +1,449 @@
//var Gun = Gun || module.exports || require('../gun');
var Gun = Gun || require('../gun');
Gun.chain.chain = function(from){
var gun = Gun(null);
from = from || this;
gun.back = from;
gun.__ = from.__;
gun._ = {on: Gun.on.create() };
return gun;
}
Gun.chain.get = function(key, cb, opt){ // get opens up a reference to a node and loads it.
var gun = this.chain(), ctx = {};
if(!key){ return cb.call(gun, {err: Gun.log("No key or relation to get!") }), gun }
ctx.key = Gun.text.is(key) && key; // if key is text, then key, else false.
ctx.soul = Gun.is.soul(key); // if key is a soul, then the soul, else false.
cb = cb || function(){};
opt = opt || {};
if(ctx.soul){
Gun.fns.async(function(){ open(ctx.soul) });
if(ctx.node = gun.__.graph[ctx.soul]){ // in memory
cb.call(gun, null, Gun.obj.copy(ctx.node));
} else { load(key) } // not in memory
} else
if(ctx.key){
(function foo(){ // TODO: UGLY!!!!
if(ctx.node = gun.__.keys[ctx.key]){ // in memory, or from put.key
if(true === ctx.node){
Gun.fns.async(foo);
} else {
cb.call(gun, null, Gun.obj.copy(ctx.node));
Gun.fns.async(function(){ open(Gun.is.soul.on(ctx.node)) });
}
} else { load(key) } // not in memory
})();
} else { cb.call(gun, {err: Gun.log("No key or relation to get!")}) }
function open(soul){
if(!soul || ctx.open){ return }
ctx.open = true;
gun._.on('soul').emit(soul);
}
function load(key){
if(Gun.fns.is(ctx.hook = gun.__.opt.hooks.get)){
ctx.hook(key, function(err, data){ // multiple times potentially
//console.log("chain.get from load", err, data);
if(err){ return cb.call(gun, err, data) }
if(!data){ return cb.call(gun, null) } // TODO: will have have `not` be based on open?
if(ctx.soul = Gun.is.soul.on(data)){
open(ctx.soul);
} else { return cb.call(gun, {err: Gun.log('No soul on data!') }, data) }
if(err = Gun.union(gun, data).err){ return cb.call(gun, err) }
cb.call(gun, null, data);
}, opt);
} else {
root.console.log("Warning! You have no persistence layer to get from!");
cb.call(gun, null, null); // Technically no error, but no way we can get data.
}
}
return gun;
}
Gun.chain.put = function(val, cb, opt){ // handle case where val is a gun context!
var gun = this.chain(), drift = Gun.time.is(), flag;
cb = cb || function(){};
opt = opt || {};
if(!gun.back.back){
gun = gun.chain();
Gun.fns.async(function(){
flag = true;
gun.back._.on('soul').emit(Gun.is.soul.on(val) || Gun.roulette.call(gun));
});
}
//gun.back._.on('soul').event(function(soul, field, from, at){
Gun.when(gun.back, function(soul, field, from, at){
console.log("chain.put", field, val, "on", soul, 'or', from, at);
var ctx = {}, obj = val;
if(Gun.is.value(obj)){
if(from && at){
soul = from;
field = at;
} // no else!
if(!field){
return cb.call(gun, {err: Gun.log("No field exists for " + (typeof obj) + "!")});
} else
if(gun.__.graph[soul]){
ctx.tmp = {};
ctx.tmp[ctx.field = field] = obj;
obj = ctx.tmp;
} else {
return cb.call(gun, {err: Gun.log("No node exists to put " + (typeof obj) + " in!")});
}
}
if(Gun.obj.is(obj)){
if(field && !ctx.field){
ctx.tmp = {};
ctx.tmp[ctx.field = field] = obj;
obj = ctx.tmp;
}
Gun.ify(obj, function(env, cb){
var at;
if(!env || !(at = env.at) || !env.at.node){ return }
if(!at.node._){
at.node._ = {};
}
if(!Gun.is.soul.on(at.node)){
if(obj === at.obj){
env.graph[at.node._[Gun._.soul] = soul] = at.node;
cb(at, soul);
} else {
console.log('we are not at root, where are we at?', at);
flag? path() : gun.back.path(at.path.join('.'), path);
function path(err, data){
var soul = Gun.is.soul.on(data) || Gun.roulette.call(gun);
console.log("put pathing not root", soul, err, data);
env.graph[at.node._[Gun._.soul] = soul] = at.node;
cb(at, soul);
};
}
}
if(!at.node._[Gun._.HAM]){
at.node._[Gun._.HAM] = {};
}
if(!at.field){ return }
at.node._[Gun._.HAM][at.field] = drift;
})(function(err, ify){
console.log("chain.put PUT", ify.graph);
if(err || ify.err){ return cb.call(gun, err || ify.err) }
if(err = Gun.union(gun, ify.graph).err){ return cb.call(gun, err) }
if(from = Gun.is.soul(ify.root[field])){ soul = from; field = null }
gun._.on('soul').emit(soul, field);
if(Gun.fns.is(ctx.hook = gun.__.opt.hooks.put)){
ctx.hook(ify.graph, function(err, data){ // now iterate through those nodes to a persistence layer and get a callback once all are saved
if(err){ return cb.call(gun, err) }
return cb.call(gun, null, data);
}, opt);
} else {
root.console.log("Warning! You have no persistence layer to save to!");
cb.call(gun, null); // This is in memory success, hardly "success" at all.
}
});
}
});
return gun;
}
Gun.chain.key = function(key, cb, opt){
var gun = this, ctx = {};
if(!key){ return cb.call(gun, {err: Gun.log('No key!')}), gun }
cb = cb || function(){};
opt = opt || {};
gun.__.keys[key] = true;
//gun._.on('soul').event(function(soul){
Gun.when(gun, function(soul){
Gun.fns.async(function wait(node){ // TODO: UGLY!!! JANKY!!!
node = gun.__.graph[soul];
if(true === node){ return Gun.fns.async(wait) }
gun.__.keys[key] = node;
});
if(Gun.fns.is(ctx.hook = gun.__.opt.hooks.key)){
ctx.hook(key, soul, function(err, data){
return cb.call(gun, err, data);
}, opt);
} else {
root.console.log("Warning! You have no key hook!");
cb.call(gun, null); // This is in memory success, hardly "success" at all.
}
});
return gun;
}
Gun.chain.path = function(path, cb){
var gun = this.chain(), ctx = {};
cb = cb || function(){};
path = (Gun.text.ify(path) || '').split('.');
//gun.back._.on('soul').event(function trace(soul){ // TODO: Check for field as well and merge?
Gun.when(gun.back, function trace(soul){ // TODO: Check for field as well and merge?
var node = gun.__.graph[soul], field = node && Gun.text.ify(path.shift()), val;
console.log("path...", soul, field, node);
if(!node){ // handle later
return Gun.fns.async(function(){ // TODO: UGLY!!! JANKY!!!
trace(soul);
});
} else
if(path.length){
if(Gun.is.soul(val = node[field])){
gun.get(val, function(err, data){
if(err){ return cb.call(gun, err, data) }
if(!data){ return cb.call(gun, null) }
trace(Gun.is.soul.on(data));
});
} else {
cb.call(gun, null);
}
} else
if(!Gun.obj.has(node, field)){ // TODO: THIS MAY NOT BE CORRECT BEHAVIOR!!!!
cb.call(gun, null, null, field);
gun._.on('soul').emit(soul, field); // if .put is after, makes sense. If anything else, makes sense to wait.
} else
if(Gun.is.soul(val = node[field])){
gun.get(val, cb);
gun._.on('soul').emit(Gun.is.soul(val), null, soul, field);
} else {
cb.call(gun, null, val, field);
gun._.on('soul').emit(soul, field);
}
});
return gun;
}
Gun.chain.on = function(cb){ // TODO: BUG! Major problem with events is that they won't re-trigger either if listened later.
var gun = this, ctx = {};
cb = cb || function(){};
Gun.when(gun, function(soul, field){
gun.__.on(soul).event(function(delta){
cb.call(gun, delta);
});
});
return gun;
}
Gun.chain.val = function(cb){ // TODO: BUG! Major problem with events is that they won't re-trigger either if listened later.
var gun = this, ctx = {};
cb = cb || function(){};
Gun.when(gun, function(soul, field){
Gun.fns.async(function wait(node){ // TODO: UGLY!!! JANKY!!!
node = gun.__.graph[soul];
if(!node || true === node){ return Gun.fns.async(wait) }
cb.call(gun, field? node[field] : Gun.obj.copy(node));
});
});
return gun;
}
Gun.when = function(gun, cb){ // how much memory will this consume?
var setImmediate = setImmediate || function(cb){return setTimeout(cb,0)};
Gun.obj.map(gun._.graph, function(on, soul){
setImmediate(function(){ cb.apply(on, on.args) });
});
gun._.on('soul').event(function(soul){
cb.apply((gun._.graph = gun._.graph || {})[this.soul = soul] = this, this.args = arguments);
});
}
Gun.union = function(gun, prime){
var ctx = {};
ctx.graph = gun.__.graph;
if(!ctx.graph){ ctx.err = {err: Gun.log("No graph!") } }
if(!prime){ ctx.err = {err: Gun.log("No data to merge!") } }
if(ctx.soul = Gun.is.soul.on(prime)){
ctx.tmp = {};
ctx.tmp[ctx.soul] = prime;
prime = ctx.tmp;
}
if(ctx.err){ return ctx }
(function union(graph, prime){
Gun.obj.map(prime, function(node, soul){
soul = Gun.is.soul.on(node);
if(!soul){ return }
var vertex = graph[soul];
if(!vertex){ // disjoint
gun.__.on(soul).emit(graph[soul] = node); // TODO: BUG! We should copy the node in, not pass by reference?
return;
}
Gun.HAM(vertex, node, function(){}, function(vertex, field, value){
if(!vertex){ return }
var change = {};
change._ = change._ || {};
change._[Gun._.soul] = Gun.is.soul.on(vertex);
change._[Gun._.HAM] = change._[Gun._.HAM] || {};
vertex[field] = change[field] = value;
vertex._[Gun._.HAM][field] = change._[Gun._.HAM][field] = node._[Gun._.HAM][field];
//context.nodes[change._[Gun._.soul]] = change;
//context('change').fire(change);
}, function(){
});
});
})(ctx.graph, prime);
return ctx;
}
Gun.HAM = function(vertex, delta, lower, each, upper){
var ctx = {};
Gun.obj.map(delta, function update(incoming, field){
if(field === Gun._.meta){ return }
if(!Gun.obj.has(vertex, field)){ // does not need to be applied through HAM
each.call({incoming: true, converge: true}, vertex, field, incoming);
}
var drift = Gun.time.is();
var value = Gun.is.soul(incoming) || incoming;
var current = Gun.is.soul(vertex[field]) || vertex[field];
// TODO! BUG: Check for state existence so we don't crash if it isn't there. Maybe do this in union?
var state = HAM(drift, delta._[Gun._.HAM][field], vertex._[Gun._.HAM][field], value, current);
//console.log("the server state is",drift,"with delta:current",delta._[Gun._.HAM][field],vertex._[Gun._.HAM][field]);
//console.log("having incoming value of",value,'and',current);
if(state.err){
root.console.log(".!HYPOTHETICAL AMNESIA MACHINE ERR!.", state.err); // this error should never happen.
return;
}
if(state.state || state.quarantineState || state.current){
lower.call(state, vertex, field, incoming);
return;
}
if(state.incoming){
each.call(state, vertex, field, incoming);
return;
}
if(state.amnesiaQuarantine){
ctx.up += 1;
Gun.schedule(delta._[Gun._.HAM][field], function(){ // TODO: BUG!!! Don't hardcode this!
update(incoming, field);
ctx.up -= 1;
upper.call(state, vertex, field, incoming);
});
}
});
function HAM(machineState, incomingState, currentState, incomingValue, currentValue){ // TODO: Lester's comments on roll backs could be vulnerable to divergence, investigate!
if(machineState < incomingState){
// the incoming value is outside the boundary of the machine's state, it must be reprocessed in another state.
return {amnesiaQuarantine: true};
}
if(incomingState < currentState){
// the incoming value is within the boundary of the machine's state, but not within the range.
return {quarantineState: true};
}
if(currentState < incomingState){
// the incoming value is within both the boundary and the range of the machine's state.
return {converge: true, incoming: true};
}
if(incomingState === currentState){
if(incomingValue === currentValue){ // Note: while these are practically the same, the deltas could be technically different
return {state: true};
}
/*
The following is a naive implementation, but will always work.
Never change it unless you have specific needs that absolutely require it.
If changed, your data will diverge unless you guarantee every peer's algorithm has also been changed to be the same.
As a result, it is highly discouraged to modify despite the fact that it is naive,
because convergence (data integrity) is generally more important.
Any difference in this algorithm must be given a new and different name.
*/
if(String(incomingValue) < String(currentValue)){ // String only works on primitive values!
return {converge: true, current: true};
}
if(String(currentValue) < String(incomingValue)){ // String only works on primitive values!
return {converge: true, incoming: true};
}
}
return {err: "you have not properly handled recursion through your data or filtered it as JSON"};
}
}
Gun.ify = (function(){
function ify(data, cb, opt){
console.log("=================================================================");
//Gun.log.verbose = true;
opt = opt || {};
cb = cb || function(env, cb){ cb(env.at, Gun.roulette()) };
var ctx = {}, end = function(fn){
Gun.fns.async(function wait(){ // TODO: clean this up, possibly?
if(ctx.err || !Gun.list.map(ctx.seen, function(at){
if(!at.soul){ return true }
})){
fn(ctx.err, ctx)
} else {
Gun.fns.async(wait); // TODO: BUG! JANKY!!! Make this cleaner.
}
});
}
if(!data){ return ctx.err = Gun.log('Serializer does not have correct parameters.'), end }
ctx.at = {};
ctx.root = {};
ctx.graph = {};
ctx.queue = [];
ctx.seen = [];
ctx.loop = true;
ctx.at.path = [];
ctx.at.obj = data;
ctx.at.node = ctx.root;
while(ctx.loop && !ctx.err){
seen(ctx, ctx.at);
map(ctx, cb);
if(ctx.queue.length){
ctx.at = ctx.queue.shift();
} else {
ctx.loop = false;
}
}
return end;
}
function map(ctx, cb){
console.log("scanning", Object.keys(ctx.at.obj));
Gun.obj.map(ctx.at.obj, function(val, field){
ctx.at.val = val;
ctx.at.field = field;
//(ctx.at.path = ctx.at.path || [field]); // TODO: BUG! Do later.
if(field === Gun._.meta){
ctx.at.node[field] = Gun.obj.copy(val); // TODO: BUG! Is this correct?
return;
}
if(false && notValidField(field)){ // TODO: BUG! Do later for ACID "consistency" guarantee.
return ctx.err = {err: Gun.log('Invalid field name on ' + ctx.at.path.join('.'))};
}
if(!Gun.is.value(val)){
var at = {obj: val, node: {}, back: [], path: [field]}, tmp = {}, was;
at.path = (ctx.at.path||[]).concat(at.path || []);
if(!Gun.obj.is(val)){
return ctx.err = {err: Gun.log('Invalid value at ' + at.path.join('.') + '!' )};
}
if(was = seen(ctx, at)){
tmp[Gun._.soul] = Gun.is.soul.on(was.node) || null;
(was.back = was.back || []).push(ctx.at.node[field] = tmp);
} else {
ctx.queue.push(at);
tmp[Gun._.soul] = null;
at.back.push(ctx.at.node[field] = tmp);
}
} else {
ctx.at.node[field] = val; // TODO: BUG? the soul could be passed as ref, is that okay?
}
cb(ctx, function(at, soul){
at.soul = at.soul || soul;
if(!at.back || !at.back.length){ return }
Gun.list.map(at.back, function(rel){ // TODO: BUG? sync issues?
rel[Gun._.soul] = at.soul;
});
});
});
}
function seen(ctx, at){
var log = []; ctx.seen.forEach(function(val){ log.push(Object.keys(val.obj)) });
//console.log('have we seen it yet?\n', at.obj, '\n = \n', log, '\n---------');
return Gun.list.map(ctx.seen, function(has){
if(at.obj === has.obj){ return has }
}) || (ctx.seen.push(at) && false);
}
return ify;
}({}));

6
lib/aws.js
View File

@ -31,7 +31,7 @@
};
s3.id = function(m){ return m.Bucket +'/'+ m.Key }
s3.chain = s3.prototype;
s3.chain.put = function(key, o, cb, m){
s3.chain.PUT = function(key, o, cb, m){
if(!key){ return }
m = m || {}
m.Bucket = m.Bucket || this.config.bucket;
@ -49,7 +49,7 @@
});
return this;
}
s3.chain.get = function(key, cb, o){
s3.chain.GET = function(key, cb, o){
if(!key){ return }
var s = this
, m = {
@ -119,7 +119,7 @@
}
this.S3().listObjects(m, function(e,r){
//a.log('list',e);
a.list.each((r||{}).Contents, function(v){console.log(v)});
a.list.map((r||{}).Contents, function(v){console.log(v)});
//a.log('---end list---');
if(!a.fns.is(cb)) return;
cb(e,r);

38
lib/file.js
View File

@ -14,13 +14,13 @@ Gun.on('opt').event(function(gun, opts){
var all = file.all = file.all || Gun.obj.ify(file.raw || {nodes: {}, keys: {}});
gun.opt({hooks: {
load: function(key, cb, options){
get: function(key, cb, options){
if(Gun.obj.is(key) && key[Gun._.soul]){
return cb(null, all.nodes[key[Gun._.soul]]);
}
cb(null, all.nodes[all.keys[key]]);
}
,set: function(graph, cb){
,put: function(graph, cb){
all.nodes = gun.__.graph;
/*for(n in all.nodes){ // this causes some divergence problems, so removed for now till later when it can be fixed.
for(k in all.nodes[n]){
@ -32,9 +32,43 @@ Gun.on('opt').event(function(gun, opts){
fs.writeFile(opts.file, Gun.text.ify(all), cb);
}
,key: function(key, soul, cb){
all.keys = all.keys || {};
all.keys[key] = soul;
fs.writeFile(opts.file, Gun.text.ify(all), cb);
}
,all: function(list, opt, cb){
opt = opt || {};
opt.from = opt.from || '';
opt.start = opt.from + (opt.start || '');
if(opt.end){ opt.end = opt.from + opt.end }
var match = {};
cb = cb || function(){};
Gun.obj.map(list, function(soul, key){
var end = opt.end || key;
if(key.indexOf(opt.from) === 0 && opt.start <= key && (key <= end || key.indexOf(end) === 0)){
if(opt.upto){
if(key.slice(opt.from.length).indexOf(opt.upto) === -1){
yes(soul, key);
}
} else {
yes(soul, key);
}
}
});
function yes(soul, key){
cb(key);
match[key] = {};
match[key][Gun._.soul] = soul;
}
return match;
}
}}, true);
gun.all = gun.all || function(url, cb){
url = require('url').parse(url, true);
var r = gun.__.opt.hooks.all(all.keys, {from: url.pathname, upto: url.query['*'], start: url.query['*>'], end: url.query['*<']});
console.log("All please", url.pathname, url.query['*'], r);
cb = cb || function(){};
cb(null, r);
}
});

18
lib/group.js
View File

@ -1,18 +0,0 @@
var Gun = Gun || require('../gun');
Gun.chain.group = function(obj, cb, opt){
var gun = this;
opt = opt || {};
cb = cb || function(){};
gun = gun.set({}); // insert assumes a graph node. So either create it or merge with the existing one.
var error, item = gun.chain().set(obj, function(err){ // create the new item in its own context.
error = err; // if this happens, it should get called before the .get
}).get(function(val){
if(error){ return cb.call(gun, error) } // which in case it is, allows us to fail fast.
var add = {}, soul = Gun.is.soul.on(val);
if(!soul){ return cb.call(gun, {err: Gun.log("No soul!")}) }
add[soul] = val; // other wise, let's then
gun.set(add, cb); // merge with the graph node.
});
return gun;
};

26
lib/list.js
View File

@ -3,20 +3,20 @@ var Gun = Gun || require('../gun');
Gun.chain.list = function(cb, opt){
opt = opt || {};
cb = cb || function(){};
var gun = this.set({}); // insert assumes a graph node. So either create it or merge with the existing one.
var gun = this.put({}); // insert assumes a graph node. So either create it or merge with the existing one.
gun.last = function(obj, cb){
var last = gun.path('last');
if(!arguments.length){ return last }
return gun.path('last').set(null).set(obj).get(function(val){ // warning! these are not transactional! They could be.
return gun.path('last').put(null).put(obj).val(function(val){ // warning! these are not transactional! They could be.
console.log("last is", val);
last.path('next').set(this._.node, cb);
last.path('next').put(this._.node, cb);
});
}
gun.first = function(obj, cb){
var first = gun.path('first');
if(!arguments.length){ return first }
return gun.path('first').set(null).set(obj).get(function(){ // warning! these are not transactional! They could be.
first.path('prev').set(this._.node, cb);
return gun.path('first').put(null).put(obj).val(function(){ // warning! these are not transactional! They could be.
first.path('prev').put(this._.node, cb);
});
}
return gun;
@ -29,24 +29,24 @@ Gun.chain.list = function(cb, opt){
Gun.log.verbose = true;
var list = gun.list();
list.last({name: "Mark Nadal", type: "human", age: 23}).get(function(val){
list.last({name: "Mark Nadal", type: "human", age: 23}).val(function(val){
//console.log("oh yes?", val, '\n', this.__.graph);
});
list.last({name: "Amber Cazzell", type: "human", age: 23}).get(function(val){
list.last({name: "Amber Cazzell", type: "human", age: 23}).val(function(val){
//console.log("oh yes?", val, '\n', this.__.graph);
});
list.list().last({name: "Hobbes", type: "kitten", age: 4}).get(function(val){
list.list().last({name: "Hobbes", type: "kitten", age: 4}).val(function(val){
//console.log("oh yes?", val, '\n', this.__.graph);
});
list.list().last({name: "Skid", type: "kitten", age: 2}).get(function(val){
list.list().last({name: "Skid", type: "kitten", age: 2}).val(function(val){
//console.log("oh yes?", val, '\n', this.__.graph);
});
setTimeout(function(){ list.get(function(val){
setTimeout(function(){ list.val(function(val){
console.log("the list!", list.__.graph);
return;
list.path('first').get(Gun.log)
.path('next').get(Gun.log)
.path('next').get(Gun.log);
list.path('first').val(Gun.log)
.path('next').val(Gun.log)
.path('next').val(Gun.log);
})}, 1000);
return;

104
lib/radix.js Normal file
View File

@ -0,0 +1,104 @@
function radix(r){
r = r || {};
var u, n = null, c = 0;
function get(p){
var v = match(p, r);
return v;
}
function match(path, tree, v){
if(!Gun.obj.map(tree, function(val, key){
if(key[0] !== path[0]){ return }
var i = 1;
while(key[i] === path[i] && path[i]){ i++ }
if(key = key.slice(i)){ // recurse
console.log("match", key, i)
v = {sub: tree, pre: path.slice(0, i), val: val, post: key, path: path.slice(i) };
} else { // replace
console.log("matching", path, key, i);
v = match(path.slice(i), val);
}
return true;
})){ console.log("matched", tree, path); v = {sub: tree, path: path} } // insert
return v;
}
function rebalance(ctx, val){
console.log("rebalance", ctx, val);
if(!ctx.post){ return ctx.sub[ctx.path] = val }
ctx.sub[ctx.pre] = ctx.sub[ctx.pre] || (ctx.post? {} : ctx.val || {});
ctx.sub[ctx.pre][ctx.path] = val;
if(ctx.post){
ctx.sub[ctx.pre][ctx.post] = ctx.val;
delete ctx.sub[ctx.pre + ctx.post];
}
}
function set(p, val){
rebalance(match(p, r), val);
console.log('-------------------------');
return r;
}
return function(p, val){
return (1 < arguments.length)? set(p, val) : get(p || '');
}
} // IT WORKS!!!!!!
var rad = radix({});
rad('user/marknadal', {'#': 'asdf'});
rad('user/ambercazzell', {'#': 'dafs'});
rad('user/taitforrest', {'#': 'sadf'});
rad('user/taitveronika', {'#': 'fdsa'});
rad('user/marknadal', {'#': 'foo'});
/*
function radix(r){
var u, n = null, c = 0;
r = r || {};
function get(){
}
function match(p, l, cb){
cb = cb || function(){};
console.log("LETS DO THIS", p, l);
if(!Gun.obj.map(l, function(v, k){
if(k[0] === p[0]){
var i = 1;
while(k[i] === p[i] && p[i]){ i++ }
k = k.slice(i);
if(k){
cb(p.slice(0, i), v, k, l, p.slice(i));
} else {
match(p.slice(i), v, cb);
}
return 1;
}
})){ cb(p, l, null, l) }
}
function set(p, val){
match(p, r, function(pre, data, f, rr, pp){
if(f === null){
rr[pre] = val;
return;
}
console.log("Match?", c, pre, data, f);
rr[pre] = r[pre] || (f? {} : data || {});
rr[pre][pp] = val;
if(f){
rr[pre][f] = data;
delete rr[pre + f];
}
});
return r;
}
return function(p, val){
return (1 < arguments.length)? set(p, val) : get(p || '');
}
} // IT WORKS!!!!!!
var rad = radix({});
rad('user/marknadal', {'#': 'asdf'});
//rad('user/ambercazzell', {'#': 'dafs'});
//rad('user/taitforrest', {'#': 'sadf'});
//rad('user/taitveronika', {'#': 'fdsa'});
*/

26
lib/s3.js
View File

@ -12,7 +12,7 @@
gun.__.opt.batch = opt.batch || gun.__.opt.batch || 10;
gun.__.opt.throttle = opt.throttle || gun.__.opt.throttle || 15;
gun.__.opt.disconnect = opt.disconnect || gun.__.opt.disconnect || 5;
s3.load = s3.load || function(key, cb, opt){
s3.get = s3.get || function(key, cb, opt){
if(!key){ return }
cb = cb || function(){};
opt = opt || {};
@ -21,10 +21,10 @@
} else {
key = s3.prefix + s3.prekey + key;
}
s3.get(key, function(err, data, text, meta){
s3.GET(key, function(err, data, text, meta){
Gun.log('via s3', key, err);
if(meta && meta[Gun._.soul]){
return s3.load(meta, cb); // SUPER SUPER IMPORTANT TODO!!!! Make this load via GUN in case soul is already cached!
return s3.get(meta, cb); // SUPER SUPER IMPORTANT TODO!!!! Make this get via GUN in case soul is already cached!
// HUGE HUGE HUGE performance gains could come from the above line being updated! (not that this module is performant).
}
if(err && err.statusCode == 404){
@ -33,7 +33,7 @@
cb(err, data);
});
}
s3.set = s3.set || function(nodes, cb){
s3.put = s3.put || function(nodes, cb){
s3.batching += 1;
cb = cb || function(){};
cb.count = 0;
@ -44,7 +44,7 @@
Gun.obj.map(nodes, function(node, soul){
cb.count += 1;
batch[soul] = (batch[soul] || 0) + 1;
//Gun.log("set listener for", next + ':' + soul, batch[soul], cb.count);
//Gun.log("put listener for", next + ':' + soul, batch[soul], cb.count);
s3.on(next + ':' + soul).event(function(){
cb.count -= 1;
//Gun.log("transaction", cb.count);
@ -55,14 +55,14 @@
});
});
if(gun.__.opt.batch < s3.batching){
return s3.set.now();
return s3.put.now();
}
if(!gun.__.opt.throttle){
return s3.set.now();
return s3.put.now();
}
s3.wait = s3.wait || setTimeout(s3.set.now, gun.__.opt.throttle * 1000); // in seconds
s3.wait = s3.wait || setTimeout(s3.put.now, gun.__.opt.throttle * 1000); // in seconds
}
s3.set.now = s3.set.now || function(){
s3.put.now = s3.put.now || function(){
clearTimeout(s3.wait);
s3.batching = 0;
s3.wait = null;
@ -71,7 +71,7 @@
s3.next = Gun.time.is();
Gun.obj.map(batch, function put(exists, soul){
var node = gun.__.graph[soul]; // the batch does not actually have the nodes, but what happens when we do cold data? Could this be gone?
s3.put(s3.prefix + s3.prenode + soul, node, function(err, reply){
s3.PUT(s3.prefix + s3.prenode + soul, node, function(err, reply){
Gun.log("s3 put reply", soul, err, reply);
if(err || !reply){
put(exists, soul); // naive implementation of retry TODO: BUG: need backoff and anti-infinite-loop!
@ -95,7 +95,7 @@
if(!soul){
return cb({err: "No soul!"});
}
s3.put(s3.prefix + s3.prekey + key, '', function(err, reply){ // key is 2 bytes??? Should be smaller. Wait HUH? What did I mean by this?
s3.PUT(s3.prefix + s3.prekey + key, '', function(err, reply){ // key is 2 bytes??? Should be smaller. Wait HUH? What did I mean by this?
Gun.log("s3 put reply", soul, err, reply);
if(err || !reply){
s3.key(key, soul, cb); // naive implementation of retry TODO: BUG: need backoff and anti-infinite-loop!
@ -107,8 +107,8 @@
opt.hooks = opt.hooks || {};
gun.opt({hooks: {
load: opt.hooks.load || s3.load
,set: opt.hooks.set || s3.set
get: opt.hooks.get || s3.get
,put: opt.hooks.put || s3.put
,key: opt.hooks.key || s3.key
}}, true);
});

18
lib/set.js Normal file
View File

@ -0,0 +1,18 @@
var Gun = Gun || require('../gun');
Gun.chain.set = function(obj, cb, opt){
var set = this;
opt = opt || {};
cb = cb || function(){};
set = set.put({}); // insert assumes a graph node. So either create it or merge with the existing one.
var error, item = set.chain().put(obj, function(err){ // create the new item in its own context.
error = err; // if this happens, it should get called before the .val
}).val(function(val){
if(error){ return cb.call(set, error) } // which in case it is, allows us to fail fast.
var add = {}, soul = Gun.is.soul.on(val);
if(!soul){ return cb.call(set, {err: Gun.log("No soul!")}) }
add[soul] = val; // other wise, let's then
set.put(add, cb); // merge with the graph node.
});
return item;
};

53
lib/wsp.js
View File

@ -87,56 +87,65 @@
return req.headers['x-forwarded-for'] || req.connection.remoteAddress || req.socket.remoteAddress || (req.connection.socket || {}).remoteAddress || '';
} */
gun.server.transport = gun.server.transport || (function(){
// all streams, technically PATCH but implemented as POST, are forwarded to other trusted peers
// all streams, technically PATCH but implemented as PUT or POST, are forwarded to other trusted peers
// except for the ones that are listed in the message as having already been sending to.
// all states, implemented with GET, are replied to the source that asked for it.
function tran(req, cb){
//Gun.log("gun.server", req);
req.method = req.body? 'post' : 'get'; // post or get is based on whether there is a body or not
req.method = req.body? 'put' : 'get'; // put or get is based on whether there is a body or not
req.url.key = req.url.pathname.replace(gun.server.regex,'').replace(/^\//i,'') || '';
if('get' == req.method){ return tran.load(req, cb) }
if('post' == req.method){ return tran.post(req, cb) }
if('get' == req.method){ return tran.get(req, cb) }
if('put' == req.method || 'post' == req.method){ return tran.put(req, cb) }
cb({body: {hello: 'world'}});
}
tran.load = function(req, cb){
tran.get = function(req, cb){
var key = req.url.key
, reply = {headers: {'Content-Type': tran.json}};
console.log(req);
if(req && req.url && Gun.obj.has(req.url.query, '*')){
return gun.all(req.url.key + req.url.search, function(err, list){
console.log("reply all with", err, list);
cb({headers: reply.headers, body: (err? (err.err? err : {err: err || "Unknown error."}) : list || null ) })
});
}
if(!key){
if(!Gun.obj.has(req.url.query, Gun._.soul)){
return cb({headers: reply.headers, body: {err: "No key or soul to load."}});
return cb({headers: reply.headers, body: {err: "No key or soul to get."}});
}
key = {};
key[Gun._.soul] = req.url.query[Gun._.soul];
}
//Gun.log("transport.loading key ->", key, gun.__.graph, gun.__.keys);
gun.load(key, function(err, node){
//Gun.log("transport.getting key ->", key, gun.__.graph, gun.__.keys);
gun.get(key, function(err, node){
//tran.sub.scribe(req.tab, node._[Gun._.soul]);
cb({headers: reply.headers, body: (err? (err.err? err : {err: err || "Unknown error."}) : node || null)});
});
}
tran.post = function(req, cb){
// NOTE: It is highly recommended you do your own POSTs through your own API that then saves to gun manually.
tran.put = function(req, cb){
// NOTE: It is highly recommended you do your own PUT/POSTs through your own API that then saves to gun manually.
// This will give you much more fine-grain control over security, transactions, and what not.
var reply = {headers: {'Content-Type': tran.json}};
if(!req.body){ return cb({headers: reply.headers, body: {err: "No body"}}) }
if(tran.post.key(req, cb)){ return }
if(tran.put.key(req, cb)){ return }
console.log("tran.put", req.body);
//return;
// saving
Gun.obj.map(req.body, function(node, soul){ // iterate over every node
if(soul != Gun.is.soul.on(node)){ return this.end("No soul!") }
gun.load(node._, this.add(soul)); // and begin loading it in case it is not cached.
gun.get({'#': soul}, this.add(soul)); // and begin getting it in case it is not cached.
}, Gun.fns.sum(function(err){
if(err){ return reply.err = err }
reply.loaded = true;
reply.got = true;
}));
// could there be a timing error somewhere in here?
var setImmediate = setImmediate || setTimeout; // TODO: BUG: This should be cleaned up, but I want Heroku to work.
setImmediate(function(){ // do not do it right away because gun.load above is async, this should be cleaner.
var context = gun.union(req.body, function check(err, ctx){ // check if the body is valid, and get it into cache immediately.
setImmediate(function(){ // do not do it right away because gun.get above is async, this should be cleaner.
var context = Gun.union(gun, req.body, function check(err, ctx){ // check if the body is valid, and get it into cache immediately.
context = ctx || context;
if(err || reply.err || context.err || !context.nodes){ return cb({headers: reply.headers, body: {err: err || reply.err || context.err || "Union failed." }}) }
if(!Gun.fns.is(gun.__.opt.hooks.set)){ return cb({headers: reply.headers, body: {err: "Persistence not supported." }}) }
if(!reply.loaded){ return setTimeout(check, 2) } // only persist if all nodes have been loaded into cache.
gun.__.opt.hooks.set(context.nodes, function(err, data){ // since we've already manually done the union, we can now directly call the persistence layer.
if(!Gun.fns.is(gun.__.opt.hooks.put)){ return cb({headers: reply.headers, body: {err: "Persistence not supported." }}) }
if(!reply.got){ return setTimeout(check, 2) } // only persist if all nodes are in cache.
gun.__.opt.hooks.put(context.nodes, function(err, data){ // since we've already manually done the union, we can now directly call the persistence layer.
if(err){ return cb({headers: reply.headers, body: {err: err || "Persistence failed." }}) }
cb({headers: reply.headers, body: {ok: "Persisted."}}); // TODO: Fix so we know what the reply is.
});
@ -144,11 +153,11 @@
}, 0);
gun.server.on('network').emit(req);
}
tran.post.key = function(req, cb){ // key hook!
tran.put.key = function(req, cb){ // key hook!
if(!req || !req.url || !req.url.key || !Gun.obj.has(req.body, Gun._.soul)){ return }
var load = {}, index = {}, soul;
soul = load[Gun._.soul] = index[req.url.key] = req.body[Gun._.soul];
gun.load(load).key(index, function(err, reply){
var get = {}, index = req.url.key, soul;
soul = get[Gun._.soul] = Gun.is.soul(req.body);
gun.get(get).key(index, function(err, reply){
if(err){ return cb({headers: {'Content-Type': tran.json}, body: {err: err}}) }
cb({headers: {'Content-Type': tran.json}, body: reply}); // TODO: Fix so we know what the reply is.
});

1050
test/common (Architect's conflicted copy 2015-05-26 (1)).js Normal file
View File

File diff suppressed because it is too large Load Diff

1043
test/common (Architect's conflicted copy 2015-05-26).js Normal file
View File

File diff suppressed because it is too large Load Diff

755
test/common.js
View File

@ -4,7 +4,7 @@ describe('Gun', function(){
var t = {};
describe('Utility', function(){
it('verbose console.log debugging', function(done) {
it('verbose console.log debugging', function(done) { console.log("TURN THIS BACK ON the DEBUGGING TEST"); done(); return;
var gun = Gun();
var log = root.console.log, counter = 1;
@ -13,11 +13,11 @@ describe('Gun', function(){
//log(a,b,c);
}
Gun.log.verbose = true;
gun.set('bar', function(err, yay){ // intentionally trigger an error that will get logged.
gun.put('bar', function(err, yay){ // intentionally trigger an error that will get logged.
expect(counter).to.be(0);
Gun.log.verbose = false;
gun.set('bar', function(err, yay){ // intentionally trigger an error that will get logged.
gun.put('bar', function(err, yay){ // intentionally trigger an error that will get logged.
expect(counter).to.be(0);
root.console.log = log;
@ -281,22 +281,96 @@ describe('Gun', function(){
});
});
it('ify', function(){
var data, test;
data = {a: false, b: true, c: 0, d: 1, e: '', f: 'g', h: null};
test = Gun.ify(data);
expect(test.err).to.not.be.ok();
data = {};
data.a = {x: 1, y: 2, z: 3}
data.b = {m: 'n', o: 'p', q: 'r', s: 't'};
data.a.kid = data.b;
data.b.parent = data.a;
data.loop = [data.b, data.a.kid, data];
test = Gun.ify(data);
expect(test.err).to.not.be.ok();
describe('ify', function(){
var test, gun = Gun();
it('null', function(done){
Gun.ify(null)(function(err, ctx){
expect(err).to.be.ok();
done();
});
});
it('basic', function(done){
var data = {a: false, b: true, c: 0, d: 1, e: '', f: 'g', h: null};
Gun.ify(data)(function(err, ctx){
expect(err).to.not.be.ok();
expect(ctx.err).to.not.be.ok();
expect(ctx.root).to.eql(data);
expect(ctx.root === data).to.not.ok();
done();
});
});
it('basic soul', function(done){
var data = {_: {'#': 'SOUL'}, a: false, b: true, c: 0, d: 1, e: '', f: 'g', h: null};
Gun.ify(data)(function(err, ctx){
expect(err).to.not.be.ok();
expect(ctx.err).to.not.be.ok();
expect(ctx.root).to.eql(data);
expect(ctx.root === data).to.not.be.ok();
expect(Gun.is.soul.on(ctx.root) === Gun.is.soul.on(data));
done();
});
});
it('arrays', function(done){
var data = {before: {path: 'kill'}, one: {two: {lol: 'troll', three: [9, 8, 7, 6, 5]}}};
Gun.ify(data)(function(err, ctx){
expect(err).to.be.ok();
expect(err.err.indexOf("one.two.three")).to.not.be(-1);
done();
});
});
it('undefined', function(done){
var data = {z: undefined, x: 'bye'};
Gun.ify(data)(function(err, ctx){
expect(err).to.be.ok();
done();
});
});
it('NaN', function(done){
var data = {a: NaN, b: 2};
Gun.ify(data)(function(err, ctx){
expect(err).to.be.ok();
done();
});
});
it('Infinity', function(done){ // SAD DAY PANDA BEAR :( :( :(... Mark wants Infinity. JSON won't allow.
var data = {a: 1, b: Infinity};
Gun.ify(data)(function(err, ctx){
expect(err).to.be.ok();
done();
});
});
it('function', function(done){
var data = {c: function(){}, d: 'hi'};
Gun.ify(data)(function(err, ctx){
expect(err).to.be.ok();
done();
});
});
return; // TODO: COME BACK HERE?
it('circular reference', function(done){
data = {};
data.a = {x: 1, y: 2, z: 3}
data.b = {m: 'n', o: 'p', q: 'r', s: 't'};
data.a.kid = data.b;
data.b.parent = data.a;
Gun.ify(data)(function(err, ctx){
console.log("circ ref", err, ctx, 'now see:');
ctx.seen.forEach(function(val){ console.log(val.node) });
expect(test.err).to.not.be.ok();
done();
});
});
data = {_: {'#': 'shhh', meta: {yay: 1}}, sneak: true};
test = Gun.ify(data);
expect(test.err).to.not.be.ok(); // metadata needs to be stored, but it can't be used for data.
@ -307,192 +381,573 @@ describe('Gun', function(){
data._ = {'#': 'shhh', data: {yay: 1}, spin: data.both};
test = Gun.ify(data);
expect(test.err.meta).to.be.ok(); // TODO: Fail: this passes, somehow? Fix ify code!
it('union', function(){
var graph, prime;
data = {one: {two: [9, 8, 7, 6, 5]}};
test = Gun.ify(data);
expect(test.err.array).to.be.ok();
graph = Gun.ify({a: false, b: true, c: 0, d: 1, e: '', f: 'g', h: null}).nodes;
prime = Gun.ify({h: 9, i: 'foo', j: 'k', l: 'bar', m: 'Mark', n: 'Nadal'}).nodes;
data = {z: undefined, x: 'bye'};
test = Gun.ify(data);
expect(test.err.invalid).to.be.ok();
data = {a: NaN, b: 2};
test = Gun.ify(data);
expect(test.err.invalid).to.be.ok();
data = {a: 1, b: Infinity};
test = Gun.ify(data);
expect(test.err.invalid).to.be.ok();
data = {c: function(){}, d: 'hi'};
test = Gun.ify(data);
expect(test.err.invalid).to.be.ok();
Gun.union(graph, prime); // TODO: BUG! Where is the expect???
});
});
it('union', function(){
var graph, prime;
graph = Gun.ify({a: false, b: true, c: 0, d: 1, e: '', f: 'g', h: null}).nodes;
prime = Gun.ify({h: 9, i: 'foo', j: 'k', l: 'bar', m: 'Mark', n: 'Nadal'}).nodes;
Gun.union(graph, prime); // TODO: BUG! Where is the expect???
describe('Event Promise Back In Time', function(){ return;
/*
var ref = gun.put({field: 'value'}).key('field/value').get('field/value', function(){
expect()
});
setTimeout(function(){
ref.get('field/value', function(){
expect();
});
}, 50);
A) Synchronous
1. fake (B)
B) Asychronous
1. In Memory
DONE
2. Will be in Memory
LISTEN to something SO WE CAN RESUME
DONE
3. Not in Memory
Ask others.
DONE
*/
it('A1', function(done){ // this has behavior of a .get(key) where we already have it in memory but need to fake async it.
var graph = {};
var keys = {};
graph['soul'] = {foo: 'bar'};
keys['some/key'] = graph['soul'];
var ctx = {key: 'some/key'};
if(ctx.node = keys[ctx.key]){
console.log("yay we are synchronously in memory!");
setTimeout(function(){
expect(ctx.flag).to.be.ok();
expect(ctx.node.foo).to.be('bar');
done();
},0);
ctx.flag = true;
}
});
it('B1', function(done){ // this has the behavior a .val() where we don't even know what is going on, we just want context.
var graph = {};
var keys = {};
var ctx = {
promise: function(cb){
setTimeout(function(){
graph['soul'] = {foo: 'bar'};
keys['some/key'] = graph['soul'];
cb('soul');
},50);
}
};
if(ctx.node = keys[ctx.key]){
// see A1 test
} else {
ctx.promise(function(soul){
if(ctx.node = graph[soul]){
expect(ctx.node.foo).to.be('bar');
done();
} else {
// I don't know
}
});
}
});
it('B2', function(done){ // this is the behavior of a .get(key) which synchronously follows a .put(obj).key(key) which fakes async.
var graph = {};
var keys = {};
var ctx = {};
(function(data){ // put
setTimeout(function(){
graph['soul'] = data;
fn();
},10);
ctx.promise = function(fn){
}
}({field: "value"}));
(function(key){ // key
keys[key] = true;
ctx.promise(function(){
keys[key] = node;
})
}('some/key'));
(function(ctx){ // get
if(get.node = keys[get.key]){
} else
if(get.inbetweenMemory){
} else {
loadFromDiskOrPeers(get.key, function(){
});
}
}({key: 'some/key'}));
});
});
describe('API', function(){
(typeof window === 'undefined') && require('../lib/file');
var gun = Gun({file: 'data.json'});
//(typeof window === 'undefined') && require('../lib/file');
var gun = Gun(); //Gun({file: 'data.json'});
it('set key get', function(done){
gun.set({hello: "world"}).key('hello/world').get(function(val){
it('put', function(done){
gun.put("hello", function(err){
expect(err).to.be.ok();
done();
});
});
it('put node', function(done){
gun.put({hello: "world"}, function(err, ok){
expect(err).to.not.be.ok();
done();
});
});
it('put node then value', function(done){
var ref = gun.put({hello: "world"});
ref.put('hello', function(err, ok){
expect(err).to.be.ok();
done();
});
});
it('put node then put', function(done){
gun.put({hello: "world"}).put({goodbye: "world"}, function(err, ok){
expect(err).to.not.be.ok();
done();
});
});
it('put node key get', function(done){
gun.put({hello: "key"}).key('yes/key', function(err, ok){
expect(err).to.not.be.ok();
}).get('yes/key', function(err, data){
expect(err).to.not.be.ok();
expect(data.hello).to.be('key');
done();
});
});
it('put node key gun get', function(done){
gun.put({hello: "key"}).key('yes/key', function(err, ok){
expect(err).to.not.be.ok();
});
gun.get('yes/key', function(err, data){
expect(err).to.not.be.ok();
expect(data.hello).to.be('key');
done();
});
});
it('gun key', function(){ // Revisit this behavior?
try{ gun.key('fail/key') }
catch(err){
expect(err).to.be.ok();
}
});
it('get key', function(done){
gun.get('yes/key', function(err, data){
expect(err).to.not.be.ok();
expect(data.hello).to.be('key');
}).key('hello/key', function(err, ok){
expect(err).to.not.be.ok();
done.key = true;
}).key('yes/hello', function(err, ok){
expect(err).to.not.be.ok();
expect(done.key).to.be.ok();
done();
});
});
it('get key null', function(done){
gun.get('yes/key').key('', function(err, ok){
expect(err).to.be.ok();
done();
});
});
it('get node put node merge', function(done){
gun.get('hello/key', function(err, data){
expect(err).to.not.be.ok();
done.soul = Gun.is.soul.on(data);
}).put({hi: 'you'}, function(err, ok){
expect(err).to.not.be.ok();
var node = gun.__.graph[done.soul];
expect(node.hello).to.be('key');
expect(node.hi).to.be('you');
done();
});
});
it('get null put node never', function(done){ // TODO: GET returns nothing, and then doing a PUT?
gun.get(null, function(err, ok){
expect(err).to.be.ok();
done.err = true;
}).put({hi: 'you'}, function(err, ok){
done.flag = true;
});
setTimeout(function(){
expect(done.err).to.be.ok();
expect(done.flag).to.not.be.ok();
done();
}, 150);
});
/*
it('get key no data put', function(done){
gun.get('this/key/definitely/does/not/exist', function(err, data){
expect(err).to.not.be.ok();
expect(data).to.not.be.ok();
}).put({testing: 'stuff'}, function(err, ok){
expect(err).to.not.be.ok();
var node = gun.__.graph[done.soul];
expect(node.hello).to.be('key');
expect(node.hi).to.be('overwritten');
done();
});
});
*/
it('get node put node merge conflict', function(done){
gun.get('hello/key', function(err, data){
expect(err).to.not.be.ok();
expect(data.hi).to.be('you');
done.soul = Gun.is.soul.on(data);
}).put({hi: 'overwritten'}, function(err, ok){
expect(err).to.not.be.ok();
var node = gun.__.graph[done.soul];
expect(node.hello).to.be('key');
expect(node.hi).to.be('overwritten');
done();
});
});
it('get node path', function(done){
gun.get('hello/key').path('hi', function(err, val){
expect(err).to.not.be.ok();
expect(val).to.be('overwritten');
done();
});
});
it('get node path put value', function(done){
gun.get('hello/key', function(err, data){
expect(err).to.not.be.ok();
expect(data.hi).to.be('overwritten');
done.soul = Gun.is.soul.on(data);
}).path('hi').put('again', function(err, ok){
expect(err).to.not.be.ok();
var node = gun.__.graph[done.soul];
expect(node.hello).to.be('key');
expect(node.hi).to.be('again');
done();
});
});
it('get node path put object', function(done){
gun.get('hello/key', function(err, data){
expect(err).to.not.be.ok();
expect(data.hi).to.be('again');
done.soul = Gun.is.soul.on(data);
}).path('hi').put({yay: "value"}, function(err, ok){
expect(err).to.not.be.ok();
var root = gun.__.graph[done.soul];
expect(root.hello).to.be('key');
expect(root.yay).to.not.be.ok();
expect(Gun.is.soul(root.hi)).to.be.ok();
expect(Gun.is.soul(root.hi)).to.not.be(done.soul);
done();
});
});
it('get node path put object merge', function(done){
gun.get('hello/key', function(err, data){
expect(err).to.not.be.ok();
expect(done.ref = Gun.is.soul(data.hi)).to.be.ok();
done.soul = Gun.is.soul.on(data);
}).path('hi').put({happy: "faces"}, function(err, ok){
expect(err).to.not.be.ok();
var root = gun.__.graph[done.soul];
var sub = gun.__.graph[done.ref];
expect(root.hello).to.be('key');
expect(root.yay).to.not.be.ok();
expect(Gun.is.soul.on(sub)).to.be(done.ref);
expect(sub.yay).to.be('value');
expect(sub.happy).to.be('faces');
done();
});
});
it('get node path put value conflict relation', function(done){
gun.get('hello/key', function(err, data){
expect(err).to.not.be.ok();
expect(done.ref = Gun.is.soul(data.hi)).to.be.ok();
done.soul = Gun.is.soul.on(data);
}).path('hi').put('crushed', function(err, ok){
expect(err).to.not.be.ok();
var root = gun.__.graph[done.soul];
var sub = gun.__.graph[done.ref];
expect(root.hello).to.be('key');
expect(root.yay).to.not.be.ok();
expect(Gun.is.soul.on(sub)).to.be(done.ref);
expect(sub.yay).to.be('value');
expect(sub.happy).to.be('faces');
expect(root.hi).to.be('crushed');
done();
});
});
/*
it('put gun node', function(done){
var mark = gun.put({age: 23, name: "Mark Nadal"});
var amber = gun.put({age: 23, name: "Amber Nadal"});
mark.path('wife').put(amber, function(err){
expect(err).to.not.be.ok();
expect(false).to.be.ok(); // what whatttt???
});
});
*/
it('put val', function(done){
gun.put({hello: "world"}).val(function(val){
expect(val.hello).to.be('world');
done();
});
});
it('load', function(done){
gun.load('hello/world').get(function(val){
it('put key val', function(done){
gun.put({hello: "world"}).key('hello/world').val(function(val){
expect(val.hello).to.be('world');
done();
});
});
it('load path', function(done){
gun.load('hello/world').path('hello').get(function(val){
it('get', function(done){
gun.get('hello/world').val(function(val){
expect(val.hello).to.be('world');
done();
});
});
it('get path', function(done){
gun.get('hello/world').path('hello').val(function(val){
console.log("comfy stuff, pal", val);
expect(val).to.be('world');
done();
});
});
it('load set path', function(done){
gun.load('hello/world').set({hello: 'Mark'}).path('hello').get(function(val){
it('get put path', function(done){
gun.get('hello/world').put({hello: 'Mark'}).path('hello').val(function(val){
expect(val).to.be('Mark');
done();
});
});
it('load path set', function(done){
gun.load('hello/world').path('hello').set('World').get(function(val){
it('get path put', function(done){
gun.get('hello/world').path('hello').put('World').val(function(val){
console.log("what up dawg?", val);
expect(val).to.be('World');
done();
});
});
it('load path empty set', function(done){
gun.load('hello/world').path('earth').set('mars').get(function(val){
it('get path empty put', function(done){
gun.get('hello/world').path('earth').put('mars').val(function(val){
expect(val).to.be('mars');
done();
});
});
it('load path get', function(done){
gun.load('hello/world').path('earth').get(function(val){
it('get path val', function(done){
gun.get('hello/world').path('earth').val(function(val){
expect(val).to.be('mars');
done();
});
});
it('key set get', function(done){
gun.key('world/hello').set({world: "hello"}).get(function(val){
expect(val.world).to.be('hello');
done();
});
});
it('load again', function(done){
gun.load('world/hello').get(function(val){
/* // CHANGELOG: This behavior is no longer allowed! Sorry peeps.
it('key put val', function(done){
gun.key('world/hello').put({world: "hello"}).val(function(val){
expect(val.world).to.be('hello');
done();
});
});
it('load blank kick get', function(done){ // it would be cool with GUN
gun.load("some/empty/thing").blank(function(){ // that if you call blank first
this.set({now: 'exists'}); // you can set stuff
}).get(function(val){ // and THEN still retrieve it.
it('get again', function(done){
gun.get('world/hello').val(function(val){
expect(val.world).to.be('hello');
done();
});
});
*/
it('get not kick val', function(done){ console.log("Undo this!"); return done(); // TODO // it would be cool with GUN
gun.get("some/empty/thing").not(function(){ // that if you call not first
this.put({now: 'exists'}); // you can put stuff
}).val(function(val){ // and THEN still retrieve it.
expect(val.now).to.be('exists');
done();
});
});
it('get not kick val when it already exists', function(done){ console.log("Undo this!"); return done(); // TODO
gun.get("some/empty/thing").not(function(){
this.put({now: 'THIS SHOULD NOT HAPPEN'});
}).val(function(val){
expect(val.now).to.be('exists');
done();
});
});
it('load blank kick get when it already exists', function(done){
gun.load("some/empty/thing").blank(function(){
this.set({now: 'THIS SHOULD NOT HAPPEN'});
}).get(function(val){
expect(val.now).to.be('exists');
done();
});
});
it('set path get sub', function(done){
gun.set({last: {some: 'object'}}).path('last').get(function(val){
it('put path val sub', function(done){
gun.put({last: {some: 'object'}}).path('last').val(function(val){
console.log("fat hat bat", val);
expect(val.some).to.be('object');
done();
});
});
it('load set null', function(done){
gun.set({last: {some: 'object'}}).path('last').get(function(val){
it('get put null', function(done){ console.log("Undo this!"); return done(); // TODO: BUG! WARNING: Occsionally failing, timing issue.
gun.put({last: {some: 'object'}}).path('last').val(function(val){
expect(val.some).to.be('object');
}).set(null, function(err){
}).put(null, function(err){
//console.log("ERR?", err);
}).get(function(val){
}).val(function(val){
expect(val).to.be(null);
done();
});
});
it('var set key path', function(done){ // contexts should be able to be saved to a variable
var foo = gun.set({foo: 'bar'}).key('foo/bar');
it('var put key path', function(done){ // contexts should be able to be saved to a variable
var foo = gun.put({foo: 'bar'}).key('foo/bar');
foo.path('hello.world.nowhere'); // this should become a sub-context, that doesn't alter the original
setTimeout(function(){
foo.path('foo').get(function(val){ // and then the original should be able to be reused later
foo.path('foo').val(function(val){ // and then the original should be able to be reused later
expect(val).to.be('bar'); // this should work
done();
});
}, 100);
});
it('var load path', function(done){ // contexts should be able to be saved to a variable
var foo = gun.load('foo/bar');
it('var get path', function(done){ // contexts should be able to be saved to a variable
var foo = gun.get('foo/bar');
foo.path('hello.world.nowhere'); // this should become a sub-context, that doesn't alter the original
setTimeout(function(){
foo.path('foo').get(function(val){ // and then the original should be able to be reused later
foo.path('foo').val(function(val){ // and then the original should be able to be reused later
expect(val).to.be('bar'); // this should work
done();
});
}, 100);
});
it('load blank set get path get', function(done){ // stickies issue
gun.load("examples/list/foobar").blank(function(){
this.set({
it('get not put val path val', function(done){ console.log("Undo this?"); return done(); // TODO // stickies issue
gun.get("examples/list/foobar").not(function(){
this.put({
id: 'foobar',
title: 'awesome title',
todos: {}
});
}).get(function(data){
}).val(function(data){
expect(data.id).to.be('foobar');
}).path('todos').get(function(todos){
}).path('todos').val(function(todos){
expect(todos).to.not.have.property('id');
done();
});
});
it('set partial sub merge', function(done){
var mark = gun.set({name: "Mark", wife: { name: "Amber" }}).key('person/mark').get(function(mark){
it('put circular ref', function(done){
var data = {};
data[0] = "DATA!";
data.a = {c: 'd', e: 1, f: true};
data.b = {x: 2, y: 'z'};
data.a.kid = data.b;
data.b.parent = data.a;
gun.put(data, function(err, ok){
expect(err).to.not.be.ok();
}).val(function(val){
var a = gun.__.graph[Gun.is.soul(val.a)];
var b = gun.__.graph[Gun.is.soul(val.b)];
expect(Gun.is.soul(val.a)).to.be(Gun.is.soul.on(a));
expect(Gun.is.soul(val.b)).to.be(Gun.is.soul.on(b));
expect(Gun.is.soul(a.kid)).to.be(Gun.is.soul.on(b));
expect(Gun.is.soul(b.parent)).to.be(Gun.is.soul.on(a));
done();
});
});
it('put circular deep', function(done){
var mark = {
age: 23,
name: "Mark Nadal"
}
var amber = {
age: 23,
name: "Amber Nadal",
phd: true
}
mark.wife = amber;
amber.husband = mark;
var cat = {
age: 3,
name: "Hobbes"
}
mark.pet = cat;
amber.pet = cat;
cat.owner = mark;
cat.master = amber;
gun.put(mark, function(err, ok){
expect(err).to.not.be.ok();
}).val(function(val){
console.log(val);
expect(val.age).to.be(23);
expect(val.name).to.be("Mark Nadal");
expect(Gun.is.soul(val.wife)).to.be.ok();
expect(Gun.is.soul(val.pet)).to.be.ok();
}).path('wife.pet.name').val(function(val){
expect(val).to.be('Hobbes');
}).back.path('pet.master').val(function(val){
expect(val.name).to.be("Amber Nadal");
expect(val.phd).to.be.ok();
expect(val.age).to.be(23);
expect(Gun.is.soul(val.pet)).to.be.ok();
done();
});
});
it('put partial sub merge', function(done){
var mark = gun.put({name: "Mark", wife: { name: "Amber" }}).key('person/mark').val(function(mark){
expect(mark.name).to.be("Mark");
});
mark.set({age: 23, wife: {age: 23}});
mark.put({age: 23, wife: {age: 23}});
setTimeout(function(){
mark.set({citizen: "USA", wife: {citizen: "USA"}}).get(function(mark){
mark.put({citizen: "USA", wife: {citizen: "USA"}}).val(function(mark){
expect(mark.name).to.be("Mark");
expect(mark.age).to.be(23);
expect(mark.citizen).to.be("USA");
this.path('wife').get(function(Amber){
this.path('wife').val(function(Amber){
console.log('wife val', Amber);
expect(Amber.name).to.be("Amber");
expect(Amber.age).to.be(23);
expect(Amber.citizen).to.be("USA");
@ -501,80 +956,80 @@ describe('Gun', function(){
});
}, 50);
});
it('path path', function(done){
var deep = gun.set({some: {deeply: {nested: 'value'}}});
deep.path('some.deeply.nested').get(function(val){
var deep = gun.put({some: {deeply: {nested: 'value'}}});
deep.path('some.deeply.nested').val(function(val){
expect(val).to.be('value');
});
deep.path('some').path('deeply').path('nested').get(function(val){
deep.path('some').path('deeply').path('nested').val(function(val){
expect(val).to.be('value');
done();
});
});
it('context null set value get error', function(done){
gun.set("oh yes",function(err){
expect(err).to.be.ok();
done();
});
});
var foo;
it('context null set node', function(done){
foo = gun.set({foo: 'bar'}).get(function(obj){
expect(obj.foo).to.be('bar');
done();
});
});
it('context node set val', function(done){
foo.set('banana', function(err){
it('context null put value val error', function(done){
gun.put("oh yes",function(err){
expect(err).to.be.ok();
done();
});
});
it('context node set node', function(done){
foo.set({bar: {zoo: 'who'}}).get(function(obj){
var foo;
it('context null put node', function(done){
foo = gun.put({foo: 'bar'}).val(function(obj){
expect(obj.foo).to.be('bar');
done();
});
});
it('context node put val', function(done){
foo.put('banana', function(err){
expect(err).to.be.ok();
done();
});
});
it('context node put node', function(done){
foo.put({bar: {zoo: 'who'}}).val(function(obj){
expect(obj.foo).to.be('bar');
expect(Gun.is.soul(obj.bar)).to.ok();
done();
});
});
it('context node and field set value', function(done){
it('context node and field put value', function(done){
var tar = foo.path('tar');
tar.set('zebra').get(function(val){
tar.put('zebra').val(function(val){
expect(val).to.be('zebra');
done();
});
});
var bar;
it('context node and field of relation set node', function(done){
it('context node and field of relation put node', function(done){
bar = foo.path('bar');
bar.set({combo: 'double'}).get(function(obj){
bar.put({combo: 'double'}).val(function(obj){
expect(obj.zoo).to.be('who');
expect(obj.combo).to.be('double');
done();
});
});
it('context node and field, set node', function(done){
bar.path('combo').set({another: 'node'}).get(function(obj){
it('context node and field, put node', function(done){
bar.path('combo').put({another: 'node'}).val(function(obj){
console.log("oh boy", obj);
expect(obj.another).to.be('node');
bar.get(function(node){
bar.val(function(node){
expect(Gun.is.soul(node.combo)).to.be.ok();
expect(Gun.is.soul(node.combo)).to.be(Gun.is.soul.on(obj));
done();
});
});
});
return;
it('map', function(done){
var c = 0, map = gun.set({a: {here: 'you'}, b: {go: 'dear'}, c: {sir: '!'} });
var c = 0, map = gun.put({a: {here: 'you'}, b: {go: 'dear'}, c: {sir: '!'} });
map.map(function(obj, soul){
c++;
if(soul === 'a'){

79
test/scan-all.js Normal file
View File

@ -0,0 +1,79 @@
var expect = global.expect = require("./expect");
var Gun = Gun || require('../gun');
Gun.log.verbose = true;
(typeof window === 'undefined') && require('../lib/file');
describe('All', function(){
var gun = Gun({file: 'data.json'});
var keys = {
'emails/aquiva@gmail.com': 'asdf',
'emails/mark@gunDB.io': 'asdf',
'user/marknadal': 'asdf',
'emails/amber@cazzell.com': 'fdsa',
'user/ambernadal': 'fdsa',
'user/forrest': 'abcd',
'emails/banana@gmail.com': 'qwert',
'user/marknadal/messages/asdf': 'rti',
'user/marknadal/messages/fobar': 'yuoi',
'user/marknadal/messages/lol': 'hjkl',
'user/marknadal/messages/nano': 'vbnm',
'user/marknadal/messages/sweet': 'xcvb',
'user/marknadal/posts': 'qvtxz',
'emails/for@rest.com': 'abcd'
};
it('from', function() {
var r = gun.__.opt.hooks.all(keys, {from: 'user/'});
console.log(r);
expect(r).to.be.eql({
'user/marknadal': { '#': 'asdf' },
'user/ambernadal': { '#': 'fdsa' },
'user/forrest': { '#': 'abcd' },
'user/marknadal/messages/asdf': { '#': 'rti' },
'user/marknadal/messages/fobar': { '#': 'yuoi' },
'user/marknadal/messages/lol': { '#': 'hjkl' },
'user/marknadal/messages/nano': { '#': 'vbnm' },
'user/marknadal/messages/sweet': { '#': 'xcvb' },
'user/marknadal/posts': { '#': 'qvtxz' }
});
});
it('from and upto', function() {
var r = gun.__.opt.hooks.all(keys, {from: 'user/', upto: '/'});
console.log('upto', r);
expect(r).to.be.eql({
'user/marknadal': { '#': 'asdf' },
'user/ambernadal': { '#': 'fdsa' },
'user/forrest': { '#': 'abcd' }
});
});
it('from and upto and start and end', function() {
var r = gun.__.opt.hooks.all(keys, {from: 'user/', upto: '/', start: "c", end: "f"});
console.log('upto and start and end', r);
expect(r).to.be.eql({
'user/forrest': { '#': 'abcd' }
});
});
it('map', function(done) { return done();
var users = gun.put({
a: {name: "Mark Nadal"},
b: {name: "Amber Nadal"},
c: {name: "Charlie Chapman"},
d: {name: "Johnny Depp"},
e: {name: "Santa Clause"}
});
console.log("map:");
users.map().val(function(user){
console.log("each user:", user);
}).path("ohboy");
return;
users.map(function(){
});
});
});

10
test/group.js → test/set.js
View File

@ -1,22 +1,22 @@
(function(){ // group test
var Gun = require('../index');
require('../lib/group');
require('../lib/set');
var gun = Gun({file: 'data.json'});
gun.group({
gun.set({
name: "Mark Nadal",
age: 23,
type: "human"
}).group({
}).back.set({
name: "Amber Nadal",
age: 23,
type: "human"
}).group({
}).back.set({
name: "Hobbes",
age: 4,
type: "kitten"
}).get(function(g){
}).back.val(function(g){
//console.log("GOT", g, this.__.graph);
}).map(function(val, id){
//console.log("map", id, val);

6
test/tmp.js
View File

@ -5,15 +5,15 @@
Gun.log.verbose = true;
/*
gun.set({foo: "bar"}).get(function(val){
gun.put({foo: "bar"}).val(function(val){
console.log("POWR HOUSE", val);
this.set({lol: 'pancakes'}).get(function(v){
this.put({lol: 'pancakes'}).val(function(v){
console.log("YEAH CAKES", v);
})
});
*/
gun.load('hello/world').set({hello: 'Mark'}).path('hello').get(function(val){
gun.get('hello/world').put({hello: 'Mark'}).path('hello').val(function(val){
console.log("YO", val);
expect(val).to.be('Mark');
done();

BIN
web/img/Thumbs.db Normal file
View File

Binary file not shown.

BIN
web/img/knockout.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 66 KiB

65
web/intro.html Normal file
View File

@ -0,0 +1,65 @@
<div class="center fold stretch" style="background: url(./img/knockout.jpg) no-repeat 50% 50%; background-size: 100%;">
<div class="stretch stick" style="top: 50%; margin-top: -2.25em; font-family: arial;">
<div style="font-size: 4em; color: white; text-shadow: black 0px 0px 1em;">GAME OVER</div>
<button style="color: #400; font-size: 1.5em; background: red; padding: .75em; box-shadow: inset 0px 0px 2em 0px maroon; border: 1px solid #444;">
play again
</button>
<span>?</span>
</div>
</div>
<div style="float: left; max-width: 750px; width: 100%; padding: 2em; line-height: 1.25em; color: #ddd;">
<p>"You don't remember what happened, do you?"</p>
<p>Violence is a jarring thing. Imagine waking up and having no memory. No notion of who you are, where you came from, or why you were chosen.</p>
<p>Your identity, <i>erased</i>. This is your story, and you are about to discover how.</p>
<h2>Hi, I'm Plublious. Let me be your guide.</h2>
<p>"You've got a dreadful case of amnesia. I guess you're just gonna have to trust me."</p>
<p>"So hey, what's your name?"</p>
<div id="namethee"><button id="whoami">I don't know</button> or <input id="myname"> <button id="iam">is my name</button>.</div>
<p class="none" id="benamedbob">"You don't know? Well then, let's call you Bob."</p>
<p class="none" id="benamed">"Hi, <span class="name"></span>!"</p>
<div class="none" id="discover">
<p>"What is this all about?" <span class="name"></span> asks.
<div><button id="answers">Find out the answer</button> or <button class="upset">Be upset your questions are being written for you</button>.</div>
<div class="none" id="distributed">
<p>"Distributed systems."</p>
<p>"What?" <span class="name"></span> gawks.
<p>"Distributed systems."</p>
</div>
</div>
</div>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
<script>
$(function(){
$("#whoami").click(function(){ $("#namethee").addClass('none'); named("Bob"); });
$("#iam").click(function(){ $("#namethee").addClass('none'); named($('#myname').val()); });
function named(name){ $(".name").text(name); $("#benamed, #discover").removeClass('none'); };
$("#answers").click(function(){ $(this).closest('div').addClass('none'); $("#distributed").removeClass('none') })
})
</script>
<style>
html, body {
margin: 0;
padding: 0;
font-size: 16pt;
font-family: 'Palatino Linotype', Verdana;
background: black;
color: white;
}
.center {
text-align: center;
}
.fold {
height: 100%;
}
.stretch {
width: 100%;
}
.stick {
position: absolute;
}
.none {
display: none;
}
</style>

58
web/notes.txt
View File

@ -1,7 +1,7 @@
HOOKS:
- TRANSPORT:
Has to basically re-implement set/load/key over some transport.
REMEMBER that you have to subscribe on all set/load/key (especially key).
Has to basically re-implement set/get/key/all over some transport.
REMEMBER that you have to subscribe on all set/get/key/all (especially key).
Notes:
@ -60,6 +60,16 @@ These are reserved for gun, to include meta-data on the data itself.
. represents walking the path through a node's scope
_ represents non-human data in the graph that the amnesia machine uses to process stuff
> and < are dedicated to comparing timestamp states, timelessly to avoid malicious abuse (this should always come last, because requests will be rejected without it)
~ is who
* relates to key prefixes
*> lexical constraint
*< lexical constraint
@ is where it should be delivered to.
@> is where it has been or will be rebroadcasted through.
% is for byte constraints.
: is time
$ is value
' is for escaping characters contained within '
{
who: {}
@ -85,9 +95,41 @@ How do we do memory management / clean up then of old dead bad data?
Init
You initialize with a node(s) you want to connect to.
Evolution
var node = gun.create('person/joe', {}); // this creates a 'new' node with an identifier to this node
node('name', 'joe'); // changes properties
node('age', 24);
node('eyes', {}); // this internally creates a new node within the same subset as joe,
node('eyes.color', 'blue');
DISK
We might want to compact everything into a journal, with this type of format:
#'ASDF'.'hello'>12743921$"world"
Over the wire though it would include more information, like the ordering of where it has/will-be traversed through.
@>'random','gunjs.herokuapp.com','127.0.0.1:8080':7894657#'ASDF'.'hello'>12743921$"world"
What about ACKs?
@'random':7894657#'ASDF'.'hello'>12743921
There is a limited amount of space on a machine, where we assume it is considered ephemeral as a user viewing device.
Such machines are the default requiring no configuration, machines that are permanent nodes can configure caps.
For instance, the browser would be a looping ephemeral device, where the 5mb localStorage gets recycled.
The localhost server of that device would be permanent and not loop, but halt when storage runs out.
By thus virtue of this, clients should be able to throttle (backpressure) their data intake.
The size of primitive values is fundamentally outside our control and left to the developer or multiparting.
If they decide to have a string that exceeds memory or local disk then their app will always fail regardless of multiparting.
However it is our duty to make sure that the rest of the structured data is streamable, including JSON.
Therefore networks and snapshotting should throttle to a size limit specified by the requesting agent.
Resuming these requests will be based soley on a lexical cursor included in the delivery, to avoid remembering state.
The asynchronicity of these lexical cursor could pose potential concurrency issues, and have to be considered ad hoc.
That is to say, if you are dealing with a large data set, you should always subscribe to updates it and never merely "get" it.
For the edge case of the singleton "get", the lexical cursor will progress until it receives the same or no cursor back from the server and terminate.
total over a range of time: {"alice", "bob", "carl", "david", "ed", "fred", "gary", "harry", "ian", "jake", "kim"}
client requests "users" at limit of 30 characters, server replies with (rounded down) {"alice", "bob", "carl"}.
after a while the client has processed this and goes for the next step, requesting /users?*>=carl&%=30 and {"david", "ed", "fred", "gary"} is returned.
then again /user?*>gary&%=30 with {"harry", "ian", "jake", "kim"} response.
then again /user?*>kim&%=30 with {} response. No subsequent cursor is possible, end.
Note: I do not know yet if the lexical cursor should be open-closed boundary, open-open, closed-closed, or closed-open - decide later.

65
web/wire.txt Normal file
View File

@ -0,0 +1,65 @@
WIRE PROTOCOL
save/set/create/put/post/delete/update/change/mutate
get/open/load/call/location/address
name/reference/key/index/point
/gun {data: 'yay', #: "soul"}
/gun/key {#: 'soul'}
/gun/key
/gun/key?*=/&*<=a&*>=c
Reads are a GET and do not contain a body.
Writes have a body.
Reads may call the callback multiple times, and will end with an empty object.
Reads are either a singular pathname or pound query to get a key or soul's individual node.
Or a read is to retrieve information on many key's and their corresponding soul.
Query formats are allowed as:
?
* = /
star means the peer should reply with all the KEYS it has up to the character in the value of the query.
Ex. "/users/?*=/" would return {"users/marknadal": {"#": "ASDF"}, "users/ambernadal": {"#": "FDSA"}}
If there is no up to character, then all subkeys would be returned as well.
The peer does not have to reply with all of its keys, however if there are more keys for the receiving peer, it should give it a lexical cursor. (how?)
Ordering is not guaranteed, however if there is ordering, it should be lexical. Therefore things like limit or skip do not necessarily apply.
*> = a
*< = c
star greater than and star less than are lexical constraints on returning all peers KEYS.
Ex. "/users/?*=/&*>=a&*<=c" asks the peer to return users that start and end between 'a' and 'c',
thus {"users/alice": {"#": "DSAF"}, "users/bob": {"#": "DAFS"}, "user/carl": {"#": "SAFD"}}
# = ASDF
pound means the peer should reply with the node that has this exact soul. There should be no key prefixed path on this type of request. A special case of "#=*" indicates to literally dump the entire graph, as is, to the client. Lexical carets are okay.
% = 30
percent means byte constraint requested by the peer asking for data.
> = 1426007247399
< = 1426007248941
greater than and less than are time/state constraints, allowing a peer to request historical data or future data.
the peer processing the request ought to reply with such state data if it has it, but has no requirement to keep such data (but is encouraged to do so).
Using query constraints is generally not advised, as it is better to do all computation at the point of data, or have all data at the point of computation, not inbetween.
This protocol should work over HTTP, or the JSONP fallback specification, and emulated over WS or WebRTC.
On a separate note, it might be advantageous to chunk node objects into pieces as well, in case they grow too big or especially contain too many field/value pairs. If this was built into the behavior, to handle better streaming and lower memory use cases, it would also become ideal for groups of data without any extra logic or behavior.
There are three types of grouped related data:
1. Dependent Causality (videos, audio, etc.)
2. Relative Ordering (age, height, users, etc.)
3. Independent
Obviously independent data is fairly uninteresting, as the HAM can handle convergence just on states alone. Relative ordering requires only application specific logic to sort data for the view, or computing averages and such. They can always be streamed in efficiently by creating indices on the desired properties and then doing lexical loading. Any conflict in ordering on one property can be handled by cascading into other properties, like from sort order to then creation date. By this means, all data should be explicitly recorded, not implicit.
Dependent Causality is the most interesting, and unfortunately not conducive towards efficient means of streaming. This means the data must be sorted in a particular direction, and even if you receive a "later" chunk, you should not reveal it until all earlier chunks have been digested. Which might means you have to discard it from memory if space runs out, and then pull it back in again at the right time. Let's look at some differences here with some concrete examples.
If we have 4 people in the back room, and we want to sort them by height as they come on to stage, then order in which they come out from behind does not matter. Say their heights are 4, 5, 6, and 7 feet tall. When the first one comes out we do not need to do anything, where the 6 is the first one. Then the second one comes out and is 4, so we put them to the left of the first. Then third comes out the 7, and we put them to the right of the first. Finally, the fourth comes out as the 5, and we put them inbetween the first and second. This method allows us to incrementally sort and always see the correct ordering without waiting.
However, lets say we have collaborative text. We have the initial text of "Hello" and an editor named Alice adds ", World!" in which each letter (' ', ',', 'W', 'o', 'r', 'l', 'd', '!') is streamed, potentially out of order, to Bob. We are going to assert that relative ordering does not work because, for the sake of explanation, any individual letter could be lost in the mail as they are sent. The last thing we want is Bob receiving the three characters 'old', which has correct relative ordering but wrong dependency, and thinking Alice is insulting him for being senile. Therefore every letter should specify the message that comes before it, the letter that it depends upon.