Almost complete test coverage

Author: danielearwicker

.gitignore

@@ -1,2 +1,3 @@
 node_modules
 built
+coverage

.vscode/launch.json

@@ -8,7 +8,7 @@
             "type": "node",
             "request": "launch",
             "name": "Launch Program",
-            "program": "${workspaceRoot}/built/test/arrays.js",
+            "program": "${workspaceRoot}/built/test/polymorph.js",
             "cwd": "${workspaceRoot}",
             "outFiles": []
         },

fix-coverage.js

@@ -0,0 +1,15 @@
+const fs = require("fs"),
+      path = require("path"),
+      under = "built/src",
+      prefixes = ["var __decorate =", "var __assign ="];
+
+// tell istanbul to ignore TS-generated decorator code 
+
+fs.readdirSync(under).forEach(file => {
+    file = path.join(under, file);
+    let src = fs.readFileSync(file, "utf8");
+    prefixes.forEach(prefix => {
+        src = src.replace(prefix, "/* istanbul ignore next */\n" + prefix);
+    });    
+    fs.writeFileSync(file, src);
+});

package.json

@@ -1,13 +1,13 @@
 {
   "name": "json-mobx",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Simple undo/redo and persistence for MobX",
   "main": "built/index.js",
   "types": "built/index.d.ts",
   "scripts": {
     "build": "tsc",
     "test": "tape built/test/**/*.js",
-    "coverage": "istanbul cover tape built/test/**/*.js",
+    "coverage": "node fix-coverage.js && istanbul cover tape built/test/**/*.js",
     "prepublish": "npm run build && npm run test",
     "all": "npm run build && npm run test && npm run coverage"
   },

src/array.ts

@@ -0,0 +1,122 @@
+import { getOrCreateComputed, isArray, save, load } from "./core";
+
+import { observable } from "mobx";
+import { Disposable } from "./Disposable";
+
+const arrayItemIdKey = "<id>";
+
+export function getArrayItemId(item: any) {
+    return (item && typeof item === "object" && item[arrayItemIdKey]) || 0;
+}
+
+function setArrayItemId(item: any, id: number) {
+    if (item && typeof item === "object") {
+        item[arrayItemIdKey] = id;
+    }
+}
+
+function setArrayItemIds(ar: any[]) {
+    let nextId = 1;
+    const usedIds: { [id: string]: boolean } = {};
+    
+    // First pass - clear IDs that are duplicates
+    for (const item of ar) {
+        const id = getArrayItemId(item);
+        if (id) {
+            nextId = Math.max(nextId, id + 1);
+
+            if (usedIds[id]) {
+                setArrayItemId(item, 0);
+            } else {
+                usedIds[id] = true;
+            }        
+        }
+    }
+
+    // Second pass - allocate IDs
+    for (const item of ar) {
+        const id = getArrayItemId(item);
+        if (!id) {
+            setArrayItemId(item, nextId++);
+        }
+    }
+}
+
+function saveArrayItem(item: any) {
+    return { ...save(item), [arrayItemIdKey]: getArrayItemId(item) };
+}
+
+function getArrayJsonComputed(ar: any[], itemFactory: () => any) {
+
+    return getOrCreateComputed(ar, "<json>", () => ({
+
+        get() {
+            setArrayItemIds(ar);
+            return ar.map(saveArrayItem);        
+        },
+
+        set(data: any) {
+            if (!isArray(data)) {
+                ar.length = 0; // most likely schema has changed
+                return;
+            }
+
+            // Build map of existing items by ID
+            const existing: { [id: string]: any } = {};
+            for (const item of ar) {
+                const id = getArrayItemId(item);
+                if (!existing[id]) {
+                    existing[id] = item;    
+                }            
+            }
+
+            // Bring into line with supplied data
+            ar.length = data.length;
+            
+            for (let i = 0; i < data.length; i++) {
+                const itemJson = data[i];
+                const itemId = getArrayItemId(itemJson);
+
+                // Reuse existing item with same id
+                let item = existing[itemId];
+                if (item) {
+                    delete existing[itemId];
+                } else {
+                    item = itemFactory();
+                    setArrayItemId(item, itemId);
+                }
+
+                load(item, itemJson);            
+                ar[i] = item;
+            }
+        
+            // Dispose any items not reused
+            for (const key of Object.keys(existing)) {
+                const item = existing[key];
+                if (item.dispose) {
+                    item.dispose();
+                }
+            }
+        }
+    }));
+}
+
+export function array<T extends Partial<Disposable>>(factory: () => T): T[] {
+
+    const result: T[] = observable([]);
+
+    Object.defineProperty(result, "json", {
+        get(this: any) {
+            return getArrayJsonComputed(this, factory).get();
+        },
+        set(this: any, data: any) {
+            getArrayJsonComputed(this, factory).set(data);
+        }
+    });
+
+    return result;
+}
+
+export function arrayOf<T extends Partial<Disposable>>(ctor: new() => T): T[] {
+    return array(() => new ctor());
+}

src/core.ts

@@ -0,0 +1,53 @@
+import { computed, IComputedValue, isObservableArray } from "mobx";
+
+export function getOrCreateComputed(obj: any, key: string, options: () => { get(): any; set(data: any): void }) {
+    let result: IComputedValue<any>;
+    if (!Object.prototype.hasOwnProperty.call(obj, key)) {
+        const { get, set } = options();
+        obj[key] = result = computed(get, set);
+    } else {
+        result = obj[key];
+    }
+    return result;
+}
+
+export function isArray(obj: any) {
+    return Array.isArray(obj) || isObservableArray(obj);
+}
+
+export function hasJsonProperty(obj: any) {
+    return obj && typeof obj === "object" && ("json" in obj);
+}
+
+export function canLoadInto(obj: any) {
+    return hasJsonProperty(obj) || (obj && isArray(obj));
+}
+
+export function save(obj: any): any {    
+    return hasJsonProperty(obj) ? obj.json : obj;
+}
+
+export function load(obj: any, data: any) {
+    if (data === "undefined" || !obj) {
+        return;
+    }
+
+    if (!canLoadInto(obj)) {
+        throw new Error("Can only load JSON into an object with a json property, or an array");
+    }
+
+    if (hasJsonProperty(obj)) {
+        obj.json = data;
+        return;
+    }
+
+    if (isArray(obj)) {
+        // Plain array data, so just replace everything
+        if (isArray(data)) {            
+            obj.splice.apply(obj, [0, obj.length].concat(data));
+        } else {
+            obj.length = 0;
+        }
+        return;
+    }
+}