Add more tests and clean lint..

Author: Ramesh VK

README.md

@@ -779,10 +779,9 @@ readable ISO string.  `Unwrap` returns this value too (though
     - ~streams.wrap support~
     - ~PathChange change type~
     - ~fields accessible using dot notation~
-6. Collections
+6. ~Collections~
     - ~map, order, orderBy, filter, groupBy~
-    - comprehensive tests
-7. Composition
+7. ~Composition~
     - ~watch, object, merge~
 8. ~Collaboration~
     - ~merge support in change types~
@@ -792,10 +791,12 @@ readable ISO string.  `Unwrap` returns this value too (though
     - multiple tabs support
     - add merge tests
 9. Branch merge support
-10. Server DB support
-11. Mutable collections support
-    - map
-    - filter
+10. Server support
+    - snapshots
+    - db storage
+    - expose writeable streams via store API
+11. ~Mutable collections support~
+    - ~order, orderBy, filter, groupBy~
 12. ~Mutable composition support~
     - ~object~
     - ~merge~

es6/changes.js

@@ -16,7 +16,7 @@ export function buildChanges(types) {
     }
 
     merge(other, older) {
-      const reuslt = [];
+      const result = [];
       for (let kk = 0; kk < this.changes.length; kk++) {
         const c = this.changes[kk];
         if (!c) continue;

es6/child_stream.js

@@ -7,8 +7,8 @@ export function buildChildStream(types) {
       this.key = key;
     }
 
-    withRef(r) {
-      throw new Error("Cannot set ref on a derived stream");
+    withRef(_r) {
+      throw new Error("NYI");
     }
 
     ref() {

es6/group.js

@@ -6,7 +6,6 @@ export function buildGroup(types) {
     return types.wrap(stream.groups, stream);
   };
 
-  const valueOf = x => x && x.valueOf();
   function group(v, fn) {
     const result = {};
     v = (v && v.valueOf()) || {};
@@ -54,7 +53,8 @@ export function buildGroup(types) {
     append(c, older) {
       if (c === null) return this;
 
-      // TODO: handle keycounts cleanups
+      // TODO: handle case when last elt of group is deleted
+      // (the whole group should also be deleted)
       const changes = new types.ChangeBuilder();
       c.visit([], {
         replace: (path, cx) => {
@@ -91,7 +91,6 @@ export function buildGroup(types) {
       let current = this.s.valueOf();
       let keycounts = counts(this.groups);
 
-      console.log("Counts", keycounts);
       c.visit([], {
         replace: (path, cx) => {
           const updated = new types.PathChange(path, cx).apply(current);
@@ -109,11 +108,9 @@ export function buildGroup(types) {
             const changed = "" + beforeGroup !== "" + afterGroup;
             if (existed && (!exists || changed)) {
               keycounts[beforeGroup]--;
-              console.log("Decrementing", beforeGroup);
               const r = new types.Replace(current[key], null);
               changes.replace(["" + beforeGroup, key], r);
               if (keycounts[beforeGroup] === 0) {
-                console.log("Removing", beforeGroup, key);
                 const rx = new types.Replace({}, null);
                 changes.replace(["" + beforeGroup], rx);
               }

es6/test/filter_test.js

@@ -7,16 +7,44 @@ import { wrap, filter } from "../main.js";
 
 describe("filter", function() {
   it("filters", () => {
-    const s = {};
-    const size = 1000;
-    for (let kk = 0; kk < size; kk++) {
-      s[kk] = kk;
-    }
-    const filtered = filter(wrap(s), v => v < 10);
-    let count = 0;
-    filtered.forEachKey(key => {
-      count++;
-    });
-    expect(count).to.equal(10);
+    const s = wrap({ hello: 4, world: 3, ok: 2 });
+    const f = filter(s, v => v % 2 === 0);
+
+    expect(f.valueOf()).to.deep.equal({ hello: 4, ok: 2 });
+  });
+
+  it("tracks changes", () => {
+    const s = wrap({ hello: 4, world: 3, ok: 2 });
+    let f = filter(s, v => v % 2 === 0);
+
+    expect(f.valueOf()).to.deep.equal({ hello: 4, ok: 2 });
+
+    s.hello.replace(9);
+    f = f.latest();
+    expect(f.valueOf()).to.deep.equal({ ok: 2 });
+  });
+
+  it("updates", () => {
+    let s = wrap({ hello: 4, world: 3, ok: 2 });
+    let f = filter(s, v => v % 2 === 0);
+
+    expect(f.valueOf()).to.deep.equal({ hello: 4, ok: 2 });
+    f.hello.replace(9);
+
+    f = f.latest();
+    s = s.latest();
+    expect(f.valueOf()).to.deep.equal({ ok: 2 });
+    expect(s.valueOf()).to.deep.equal({ hello: 9, world: 3, ok: 2 });
+  });
+
+  it("updates #2", () => {
+    let s = wrap({ hello: 4, world: 3, ok: 2 });
+    let f = filter(s, v => v % 2 === 0);
+
+    expect(f.valueOf()).to.deep.equal({ hello: 4, ok: 2 });
+    f.replace(null);
+
+    s = s.latest();
+    expect(s.valueOf()).to.deep.equal({ world: 3 });
   });
 });

es6/test/map_test.js

@@ -75,4 +75,13 @@ describe("map", () => {
     const c = new PathChange(["last"], new Replace("SCHMOE", "DOE"));
     expect(mapped.nextChange()).to.deep.equal(c);
   });
+
+  it("handles deep changes", () => {
+    let x = wrap({ first: { second: 5 } });
+    let mapped = map(x, val => val.second);
+
+    expect(JSON.stringify(mapped)).to.equal(`{"first":5}`);
+    x.first.second.replace(7);
+    expect(JSON.stringify(mapped.latest())).to.equal(`{"first":7}`);
+  });
 });

es6/test/order_test.js

@@ -3,25 +3,34 @@
 /* eslint-env mocha, browser */
 
 import { expect } from "./expect.js";
-import { wrap, order, PathChange, Replace } from "../main.js";
+import { wrap, order, orderBy } from "../main.js";
 
 describe("order", () => {
+  function keys(s) {
+    const result = [];
+    s.forEachKey(key => result.push(key) && false);
+    return result;
+  }
+
   it("wraps dict", () => {
     let s = wrap({ hello: 42, ok: 33 });
-    let o = order(s, (list, x, y) => list[x] - list[y]);
+    let o = order(s, (x, y) => x - y);
 
     expect(JSON.stringify(s)).to.equal(JSON.stringify(o));
     expect(o.exists("hello")).to.equal(true);
     expect(o.withRef(["boo"]).ref()).to.deep.equal(["boo"]);
+
+    expect(keys(o)).to.deep.equal(["ok", "hello"]);
   });
 
   it("tracks dict", () => {
     let s = wrap({ hello: 42, ok: 33 });
-    let o = order(s, (list, x, y) => list[x] - list[y]);
+    let o = order(s, (x, y) => x - y);
 
     s.hello.replace(22);
 
     expect(s.nextChange()).to.deep.equal(o.nextChange());
+    expect(keys(o.latest())).to.deep.equal(["hello", "ok"]);
 
     s = s.next();
     o = o.next();
@@ -31,11 +40,12 @@ describe("order", () => {
 
   it("writes through changes #1", () => {
     let s = wrap({ hello: 42, ok: 33 });
-    let o = order(s, (list, x, y) => list[x] - list[y]);
+    let o = order(s, (x, y) => x - y);
 
     o.hello.replace(22);
 
     expect(s.nextChange()).to.deep.equal(o.nextChange());
+    expect(keys(o.latest())).to.deep.equal(["hello", "ok"]);
 
     s = s.next();
     o = o.next();
@@ -45,11 +55,12 @@ describe("order", () => {
 
   it("writes through changes #2", () => {
     let s = wrap({ hello: 42, ok: 33 });
-    let o = order(s, (list, x, y) => list[x] - list[y]);
+    let o = order(s, (x, y) => x - y);
 
     o.replace({ hello: 22, ok: 33 });
 
     expect(s.nextChange()).to.deep.equal(o.nextChange());
+    expect(keys(o.latest())).to.deep.equal(["hello", "ok"]);
 
     s = s.next();
     o = o.next();
@@ -59,15 +70,27 @@ describe("order", () => {
 
   it("writes through changes #3", () => {
     let s = wrap({ hello: 42, ok: 33 });
-    let o = order(s, (list, x, y) => list[x] - list[y]);
+    let o = order(s, (x, y) => x - y);
 
     o.replacePath(["hello"], 22);
 
     expect(s.nextChange()).to.deep.equal(o.nextChange());
+    expect(keys(o.latest())).to.deep.equal(["hello", "ok"]);
 
     s = s.next();
     o = o.next();
 
     expect(JSON.stringify(s)).to.equal(JSON.stringify(o));
   });
+
+  it("sorts with orderBy", () => {
+    let s = wrap({ hello: 42, ok: 33 });
+    let o = orderBy(s, x => x);
+
+    expect(JSON.stringify(s)).to.equal(JSON.stringify(o));
+    expect(o.exists("hello")).to.equal(true);
+    expect(o.withRef(["boo"]).ref()).to.deep.equal(["boo"]);
+
+    expect(keys(o)).to.deep.equal(["ok", "hello"]);
+  });
 });