statebus 7.1.0 → 7.1.2

package/extras/tests.js

@@ -319,48 +319,128 @@ test(function proxy_link (done) {
     done()
 })
 
-test(function proxy_links_through (done) {
-    var bus = require('../statebus')()
+// Disable the version of proxy_links_through where the user does not have to
+// explicitly traverse links with ._()
+if (true)
+    test(function proxy_links_through2 (done) {
+        var bus = require('../statebus')()
 
-    // First try to dereference through three links
+        // First try to dereference through three links
 
-    bus.state.a = [bus.link('b')]
-    bus.state.b = bus.link('c')
-    bus.state.c = 'see'
-    
-    log('state.c is', bus.state.c)
-    log('state.b is', bus.state.b, 'from cache', bus.cache.b)
-    log('state.a is', bus.state.a)
-    log('state.a[0] is', bus.state.a[0])
-    log('state.a[0]() is', bus.state.a[0]())
-    log('state.a[0]()() is', bus.state.a[0]()())
-    assert(bus.state.a[0]()() === 'see')
-
-    // Add a little more wrapping and try some more
-
-    bus.state.nested = [99, {a: bus.link('a')}]
-    log('nested is', bus.state.nested)
-    log('nested[1].a()[0]()() is', bus.state.nested[1].a()[0]()())
-    assert(bus.state.nested[1].a()[0]()() === 'see')
-
-    // Now try to go raw at the top-level
-
-    log('Raw is', bus.state[bus.symbols.raw].nested)
-    log('Raw is', bus.raw(bus.state).nested)
-    assert(bus.deep_equals(
-        bus.state[bus.symbols.raw].nested,
-        bus.raw(bus.state).nested
-    ))
-    assert(bus.deep_equals(
-        bus.raw(bus.state).nested,
-        [ 99, { a: { link: 'a' } } ]
-    ))
-
-    // Now try to go raw within
-
-    log('Raw inner is', bus.raw(bus.state.nested[1]))
-
-    log('Bad raw call is', bus.raw(bus.state.nested[0]))
+        bus.state.a = [bus.link('b')]
+        bus.state.b = bus.link('c')
+        bus.state.c = 'see'
+
+        log('state.c is', bus.state.c)
+        log('state.b is', bus.state.b, 'from cache', bus.cache.b)
+        log('state.a is', bus.state.a)
+        log('state.a[0] is', bus.state.a[0])
+        log('state.a[0]._() is', bus.state.a[0]._())
+        log('state.a[0]._()._() is', bus.state.a[0]._()._())
+        assert(bus.state.a[0]._()._() === 'see')
+
+        // Add a little more wrapping and try some more
+
+        bus.state.nested = [99, {a: bus.link('a')}]
+        log('nested is', bus.state.nested)
+        log('nested[1].a._()[0]._()._() is', bus.state.nested[1].a._()[0]._()._())
+        assert(bus.state.nested[1].a._()[0]._()._() === 'see')
+
+        // Now try to go raw at the top-level
+
+        log('Raw is', bus.state[bus.symbols.raw].nested)
+        log('Raw is', bus.raw(bus.state).nested)
+        assert(bus.deep_equals(
+            bus.state[bus.symbols.raw].nested,
+            bus.raw(bus.state).nested
+        ))
+
+        log('Gonna deep_quals between:',
+            bus.raw(bus.state).nested,
+            [ 99, { a: { link: 'a' } } ])
+
+        assert(bus.deep_equals(
+            bus.raw(bus.state).nested,
+            [ 99, { a: { link: 'a' } } ]
+        ))
+
+        // Now try to go raw within
+
+        log('Raw inner is', bus.raw(bus.state.nested[1]))
+
+        log('Bad raw call is', bus.raw(bus.state.nested[0]))
+
+        done()
+    })
+else
+    test(function proxy_links_through1 (done) {
+        var bus = require('../statebus')()
+
+        // First try to dereference through three links
+
+        bus.state.a = [bus.link('b')]
+        bus.state.b = bus.link('c')
+        bus.state.c = 'see'
+
+        log('state.c is', bus.state.c)
+        log('state.b is', bus.state.b, 'from cache', bus.cache.b)
+        log('state.a is', bus.state.a)
+        log('state.a[0] is', bus.state.a[0])
+        log('state.a[0] is', bus.state.a[0])
+        assert(bus.state.a[0] === 'see')
+
+        // Add a little more wrapping and try some more
+
+        bus.state.nested = [99, {a: bus.link('a')}]
+        log('nested is', bus.state.nested)
+        log('nested[1].a[0] is', bus.state.nested[1].a[0])
+        assert(bus.state.nested[1].a[0] === 'see')
+
+        // Now try to go raw at the top-level
+
+        log('Raw is', bus.state[bus.symbols.raw].nested)
+        log('Raw is', bus.raw(bus.state).nested)
+        assert(bus.deep_equals(
+            bus.state[bus.symbols.raw].nested,
+            bus.raw(bus.state).nested
+        ))
+
+        log('Gonna deep_quals between:',
+            bus.raw(bus.state).nested,
+            [ 99, { a: { link: 'a' } } ])
+
+        assert(bus.deep_equals(
+            bus.raw(bus.state).nested,
+            [ 99, { a: { link: 'a' } } ]
+        ))
+
+        // Now try to go raw within
+
+        log('Raw inner is', bus.raw(bus.state.nested[1]))
+
+        log('Bad raw call is', bus.raw(bus.state.nested[0]))
+
+        done()
+    })
+
+
+test(function copy_link (done) {
+    var bus = require('../statebus')(), state = bus.state
+
+    state.a = [bus.link('b')]
+    state.b = 3
+    state.copy_of_a = state.a
+    state.copy_of_a0 = state.a[0]
+
+    console.log(bus.cache.a)
+    console.log(bus.cache.b)
+    console.log(bus.cache.copy_of_a)
+    console.log(bus.cache.copy_of_a0)
+
+    assert(bus.cache.a.val[0].link === 'b')
+    assert(bus.cache.b.val === 3)
+    assert(bus.cache.copy_of_a.val[0].link === 'b')
+    assert(bus.cache.copy_of_a0.val.link === 'b')
 
     done()
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "statebus",
-  "version": "7.1.0",
+  "version": "7.1.2",
   "description": "Synchronize state.",
   "main": "statebus.js",
   "scripts": {

package/statebus.js

@@ -1455,203 +1455,124 @@
         raw: Symbol('raw'),
         link: Symbol('link')
     }
-    function make_proxy () {
-        // var custom_inspect_symbol = nodejs && require('util').inspect.custom,
-        //     custom_inspect = function (depth, options) {
-        //         return '3333333333';// util.inspect(bus.unescape_from_nelson(this), options)
-        //     }
-        function item_proxy (base, path, o) {
-
-            // Primitives pass through unscathed
-            if (typeof o === 'number'
-                || typeof o === 'string'
-                || typeof o === 'boolean'
-                || o === undefined
-                || o === null
-                || typeof o === 'function')
-
-                return o
-
-            // We recursively descend through {key: ...} links
-            if (typeof o === 'object' && 'link' in o) {
-                // var new_base = bus.get(o.link)
-                // return item_proxy(new_base, '', new_base.val)
-                return link_proxy(o.link)
-            }
 
+    // The top-level Proxy object holds HTTP resources
+    var top_level_proxy = new Proxy(cache, {
+        get: function get(o, k) {
+            if (k === symbols.is_proxy)
+                return true
+            if (k === symbols.raw)
+                return raw_proxy()
+            if (k === 'inspect' || k === 'valueOf' || typeof k === 'symbol')
+                return undefined
+            bogus_check(k)
+            var base = bus.get(k)
+            return json_proxy(base, '', base.val)
+        },
+        set: function set(o, key, val) {
+            bus.set({
+                key: key,
+                val: escape_json_to_bus(val)
+            })
+            return true
+        },
+        deleteProperty: function del (o, k) {
+            bus.delete(escape_field_to_bus(k))
+            return true // Report success to Proxy
+        }
+    })
 
-            // For function proxies:
-            //
-            // // Javascript won't let us function call a proxy unless the
-            // // "target" is a function.  So we make a dummy target, and
-            // // don't use it.
-            // var dummy = function () {}
-
-
-            return new Proxy(o, {
-                get: function (o, k) {
-                    if (k === 'inspect' || k === 'valueOf')
-                        return undefined
-                    // if (custom_inspect && k === custom_inspect)
-                    //     return custom_inspect
-                    if (k === symbols.is_proxy)
-                        return true
-                    if (k === symbols.raw)
-                        return o
-                    if (typeof k === 'symbol')
-                        return undefined
-
-                    // Compute the new path
-                    var new_path = path + '[' + JSON.stringify(k) + ']'
-                    return item_proxy(base, new_path, o[escape_field_json_to_bus(k)])
-                },
-                set: function (o, k, v) {
-                    var value = escape_json_to_bus(v)
-                    o[escape_field_json_to_bus(k)] = value
-                    var new_path = path + '[' + JSON.stringify(k) + ']'
-                    bus.set.sync(
-                        base,
-                        // Forward the patches too
-                        {patches: [{unit: 'json',
-                                    range: new_path,
-                                    content: JSON.stringify(v)}]}
-                    )
-                    return true
-                },
-                has: function (o, k) {
-                    // if (custom_inspect && k === custom_inspect)
-                    //     return true
-                    return o.hasOwnProperty(escape_field_json_to_bus(k))
-                },
-                ownKeys: function () {
-                    return Object.keys(o).map(unescape_field_bus_to_json)
-                },
-                getOwnPropertyDescriptor: function (target, key) {
-                    return { enumerable: true, configurable: true, value: this.get(o, key) }
-                },
-                deleteProperty: function del (o, k) {
-                    var new_path = path + '[' + JSON.stringify(k) + ']'
-                    delete o[escape_field_json_to_bus(k)]
-                    bus.set(
-                        base,
-                        // Forward the patches too
-                        {patches: [{unit: 'json',
-                                    range: new_path,
-                                    content: undefined}]}
-                    )
-                    return true // Report success to Proxy
-                }
-                // For function proxies:
-                //
-                // apply: function apply (o, This, args) {
-                //     return translate_fields(o, unescape_field_from_bus)
-                // }
-            })}
-
-        function link_proxy (url) {
-            return new Proxy(function follow_link () {}, {
-                get: function (o, k) {
-                    if (k === 'inspect' || k === 'valueOf')
-                        return undefined
-                    // if (custom_inspect && k === custom_inspect)
-                    //     return custom_inspect
-                    if (k === symbols.is_proxy)
-                        return true
-                    if (k === symbols.raw)
-                        return {link: url}
-                    if (typeof k === 'symbol')
-                        return undefined
-
-                    if (k === 'link')
-                        return url
+    // The proxy within; a recursive tree holds each piece of JSON in a resource
+    function json_proxy (base, path, o) {
 
-                    return undefined
-                },
-                set: function (o, k, v) {
-                    if (k === 'link') {
-                        url = v
-                    }
+        // Primitives pass through unscathed
+        if (typeof o === 'number'
+            || typeof o === 'string'
+            || typeof o === 'boolean'
+            || o === undefined
+            || o === null
+            || typeof o === 'function')
 
-                    console.assert(false, "Have not fully implemented setting links yet")
-
-                    // Todo: update the containing proxy object with bus.set.sync
-                    // else return 
-                    // var value = escape_json_to_bus(v)
-                    // o[escape_field_json_to_bus(k)] = value
-                    // var new_path = path + '[' + JSON.stringify(k) + ']'
-                    // bus.set.sync(
-                    //     base,
-                    //     // Forward the patches too
-                    //     {patches: [{unit: 'json',
-                    //                 range: new_path,
-                    //                 content: JSON.stringify(v)}]}
-                    // )
-                    return true
-                },
-                has: function (o, k) {
-                    return k === 'link'
-                },
-                ownKeys: function () {
-                    return ['link']
-                },
-                // getOwnPropertyDescriptor: function (target, key) {
-                //     return { enumerable: true, configurable: true, value: this.get(o, key) }
-                // },
-                // deleteProperty: function del (o, k) {
-                //     var new_path = path + '[' + JSON.stringify(k) + ']'
-                //     delete o[escape_field_json_to_bus(k)]
-                //     bus.set(
-                //         base,
-                //         // Forward the patches too
-                //         {patches: [{unit: 'json',
-                //                     range: new_path,
-                //                     content: undefined}]}
-                //     )
-                //     return true // Report success to Proxy
-                // }
-
-                // For function proxy:
-                apply: function apply (o, This, args) {
-                    // console.log('Descending into the link', url, '!')
-                    return top_level_proxy[url]
-                }
-            })            
+            return o
+
+        // We recursively descend through {key: ...} links
+        if (typeof o === 'object' && 'link' in o) {
+            // var new_base = bus.get(o.link)
+            // return json_proxy(new_base, '', new_base.val)
+            return link(o.link)
         }
 
 
-        // The top-level Proxy object holds HTTP resources
-        var top_level_proxy = new Proxy(cache, {
-            get: function get(o, k) {
+        // For function proxies:
+        //
+        // // Javascript won't let us function call a proxy unless the
+        // // "target" is a function.  So we make a dummy target, and
+        // // don't use it.
+        // var dummy = function () {}
+
+
+        return new Proxy(o, {
+            get: function (o, k) {
+                if (k === 'inspect' || k === 'valueOf')
+                    return undefined
+                // if (custom_inspect && k === custom_inspect)
+                //     return custom_inspect
                 if (k === symbols.is_proxy)
                     return true
                 if (k === symbols.raw)
-                    return raw_proxy()
-                if (k === 'inspect' || k === 'valueOf' || typeof k === 'symbol')
+                    return o
+                if (typeof k === 'symbol')
                     return undefined
-                bogus_check(k)
-                var base = bus.get(k)
-                return item_proxy(base, '', base.val)
+
+                // Compute the new path
+                var new_path = path + '[' + JSON.stringify(k) + ']'
+                return json_proxy(base, new_path, o[escape_field_json_to_bus(k)])
             },
-            set: function set(o, key, val) {
-                bus.set({
-                    key: key,
-                    val: escape_json_to_bus(val)
-                })
+            set: function (o, k, v) {
+                var value = escape_json_to_bus(v)
+                o[escape_field_json_to_bus(k)] = value
+                var new_path = path + '[' + JSON.stringify(k) + ']'
+                bus.set.sync(
+                    base,
+                    // Forward the patches too
+                    {patches: [{unit: 'json',
+                                range: new_path,
+                                content: JSON.stringify(v)}]}
+                )
                 return true
             },
+            has: function (o, k) {
+                // if (custom_inspect && k === custom_inspect)
+                //     return true
+                return o.hasOwnProperty(escape_field_json_to_bus(k))
+            },
+            ownKeys: function () {
+                return Object.keys(o).map(unescape_field_bus_to_json)
+            },
+            getOwnPropertyDescriptor: function (target, key) {
+                return { enumerable: true, configurable: true, value: this.get(o, key) }
+            },
             deleteProperty: function del (o, k) {
-                bus.delete(escape_field_to_bus(k))
+                var new_path = path + '[' + JSON.stringify(k) + ']'
+                delete o[escape_field_json_to_bus(k)]
+                bus.set(
+                    base,
+                    // Forward the patches too
+                    {patches: [{unit: 'json',
+                                range: new_path,
+                                content: undefined}]}
+                )
                 return true // Report success to Proxy
-            },
+            }
             // For function proxies:
+            //
             // apply: function apply (o, This, args) {
-            //     return 'fluffy'
+            //     return translate_fields(o, unescape_field_from_bus)
             // }
         })
-
-        return top_level_proxy
     }
-    bus.state = make_proxy()
+
+    bus.state = top_level_proxy
 
     // This is temporary code to wrap the cache as a flat key/valuel store
     // that returns raw objects, dereferencing .val.  We can remove it once we
@@ -1668,9 +1589,104 @@
         })
     }
 
+    // How proxy links work right now:
+    //  - The user creates a link with bus.link(key)
+    //    - which produces a {[symbols.link]: key}
+    //    - which when set() into a proxy, is replaced with a {link: key}, to store internally
+    //  - Then, when get()ing that internal {link: key} through Proxy:
+    //    - We auto-dereference the key, with another get()
+    //    - So the user actually sees the value of the resource on the other side of the link
     function link (url) {
-        return {[symbols.link]: url}
-    }
+        return {
+            link: url,
+            [symbols.link]: true,
+            _: (args, o) => (o = get(url), json_proxy(o, '', o.val))
+        }
+    }
+
+    // // The proxy object for links.  Disabled for now.
+    // // This type of link has to be function called, as link(), to dereference.
+    // function proxy_link (url) {
+    //     function follow_link () {}
+    //     return new Proxy(follow_link, {
+    //         get: function (o, k) {
+    //             console.log('get', k)
+    //             if (k === 'inspect' || k === 'valueOf')
+    //                 return undefined
+    //             // if (custom_inspect && k === custom_inspect)
+    //             //     return custom_inspect
+    //             if (k === symbols.is_proxy)
+    //                 return true
+    //             if (k === symbols.link)
+    //                 return true
+    //             if (k === symbols.raw)
+    //                 return {link: url}
+    //             if (typeof k === 'symbol')
+    //                 return undefined
+
+    //             if (k === 'link')
+    //                 return url
+
+    //             return follow_link[k]
+
+    //             // return undefined
+    //         },
+    //         set: function (o, k, v) {
+    //             if (k === 'link') {
+    //                 url = v
+    //             }
+
+    //             console.assert(false, "Have not fully implemented setting links yet")
+
+    //             // Todo: update the containing proxy object with bus.set.sync
+    //             // else return
+    //             // var value = escape_json_to_bus(v)
+    //             // o[escape_field_json_to_bus(k)] = value
+    //             // var new_path = path + '[' + JSON.stringify(k) + ']'
+    //             // bus.set.sync(
+    //             //     base,
+    //             //     // Forward the patches too
+    //             //     {patches: [{unit: 'json',
+    //             //                 range: new_path,
+    //             //                 content: JSON.stringify(v)}]}
+    //             // )
+    //             return true
+    //         },
+    //         has: function (o, k) {
+    //             return k === 'link'
+    //         },
+    //         ownKeys: function () {
+    //             console.log('ownkeys')
+    //             return ['link', 'arguments', 'caller', 'prototype']
+    //         },
+    //         getOwnPropertyDescriptor: function (target, key) {
+    //             console.log('getownpropertydescriptor', key)
+    //             return {
+    //                 enumerable: true,
+    //                 configurable: true,
+    //                 value: key === 'link' ? url : undefined
+    //             }
+    //         },
+    //         // deleteProperty: function del (o, k) {
+    //         //     var new_path = path + '[' + JSON.stringify(k) + ']'
+    //         //     delete o[escape_field_json_to_bus(k)]
+    //         //     bus.set(
+    //         //         base,
+    //         //         // Forward the patches too
+    //         //         {patches: [{unit: 'json',
+    //         //                     range: new_path,
+    //         //                     content: undefined}]}
+    //         //     )
+    //         //     return true // Report success to Proxy
+    //         // }
+
+    //         // For function proxy:
+    //         apply: function apply (o, This, args) {
+    //             // console.log('Descending into the link', url, '!')
+    //             return top_level_proxy[url]
+    //         }
+    //     })
+    // }
     function raw (proxy) {
         if (!(typeof proxy === 'object' && proxy[symbols.is_proxy]))
             return proxy
@@ -2064,7 +2080,7 @@
 
     // Three levels of escaping through state:
     //
-    //  - statebus-internal escapes key  -> _key
+    //  - bus internal      escapes key  -> _key
     //  - nelSON            escapes link -> _link
     //  - JSON
     //
@@ -2086,11 +2102,11 @@
     var escape_json_to_bus = (obj) => {
         obj = translate_fields(obj, escape_field_json_to_bus)
         return deep_map(obj, o => (typeof o === 'object' && symbols.link in o
-                                   ? {link: o[symbols.link]}
+                                   ? {link: o.link}
                                    : o))
     }
     var unescape_bus_to_json = (obj) =>
-        translate_fields(obj, field => unescape_field_bus_to_jsob(field))
+        translate_fields(obj, field => unescape_field_bus_to_json(field))
         
 
     var field_replace = (field, pattern, replacement) => (typeof field === 'string'
@@ -2276,12 +2292,17 @@
         return object
     }
     function deep_equals (a, b) {
+        // This code was only needed for link_proxy:
+        // // Treat link proxy objects as regular JSON links.  Otherwise, the
+        // // function fields on them confuse everything.
+        // if (a && typeof a === 'object' && a[symbols.link]) a = {link: a.link}
+        // if (b && typeof b === 'object' && b[symbols.link]) b = {link: b.link}
+
         // Equal Primitives?
         if (a === b
             // But because NaN === NaN returns false:
-            || (isNaN(a) && isNaN(b)
-                // And because isNaN(undefined) returns true:
-                && typeof a === 'number' && typeof b === 'number'))
+            || (typeof a === 'number' && typeof b === 'number'
+                && isNaN(a) && isNaN(b)))
             return true
 
         // Equal Arrays?
@@ -2319,9 +2340,8 @@
         // Equal Primitives?
         if (a === b
             // But because NaN === NaN returns false:
-            || (isNaN(a) && isNaN(b)
-                // And because isNaN(undefined) returns true:
-                && typeof a === 'number' && typeof b === 'number'))
+            || (typeof a === 'number' && typeof b === 'number'
+                && isNaN(a) && isNaN(b)))
             return null
 
         // Equal Arrays?