statebus 7.0.2 → 7.0.5

package/statebus.js

@@ -14,8 +14,8 @@
             && !(typeof key === 'object' && typeof key.key === 'string'))
             throw ('Error: get(key) called with key = '
                    + JSON.stringify(key))
-        key = key.key || key    // You can pass in an object instead of key
-                                // We should probably disable this in future
+        key = key.key || key  // You can pass in an object instead of key
+                              // We should probably disable this in future
         bogus_check(key)
 
         var called_from_reactive_funk = !callback
@@ -51,9 +51,9 @@
         // arrived nested within a bigger object, because we never explicity
         // got those keys.  But we don't need to get them now cause we
         // already have them.
-        var to_getters = 0
+        var getterters = 0
         if (!gets_out[key])
-            to_getters = bus.route(key, 'to_get', key)
+            getterters = bus.route(key, 'getter', key)
 
         // Now there might be a new value pubbed onto this bus.
         // Or there might be a pending get.
@@ -71,9 +71,9 @@
 
         // Otherwise, we want to make sure that a pub gets called on the
         // handler.  If there's a pending get, then it'll get called later.
-        // If there was a to_get, then it already got called.  Otherwise,
+        // If there was a getter, then it already got called.  Otherwise,
         // let's call it now.
-        else if (!pending_gets[key] && to_getters === 0) {
+        else if (!pending_gets[key] && getterters === 0) {
             // TODO: my intuition suggests that we might prefer to delay this
             // .on_set getting called in a setTimeout(f,0), to be consistent
             // with other calls to .on_set.
@@ -130,8 +130,8 @@
             var was_saving = currently_saving
             currently_saving = obj.key
 
-            // Call the to_set() handlers!
-            var num_handlers = bus.route(obj.key, 'to_set', obj, t)
+            // Call the setter() handlers!
+            var num_handlers = bus.route(obj.key, 'setter', obj, t)
             if (num_handlers === 0) {
                 // And fire if there weren't any!
                 set.fire(obj, t)
@@ -143,7 +143,7 @@
             currently_saving = was_saving
         }
         // TODO: Here's an alternative.  Instead of counting the handlers and
-        // seeing if there are zero, I could just make a to_set handler that
+        // seeing if there are zero, I could just make a setter handler that
         // is shadowed by other handlers if I can get later handlers to shadow
         // earlier ones.
     }
@@ -191,7 +191,7 @@
                 if (obj.key && !changed(obj)) {
                     color = grey
                     icon = 'x'
-                    if (t.to_get)
+                    if (t.getter)
                         message = (t.m) || 'Got ' + bus + "('"+obj.key+"')"
                     if (t.version) message += ' [' + t.version + ']'
                     statelog(obj.key, color, icon, message)
@@ -199,7 +199,7 @@
                 }
 
                 color = red, icon = '•'
-                if (t.to_get || pending_gets[obj.key]) {
+                if (t.getter || pending_gets[obj.key]) {
                     color = green
                     icon = '^'
                     message = add_diff_msg((t.m)||'Got '+bus+"('"+obj.key+"')",
@@ -409,10 +409,11 @@
             clearTimeout(to_be_forgotten[key])
             to_be_forgotten[key] = setTimeout(function () {
                 // Send a forget upstream
-                bus.route(key, 'to_forget', key, t)
+                bus.route(key, 'forgetter', key, t)
 
                 // Delete the cache entry...?
                 // delete cache[key]
+                // delete backup_cache[key]
                 delete gets_out[key]
                 delete to_be_forgotten[key]
             }, 200)
@@ -428,8 +429,8 @@
         }
 
         statelog(key, yellow, 'v', 'Deleting ' + key)
-        // Call the to_delete handlers
-        var handlers_called = bus.route(key, 'to_delete', key)
+        // Call the deleter handlers
+        var handlers_called = bus.route(key, 'deleter', key)
         if (handlers_called === 0)
             // And go ahead and delete if there aren't any!
             delete cache[key]
@@ -444,11 +445,11 @@
         //  - Add transactions, so you can check permissions, abort a delete,
         //    etc.
         //    - NOTE: I did a crappy implementation of abort just now above!
-        //      But it doesn't work if called after the to_delete handler returns.
+        //      But it doesn't work if called after the deleter handler returns.
         //    - Generalize the code across set and del with a "mutate"
         //      operation
         //
-        //  - Right now we fire the to_delete handlers right here.
+        //  - Right now we fire the deleter handlers right here.
         //
         //    - Do we want to batch them up and fire them later?
         //      e.g. we could make a mark_deleted(key) like mark_changed(key)
@@ -467,7 +468,7 @@
 
         var version = (t && t.version) || 'dirty-' + new_version()
 
-        // Find any .to_get, and mark as dirty so that it re-runs
+        // Find any .getter, and mark as dirty so that it re-runs
         var found = false
         if (gets_out.hasOwnProperty(key))
             for (var i=0; i<gets_out[key].length; i++) {
@@ -503,7 +504,6 @@
             var funk    = funks[k],
                 version = dirty_funks[k]
 
-            // console.log(funks[dirty_funks[i]].proxies_for)
             var p = funk.proxies_for
             if (p && p.priority) {
                 log('Clean-early:', funk_name(funk))
@@ -525,7 +525,7 @@
                 funk.react()
             }
         }
-        // log('We just cleaned up', dirty_funks.length, 'funks!')
+        // console.log('We just cleaned up', dirty_funks.length, 'funks!')
     }
 
     // Let's change this function to go through each key and grab the latest
@@ -537,7 +537,7 @@
         var result = []
         var keys = changed_keys.values()
 
-        //log(bus+' Cleaning up!', keys, 'keys, and', getters.length, 'getters')
+        // console.log(bus+' Finding rerunnable funcs for', keys, 'keys, and', Object.keys(dirty_getters).length, 'dirty_getters')
         for (var i=0; i<keys.length; i++) {          // Collect all keys
             // if (to_be_forgotten[keys[i]])
             //     // Ignore changes to keys that have been forgotten, but not
@@ -549,7 +549,7 @@
                 if (f.react) {
                     // Skip if it's already up to date
                     var v = f.getted_keys[JSON.stringify([this.id, keys[i]])]
-                    //log('re-run:', keys[i], f.statebus_id, f.getted_keys)
+                    // console.log('re-run:', keys[i], f.statebus_id, f.getted_keys)
                     if (v && v.indexOf(versions[keys[i]]) !== -1) {
                         log('skipping', funk_name(f), 'already at version', versions[keys[i]], 'proof:', v)
                         continue
@@ -580,7 +580,7 @@
         changed_keys.clear()
         dirty_getters = {}
 
-        //log('found', result.length, 'funks to re run')
+        // console.log('found', result.length, 'funks to re run')
 
         return result
     }
@@ -588,13 +588,21 @@
     // ****************
     // Connections
     function subspace (key, params) {
-        var methods = {to_get:null, to_set:null, on_set:null, on_set_sync:null,
-                       on_delete:null, to_delete:null, to_forget:null}
+        var methods = {getter:null, setter:null, on_set:null, on_set_sync:null,
+                       on_delete:null, deleter:null, forgetter:null}
 
         if (params) {
             for (var method in params) {
-                console.assert(method in methods)
                 var func = params[method]
+                var param_names = {get:'getter', set:'setter',
+                                   delete: 'deleter', forget: 'forgetter',
+                                   on_set:'on_set', on_set_sync:'on_set_sync'}
+
+                // Map it from the API's name to our internal name
+                console.assert(param_names[method],
+                               'Method "' + method + '" is invalid')
+                method = param_names[method]
+
                 autodetect_args(func)
                 func.defined = func.defined || []
                 func.defined.push({bus, method, key, as: 'handler'})
@@ -756,8 +764,8 @@
 
         if (false && !funck.global_funk) {
             // \u26A1
-            var event = {'to_set':'set','on_set':'set.fire','to_get':'get',
-                         'to_delete':'delete','to_forget':'forget'}[method],
+            var event = {'setter':'set','on_set':'set.fire','getter':'get',
+                         'deleter':'delete','forgetter':'forget'}[method],
                 triggering = funk ? 're-running' : 'initiating'
             console.log('   > a', bus+'.'+event + "('" + (arg.key||arg) + "') is " + triggering
                 +'\n     ' + funk_name(funck))
@@ -802,7 +810,8 @@
         function key_arg () { return ((typeof arg.key) == 'string') ? arg.key : arg }
         function rest_arg () { return (key_arg()).substr(binding.length-1) }
         function val_arg () {
-            console.assert(method === 'to_set' || method === 'on_set' || method === 'on_set_sync')
+            console.assert(method === 'setter' || method === 'on_set' || method === 'on_set_sync',
+                           'Bad method for val_arg()')
             // Is there a time I am supposed to return bus.cache[arg]?  It used to say:
             // arg.key ? arg : bus.cache[arg]
 
@@ -821,9 +830,9 @@
             t = clone(t || {})
 
             // Add .abort() method
-            if (method === 'to_set' || method === 'to_delete')
+            if (method === 'setter' || method === 'deleter')
                 t.abort = function () {
-                    var key = method === 'to_set' ? arg.key : arg
+                    var key = method === 'setter' ? arg.key : arg
                     if (f.loading()) return
                     bus.cache[key] = bus.cache[key] || {key: key}
                     bus.backup_cache[key] = bus.backup_cache[key] || {key: key}
@@ -831,34 +840,34 @@
                 }
 
             // Add .done() method
-            if (method !== 'to_forget')
+            if (method !== 'forgetter')
                 t.done = function (o) {
-                    var key = method === 'to_set' ? arg.key : arg
+                    var key = method === 'setter' ? arg.key : arg
                     if (func.use_linked_json)
                         o = {key, val: o}
                     bus.log('We are DONE()ing', method, key, o||arg)
 
                     // We use a simple (and crappy?) heuristic to know if the
-                    // to_set handler has changed the state: whether the
+                    // setter handler has changed the state: whether the
                     // programmer passed (o) to the t.done(o) handler.  If
                     // not, we assume it hasn't changed.  If so, we assume it
                     // *has* changed, and thus we change the version of the
                     // state.  I imagine it would be more accurate to diff
-                    // from before the to_set handler began with when
+                    // from before the setter handler began with when
                     // t.done(o) ran.
                     //
                     // Note: We will likely solve this in the future by
-                    // preventing .to_set() from changing the incoming state,
+                    // preventing .setter() from changing the incoming state,
                     // except through an explicit .revise() function.
                     if (o) t.version = new_version()
 
-                    if (method === 'to_delete')
+                    if (method === 'deleter')
                         delete bus.cache[key]
-                    else if (method === 'to_set') {
+                    else if (method === 'setter') {
                         bus.set.fire(o || arg, t)
                         bus.route(key, 'on_set_sync', o || arg, t)
                     } else {
-                        // Now method === 'to_get'
+                        // Now method === 'getter'
                         o.key = key
                         bus.set.fire(o, t)
                         // And now reset the version cause it could get called again
@@ -869,14 +878,20 @@
             // Alias .return() to .done(), in case that feels better to you
             t.return = t.done
 
+            // Prepush Scratch:
+            //   var prepushed = {}
+            //   t.prepush = function (key) {
+            //       prepushed[key] = bus.get(key)
+            //   }
+
             // Alias t.reget() to bus.dirty()
-            if (method === 'to_set')
+            if (method === 'setter')
                 t.reget = function () { bus.dirty(arg.key) }
 
             // Now to call the handler, let's line up the function's special
             // named arguemnts like key, o, t, rest, vars, etc.
             var args = []
-            args[0] = (method in {to_set:1, on_set:1, on_set_sync:1}) ? val_arg() : arg
+            args[0] = (method in {setter:1, on_set:1, on_set_sync:1}) ? val_arg() : arg
             args[1] = t
             for (var k in (func.args||{})) {
                 switch (k) {
@@ -907,28 +922,29 @@
             //    arr[func.args[k]] = <compute_blah(k)>
 
             // Trigger done() or abort() by return value
-            console.assert(!(result === 'to_get' &&
+            console.assert(!(result === 'getter' &&
                              (result === 'done' || result === 'abort')),
-                           'Returning "done" or "abort" is not allowed from to_get handlers')
+                           'Returning "done" or "abort" is not allowed from getter handlers')
+
             if (result === 'done')  t.done()
             if (result === 'abort') t.abort()
 
             // For get
             if (func.use_linked_json) {
-                if (method === 'to_get' && result !== undefined && !f.loading()) {
+                if (method === 'getter' && result !== undefined && !f.loading()) {
                     var obj = {key: arg, val: result}
                     var new_t = clone(t || {})
-                    new_t.to_get = true
+                    new_t.getter = true
                     set.fire(obj, new_t)
                     return result
                 }
             } else {
-                if (method === 'to_get' && result instanceof Object
+                if (method === 'getter' && result instanceof Object
                     && !f.loading()     // Experimental.
                    ) {
                     result.key = arg
                     var new_t = clone(t || {})
-                    new_t.to_get = true
+                    new_t.getter = true
                     set.fire(result, new_t)
                     return result
                 }
@@ -937,29 +953,29 @@
             // Set, forget and delete handlers stop re-running once they've
             // completed without anything loading.
             // ... with f.forget()
-            if (method !== 'to_get' && !f.loading())
+            if (method !== 'getter' && !f.loading())
                 f.forget()
         })
         f.proxies_for = func
         f.arg = arg
         f.transaction = t || {}
 
-        // to_get handlers stop re-running when the key is forgotten
-        if (method === 'to_get') {
+        // getter handlers stop re-running when the key is forgotten
+        if (method === 'getter') {
             var key = arg
             function handler_done () {
                 f.forget()
-                unbind(key, 'to_forget', handler_done)
+                unbind(key, 'forgetter', handler_done)
             }
-            bind(key, 'to_forget', handler_done)
+            bind(key, 'forgetter', handler_done)
 
             // // Check if it's doubled-up
             // if (gets_out[key])
-            //     console.error('Two .to_get functions are running on the same key',
+            //     console.error('Two .getter functions are running on the same key',
             //                   key+'!', funk_name(funck), funk_name(gets_out[key]))
 
             gets_out[key] = gets_out[key] || []
-            gets_out[key].push(f)   // Record active to_get handler
+            gets_out[key].push(f)   // Record active getter handler
             pending_gets[key] = f   // Record that the get is pending
         }
 
@@ -979,9 +995,9 @@
         for (var i=0; i<handlers.length; i++)
             bus.run_handler(handlers[i].func, method, arg, {t: t, binding: handlers[i].key})
 
-        // if (method === 'to_get')
+        // if (method === 'getter')
         //     console.assert(handlers.length<2,
-        //                    'Two to_get functions are registered for the same key '+key,
+        //                    'Two getter functions are registered for the same key '+key,
         //                    handlers)
         return handlers.length
     }
@@ -1187,7 +1203,7 @@
         if (!name) throw 'Uncallback function needs a name'
         var watching = {}
         var prefix = 'uncallback/' + name
-        bus(prefix + '/*').to_get = function (key, json) {
+        bus(prefix + '/*').getter = function (key, json) {
             var args = json
             function cb (err, result) {
                 if (err) {
@@ -1212,7 +1228,7 @@
             }
         }
         if (options.stop_watching)
-            bus(prefix + '/*').to_forget = function (key, json) {
+            bus(prefix + '/*').forgetter = function (key, json) {
                 console.assert(watching[key],
                                'Forgetting a watcher for ' + JSON.stringify(key)
                                + ' that is not enabled')
@@ -1234,6 +1250,10 @@
         })
     }
 
+    function aget (key) {
+        return new Promise((resolve, reject) =>
+            bus.get_once(key, (o) => resolve(o)))
+    }
 
     // ******************
     // Proxy
@@ -1258,8 +1278,8 @@
                 return o
 
             // We recursively descend through {key: ...} links
-            if (typeof o === 'object' && 'key' in o) {
-                var new_base = bus.get(o.key)
+            if (typeof o === 'object' && 'link' in o) {
+                var new_base = bus.get(o.link)
                 return item_proxy(new_base, new_base.val)
             }
 
@@ -1409,11 +1429,15 @@
         function rem_prefix (key) {
             return has_prefix.test(key) ? key.substr(preprefix.length) : key }
         function add_prefixes (obj) {
-            return bus.translate_keys(bus.clone(obj), add_prefix) }
+            var keyed = bus.translate_keys(bus.clone(obj), add_prefix)
+            return bus.translate_links(bus.clone(keyed), add_prefix)
+        }
         function rem_prefixes (obj) {
-            return bus.translate_keys(bus.clone(obj), rem_prefix) }
+            var keyed = bus.translate_keys(bus.clone(obj), rem_prefix)
+            return bus.translate_links(bus.clone(keyed), rem_prefix)
+        }
 
-        bus(prefix).to_set   = function (obj, t) {
+        bus(prefix).setter   = function (obj, t) {
             bus.set.fire(obj)
             var x = {set: obj}
             if (t.version) x.version = t.version
@@ -1422,11 +1446,11 @@
             if (t.patch)   x.set    = rem_prefix(x.set.key)
             send(x)
         }
-        bus(prefix).to_get  = function (key) { send({get: key}),
+        bus(prefix).getter  = function (key) { send({get: key}),
                                                  client_getted_keys.add(key) }
-        bus(prefix).to_forget = function (key) { send({forget: key}),
+        bus(prefix).forgetter = function (key) { send({forget: key}),
                                                  client_getted_keys.delete(key) }
-        bus(prefix).to_delete = function (key) { send({'delete': key}) }
+        bus(prefix).deleter = function (key) { send({'delete': key}) }
 
         function connect () {
             nlog('[ ] trying to open ' + url)
@@ -1446,9 +1470,9 @@
                     var i = []
                     function intro (o) {i.push(JSON.stringify({set: o}))}
                     if (creds.clientid)
-                        intro({key: 'current_user', client: creds.clientid})
+                        intro({key: 'current_user', val: {client: creds.clientid}})
                     if (creds.name && creds.pass)
-                        intro({key: 'current_user', login_as: {name: creds.name, pass: creds.pass}})
+                        intro({key: 'current_user', val: {login_as: {name: creds.name, pass: creds.pass}}})
                     // Todo: make this kinda thing work:
                     if (creds.private_key && creds.public_key) {
                         // Send public_key... start waiting for a
@@ -1540,6 +1564,14 @@
         return {send: send, sock: sock, close: function () {done = true; sock.close()}}
     }
 
+    bus.client_creds = function client_creds (server_url) {
+        // This default implementation just creates a different random id each time
+        // we connect.  Override this if you want a client ID that persists.
+        return {clientid: (Math.random().toString(36).substring(2)
+                           + Math.random().toString(36).substring(2)
+                           + Math.random().toString(36).substring(2))}
+    }
+
     function net_automount () {
         var bus = this
         var old_route = bus.route
@@ -1586,6 +1618,30 @@
         return k.replace(/(_$)/, '')
     }
 
+    // ************************************************
+    // Translating the URLs under links of state
+    function translate_links (obj, f) {
+        // Recurse through each element in arrays
+        if (Array.isArray(obj))
+            for (var i=0; i < obj.length; i++)
+                translate_links(obj[i], f)
+
+        // Recurse through each property on objects
+        else if (typeof obj === 'object')
+            for (var k in obj) {
+                if (k === 'link')
+                    if (typeof obj[k] == 'string')
+                        obj[k] = f(obj[k])
+                    else if (Array.isArray(obj[k]))
+                        for (var i=0; i < obj[k].length; i++) {
+                            if (typeof obj[k][i] === 'string')
+                                obj[k][i] = f(obj[k][i])
+                        }
+                translate_links(obj[k], f)
+            }
+        return obj
+    }
+
 
     // ************************************************
     // Translating fields of objects
@@ -1863,13 +1919,13 @@
         if (a_array !== b_array) return ' = ' + JSON.stringify(b)
         if (a_array) {
             if (a.length === b.length-1
-                && !deep_equals(a[a.length], b[b.length])) {
-                return '.push(' +JSON.stringify(b[b.length]) + ')'
+                && deep_equals(a[a.length-1], b[b.length-2])) {
+                return '.push(' +JSON.stringify(b[b.length-1]) + ')'
             }
             for (var i=0; i < a.length; i++) {
                 var tmp = sorta_diff (a[i], b[i])
                 if (tmp)
-                    return '['+i+'] = '+tmp
+                    return '['+i+']'+tmp
             }
             return null
         }
@@ -1897,7 +1953,7 @@
 
     // This prune() function is a temporary workaround for dealing with nested
     // objects in set() handlers, until we change statebus' behavior.  Right
-    // now, it calls .to_set only on the top-level state.  But if that state
+    // now, it calls .setter only on the top-level state.  But if that state
     // validates, it calls fire() on *every* level of state.  This means that
     // state changes can sneak inside.  Prune() will take out any changes from
     // the nested levels of state in a new object -- replacing them with the
@@ -2070,7 +2126,7 @@
         if (!(key in bogus_keys))
             return
 
-        var msg = "Sorry, statebus.js currently prohibits use of the key \""+key+"\", and in fact all of these keys: " + Object.keys(bogus_keys).join(', ') + ".  This is because Javascript is kinda lame, and even empty objects like \"{}\" have the \""+key+"\" field defined on them.  Try typing this in your Javascript console: \"({}).constructor\" -- it returns a function instead of undefined!  We could work around it by meticulously replacing every \"obj[key]\" with \"obj.hasOwnProperty(key) && obj[key]\" in the statebus code, but that will make the source more difficult to understand.  So please contact us if this use-case is important for you, and we'll consider doing it.  We're hoping that, for now, our users don't need to use these keys."
+        var msg = "Sorry, statebus.js currently prohibits use of the key \""+key+"\", and in fact all of these keys: " + Object.keys(bogus_keys).join(', ') + ".  This is because Javascript is kinda lame, and even empty objects like \"{}\" have the \""+key+"\" field defined on them.  Try typing this in your Javascript console: \"({}).constructor\" -- it returns a function instead of undefined!  Mike needs to work around it by replacing every \"obj[key]\" with \"obj.hasOwnProperty(key) && obj[key]\" in the statebus code, or switching to a Map() object.  Please contact him and let him know where this is impacting you, so he can bump the priority on it."
         console.error(msg)
         throw 'Invalid key'
     }
@@ -2079,11 +2135,11 @@
     var api = ['cache backup_cache get set forget del fire dirty get_once',
                'subspace bindings run_handler bind unbind reactive uncallback',
                'versions new_version',
-               'link',
+               'link aget',
                'funk_key funk_name funks key_id key_name id',
                'pending_gets gets_in gets_out loading_keys loading once',
                'global_funk busses rerunnable_funks',
-               'escape_keys unescape_keys translate_keys apply_patch',
+               'escape_keys unescape_keys translate_keys translate_links apply_patch',
                'keyed_2_proxied proxied_2_keyed translate_fields',
                'ws_mount net_automount message_method',
                'parse Set One_To_Many clone extend deep_map deep_equals prune validate sorta_diff log deps symbols'
@@ -2110,13 +2166,13 @@
     bus.libs = {}
 
     if (nodejs)
-        require('./servers').import_server(bus, options)
+        require('./server-library').import_server(bus, make_bus, options)
     
     bus.render_when_loading = true
     return bus
 }
 
-if (nodejs) require('./servers').import_module(make_bus)
+if (nodejs) require('./server-library').import_module(make_bus)
 
 return make_bus
 }))