Changeset: Migrate from mergingOpAssembler() to squashOps()

Author: rhansen

CHANGELOG.md

@@ -45,6 +45,8 @@
       generator function. Also, the unused start index parameter has been
       removed, as has the unused `lastIndex()` method on the returned object.
     * `opAssembler()`: Deprecated in favor of the new `serializeOps()` function.
+    * `mergingOpAssembler()`: Deprecated in favor of the new `squashOps()`
+      generator function (combined with `serializeOps()`).
     * `smartOpAssembler()`: The returned object's `appendOpWithText()` method is
       deprecated without a replacement available to plugins (if you need one,
       let us know and we can make the private `opsFromText()` function public).

src/static/js/Changeset.js

@@ -356,7 +356,7 @@ class OpAssembler {
  * @yields {Op} The squashed operations.
  * @returns {Generator<Op>}
  */
-const squashOps = function* (ops, finalize) {
+exports.squashOps = function* (ops, finalize) {
   let prevOp = new Op();
   // If we get, for example, insertions [xxx\n,yyy], those don't merge, but if we get
   // [xxx\n,yyy,zzz\n], that merges to [xxx\nyyyzzz\n]. This variable stores the length of yyy and
@@ -415,7 +415,7 @@ class MergingOpAssembler {
   }
 
   _serialize(finalize) {
-    this._serialized = exports.serializeOps(squashOps(this._ops, finalize));
+    this._serialized = exports.serializeOps(exports.squashOps(this._ops, finalize));
   }
 
   clear() {
@@ -458,14 +458,14 @@ const canonicalizeOps = function* (ops, finalize) {
   let lengthChange = 0;
 
   const flushPlusMinus = function* () {
-    yield* squashOps(minusOps, false);
+    yield* exports.squashOps(minusOps, false);
     minusOps = [];
-    yield* squashOps(plusOps, false);
+    yield* exports.squashOps(plusOps, false);
     plusOps = [];
   };
 
   const flushKeeps = function* (finalize) {
-    yield* squashOps(keepOps, finalize);
+    yield* exports.squashOps(keepOps, finalize);
     keepOps = [];
   };
 
@@ -646,9 +646,13 @@ exports.checkRep = (cs) => {
 exports.smartOpAssembler = () => new SmartOpAssembler();
 
 /**
+ * @deprecated Use `squashOps` with `serializeOps` instead.
  * @returns {MergingOpAssembler}
  */
-exports.mergingOpAssembler = () => new MergingOpAssembler();
+exports.mergingOpAssembler = () => {
+  warnDeprecated('Changeset.mergingOpAssembler() is deprecated; use Changeset.squashOps() instead');
+  return new MergingOpAssembler();
+};
 
 /**
  * @deprecated Use `serializeOps` instead.
@@ -1384,16 +1388,16 @@ exports.mutateAttributionLines = (cs, lines, pool) => {
     lineOpsNext = lineOps.next();
     return op;
   };
-  let lineAssem = null;
+  let lineOps = null;
 
   const outputMutOp = (op) => {
-    if (!lineAssem) lineAssem = new MergingOpAssembler();
-    lineAssem.append(op);
+    if (lineOps == null) lineOps = [];
+    lineOps.push(op);
     if (op.lines <= 0) return;
     assert(op.lines === 1, `Can't have op.lines of ${op.lines} in attribution lines`);
     // ship it to the mut
-    mut.insert(lineAssem.toString(), 1);
-    lineAssem = null;
+    mut.insert(exports.serializeOps(exports.squashOps(lineOps, false)), 1);
+    lineOps = null;
   };
 
   let csOp = new Op();
@@ -1403,10 +1407,10 @@ exports.mutateAttributionLines = (cs, lines, pool) => {
       csOp = csOpsNext.value;
       csOpsNext = csOps.next();
     }
-    if (!csOp.opcode && !attOp.opcode && !lineAssem && !lineOpsHasNext()) {
+    if (!csOp.opcode && !attOp.opcode && lineOps == null && !lineOpsHasNext()) {
       break; // done
     } else if (csOp.opcode === '=' && csOp.lines > 0 && !csOp.attribs && !attOp.opcode &&
-               !lineAssem && !lineOpsHasNext()) {
+               lineOps == null && !lineOpsHasNext()) {
       // skip multiple lines; this is what makes small changes not order of the document size
       mut.skipLines(csOp.lines);
       csOp.opcode = '';
@@ -1430,7 +1434,7 @@ exports.mutateAttributionLines = (cs, lines, pool) => {
     }
   }
 
-  assert(!lineAssem, `line assembler not finished:${cs}`);
+  assert(lineOps == null, `line assembler not finished: ${cs}`);
   mut.close();
 };
 
@@ -1441,23 +1445,22 @@ exports.mutateAttributionLines = (cs, lines, pool) => {
  * @returns {string} joined Attribution lines
  */
 exports.joinAttributionLines = (theAlines) => {
-  const assem = new MergingOpAssembler();
-  for (const aline of theAlines) {
-    for (const op of exports.deserializeOps(aline)) assem.append(op);
-  }
-  return assem.toString();
+  const ops = (function* () {
+    for (const aline of theAlines) yield* exports.deserializeOps(aline);
+  })();
+  return exports.serializeOps(exports.squashOps(ops, false));
 };
 
 exports.splitAttributionLines = (attrOps, text) => {
-  const assem = new MergingOpAssembler();
+  let ops = [];
   const lines = [];
   let pos = 0;
 
   const appendOp = (op) => {
-    assem.append(op);
+    ops.push(op);
     if (op.lines > 0) {
-      lines.push(assem.toString());
-      assem.clear();
+      lines.push(exports.serializeOps(exports.squashOps(ops, false)));
+      ops = [];
     }
     pos += op.chars;
   };

src/static/js/changesettracker.js

@@ -153,27 +153,27 @@ const makeChangesetTracker = (scheduler, apool, aceCallbacksProvider) => {
 
           // Replace all added 'author' attribs with the value of the current user
           const cs = Changeset.unpack(userChangeset);
-          const assem = Changeset.mergingOpAssembler();
-
-          for (const op of Changeset.deserializeOps(cs.ops)) {
-            if (op.opcode === '+') {
-              let newAttrs = '';
-
-              op.attribs.split('*').forEach((attrNum) => {
-                if (!attrNum) return;
-                const attr = apool.getAttrib(parseInt(attrNum, 36));
-                if (!attr) return;
-                if ('author' === attr[0]) {
-                  // replace that author with the current one
-                  newAttrs += `*${authorAttr}`;
-                } else { newAttrs += `*${attrNum}`; } // overtake all other attribs as is
-              });
-              op.attribs = newAttrs;
+          const ops = (function* () {
+            for (const op of Changeset.deserializeOps(cs.ops)) {
+              if (op.opcode === '+') {
+                let newAttrs = '';
+
+                op.attribs.split('*').forEach((attrNum) => {
+                  if (!attrNum) return;
+                  const attr = apool.getAttrib(parseInt(attrNum, 36));
+                  if (!attr) return;
+                  if ('author' === attr[0]) {
+                    // replace that author with the current one
+                    newAttrs += `*${authorAttr}`;
+                  } else { newAttrs += `*${attrNum}`; } // overtake all other attribs as is
+                });
+                op.attribs = newAttrs;
+              }
+              yield op;
             }
-            assem.append(op);
-          }
-          assem.endDocument();
-          userChangeset = Changeset.pack(cs.oldLen, cs.newLen, assem.toString(), cs.charBank);
+          })();
+          const serializedOps = Changeset.serializeOps(Changeset.squashOps(ops, true));
+          userChangeset = Changeset.pack(cs.oldLen, cs.newLen, serializedOps, cs.charBank);
           Changeset.checkRep(userChangeset);
         }
         if (Changeset.isIdentity(userChangeset)) toSubmit = null;

src/tests/frontend/specs/easysync.js

@@ -646,16 +646,17 @@ describe('easysync', function () {
 
   const testSplitJoinAttributionLines = (randomSeed) => {
     const stringToOps = (str) => {
-      const assem = Changeset.mergingOpAssembler();
-      const o = new Changeset.Op('+');
-      o.chars = 1;
-      for (let i = 0; i < str.length; i++) {
-        const c = str.charAt(i);
-        o.lines = (c === '\n' ? 1 : 0);
-        o.attribs = (c === 'a' || c === 'b' ? `*${c}` : '');
-        assem.append(o);
-      }
-      return assem.toString();
+      const ops = (function* () {
+        for (let i = 0; i < str.length; i++) {
+          const c = str.charAt(i);
+          const o = new Changeset.Op('+');
+          o.chars = 1;
+          o.lines = (c === '\n' ? 1 : 0);
+          o.attribs = (c === 'a' || c === 'b' ? `*${c}` : '');
+          yield o;
+        }
+      })();
+      return Changeset.serializeOps(Changeset.squashOps(ops, false));
     };
 
     it(`testSplitJoinAttributionLines#${randomSeed}`, async function () {