fuwafuwa
/
etherpad-lite
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge pull request #850 from fourplusone/feature/remove_opt 

CodeCleanup: remove unused _opt in favor of code size/readability
This commit is contained in:
Marcel Klehr 2012-07-10 13:03:44 -07:00
parent 72532fadc9 3a0015c357
commit beb6378656
1 changed files with 89 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

245
src/static/js/Changeset.js
View File

@ -27,8 +27,6 @@
var AttributePool = require("./AttributePool"); var AttributePool = require("./AttributePool");
var _opt = null;
/** /**
* ==================== General Util Functions ======================= * ==================== General Util Functions =======================
*/ */
@ -127,22 +125,13 @@ exports.opIterator = function (opsStr, optStartIndex) {
function nextRegexMatch() { function nextRegexMatch() {
prevIndex = curIndex; prevIndex = curIndex;
var result; var result;
if (_opt) { regex.lastIndex = curIndex;
result = _opt.nextOpInString(opsStr, curIndex); result = regex.exec(opsStr);
if (result) { curIndex = regex.lastIndex;
if (result.opcode() == '?') { if (result[0] == '?') {
exports.error("Hit error opcode in op stream"); exports.error("Hit error opcode in op stream");
}
curIndex = result.lastIndex();
}
} else {
regex.lastIndex = curIndex;
result = regex.exec(opsStr);
curIndex = regex.lastIndex;
if (result[0] == '?') {
exports.error("Hit error opcode in op stream");
}
} }
return result; return result;
} }
var regexResult = nextRegexMatch(); var regexResult = nextRegexMatch();
@ -150,13 +139,7 @@ exports.opIterator = function (opsStr, optStartIndex) {
function next(optObj) { function next(optObj) {
var op = (optObj || obj); var op = (optObj || obj);
if (_opt && regexResult) { if (regexResult[0]) {
op.attribs = regexResult.attribs();
op.lines = regexResult.lines();
op.chars = regexResult.chars();
op.opcode = regexResult.opcode();
regexResult = nextRegexMatch();
} else if ((!_opt) && regexResult[0]) {
op.attribs = regexResult[1]; op.attribs = regexResult[1];
op.lines = exports.parseNum(regexResult[2] || 0); op.lines = exports.parseNum(regexResult[2] || 0);
op.opcode = regexResult[3]; op.opcode = regexResult[3];
@ -169,7 +152,7 @@ exports.opIterator = function (opsStr, optStartIndex) {
} }
function hasNext() { function hasNext() {
return !!(_opt ? regexResult : regexResult[0]); return !!(regexResult[0]);
} }
function lastIndex() { function lastIndex() {
@ -414,159 +397,109 @@ exports.smartOpAssembler = function () {
}; };
}; };
if (_opt) {
exports.mergingOpAssembler = function () {
var assem = _opt.mergingOpAssembler();
function append(op) { exports.mergingOpAssembler = function () {
assem.append(op.opcode, op.chars, op.lines, op.attribs); // This assembler can be used in production; it efficiently
} // merges consecutive operations that are mergeable, ignores
// no-ops, and drops final pure "keeps". It does not re-order
// operations.
var assem = exports.opAssembler();
var bufOp = exports.newOp();
function toString() { // If we get, for example, insertions [xxx\n,yyy], those don't merge,
return assem.toString(); // 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.
var bufOpAdditionalCharsAfterNewline = 0;
function clear() { function flush(isEndDocument) {
assem.clear(); if (bufOp.opcode) {
} if (isEndDocument && bufOp.opcode == '=' && !bufOp.attribs) {
// final merged keep, leave it implicit
function endDocument() { } else {
assem.endDocument(); assem.append(bufOp);
} if (bufOpAdditionalCharsAfterNewline) {
bufOp.chars = bufOpAdditionalCharsAfterNewline;
return { bufOp.lines = 0;
append: append,
toString: toString,
clear: clear,
endDocument: endDocument
};
};
} else {
exports.mergingOpAssembler = function () {
// This assembler can be used in production; it efficiently
// merges consecutive operations that are mergeable, ignores
// no-ops, and drops final pure "keeps". It does not re-order
// operations.
var assem = exports.opAssembler();
var bufOp = exports.newOp();
// 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.
var bufOpAdditionalCharsAfterNewline = 0;
function flush(isEndDocument) {
if (bufOp.opcode) {
if (isEndDocument && bufOp.opcode == '=' && !bufOp.attribs) {
// final merged keep, leave it implicit
} else {
assem.append(bufOp); assem.append(bufOp);
if (bufOpAdditionalCharsAfterNewline) { bufOpAdditionalCharsAfterNewline = 0;
bufOp.chars = bufOpAdditionalCharsAfterNewline;
bufOp.lines = 0;
assem.append(bufOp);
bufOpAdditionalCharsAfterNewline = 0;
}
} }
bufOp.opcode = '';
} }
bufOp.opcode = '';
} }
}
function append(op) { function append(op) {
if (op.chars > 0) { if (op.chars > 0) {
if (bufOp.opcode == op.opcode && bufOp.attribs == op.attribs) { if (bufOp.opcode == op.opcode && bufOp.attribs == op.attribs) {
if (op.lines > 0) { if (op.lines > 0) {
// bufOp and additional chars are all mergeable into a multi-line op // bufOp and additional chars are all mergeable into a multi-line op
bufOp.chars += bufOpAdditionalCharsAfterNewline + op.chars; bufOp.chars += bufOpAdditionalCharsAfterNewline + op.chars;
bufOp.lines += op.lines; bufOp.lines += op.lines;
bufOpAdditionalCharsAfterNewline = 0; bufOpAdditionalCharsAfterNewline = 0;
} else if (bufOp.lines == 0) { } else if (bufOp.lines == 0) {
// both bufOp and op are in-line // both bufOp and op are in-line
bufOp.chars += op.chars; bufOp.chars += op.chars;
} else {
// append in-line text to multi-line bufOp
bufOpAdditionalCharsAfterNewline += op.chars;
}
} else { } else {
flush(); // append in-line text to multi-line bufOp
exports.copyOp(op, bufOp); bufOpAdditionalCharsAfterNewline += op.chars;
} }
} else {
flush();
exports.copyOp(op, bufOp);
} }
} }
}
function endDocument() { function endDocument() {
flush(true); flush(true);
} }
function toString() { function toString() {
flush(); flush();
return assem.toString(); return assem.toString();
} }
function clear() { function clear() {
assem.clear(); assem.clear();
exports.clearOp(bufOp); exports.clearOp(bufOp);
} }
return { return {
append: append, append: append,
toString: toString, toString: toString,
clear: clear, clear: clear,
endDocument: endDocument endDocument: endDocument
};
}; };
} };
if (_opt) {
exports.opAssembler = function () {
var assem = _opt.opAssembler();
// this function allows op to be mutated later (doesn't keep a ref)
function append(op) {
assem.append(op.opcode, op.chars, op.lines, op.attribs); exports.opAssembler = function () {
var pieces = [];
// this function allows op to be mutated later (doesn't keep a ref)
function append(op) {
pieces.push(op.attribs);
if (op.lines) {
pieces.push('|', exports.numToString(op.lines));
} }
pieces.push(op.opcode);
pieces.push(exports.numToString(op.chars));
}
function toString() { function toString() {
return assem.toString(); return pieces.join('');
} }
function clear() { function clear() {
assem.clear(); pieces.length = 0;
} }
return { return {
append: append, append: append,
toString: toString, toString: toString,
clear: clear clear: clear
};
}; };
} else { };
exports.opAssembler = function () {
var pieces = [];
// this function allows op to be mutated later (doesn't keep a ref)
function append(op) {
pieces.push(op.attribs);
if (op.lines) {
pieces.push('|', exports.numToString(op.lines));
}
pieces.push(op.opcode);
pieces.push(exports.numToString(op.chars));
}
function toString() {
return pieces.join('');
}
function clear() {
pieces.length = 0;
}
return {
append: append,
toString: toString,
clear: clear
};
};
}
/** /**
* A custom made String Iterator * A custom made String Iterator