braid-text 0.1.3 → 0.1.4

package/README.md

@@ -176,3 +176,28 @@ simpleton = simpleton_client(url, options)
   - `content_type`: <small style="color:lightgrey">[optional]</small> If set, this value will be sent in the `Accept` and `Content-Type` headers to the server.
 
 - `simpleton.changed()`: Call this function to report local updates whenever they occur, e.g., in the `oninput` event handler of a textarea being synchronized.
+
+## Testing
+
+### to run unit tests:
+first run the demo server as usual:
+
+    npm install
+    node server-demo.js
+
+then open http://localhost:8888/test.html, and the boxes should turn green as the tests pass.
+
+### to run fuzz tests:
+
+    npm install
+    node test.js
+
+if the last output line looks like this, good:
+
+    t = 9999, seed = 1397019, best_n = Infinity @ NaN
+
+but it's bad if it looks like this:
+
+    t = 9999, seed = 1397019, best_n = 5 @ 1396791
+
+the number at the end is the random seed that generated the simplest error example

package/index.js

@@ -304,6 +304,19 @@ braid_text.forget = async (key, options) => {
 braid_text.put = async (key, options) => {
     let { version, patches, body, peer } = options
 
+    // support for json patch puts..
+    if (patches?.length && patches.every(x => x.unit === 'json')) {
+        let resource = (typeof key == 'string') ? await get_resource(key) : key
+        
+        let x = JSON.parse(resource.doc.get())
+        for (let p of patches)
+            apply_patch(x, p.range, JSON.parse(p.content))
+
+        return await braid_text.put(key, {
+            body: JSON.stringify(x, null, 4)
+        })
+    }
+
     if (version) validate_version_array(version)
 
     // translate a single parent of "root" to the empty array (same meaning)
@@ -1618,6 +1631,84 @@ function createSimpleCache(size) {
     }
 }
 
+function apply_patch(obj, range, content) {
+
+    // Descend down a bunch of objects until we get to the final object
+    // The final object can be a slice
+    // Set the value in the final object
+
+    var path = range,
+        new_stuff = content
+
+    var path_segment = /^(\.?([^\.\[]+))|(\[((-?\d+):)?(-?\d+)\])|\[("(\\"|[^"])*")\]/
+    var curr_obj = obj,
+        last_obj = null
+
+    // Handle negative indices, like "[-9]" or "[-0]"
+    function de_neg (x) {
+        return x[0] === '-'
+            ? curr_obj.length - parseInt(x.substr(1), 10)
+            : parseInt(x, 10)
+    }
+
+    // Now iterate through each segment of the range e.g. [3].a.b[3][9]
+    while (true) {
+        var match = path_segment.exec(path),
+            subpath = match ? match[0] : '',
+            field = match && match[2],
+            slice_start = match && match[5],
+            slice_end = match && match[6],
+            quoted_field = match && match[7]
+
+        // The field could be expressed as ["nnn"] instead of .nnn
+        if (quoted_field) field = JSON.parse(quoted_field)
+
+        slice_start = slice_start && de_neg(slice_start)
+        slice_end = slice_end && de_neg(slice_end)
+
+        // console.log('Descending', {curr_obj, path, subpath, field, slice_start, slice_end, last_obj})
+
+        // If it's the final item, set it
+        if (path.length === subpath.length) {
+            if (!subpath) return new_stuff
+            else if (field) {                           // Object
+                if (new_stuff === undefined)
+                    delete curr_obj[field]              // - Delete a field in object
+                else
+                    curr_obj[field] = new_stuff         // - Set a field in object
+            } else if (typeof curr_obj === 'string') {  // String
+                console.assert(typeof new_stuff === 'string')
+                if (!slice_start) {slice_start = slice_end; slice_end = slice_end+1}
+                if (last_obj) {
+                    var s = last_obj[last_field]
+                    last_obj[last_field] = (s.slice(0, slice_start)
+                                            + new_stuff
+                                            + s.slice(slice_end))
+                } else
+                    return obj.slice(0, slice_start) + new_stuff + obj.slice(slice_end)
+            } else                                     // Array
+                if (slice_start)                       //  - Array splice
+                    [].splice.apply(curr_obj, [slice_start, slice_end-slice_start]
+                                    .concat(new_stuff))
+            else {                                     //  - Array set
+                console.assert(slice_end >= 0, 'Index '+subpath+' is too small')
+                console.assert(slice_end <= curr_obj.length - 1,
+                               'Index '+subpath+' is too big')
+                curr_obj[slice_end] = new_stuff
+            }
+
+            return obj
+        }
+
+        // Otherwise, descend down the path
+        console.assert(!slice_start, 'No splices allowed in middle of path')
+        last_obj = curr_obj
+        last_field = field || slice_end
+        curr_obj = curr_obj[last_field]
+        path = path.substr(subpath.length)
+    }
+}
+
 braid_text.encode_filename = encode_filename
 braid_text.decode_filename = decode_filename
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "braid-text",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Library for collaborative text over http using braid.",
   "author": "Braid Working Group",
   "repository": "braid-org/braidjs",

package/server-demo.js

@@ -34,6 +34,12 @@ var server = require("http").createServer(async (req, res) => {
         return
     }
 
+    if (req.url == '/test.html') {
+        res.writeHead(200, { "Content-Type": "text/html", "Cache-Control": "no-cache" })
+        require("fs").createReadStream("./test.html").pipe(res)
+        return
+    }
+
     // TODO: uncomment out the code below to add /pages endpoint,
     // which displays all the currently used keys
     // 

package/test.html

@@ -0,0 +1,118 @@
+<style>
+    body {
+        font-family: Arial, sans-serif;
+        max-width: 800px;
+        margin: 0 auto;
+        padding: 10px;
+    }
+    .test {
+        margin-bottom: 3px;
+        padding: 3px;
+    }
+    .running {
+        background-color: #fffde7;
+    }
+    .passed {
+        background-color: #e8f5e9;
+    }
+    .failed {
+        background-color: #ffebee;
+    }
+</style>
+<script src="https://unpkg.com/braid-http@~1.1/braid-http-client.js"></script>
+<div id="testContainer"></div>
+<script type=module>
+
+let delay = 0
+
+function createTestDiv(testName) {
+    const div = document.createElement("div")
+    div.className = "test running"
+    div.innerHTML = `<span style="font-weight:bold">${testName}: </span><span class="result">Running...</span>`
+    testContainer.appendChild(div)
+    return div
+}
+
+function updateTestResult(div, passed, message, got, expected) {
+    div.className = `test ${passed ? "passed" : "failed"}`
+    
+    if (passed) {
+        div.querySelector(".result").textContent = message
+        div.querySelector(".result").style.fontSize = message.length > 400 ? 'xx-small' : message.length > 100 ? 'small' : ''
+    } else {
+        div.querySelector(".result").innerHTML = `${message}<br><strong>Got:</strong> ${got}<br><strong>Expected:</strong> ${expected}`
+    }
+}
+
+async function runTest(testName, testFunction, expectedResult) {
+    delay += 70
+
+    await new Promise(done => setTimeout(done, delay))
+    const div = createTestDiv(testName)
+    try {
+        let x = await testFunction()
+        if (x == expectedResult) {
+            updateTestResult(div, true, x)
+        } else {
+            updateTestResult(div, false, "Mismatch:", x, expectedResult)
+        }
+    } catch (error) {
+        updateTestResult(div, false, "Error:", error.message || error, expectedResult)
+    }
+}
+
+runTest(
+    "test sending a json patch to some json-text",
+    async () => {
+        let key = 'test-' + Math.random().toString(36).slice(2)
+
+        await fetch(`/${key}`, {
+            method: 'PUT',
+            body: JSON.stringify({a: 5, b: 6})
+        })
+
+        await fetch(`/${key}`, {
+            method: 'PUT',
+            headers: { 'Content-Range': 'json a' },
+            body: '67'
+        })
+
+        let r = await fetch(`/${key}`)
+
+        return await r.text()
+    },
+    JSON.stringify({a: 67, b: 6}, null, 4)
+)
+
+runTest(
+    "test sending multiple json patches to some json-text",
+    async () => {
+        let key = 'test-' + Math.random().toString(36).slice(2)
+
+        await fetch(`/${key}`, {
+            method: 'PUT',
+            body: JSON.stringify({a: 5, b: 6, c: 7})
+        })
+
+        await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            headers: { 'Content-Range': 'json a' },
+            patches: [{
+                unit: 'json',
+                range: 'a',
+                content: '55',
+            }, {
+                unit: 'json',
+                range: 'b',
+                content: '66',
+            }]
+        })
+
+        let r = await fetch(`/${key}`)
+
+        return await r.text()
+    },
+    JSON.stringify({a: 55, b: 66, c: 7}, null, 4)
+)
+
+</script>