Changeset: Use a generator to implement MergingOpAssembler

Eventually all uses of the class will be switched to the generator.

Author: rhansen

src/static/js/Changeset.js

@@ -309,6 +309,18 @@ exports.newOp = (optOpcode) => {
  */
 const copyOp = (op1, op2 = new Op()) => Object.assign(op2, op1);
 
+/**
+ * Converts an iterable of operation objects to wire format.
+ *
+ * @param {Iterable<Op>} ops - Iterable of operations to serialize.
+ * @returns {string} A string containing the encoded op data (example: '|5=2p=v*4*5+1').
+ */
+const serializeOps = (ops) => {
+  let res = '';
+  for (const op of ops) res += op.toString();
+  return res;
+};
+
 /**
  * Serializes a sequence of Ops.
  */
@@ -335,68 +347,92 @@ class OpAssembler {
 }
 
 /**
- * Efficiently merges consecutive operations that are mergeable, ignores no-ops, and drops final
- * pure "keeps". It does not re-order operations.
+ * Combines consecutive operations when possible. Also skips no-op changes.
+ *
+ * @param {Iterable<Op>} ops - Iterable of operations to combine.
+ * @param {boolean} finalize - If truthy, omits the final op if it is an attributeless keep op.
+ * @yields {Op} The squashed operations.
+ * @returns {Generator<Op>}
  */
-class MergingOpAssembler {
-  constructor() {
-    this._assem = new OpAssembler();
-    this._bufOp = 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
-    // any other newline-less ops immediately after it.
-    this._bufOpAdditionalCharsAfterNewline = 0;
-  }
+const 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
+  // any other newline-less ops immediately after it.
+  let prevOpAdditionalCharsAfterNewline = 0;
 
-  _flush(isEndDocument) {
-    if (!this._bufOp.opcode) return;
-    if (isEndDocument && this._bufOp.opcode === '=' && !this._bufOp.attribs) {
+  const flush = function* (finalize) {
+    if (!prevOp.opcode) return;
+    if (finalize && prevOp.opcode === '=' && !prevOp.attribs) {
       // final merged keep, leave it implicit
     } else {
-      this._assem.append(this._bufOp);
-      if (this._bufOpAdditionalCharsAfterNewline) {
-        this._bufOp.chars = this._bufOpAdditionalCharsAfterNewline;
-        this._bufOp.lines = 0;
-        this._assem.append(this._bufOp);
-        this._bufOpAdditionalCharsAfterNewline = 0;
+      yield prevOp;
+      if (prevOpAdditionalCharsAfterNewline) {
+        const op = new Op(prevOp.opcode);
+        op.chars = prevOpAdditionalCharsAfterNewline;
+        op.lines = 0;
+        op.attribs = prevOp.attribs;
+        yield op;
+        prevOpAdditionalCharsAfterNewline = 0;
       }
     }
-    this._bufOp.opcode = '';
-  }
+    prevOp = new Op();
+  };
 
-  append(op) {
-    if (op.chars <= 0) return;
-    if (this._bufOp.opcode === op.opcode && this._bufOp.attribs === op.attribs) {
+  for (const op of ops) {
+    if (!op.opcode || op.chars <= 0) continue;
+    if (prevOp.opcode === op.opcode && prevOp.attribs === op.attribs) {
       if (op.lines > 0) {
-        // this._bufOp and additional chars are all mergeable into a multi-line op
-        this._bufOp.chars += this._bufOpAdditionalCharsAfterNewline + op.chars;
-        this._bufOp.lines += op.lines;
-        this._bufOpAdditionalCharsAfterNewline = 0;
-      } else if (this._bufOp.lines === 0) {
-        // both this._bufOp and op are in-line
-        this._bufOp.chars += op.chars;
+        // bufOp and additional chars are all mergeable into a multi-line op
+        prevOp.chars += prevOpAdditionalCharsAfterNewline + op.chars;
+        prevOp.lines += op.lines;
+        prevOpAdditionalCharsAfterNewline = 0;
+      } else if (prevOp.lines === 0) {
+        // both prevOp and op are in-line
+        prevOp.chars += op.chars;
       } else {
-        // append in-line text to multi-line this._bufOp
-        this._bufOpAdditionalCharsAfterNewline += op.chars;
+        // append in-line text to multi-line prevOp
+        prevOpAdditionalCharsAfterNewline += op.chars;
       }
     } else {
-      this._flush();
-      copyOp(op, this._bufOp);
+      yield* flush(false);
+      prevOp = copyOp(op); // prevOp is mutated, so make a copy to protect op.
     }
   }
 
-  endDocument() {
-    this._flush(true);
+  yield* flush(finalize);
+};
+
+/**
+ * Efficiently merges consecutive operations that are mergeable, ignores no-ops, and drops final
+ * pure "keeps". It does not re-order operations.
+ */
+class MergingOpAssembler {
+  constructor() {
+    this.clear();
   }
 
-  toString() {
-    this._flush();
-    return this._assem.toString();
+  _serialize(finalize) {
+    this._serialized = serializeOps(squashOps(this._ops, finalize));
   }
 
   clear() {
-    this._assem.clear();
-    clearOp(this._bufOp);
+    this._ops = [];
+    this._serialized = null;
+  }
+
+  append(op) {
+    this._serialized = null;
+    this._ops.push(copyOp(op));
+  }
+
+  endDocument() {
+    this._serialize(true);
+  }
+
+  toString() {
+    if (this._serialized == null) this._serialize(false);
+    return this._serialized;
   }
 }