aberdeen 0.2.1 → 0.2.3

package/tests/immediate.js

@@ -1,87 +0,0 @@
-describe('Immediate observe', function() {
-
-    it('runs immediately', () => {
-        let store = new Store({a: 1})
-        let count = 0
-        immediateObserve(() => {
-            store.set('b', store.get('a') * 2)
-            count++
-        })
-        assertEqual(store.get('b'), 2)
-        assertEqual(count, 1)
-
-        store.set('a', 3)
-        assertEqual(store.get('b'), 6)
-        assertEqual(count, 2)
-
-        passTime() // shouldn't change anything
-        assertEqual(store.get('b'), 6)
-        assertEqual(count, 2)
-    });
-
-    it('stabilizes dependent values', () => {
-        let store = new Store({num: 1})
-        immediateObserve(() => { // num to str
-            let num = store.get("num")
-            if (typeof num === 'number') {
-                store.set('str', "x".repeat(num))
-            } else {
-                store.set('num', 0) // will call this observer recursively
-            }
-        })
-        immediateObserve(() => {  // str to num
-            let str = store.get('str')
-            if (typeof str === 'string') {
-                store.set('str', "x".repeat(str.length)) // replace str chars by 'x'
-                store.set('num', str.length) // may call this observer recursively
-            } else {
-                store.set('str', "") // will call this observer recursively
-            }
-        })
-        assertEqual(store.get(), {num: 1, str: 'x'})
-
-        store.set('num', 3)
-        assertEqual(store.get(), {num: 3, str: 'xxx'})
-
-        store.set('num', '')
-        assertEqual(store.get(), {num: 0, str: ''})
-
-        store.set('str', 'af123')
-        assertEqual(store.get(), {num: 5, str: 'xxxxx'})
-    })
-
-    it('stops when it goes out of scope', () => {
-        let store = new Store({a: 1})
-        observe(() => {
-            if (store.get('stop')) return
-            immediateObserve(() => {
-                store.set('b', store.get('a') * 2)
-            })
-        })
-        assertEqual(store.get('b'), 2)
-
-        store.set('a', 3)
-        assertEqual(store.get('b'), 6)
-
-        store.set('stop', true)
-        passTime() // allow the deferred observe to rerun, expiring the immediate observe
-
-        store.set('a', 5)
-        assertEqual(store.get('b'), 6)
-    })
-
-    it('throws an error if a loop does not stabilize', () => {
-        let store = new Store({a: 1})
-        immediateObserve(() => {
-            store.set('b', store.get('a') + 1)
-        })
-        // This will start an infinite recursion, which should be broken up.
-        immediateObserve(() => { 
-            store.set('a', store.get('b') + 1)
-        })
-        // The error for the above is to be thrown async.
-        assertThrow('recursive updates', () => {
-            passTime()
-        })
-    })
-})

package/tests/map.js

@@ -1,76 +0,0 @@
-describe('The map() and multiMap() methods', () => {
-    it('transforms Maps to Maps', () => {
-        let store = new Store(objToMap({a: 0, b: 2, c: 3}))
-        let cnt1 = 0, cnt2 = 0
-
-        mount(document.body, () => {
-            let out = store.map(s => {
-                cnt1++
-                if (s.get()) return s.get()*10
-            })
-
-            out.onEach(s => {
-                cnt2++
-                text(s.index()+"="+s.get())
-            }, s => s.index())
-        })
-
-        assertBody(`"b=20" "c=30"`)
-        assertEqual([cnt1, cnt2], [3, 2])
-
-        store.merge(objToMap({a: 1, c: undefined}))
-        passTime()
-        assertBody(`"a=10" "b=20"`)
-        assertEqual([cnt1, cnt2], [4, 3])
-    })
-    it('transforms Arrays to Objects', () => {
-        let store = new Store(['a', 'b'])
-        let cnt1 = 0, cnt2 = 0
-        let out
-
-        mount(document.body, () => {
-            out = store.multiMap(s => {
-                cnt1++
-                return {[s.get()]: s.index()}
-            })
-
-            out.onEach(s => {
-                cnt2++
-                text(s.index()+'='+s.get())
-            }, s => -s.get())
-        })
-
-        assertEqual(out.peek(), objToMap({a: 0, b: 1}))
-        assertBody(`"b=1" "a=0"`)
-        assertEqual([cnt1, cnt2], [2, 2])
-
-        store.set(0, 'A')
-        store.push('c')
-        passTime()
-        assertEqual(store.peek(), ['A', 'b', 'c'])
-        assertEqual(out.peek(), objToMap({A: 0, b: 1, c: 2}))
-        assertBody(`"c=2" "b=1" "A=0"`)
-        assertEqual([cnt1, cnt2], [4, 4])
-    })
-    it('transforms Objects to Maps', () => {
-        let store = new Store({a: {a:[]}, b: new Map([[1,2], [3,4]]), c: {c:5}, d: {}, e: 123})
-        let cnt1 = 0
-        let out
-
-        observe(() => {
-            out = store.multiMap(s => {
-                cnt1++
-                return s.get()
-            })
-        })
-
-        assertEqual(out.peek(), new Map([['a',[]], [1,2], [3,4], ['c',5]]))
-        assertEqual(cnt1, 5)
-
-        store.delete('b')
-        store.set('a', {})
-        passTime()
-        assertEqual(out.peek(), new Map([['c',5]]))
-        assertEqual(cnt1, 6)
-    })
-})

package/tests/objmap.js

@@ -1,40 +0,0 @@
-describe('Objects and maps', () => {
-    it('map fetches with a limited depth', () => {
-        let store = new Store(objToMap({a: {b: {c: {d: 42}}}}))
-        
-        let res = store.query({depth: 2, type: 'map'})
-        assertEqual(res.size, 1)
-        assertEqual(res.get('a').get('b').get(), objToMap({c: {d: 42}}))
-    })
-    it('merges maps collapsing changes', () => {
-        for(let converter of [objToMap, a=>a]) {
-            let store = new Store(converter({a: 1, b: 2, c: 3, d: undefined}))
-            assertEqual(store.count(), 3)
-            let cnt = 0
-            mount(document.body, () => {
-                cnt++
-                text(store.get('a')+store.get('a')+store.get('b'))
-                store.get()
-                store.get()
-            })
-            assertBody(`"4"`)
-
-            store.set(converter({a: 3, b: 4}))
-            passTime()
-            assertBody(`"10"`)
-            assertEqual(cnt, 2)
-
-            store.merge(converter({c: 4}))
-            passTime()
-            assertBody(`"10"`)
-            assertEqual(cnt, 3)
-
-            unmount()
-        }
-    })
-
-	it('handles invalid indexes', () => {
-		let store = new Store({})
-        assertThrow('Invalid object index', () => store.set(true, 1))
-	})
-})

package/tests/onEach.js

@@ -1,392 +0,0 @@
-describe('onEach', function() {
-
-	it('ignores undefined values', () => {
-		let cnt = 0
-		mount(document.body, () => {
-			let store = new Store()
-			store.onEach(() => cnt++)
-		})
-		assertEqual(cnt, 0)
-	})
-
-	it('handles unsuitable store values', () => {
-		for(let value of [3, "", false]) {
-			let cnt = 0
-			mount(document.body, () => {
-				let store = new Store(value)
-				assertThrow(`onEach() attempted`, () => {
-					store.onEach(() => cnt++)
-				})
-
-			})
-			assertEqual(cnt, 0, "cnt mismatch for "+JSON.stringify(value))
-		}
-	})
-
-	it('does nothing for an empty map', () => {
-		let cnt = 0
-		mount(document.body, () => {
-			let store = new Store({})
-			store.onEach(function() {
-				cnt++
-			})
-		})
-		assertEqual(cnt, 0)
-	})
-
-
-	it('emits a single entry', () => {
-		let result = []
-		mount(document.body, () => {
-			let store = new Store({x: 3})
-			store.onEach(function(store) {
-				result.push([store.index(),store.get()])
-			})
-		})
-		assertEqual(result, [['x', 3]])
-	})
-
-	it('emits multiple entries', () => {
-		let result = []
-		mount(document.body, () => {
-			let store = new Store({x: 3, y: 4, z: 5})
-			store.onEach(function(store) {
-				result.push([store.index(),store.get()])
-			})
-			// The order is undefined, so we'll sort it
-			result.sort((a,b) => a[1] - b[1])
-		})
-		assertEqual(result, [['x', 3], ['y', 4], ['z', 5]])
-	})
-
-	it('adds a single item to the DOM', () => {
-		mount(document.body, () => {
-			let store = new Store({x: 3})
-			store.onEach(function(store) {
-				node('p', {className: store.index()}, store.getNumber())
-			})
-		})
-		assertBody(`p{@class="x" "3"}`)
-	})
-
-	it('adds multiple items to the DOM in default order', () => {
-		mount(document.body, () => {
-			let store = new Store({c: 3, a: 1, b: 2})
-			store.onEach(function(store) {
-				node('p', store.index())
-			})
-		})
-		assertBody(`p{"a"} p{"b"} p{"c"}`)
-	})
-
-	it('maintains the last-element marker', () => {
-		mount(document.body, () => {
-			let store = new Store({c: 3, a: 1, b: 2})
-			store.onEach(function(store) {
-				node('p', store.index())
-			})
-			node('div')
-		})
-		assertBody(`p{"a"} p{"b"} p{"c"} div{}`)
-	})
-
-	it('maintains position for items', () => {
-		let store = new Store({0: false, 1: false, 2: false, 3: false})
-		let cnts = [0,0,0,0];
-		mount(document.body, () => {
-			store.onEach(item => {
-				cnts[item.index()]++;
-				if (item.getBoolean()) node('p', {id: item.index()})
-			})
-		})
-
-		assertBody(``);
-		assertEqual(cnts, [1,1,1,1]);
-
-		store.merge({1: true});
-		passTime();
-		assertBody(`p{@id="1"}`)
-		assertEqual(cnts, [1,2,1,1]);
-
-		store.merge({0: true, 2: true, 3: true});
-		passTime();
-		assertBody(`p{@id="0"} p{@id="1"} p{@id="2"} p{@id="3"}`)
-		assertEqual(cnts, [2,2,2,2]);
-	})
-
-	it('adds items in the right position', () => {
-		let store = new Store({});
-
-		mount(document.body, () => {
-			store.onEach(item => {
-				node(item.index())
-			})
-		})
-
-		let items = ['d', 'a', 'b', 'f', 'c', 'e'];
-		let seen = [];
-
-		for(let item of items) {
-			seen.push(item+'{}')
-			seen.sort();
-
-			store.set(item, true);
-			passTime()
-			assertBody(seen.join(' '))
-		}
-	})
-
-	it('removes items and calls cleaners', () => {
-		let items = ['d', 'a', 'b', 'f', 'c', 'e']
-		let store = new Store({})
-		for(let item of items) {
-			store.set(item, true)
-		}
-		let cleaned = [];
-
-		mount(document.body, () => {
-			store.onEach(item => {
-				node(item.index())
-				clean(() => {
-					cleaned.push(item.index())
-				});
-			})
-		})
-
-		let current = items.slice().sort();
-
-		let cleanedExpected = [];
-
-		for(let item of items) {
-			current.splice(current.indexOf(item), 1)
-			
-			store.merge({[item]: undefined});
-			cleanedExpected.push(item);
-			passTime()
-			assertBody(current.map(s => s+'{}').join(' '))
-			assertEqual(cleaned, cleanedExpected)
-		}
-	})
-
-	it(`removes an entire object and calls cleaners`, () => {
-		let cleaned = {};
-		let store = new Store({b:2,c:3,a:1})
-		let cnt = 0
-		mount(document.body, () => {
-			if (store.getType()==="object") {
-				store.onEach(item => {
-					cnt++
-					node(item.index())
-					clean(() => {
-						cleaned[item.index()] = true;
-					})
-				})
-			} else {
-				text(JSON.stringify(store.get()))
-			}
-		})
-		assertBody(`a{} b{} c{}`)
-		
-		store.set(true)
-		passTime()
-		assertBody(`"true"`)
-		assertEqual(cleaned, {a:true, b:true, c:true})
-		assertEqual(cnt, 3)
-	})
-
-	it('should ignore on delete followed by set', () => {
-		let store = new Store({a:1, b:2})
-		let cnt = 0
-		mount(document.body, () => {
-			store.onEach(item => {
-				node(item.index())
-				cnt++
-			})
-		})
-		assertBody(`a{} b{}`)
-		assertEqual(cnt, 2)
-
-		store.delete('a')
-		assertEqual(store.get(), {b: 2})
-		store.set('a', 3)
-		passTime()
-		assertBody(`a{} b{}`)
-		assertEqual(cnt, 2) // should not trigger again as the value is not subscribed
-	});
-
-	it('should do nothing on set followed by delete', () => {
-		let store = new Store({a:1})
-		let cnt = 0
-		mount(document.body, () => {
-			store.onEach(item => {
-				node(item.index())
-				cnt++
-			})
-		})
-		assertBody(`a{}`)
-		assertEqual(cnt, 1)
-
-		store.set('b', 2)
-		assertEqual(store.get(), {a: 1, b: 2})
-		store.delete('b')
-		passTime()
-		assertBody(`a{}`)
-		assertEqual(cnt, 1)
-	})
-
-	it(`should handle items with identical sort keys`, () => {
-		let store = new Store({a: 1, b: 1, c: 1, d: 1})
-		mount(document.body, () => {
-			store.onEach(item => {
-				node(item.index())
-			}, item => item.getNumber())
-		})
-		assertEqual(getBody().split(' ').sort().join(' '), `a{} b{} c{} d{}`)
-
-		store.delete('b')
-		passTime()
-		assertEqual(getBody().split(' ').sort().join(' '), `a{} c{} d{}`)
-
-		store.delete('d')
-		passTime()
-		assertEqual(getBody().split(' ').sort().join(' '), `a{} c{}`)
-
-		store.delete('a')
-		passTime()
-		assertEqual(getBody().split(' ').sort().join(' '), `c{}`)
-
-	})
-
-	it('keeps two onEaches in order', () => {
-		let store1 = new Store(['c1'])
-		let store2 = new Store(['c2'])
-		mount(document.body, () => {
-			store1.onEach(item => {
-				node(item.getString())
-			})
-			store2.onEach(item => {
-				node(item.getString())
-			}, item => item.getString())
-		})
-		assertBody(`c1{} c2{}`)
-		
-		store1.set(1, 'b1')
-		passTime()
-		assertBody(`c1{} b1{} c2{}`)
-
-		store2.set(['b2', 'c2', 'd2'])
-		passTime()
-		assertBody(`c1{} b1{} b2{} c2{} d2{}`)
-
-		store1.set([])
-		passTime()
-		assertBody(`b2{} c2{} d2{}`)
-
-		store2.set([])
-		passTime()
-		assertBody(``)
-
-		store2.set(['c2', 'b2'])
-		passTime()
-		assertBody(`b2{} c2{}`)
-
-		store1.set(['c1', 'b1'])
-		passTime()
-		assertBody(`c1{} b1{} b2{} c2{}`)
-	})
-	
-	it(`iterates arrays`, () => {
-		let store = new Store(['e', 'b', 'a', 'd'])
-		mount(document.body, () => {
-			store.onEach(item => {
-				node('h'+item.index())
-			})
-			store.onEach(item => {
-				node('i'+item.index())
-			}, item => item.getString())
-		})
-
-		assertBody(`h0{} h1{} h2{} h3{} i2{} i1{} i3{} i0{}`)
-
-		store.set(4,'c')
-
-		passTime()
-		assertBody(`h0{} h1{} h2{} h3{} h4{} i2{} i1{} i4{} i3{} i0{}`)
-	})
-
-	it(`iterates arrays that are pushed into`, () => {
-		let store = new Store(['e', 'b', 'a', 'd'])
-		mount(document.body, () => {
-			store.onEach(item => {
-				node('h'+item.index())
-			})
-			store.onEach(item => {
-				node('i'+item.index())
-			}, item => item.getString())
-		})
-
-		store.push('c')
-		
-		passTime()
-		assertBody(`h0{} h1{} h2{} h3{} h4{} i2{} i1{} i4{} i3{} i0{}`) 
-	})
-
-	it(`removes all children before redrawing`, () => {
-		let store = new Store({a:1, b:2})
-		let select = new Store(1)
-		mount(document.body, () => {
-			select.get();
-			store.onEach(item => {
-				node(item.index())
-			}, item => {
-				if (select.get() == item.get()) {
-					return item.index();
-				}
-			})
-		})
-		assertBody(`a{}`) 
-
-		select.set('2')
-		passTime()
-		assertBody(`b{}`) 
-	})
-
-	it('should handle items that don\'t create DOM elements', () => {
-		let store = new Store("b0 b1 c1 b2 c0 a1 a0 a2".split(" "))
-		mount(document.body, () => {
-			store.onEach(item => {
-				let letter = item.get()[0]
-				let count = 0 | item.get()[1]
-				for(let i=0; i<count; i++) {
-					text(item.index()+letter)
-				}
-			}, item => item.get()[0])
-		})
-		assertBody(`"7a" "7a" "5a" "3b" "3b" "1b" "2c"`) // The order within the same letter is unspecified
-
-		store.set(5, undefined)
-		store.set(3, undefined)
-		passTime()
-		assertBody(`"7a" "7a" "1b" "2c"`) // The order within the same letter is unspecified
-
-		store.set(0, undefined)
-		store.set(4, undefined)
-		store.set(6, undefined)
-		passTime()
-		assertBody(`"7a" "7a" "1b" "2c"`) // The order within the same letter is unspecified
-	})
-
-	it('filters when there is no sort key', () => {
-		let store = new Store(['a','b','c'])
-		mount(document.body, () => {
-			store.onEach(item => {
-				node(item.get())
-			}, item => item.get()=='b' ? undefined : item.get())
-		})
-		assertBody(`a{} c{}`)
-		
-		store.set([])
-		passTime()
-		assertBody(``)
-	})
-})

package/tests/prediction.js

@@ -1,97 +0,0 @@
-describe('Prediction', function() {
-
-    it('reverts', () => {
-        let store = new Store('a')
-		mount(document.body, () => {
-            node(store.get())
-		})
-		assertBody(`a{}`)
-
-        let prediction = applyPrediction(() => store.set('b'))
-        passTime()
-		assertBody(`b{}`)
-
-        applyCanon(undefined, [prediction])
-        passTime()
-		assertBody(`a{}`)
-
-        // Doing this again shouldn't break anything
-        applyCanon(undefined, [prediction])
-        passTime()
-		assertBody(`a{}`)
-    });
-
-    it('reverts entire patch when it can no longer apply', () => {
-        let store = new Store({1: 'a', 2: 'x', 3: 'm'})
-		mount(document.body, () => {
-            node(store.get(1))
-            node(store.get(2))
-            node(store.get(3))
-		})
-		assertBody(`a{} x{} m{}`)
-
-        // This prediction should be flushed out due to conflict
-        applyPrediction(() => store.merge({1: 'b', 2: 'y'}))
-        passTime()
-		assertBody(`b{} y{} m{}`)
-
-        // This prediction should be kept
-        applyPrediction(() => store.set(3, 'n'))
-        passTime()
-		assertBody(`b{} y{} n{}`)
-
-        // Create the conflict
-        applyCanon(() => {
-            // Check that state was reverted to pre-predictions
-            assertEqual(store.get(1), 'a')
-            store.set(1, 'c')
-        })
-
-        // Check that only the first prediction has been reverted as a whole
-        passTime()
-		assertBody(`c{} x{} n{}`)
-    });
-
-    it('forcibly reverts to canon state', () => {
-        let store = new Store('a')
-		mount(document.body, () => {
-            node(store.get())
-		})
-		assertBody(`a{}`)
-
-        let prediction = applyPrediction(() => store.set('b'))
-        passTime()
-		assertBody(`b{}`)
-
-        store.set('z')
-
-        applyCanon(undefined, [prediction])
-
-        // An error should be thrown asynchronously
-        assertThrow('Error', () => {
-            passTime()
-        })
-		assertBody(`a{}`)
-    })
-
-    it('does not cause redraw when it comes true', () => {
-        let store = new Store('a')
-        let draws = 0
-		mount(document.body, () => {
-            node(store.get())
-            draws++
-		})
-		assertBody(`a{}`)
-        assertEqual(draws, 1)
-
-        let prediction = applyPrediction(() => store.set('b'))
-        passTime()
-		assertBody(`b{}`)
-        assertEqual(draws, 2)
-
-        applyCanon(() => store.set('b'), [prediction])
-        passTime()
-		assertBody(`b{}`)
-        assertEqual(draws, 2)
-    })
-})