mirror of
https://github.com/overleaf/overleaf.git
synced 2024-09-16 02:52:31 -04:00
300 lines
8.1 KiB
JavaScript
300 lines
8.1 KiB
JavaScript
/* eslint-disable
|
|
camelcase,
|
|
no-proto,
|
|
no-unused-vars,
|
|
*/
|
|
// TODO: This file was created by bulk-decaffeinate.
|
|
// Fix any style issues and re-enable lint.
|
|
/*
|
|
* decaffeinate suggestions:
|
|
* DS101: Remove unnecessary use of Array.from
|
|
* DS102: Remove unnecessary code created because of implicit returns
|
|
* DS207: Consider shorter variations of null checks
|
|
* Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
|
|
*/
|
|
let DiffGenerator;
|
|
var ConsistencyError = function(message) {
|
|
const error = new Error(message);
|
|
error.name = "ConsistencyError";
|
|
error.__proto__ = ConsistencyError.prototype;
|
|
return error;
|
|
};
|
|
ConsistencyError.prototype.__proto__ = Error.prototype;
|
|
|
|
const logger = require("logger-sharelatex");
|
|
|
|
module.exports = (DiffGenerator = {
|
|
ConsistencyError,
|
|
|
|
rewindUpdate(content, update) {
|
|
for (let j = update.op.length - 1, i = j; j >= 0; j--, i = j) {
|
|
const op = update.op[i];
|
|
if (op.broken !== true) {
|
|
try {
|
|
content = DiffGenerator.rewindOp(content, op);
|
|
} catch (e) {
|
|
if (e instanceof ConsistencyError && (i = update.op.length - 1)) {
|
|
// catch known case where the last op in an array has been
|
|
// merged into a later op
|
|
logger.error({err: e, update, op: JSON.stringify(op)}, "marking op as broken");
|
|
op.broken = true;
|
|
} else {
|
|
throw e; // rethrow the execption
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return content;
|
|
},
|
|
|
|
rewindOp(content, op) {
|
|
let p;
|
|
if (op.i != null) {
|
|
// ShareJS will accept an op where p > content.length when applied,
|
|
// and it applies as though p == content.length. However, the op is
|
|
// passed to us with the original p > content.length. Detect if that
|
|
// is the case with this op, and shift p back appropriately to match
|
|
// ShareJS if so.
|
|
({ p } = op);
|
|
const max_p = content.length - op.i.length;
|
|
if (p > max_p) {
|
|
logger.warn({max_p, p}, "truncating position to content length");
|
|
p = max_p;
|
|
}
|
|
|
|
const textToBeRemoved = content.slice(p, p + op.i.length);
|
|
if (op.i !== textToBeRemoved) {
|
|
throw new ConsistencyError(
|
|
`Inserted content, '${op.i}', does not match text to be removed, '${textToBeRemoved}'`
|
|
);
|
|
}
|
|
|
|
return content.slice(0, p) + content.slice(p + op.i.length);
|
|
|
|
} else if (op.d != null) {
|
|
return content.slice(0, op.p) + op.d + content.slice(op.p);
|
|
|
|
} else {
|
|
return content;
|
|
}
|
|
},
|
|
|
|
rewindUpdates(content, updates) {
|
|
for (const update of Array.from(updates.reverse())) {
|
|
try {
|
|
content = DiffGenerator.rewindUpdate(content, update);
|
|
} catch (e) {
|
|
e.attempted_update = update; // keep a record of the attempted update
|
|
throw e; // rethrow the exception
|
|
}
|
|
}
|
|
return content;
|
|
},
|
|
|
|
buildDiff(initialContent, updates) {
|
|
let diff = [ {u: initialContent} ];
|
|
for (const update of Array.from(updates)) {
|
|
diff = DiffGenerator.applyUpdateToDiff(diff, update);
|
|
}
|
|
diff = DiffGenerator.compressDiff(diff);
|
|
return diff;
|
|
},
|
|
|
|
compressDiff(diff) {
|
|
const newDiff = [];
|
|
for (const part of Array.from(diff)) {
|
|
const lastPart = newDiff[newDiff.length - 1];
|
|
if ((lastPart != null) && ((lastPart.meta != null ? lastPart.meta.user : undefined) != null) && ((part.meta != null ? part.meta.user : undefined) != null)) {
|
|
if ((lastPart.i != null) && (part.i != null) && (lastPart.meta.user.id === part.meta.user.id)) {
|
|
lastPart.i += part.i;
|
|
lastPart.meta.start_ts = Math.min(lastPart.meta.start_ts, part.meta.start_ts);
|
|
lastPart.meta.end_ts = Math.max(lastPart.meta.end_ts, part.meta.end_ts);
|
|
} else if ((lastPart.d != null) && (part.d != null) && (lastPart.meta.user.id === part.meta.user.id)) {
|
|
lastPart.d += part.d;
|
|
lastPart.meta.start_ts = Math.min(lastPart.meta.start_ts, part.meta.start_ts);
|
|
lastPart.meta.end_ts = Math.max(lastPart.meta.end_ts, part.meta.end_ts);
|
|
} else {
|
|
newDiff.push(part);
|
|
}
|
|
} else {
|
|
newDiff.push(part);
|
|
}
|
|
}
|
|
return newDiff;
|
|
},
|
|
|
|
applyOpToDiff(diff, op, meta) {
|
|
let consumedDiff;
|
|
const position = 0;
|
|
|
|
let remainingDiff = diff.slice();
|
|
({consumedDiff, remainingDiff} = DiffGenerator._consumeToOffset(remainingDiff, op.p));
|
|
const newDiff = consumedDiff;
|
|
|
|
if (op.i != null) {
|
|
newDiff.push({
|
|
i: op.i,
|
|
meta
|
|
});
|
|
} else if (op.d != null) {
|
|
({consumedDiff, remainingDiff} = DiffGenerator._consumeDiffAffectedByDeleteOp(remainingDiff, op, meta));
|
|
newDiff.push(...Array.from(consumedDiff || []));
|
|
}
|
|
|
|
newDiff.push(...Array.from(remainingDiff || []));
|
|
|
|
return newDiff;
|
|
},
|
|
|
|
applyUpdateToDiff(diff, update) {
|
|
for (const op of Array.from(update.op)) {
|
|
if (op.broken !== true) {
|
|
diff = DiffGenerator.applyOpToDiff(diff, op, update.meta);
|
|
}
|
|
}
|
|
return diff;
|
|
},
|
|
|
|
_consumeToOffset(remainingDiff, totalOffset) {
|
|
let part;
|
|
const consumedDiff = [];
|
|
let position = 0;
|
|
while ((part = remainingDiff.shift())) {
|
|
const length = DiffGenerator._getLengthOfDiffPart(part);
|
|
if (part.d != null) {
|
|
consumedDiff.push(part);
|
|
} else if ((position + length) >= totalOffset) {
|
|
const partOffset = totalOffset - position;
|
|
if (partOffset > 0) {
|
|
consumedDiff.push(DiffGenerator._slicePart(part, 0, partOffset));
|
|
}
|
|
if (partOffset < length) {
|
|
remainingDiff.unshift(DiffGenerator._slicePart(part, partOffset));
|
|
}
|
|
break;
|
|
} else {
|
|
position += length;
|
|
consumedDiff.push(part);
|
|
}
|
|
}
|
|
|
|
return {
|
|
consumedDiff,
|
|
remainingDiff
|
|
};
|
|
},
|
|
|
|
_consumeDiffAffectedByDeleteOp(remainingDiff, deleteOp, meta) {
|
|
const consumedDiff = [];
|
|
let remainingOp = deleteOp;
|
|
while (remainingOp && (remainingDiff.length > 0)) {
|
|
let newPart;
|
|
({newPart, remainingDiff, remainingOp} = DiffGenerator._consumeDeletedPart(remainingDiff, remainingOp, meta));
|
|
if (newPart != null) { consumedDiff.push(newPart); }
|
|
}
|
|
return {
|
|
consumedDiff,
|
|
remainingDiff
|
|
};
|
|
},
|
|
|
|
_consumeDeletedPart(remainingDiff, op, meta) {
|
|
let deletedContent, newPart, remainingOp;
|
|
const part = remainingDiff.shift();
|
|
const partLength = DiffGenerator._getLengthOfDiffPart(part);
|
|
|
|
if (part.d != null) {
|
|
// Skip existing deletes
|
|
remainingOp = op;
|
|
newPart = part;
|
|
|
|
} else if (partLength > op.d.length) {
|
|
// Only the first bit of the part has been deleted
|
|
const remainingPart = DiffGenerator._slicePart(part, op.d.length);
|
|
remainingDiff.unshift(remainingPart);
|
|
|
|
deletedContent = DiffGenerator._getContentOfPart(part).slice(0, op.d.length);
|
|
if (deletedContent !== op.d) {
|
|
throw new ConsistencyError(`deleted content, '${deletedContent}', does not match delete op, '${op.d}'`);
|
|
}
|
|
|
|
if (part.u != null) {
|
|
newPart = {
|
|
d: op.d,
|
|
meta
|
|
};
|
|
} else if (part.i != null) {
|
|
newPart = null;
|
|
}
|
|
|
|
remainingOp = null;
|
|
|
|
} else if (partLength === op.d.length) {
|
|
// The entire part has been deleted, but it is the last part
|
|
|
|
deletedContent = DiffGenerator._getContentOfPart(part);
|
|
if (deletedContent !== op.d) {
|
|
throw new ConsistencyError(`deleted content, '${deletedContent}', does not match delete op, '${op.d}'`);
|
|
}
|
|
|
|
if (part.u != null) {
|
|
newPart = {
|
|
d: op.d,
|
|
meta
|
|
};
|
|
} else if (part.i != null) {
|
|
newPart = null;
|
|
}
|
|
|
|
remainingOp = null;
|
|
|
|
} else if (partLength < op.d.length) {
|
|
// The entire part has been deleted and there is more
|
|
|
|
deletedContent = DiffGenerator._getContentOfPart(part);
|
|
const opContent = op.d.slice(0, deletedContent.length);
|
|
if (deletedContent !== opContent) {
|
|
throw new ConsistencyError(`deleted content, '${deletedContent}', does not match delete op, '${opContent}'`);
|
|
}
|
|
|
|
if (part.u) {
|
|
newPart = {
|
|
d: part.u,
|
|
meta
|
|
};
|
|
} else if (part.i != null) {
|
|
newPart = null;
|
|
}
|
|
|
|
remainingOp =
|
|
{p: op.p, d: op.d.slice(DiffGenerator._getLengthOfDiffPart(part))};
|
|
}
|
|
|
|
return {
|
|
newPart,
|
|
remainingDiff,
|
|
remainingOp
|
|
};
|
|
},
|
|
|
|
_slicePart(basePart, from, to) {
|
|
let part;
|
|
if (basePart.u != null) {
|
|
part = { u: basePart.u.slice(from, to) };
|
|
} else if (basePart.i != null) {
|
|
part = { i: basePart.i.slice(from, to) };
|
|
}
|
|
if (basePart.meta != null) {
|
|
part.meta = basePart.meta;
|
|
}
|
|
return part;
|
|
},
|
|
|
|
_getLengthOfDiffPart(part) {
|
|
return (part.u || part.d || part.i || '').length;
|
|
},
|
|
|
|
_getContentOfPart(part) {
|
|
return part.u || part.d || part.i || '';
|
|
}
|
|
});
|