mirror of
https://github.com/hedgedoc/hedgedoc.git
synced 2024-11-29 23:48:47 -05:00
530 lines
17 KiB
JavaScript
530 lines
17 KiB
JavaScript
|
if (typeof ot === 'undefined') {
|
|||
|
// Export for browsers
|
|||
|
var ot = {};
|
|||
|
}
|
|||
|
|
|||
|
ot.TextOperation = (function () {
|
|||
|
'use strict';
|
|||
|
|
|||
|
// Constructor for new operations.
|
|||
|
function TextOperation () {
|
|||
|
if (!this || this.constructor !== TextOperation) {
|
|||
|
// => function was called without 'new'
|
|||
|
return new TextOperation();
|
|||
|
}
|
|||
|
|
|||
|
// When an operation is applied to an input string, you can think of this as
|
|||
|
// if an imaginary cursor runs over the entire string and skips over some
|
|||
|
// parts, deletes some parts and inserts characters at some positions. These
|
|||
|
// actions (skip/delete/insert) are stored as an array in the "ops" property.
|
|||
|
this.ops = [];
|
|||
|
// An operation's baseLength is the length of every string the operation
|
|||
|
// can be applied to.
|
|||
|
this.baseLength = 0;
|
|||
|
// The targetLength is the length of every string that results from applying
|
|||
|
// the operation on a valid input string.
|
|||
|
this.targetLength = 0;
|
|||
|
}
|
|||
|
|
|||
|
TextOperation.prototype.equals = function (other) {
|
|||
|
if (this.baseLength !== other.baseLength) { return false; }
|
|||
|
if (this.targetLength !== other.targetLength) { return false; }
|
|||
|
if (this.ops.length !== other.ops.length) { return false; }
|
|||
|
for (var i = 0; i < this.ops.length; i++) {
|
|||
|
if (this.ops[i] !== other.ops[i]) { return false; }
|
|||
|
}
|
|||
|
return true;
|
|||
|
};
|
|||
|
|
|||
|
// Operation are essentially lists of ops. There are three types of ops:
|
|||
|
//
|
|||
|
// * Retain ops: Advance the cursor position by a given number of characters.
|
|||
|
// Represented by positive ints.
|
|||
|
// * Insert ops: Insert a given string at the current cursor position.
|
|||
|
// Represented by strings.
|
|||
|
// * Delete ops: Delete the next n characters. Represented by negative ints.
|
|||
|
|
|||
|
var isRetain = TextOperation.isRetain = function (op) {
|
|||
|
return typeof op === 'number' && op > 0;
|
|||
|
};
|
|||
|
|
|||
|
var isInsert = TextOperation.isInsert = function (op) {
|
|||
|
return typeof op === 'string';
|
|||
|
};
|
|||
|
|
|||
|
var isDelete = TextOperation.isDelete = function (op) {
|
|||
|
return typeof op === 'number' && op < 0;
|
|||
|
};
|
|||
|
|
|||
|
|
|||
|
// After an operation is constructed, the user of the library can specify the
|
|||
|
// actions of an operation (skip/insert/delete) with these three builder
|
|||
|
// methods. They all return the operation for convenient chaining.
|
|||
|
|
|||
|
// Skip over a given number of characters.
|
|||
|
TextOperation.prototype.retain = function (n) {
|
|||
|
if (typeof n !== 'number') {
|
|||
|
throw new Error("retain expects an integer");
|
|||
|
}
|
|||
|
if (n === 0) { return this; }
|
|||
|
this.baseLength += n;
|
|||
|
this.targetLength += n;
|
|||
|
if (isRetain(this.ops[this.ops.length-1])) {
|
|||
|
// The last op is a retain op => we can merge them into one op.
|
|||
|
this.ops[this.ops.length-1] += n;
|
|||
|
} else {
|
|||
|
// Create a new op.
|
|||
|
this.ops.push(n);
|
|||
|
}
|
|||
|
return this;
|
|||
|
};
|
|||
|
|
|||
|
// Insert a string at the current position.
|
|||
|
TextOperation.prototype.insert = function (str) {
|
|||
|
if (typeof str !== 'string') {
|
|||
|
throw new Error("insert expects a string");
|
|||
|
}
|
|||
|
if (str === '') { return this; }
|
|||
|
this.targetLength += str.length;
|
|||
|
var ops = this.ops;
|
|||
|
if (isInsert(ops[ops.length-1])) {
|
|||
|
// Merge insert op.
|
|||
|
ops[ops.length-1] += str;
|
|||
|
} else if (isDelete(ops[ops.length-1])) {
|
|||
|
// It doesn't matter when an operation is applied whether the operation
|
|||
|
// is delete(3), insert("something") or insert("something"), delete(3).
|
|||
|
// Here we enforce that in this case, the insert op always comes first.
|
|||
|
// This makes all operations that have the same effect when applied to
|
|||
|
// a document of the right length equal in respect to the `equals` method.
|
|||
|
if (isInsert(ops[ops.length-2])) {
|
|||
|
ops[ops.length-2] += str;
|
|||
|
} else {
|
|||
|
ops[ops.length] = ops[ops.length-1];
|
|||
|
ops[ops.length-2] = str;
|
|||
|
}
|
|||
|
} else {
|
|||
|
ops.push(str);
|
|||
|
}
|
|||
|
return this;
|
|||
|
};
|
|||
|
|
|||
|
// Delete a string at the current position.
|
|||
|
TextOperation.prototype['delete'] = function (n) {
|
|||
|
if (typeof n === 'string') { n = n.length; }
|
|||
|
if (typeof n !== 'number') {
|
|||
|
throw new Error("delete expects an integer or a string");
|
|||
|
}
|
|||
|
if (n === 0) { return this; }
|
|||
|
if (n > 0) { n = -n; }
|
|||
|
this.baseLength -= n;
|
|||
|
if (isDelete(this.ops[this.ops.length-1])) {
|
|||
|
this.ops[this.ops.length-1] += n;
|
|||
|
} else {
|
|||
|
this.ops.push(n);
|
|||
|
}
|
|||
|
return this;
|
|||
|
};
|
|||
|
|
|||
|
// Tests whether this operation has no effect.
|
|||
|
TextOperation.prototype.isNoop = function () {
|
|||
|
return this.ops.length === 0 || (this.ops.length === 1 && isRetain(this.ops[0]));
|
|||
|
};
|
|||
|
|
|||
|
// Pretty printing.
|
|||
|
TextOperation.prototype.toString = function () {
|
|||
|
// map: build a new array by applying a function to every element in an old
|
|||
|
// array.
|
|||
|
var map = Array.prototype.map || function (fn) {
|
|||
|
var arr = this;
|
|||
|
var newArr = [];
|
|||
|
for (var i = 0, l = arr.length; i < l; i++) {
|
|||
|
newArr[i] = fn(arr[i]);
|
|||
|
}
|
|||
|
return newArr;
|
|||
|
};
|
|||
|
return map.call(this.ops, function (op) {
|
|||
|
if (isRetain(op)) {
|
|||
|
return "retain " + op;
|
|||
|
} else if (isInsert(op)) {
|
|||
|
return "insert '" + op + "'";
|
|||
|
} else {
|
|||
|
return "delete " + (-op);
|
|||
|
}
|
|||
|
}).join(', ');
|
|||
|
};
|
|||
|
|
|||
|
// Converts operation into a JSON value.
|
|||
|
TextOperation.prototype.toJSON = function () {
|
|||
|
return this.ops;
|
|||
|
};
|
|||
|
|
|||
|
// Converts a plain JS object into an operation and validates it.
|
|||
|
TextOperation.fromJSON = function (ops) {
|
|||
|
var o = new TextOperation();
|
|||
|
for (var i = 0, l = ops.length; i < l; i++) {
|
|||
|
var op = ops[i];
|
|||
|
if (isRetain(op)) {
|
|||
|
o.retain(op);
|
|||
|
} else if (isInsert(op)) {
|
|||
|
o.insert(op);
|
|||
|
} else if (isDelete(op)) {
|
|||
|
o['delete'](op);
|
|||
|
} else {
|
|||
|
throw new Error("unknown operation: " + JSON.stringify(op));
|
|||
|
}
|
|||
|
}
|
|||
|
return o;
|
|||
|
};
|
|||
|
|
|||
|
// Apply an operation to a string, returning a new string. Throws an error if
|
|||
|
// there's a mismatch between the input string and the operation.
|
|||
|
TextOperation.prototype.apply = function (str) {
|
|||
|
var operation = this;
|
|||
|
if (str.length !== operation.baseLength) {
|
|||
|
throw new Error("The operation's base length must be equal to the string's length.");
|
|||
|
}
|
|||
|
var newStr = [], j = 0;
|
|||
|
var strIndex = 0;
|
|||
|
var ops = this.ops;
|
|||
|
for (var i = 0, l = ops.length; i < l; i++) {
|
|||
|
var op = ops[i];
|
|||
|
if (isRetain(op)) {
|
|||
|
if (strIndex + op > str.length) {
|
|||
|
throw new Error("Operation can't retain more characters than are left in the string.");
|
|||
|
}
|
|||
|
// Copy skipped part of the old string.
|
|||
|
newStr[j++] = str.slice(strIndex, strIndex + op);
|
|||
|
strIndex += op;
|
|||
|
} else if (isInsert(op)) {
|
|||
|
// Insert string.
|
|||
|
newStr[j++] = op;
|
|||
|
} else { // delete op
|
|||
|
strIndex -= op;
|
|||
|
}
|
|||
|
}
|
|||
|
if (strIndex !== str.length) {
|
|||
|
throw new Error("The operation didn't operate on the whole string.");
|
|||
|
}
|
|||
|
return newStr.join('');
|
|||
|
};
|
|||
|
|
|||
|
// Computes the inverse of an operation. The inverse of an operation is the
|
|||
|
// operation that reverts the effects of the operation, e.g. when you have an
|
|||
|
// operation 'insert("hello "); skip(6);' then the inverse is 'delete("hello ");
|
|||
|
// skip(6);'. The inverse should be used for implementing undo.
|
|||
|
TextOperation.prototype.invert = function (str) {
|
|||
|
var strIndex = 0;
|
|||
|
var inverse = new TextOperation();
|
|||
|
var ops = this.ops;
|
|||
|
for (var i = 0, l = ops.length; i < l; i++) {
|
|||
|
var op = ops[i];
|
|||
|
if (isRetain(op)) {
|
|||
|
inverse.retain(op);
|
|||
|
strIndex += op;
|
|||
|
} else if (isInsert(op)) {
|
|||
|
inverse['delete'](op.length);
|
|||
|
} else { // delete op
|
|||
|
inverse.insert(str.slice(strIndex, strIndex - op));
|
|||
|
strIndex -= op;
|
|||
|
}
|
|||
|
}
|
|||
|
return inverse;
|
|||
|
};
|
|||
|
|
|||
|
// Compose merges two consecutive operations into one operation, that
|
|||
|
// preserves the changes of both. Or, in other words, for each input string S
|
|||
|
// and a pair of consecutive operations A and B,
|
|||
|
// apply(apply(S, A), B) = apply(S, compose(A, B)) must hold.
|
|||
|
TextOperation.prototype.compose = function (operation2) {
|
|||
|
var operation1 = this;
|
|||
|
if (operation1.targetLength !== operation2.baseLength) {
|
|||
|
throw new Error("The base length of the second operation has to be the target length of the first operation");
|
|||
|
}
|
|||
|
|
|||
|
var operation = new TextOperation(); // the combined operation
|
|||
|
var ops1 = operation1.ops, ops2 = operation2.ops; // for fast access
|
|||
|
var i1 = 0, i2 = 0; // current index into ops1 respectively ops2
|
|||
|
var op1 = ops1[i1++], op2 = ops2[i2++]; // current ops
|
|||
|
while (true) {
|
|||
|
// Dispatch on the type of op1 and op2
|
|||
|
if (typeof op1 === 'undefined' && typeof op2 === 'undefined') {
|
|||
|
// end condition: both ops1 and ops2 have been processed
|
|||
|
break;
|
|||
|
}
|
|||
|
|
|||
|
if (isDelete(op1)) {
|
|||
|
operation['delete'](op1);
|
|||
|
op1 = ops1[i1++];
|
|||
|
continue;
|
|||
|
}
|
|||
|
if (isInsert(op2)) {
|
|||
|
operation.insert(op2);
|
|||
|
op2 = ops2[i2++];
|
|||
|
continue;
|
|||
|
}
|
|||
|
|
|||
|
if (typeof op1 === 'undefined') {
|
|||
|
throw new Error("Cannot compose operations: first operation is too short.");
|
|||
|
}
|
|||
|
if (typeof op2 === 'undefined') {
|
|||
|
throw new Error("Cannot compose operations: first operation is too long.");
|
|||
|
}
|
|||
|
|
|||
|
if (isRetain(op1) && isRetain(op2)) {
|
|||
|
if (op1 > op2) {
|
|||
|
operation.retain(op2);
|
|||
|
op1 = op1 - op2;
|
|||
|
op2 = ops2[i2++];
|
|||
|
} else if (op1 === op2) {
|
|||
|
operation.retain(op1);
|
|||
|
op1 = ops1[i1++];
|
|||
|
op2 = ops2[i2++];
|
|||
|
} else {
|
|||
|
operation.retain(op1);
|
|||
|
op2 = op2 - op1;
|
|||
|
op1 = ops1[i1++];
|
|||
|
}
|
|||
|
} else if (isInsert(op1) && isDelete(op2)) {
|
|||
|
if (op1.length > -op2) {
|
|||
|
op1 = op1.slice(-op2);
|
|||
|
op2 = ops2[i2++];
|
|||
|
} else if (op1.length === -op2) {
|
|||
|
op1 = ops1[i1++];
|
|||
|
op2 = ops2[i2++];
|
|||
|
} else {
|
|||
|
op2 = op2 + op1.length;
|
|||
|
op1 = ops1[i1++];
|
|||
|
}
|
|||
|
} else if (isInsert(op1) && isRetain(op2)) {
|
|||
|
if (op1.length > op2) {
|
|||
|
operation.insert(op1.slice(0, op2));
|
|||
|
op1 = op1.slice(op2);
|
|||
|
op2 = ops2[i2++];
|
|||
|
} else if (op1.length === op2) {
|
|||
|
operation.insert(op1);
|
|||
|
op1 = ops1[i1++];
|
|||
|
op2 = ops2[i2++];
|
|||
|
} else {
|
|||
|
operation.insert(op1);
|
|||
|
op2 = op2 - op1.length;
|
|||
|
op1 = ops1[i1++];
|
|||
|
}
|
|||
|
} else if (isRetain(op1) && isDelete(op2)) {
|
|||
|
if (op1 > -op2) {
|
|||
|
operation['delete'](op2);
|
|||
|
op1 = op1 + op2;
|
|||
|
op2 = ops2[i2++];
|
|||
|
} else if (op1 === -op2) {
|
|||
|
operation['delete'](op2);
|
|||
|
op1 = ops1[i1++];
|
|||
|
op2 = ops2[i2++];
|
|||
|
} else {
|
|||
|
operation['delete'](op1);
|
|||
|
op2 = op2 + op1;
|
|||
|
op1 = ops1[i1++];
|
|||
|
}
|
|||
|
} else {
|
|||
|
throw new Error(
|
|||
|
"This shouldn't happen: op1: " +
|
|||
|
JSON.stringify(op1) + ", op2: " +
|
|||
|
JSON.stringify(op2)
|
|||
|
);
|
|||
|
}
|
|||
|
}
|
|||
|
return operation;
|
|||
|
};
|
|||
|
|
|||
|
function getSimpleOp (operation, fn) {
|
|||
|
var ops = operation.ops;
|
|||
|
var isRetain = TextOperation.isRetain;
|
|||
|
switch (ops.length) {
|
|||
|
case 1:
|
|||
|
return ops[0];
|
|||
|
case 2:
|
|||
|
return isRetain(ops[0]) ? ops[1] : (isRetain(ops[1]) ? ops[0] : null);
|
|||
|
case 3:
|
|||
|
if (isRetain(ops[0]) && isRetain(ops[2])) { return ops[1]; }
|
|||
|
}
|
|||
|
return null;
|
|||
|
}
|
|||
|
|
|||
|
function getStartIndex (operation) {
|
|||
|
if (isRetain(operation.ops[0])) { return operation.ops[0]; }
|
|||
|
return 0;
|
|||
|
}
|
|||
|
|
|||
|
// When you use ctrl-z to undo your latest changes, you expect the program not
|
|||
|
// to undo every single keystroke but to undo your last sentence you wrote at
|
|||
|
// a stretch or the deletion you did by holding the backspace key down. This
|
|||
|
// This can be implemented by composing operations on the undo stack. This
|
|||
|
// method can help decide whether two operations should be composed. It
|
|||
|
// returns true if the operations are consecutive insert operations or both
|
|||
|
// operations delete text at the same position. You may want to include other
|
|||
|
// factors like the time since the last change in your decision.
|
|||
|
TextOperation.prototype.shouldBeComposedWith = function (other) {
|
|||
|
if (this.isNoop() || other.isNoop()) { return true; }
|
|||
|
|
|||
|
var startA = getStartIndex(this), startB = getStartIndex(other);
|
|||
|
var simpleA = getSimpleOp(this), simpleB = getSimpleOp(other);
|
|||
|
if (!simpleA || !simpleB) { return false; }
|
|||
|
|
|||
|
if (isInsert(simpleA) && isInsert(simpleB)) {
|
|||
|
return startA + simpleA.length === startB;
|
|||
|
}
|
|||
|
|
|||
|
if (isDelete(simpleA) && isDelete(simpleB)) {
|
|||
|
// there are two possibilities to delete: with backspace and with the
|
|||
|
// delete key.
|
|||
|
return (startB - simpleB === startA) || startA === startB;
|
|||
|
}
|
|||
|
|
|||
|
return false;
|
|||
|
};
|
|||
|
|
|||
|
// Decides whether two operations should be composed with each other
|
|||
|
// if they were inverted, that is
|
|||
|
// `shouldBeComposedWith(a, b) = shouldBeComposedWithInverted(b^{-1}, a^{-1})`.
|
|||
|
TextOperation.prototype.shouldBeComposedWithInverted = function (other) {
|
|||
|
if (this.isNoop() || other.isNoop()) { return true; }
|
|||
|
|
|||
|
var startA = getStartIndex(this), startB = getStartIndex(other);
|
|||
|
var simpleA = getSimpleOp(this), simpleB = getSimpleOp(other);
|
|||
|
if (!simpleA || !simpleB) { return false; }
|
|||
|
|
|||
|
if (isInsert(simpleA) && isInsert(simpleB)) {
|
|||
|
return startA + simpleA.length === startB || startA === startB;
|
|||
|
}
|
|||
|
|
|||
|
if (isDelete(simpleA) && isDelete(simpleB)) {
|
|||
|
return startB - simpleB === startA;
|
|||
|
}
|
|||
|
|
|||
|
return false;
|
|||
|
};
|
|||
|
|
|||
|
// Transform takes two operations A and B that happened concurrently and
|
|||
|
// produces two operations A' and B' (in an array) such that
|
|||
|
// `apply(apply(S, A), B') = apply(apply(S, B), A')`. This function is the
|
|||
|
// heart of OT.
|
|||
|
TextOperation.transform = function (operation1, operation2) {
|
|||
|
if (operation1.baseLength !== operation2.baseLength) {
|
|||
|
throw new Error("Both operations have to have the same base length");
|
|||
|
}
|
|||
|
|
|||
|
var operation1prime = new TextOperation();
|
|||
|
var operation2prime = new TextOperation();
|
|||
|
var ops1 = operation1.ops, ops2 = operation2.ops;
|
|||
|
var i1 = 0, i2 = 0;
|
|||
|
var op1 = ops1[i1++], op2 = ops2[i2++];
|
|||
|
while (true) {
|
|||
|
// At every iteration of the loop, the imaginary cursor that both
|
|||
|
// operation1 and operation2 have that operates on the input string must
|
|||
|
// have the same position in the input string.
|
|||
|
|
|||
|
if (typeof op1 === 'undefined' && typeof op2 === 'undefined') {
|
|||
|
// end condition: both ops1 and ops2 have been processed
|
|||
|
break;
|
|||
|
}
|
|||
|
|
|||
|
// next two cases: one or both ops are insert ops
|
|||
|
// => insert the string in the corresponding prime operation, skip it in
|
|||
|
// the other one. If both op1 and op2 are insert ops, prefer op1.
|
|||
|
if (isInsert(op1)) {
|
|||
|
operation1prime.insert(op1);
|
|||
|
operation2prime.retain(op1.length);
|
|||
|
op1 = ops1[i1++];
|
|||
|
continue;
|
|||
|
}
|
|||
|
if (isInsert(op2)) {
|
|||
|
operation1prime.retain(op2.length);
|
|||
|
operation2prime.insert(op2);
|
|||
|
op2 = ops2[i2++];
|
|||
|
continue;
|
|||
|
}
|
|||
|
|
|||
|
if (typeof op1 === 'undefined') {
|
|||
|
throw new Error("Cannot compose operations: first operation is too short.");
|
|||
|
}
|
|||
|
if (typeof op2 === 'undefined') {
|
|||
|
throw new Error("Cannot compose operations: first operation is too long.");
|
|||
|
}
|
|||
|
|
|||
|
var minl;
|
|||
|
if (isRetain(op1) && isRetain(op2)) {
|
|||
|
// Simple case: retain/retain
|
|||
|
if (op1 > op2) {
|
|||
|
minl = op2;
|
|||
|
op1 = op1 - op2;
|
|||
|
op2 = ops2[i2++];
|
|||
|
} else if (op1 === op2) {
|
|||
|
minl = op2;
|
|||
|
op1 = ops1[i1++];
|
|||
|
op2 = ops2[i2++];
|
|||
|
} else {
|
|||
|
minl = op1;
|
|||
|
op2 = op2 - op1;
|
|||
|
op1 = ops1[i1++];
|
|||
|
}
|
|||
|
operation1prime.retain(minl);
|
|||
|
operation2prime.retain(minl);
|
|||
|
} else if (isDelete(op1) && isDelete(op2)) {
|
|||
|
// Both operations delete the same string at the same position. We don't
|
|||
|
// need to produce any operations, we just skip over the delete ops and
|
|||
|
// handle the case that one operation deletes more than the other.
|
|||
|
if (-op1 > -op2) {
|
|||
|
op1 = op1 - op2;
|
|||
|
op2 = ops2[i2++];
|
|||
|
} else if (op1 === op2) {
|
|||
|
op1 = ops1[i1++];
|
|||
|
op2 = ops2[i2++];
|
|||
|
} else {
|
|||
|
op2 = op2 - op1;
|
|||
|
op1 = ops1[i1++];
|
|||
|
}
|
|||
|
// next two cases: delete/retain and retain/delete
|
|||
|
} else if (isDelete(op1) && isRetain(op2)) {
|
|||
|
if (-op1 > op2) {
|
|||
|
minl = op2;
|
|||
|
op1 = op1 + op2;
|
|||
|
op2 = ops2[i2++];
|
|||
|
} else if (-op1 === op2) {
|
|||
|
minl = op2;
|
|||
|
op1 = ops1[i1++];
|
|||
|
op2 = ops2[i2++];
|
|||
|
} else {
|
|||
|
minl = -op1;
|
|||
|
op2 = op2 + op1;
|
|||
|
op1 = ops1[i1++];
|
|||
|
}
|
|||
|
operation1prime['delete'](minl);
|
|||
|
} else if (isRetain(op1) && isDelete(op2)) {
|
|||
|
if (op1 > -op2) {
|
|||
|
minl = -op2;
|
|||
|
op1 = op1 + op2;
|
|||
|
op2 = ops2[i2++];
|
|||
|
} else if (op1 === -op2) {
|
|||
|
minl = op1;
|
|||
|
op1 = ops1[i1++];
|
|||
|
op2 = ops2[i2++];
|
|||
|
} else {
|
|||
|
minl = op1;
|
|||
|
op2 = op2 + op1;
|
|||
|
op1 = ops1[i1++];
|
|||
|
}
|
|||
|
operation2prime['delete'](minl);
|
|||
|
} else {
|
|||
|
throw new Error("The two operations aren't compatible");
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
return [operation1prime, operation2prime];
|
|||
|
};
|
|||
|
|
|||
|
return TextOperation;
|
|||
|
|
|||
|
}());
|
|||
|
|
|||
|
// Export for CommonJS
|
|||
|
if (typeof module === 'object') {
|
|||
|
module.exports = ot.TextOperation;
|
|||
|
}
|