forked from Mirrors/doipjs
1520 lines
42 KiB
JavaScript
1520 lines
42 KiB
JavaScript
|
function Diff() {}
|
|||
|
Diff.prototype = {
|
|||
|
diff: function diff(oldString, newString) {
|
|||
|
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
|||
|
var callback = options.callback;
|
|||
|
|
|||
|
if (typeof options === 'function') {
|
|||
|
callback = options;
|
|||
|
options = {};
|
|||
|
}
|
|||
|
|
|||
|
this.options = options;
|
|||
|
var self = this;
|
|||
|
|
|||
|
function done(value) {
|
|||
|
if (callback) {
|
|||
|
setTimeout(function () {
|
|||
|
callback(undefined, value);
|
|||
|
}, 0);
|
|||
|
return true;
|
|||
|
} else {
|
|||
|
return value;
|
|||
|
}
|
|||
|
} // Allow subclasses to massage the input prior to running
|
|||
|
|
|||
|
|
|||
|
oldString = this.castInput(oldString);
|
|||
|
newString = this.castInput(newString);
|
|||
|
oldString = this.removeEmpty(this.tokenize(oldString));
|
|||
|
newString = this.removeEmpty(this.tokenize(newString));
|
|||
|
var newLen = newString.length,
|
|||
|
oldLen = oldString.length;
|
|||
|
var editLength = 1;
|
|||
|
var maxEditLength = newLen + oldLen;
|
|||
|
var bestPath = [{
|
|||
|
newPos: -1,
|
|||
|
components: []
|
|||
|
}]; // Seed editLength = 0, i.e. the content starts with the same values
|
|||
|
|
|||
|
var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);
|
|||
|
|
|||
|
if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) {
|
|||
|
// Identity per the equality and tokenizer
|
|||
|
return done([{
|
|||
|
value: this.join(newString),
|
|||
|
count: newString.length
|
|||
|
}]);
|
|||
|
} // Main worker method. checks all permutations of a given edit length for acceptance.
|
|||
|
|
|||
|
|
|||
|
function execEditLength() {
|
|||
|
for (var diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) {
|
|||
|
var basePath = void 0;
|
|||
|
|
|||
|
var addPath = bestPath[diagonalPath - 1],
|
|||
|
removePath = bestPath[diagonalPath + 1],
|
|||
|
_oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;
|
|||
|
|
|||
|
if (addPath) {
|
|||
|
// No one else is going to attempt to use this value, clear it
|
|||
|
bestPath[diagonalPath - 1] = undefined;
|
|||
|
}
|
|||
|
|
|||
|
var canAdd = addPath && addPath.newPos + 1 < newLen,
|
|||
|
canRemove = removePath && 0 <= _oldPos && _oldPos < oldLen;
|
|||
|
|
|||
|
if (!canAdd && !canRemove) {
|
|||
|
// If this path is a terminal then prune
|
|||
|
bestPath[diagonalPath] = undefined;
|
|||
|
continue;
|
|||
|
} // Select the diagonal that we want to branch from. We select the prior
|
|||
|
// path whose position in the new string is the farthest from the origin
|
|||
|
// and does not pass the bounds of the diff graph
|
|||
|
|
|||
|
|
|||
|
if (!canAdd || canRemove && addPath.newPos < removePath.newPos) {
|
|||
|
basePath = clonePath(removePath);
|
|||
|
self.pushComponent(basePath.components, undefined, true);
|
|||
|
} else {
|
|||
|
basePath = addPath; // No need to clone, we've pulled it from the list
|
|||
|
|
|||
|
basePath.newPos++;
|
|||
|
self.pushComponent(basePath.components, true, undefined);
|
|||
|
}
|
|||
|
|
|||
|
_oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath); // If we have hit the end of both strings, then we are done
|
|||
|
|
|||
|
if (basePath.newPos + 1 >= newLen && _oldPos + 1 >= oldLen) {
|
|||
|
return done(buildValues(self, basePath.components, newString, oldString, self.useLongestToken));
|
|||
|
} else {
|
|||
|
// Otherwise track this path as a potential candidate and continue.
|
|||
|
bestPath[diagonalPath] = basePath;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
editLength++;
|
|||
|
} // Performs the length of edit iteration. Is a bit fugly as this has to support the
|
|||
|
// sync and async mode which is never fun. Loops over execEditLength until a value
|
|||
|
// is produced.
|
|||
|
|
|||
|
|
|||
|
if (callback) {
|
|||
|
(function exec() {
|
|||
|
setTimeout(function () {
|
|||
|
// This should not happen, but we want to be safe.
|
|||
|
|
|||
|
/* istanbul ignore next */
|
|||
|
if (editLength > maxEditLength) {
|
|||
|
return callback();
|
|||
|
}
|
|||
|
|
|||
|
if (!execEditLength()) {
|
|||
|
exec();
|
|||
|
}
|
|||
|
}, 0);
|
|||
|
})();
|
|||
|
} else {
|
|||
|
while (editLength <= maxEditLength) {
|
|||
|
var ret = execEditLength();
|
|||
|
|
|||
|
if (ret) {
|
|||
|
return ret;
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
},
|
|||
|
pushComponent: function pushComponent(components, added, removed) {
|
|||
|
var last = components[components.length - 1];
|
|||
|
|
|||
|
if (last && last.added === added && last.removed === removed) {
|
|||
|
// We need to clone here as the component clone operation is just
|
|||
|
// as shallow array clone
|
|||
|
components[components.length - 1] = {
|
|||
|
count: last.count + 1,
|
|||
|
added: added,
|
|||
|
removed: removed
|
|||
|
};
|
|||
|
} else {
|
|||
|
components.push({
|
|||
|
count: 1,
|
|||
|
added: added,
|
|||
|
removed: removed
|
|||
|
});
|
|||
|
}
|
|||
|
},
|
|||
|
extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) {
|
|||
|
var newLen = newString.length,
|
|||
|
oldLen = oldString.length,
|
|||
|
newPos = basePath.newPos,
|
|||
|
oldPos = newPos - diagonalPath,
|
|||
|
commonCount = 0;
|
|||
|
|
|||
|
while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) {
|
|||
|
newPos++;
|
|||
|
oldPos++;
|
|||
|
commonCount++;
|
|||
|
}
|
|||
|
|
|||
|
if (commonCount) {
|
|||
|
basePath.components.push({
|
|||
|
count: commonCount
|
|||
|
});
|
|||
|
}
|
|||
|
|
|||
|
basePath.newPos = newPos;
|
|||
|
return oldPos;
|
|||
|
},
|
|||
|
equals: function equals(left, right) {
|
|||
|
if (this.options.comparator) {
|
|||
|
return this.options.comparator(left, right);
|
|||
|
} else {
|
|||
|
return left === right || this.options.ignoreCase && left.toLowerCase() === right.toLowerCase();
|
|||
|
}
|
|||
|
},
|
|||
|
removeEmpty: function removeEmpty(array) {
|
|||
|
var ret = [];
|
|||
|
|
|||
|
for (var i = 0; i < array.length; i++) {
|
|||
|
if (array[i]) {
|
|||
|
ret.push(array[i]);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
return ret;
|
|||
|
},
|
|||
|
castInput: function castInput(value) {
|
|||
|
return value;
|
|||
|
},
|
|||
|
tokenize: function tokenize(value) {
|
|||
|
return value.split('');
|
|||
|
},
|
|||
|
join: function join(chars) {
|
|||
|
return chars.join('');
|
|||
|
}
|
|||
|
};
|
|||
|
|
|||
|
function buildValues(diff, components, newString, oldString, useLongestToken) {
|
|||
|
var componentPos = 0,
|
|||
|
componentLen = components.length,
|
|||
|
newPos = 0,
|
|||
|
oldPos = 0;
|
|||
|
|
|||
|
for (; componentPos < componentLen; componentPos++) {
|
|||
|
var component = components[componentPos];
|
|||
|
|
|||
|
if (!component.removed) {
|
|||
|
if (!component.added && useLongestToken) {
|
|||
|
var value = newString.slice(newPos, newPos + component.count);
|
|||
|
value = value.map(function (value, i) {
|
|||
|
var oldValue = oldString[oldPos + i];
|
|||
|
return oldValue.length > value.length ? oldValue : value;
|
|||
|
});
|
|||
|
component.value = diff.join(value);
|
|||
|
} else {
|
|||
|
component.value = diff.join(newString.slice(newPos, newPos + component.count));
|
|||
|
}
|
|||
|
|
|||
|
newPos += component.count; // Common case
|
|||
|
|
|||
|
if (!component.added) {
|
|||
|
oldPos += component.count;
|
|||
|
}
|
|||
|
} else {
|
|||
|
component.value = diff.join(oldString.slice(oldPos, oldPos + component.count));
|
|||
|
oldPos += component.count; // Reverse add and remove so removes are output first to match common convention
|
|||
|
// The diffing algorithm is tied to add then remove output and this is the simplest
|
|||
|
// route to get the desired output with minimal overhead.
|
|||
|
|
|||
|
if (componentPos && components[componentPos - 1].added) {
|
|||
|
var tmp = components[componentPos - 1];
|
|||
|
components[componentPos - 1] = components[componentPos];
|
|||
|
components[componentPos] = tmp;
|
|||
|
}
|
|||
|
}
|
|||
|
} // Special case handle for when one terminal is ignored (i.e. whitespace).
|
|||
|
// For this case we merge the terminal into the prior string and drop the change.
|
|||
|
// This is only available for string mode.
|
|||
|
|
|||
|
|
|||
|
var lastComponent = components[componentLen - 1];
|
|||
|
|
|||
|
if (componentLen > 1 && typeof lastComponent.value === 'string' && (lastComponent.added || lastComponent.removed) && diff.equals('', lastComponent.value)) {
|
|||
|
components[componentLen - 2].value += lastComponent.value;
|
|||
|
components.pop();
|
|||
|
}
|
|||
|
|
|||
|
return components;
|
|||
|
}
|
|||
|
|
|||
|
function clonePath(path) {
|
|||
|
return {
|
|||
|
newPos: path.newPos,
|
|||
|
components: path.components.slice(0)
|
|||
|
};
|
|||
|
}
|
|||
|
|
|||
|
var characterDiff = new Diff();
|
|||
|
function diffChars(oldStr, newStr, options) {
|
|||
|
return characterDiff.diff(oldStr, newStr, options);
|
|||
|
}
|
|||
|
|
|||
|
function generateOptions(options, defaults) {
|
|||
|
if (typeof options === 'function') {
|
|||
|
defaults.callback = options;
|
|||
|
} else if (options) {
|
|||
|
for (var name in options) {
|
|||
|
/* istanbul ignore else */
|
|||
|
if (options.hasOwnProperty(name)) {
|
|||
|
defaults[name] = options[name];
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
return defaults;
|
|||
|
}
|
|||
|
|
|||
|
//
|
|||
|
// Ranges and exceptions:
|
|||
|
// Latin-1 Supplement, 0080–00FF
|
|||
|
// - U+00D7 × Multiplication sign
|
|||
|
// - U+00F7 ÷ Division sign
|
|||
|
// Latin Extended-A, 0100–017F
|
|||
|
// Latin Extended-B, 0180–024F
|
|||
|
// IPA Extensions, 0250–02AF
|
|||
|
// Spacing Modifier Letters, 02B0–02FF
|
|||
|
// - U+02C7 ˇ ˇ Caron
|
|||
|
// - U+02D8 ˘ ˘ Breve
|
|||
|
// - U+02D9 ˙ ˙ Dot Above
|
|||
|
// - U+02DA ˚ ˚ Ring Above
|
|||
|
// - U+02DB ˛ ˛ Ogonek
|
|||
|
// - U+02DC ˜ ˜ Small Tilde
|
|||
|
// - U+02DD ˝ ˝ Double Acute Accent
|
|||
|
// Latin Extended Additional, 1E00–1EFF
|
|||
|
|
|||
|
var extendedWordChars = /^[A-Za-z\xC0-\u02C6\u02C8-\u02D7\u02DE-\u02FF\u1E00-\u1EFF]+$/;
|
|||
|
var reWhitespace = /\S/;
|
|||
|
var wordDiff = new Diff();
|
|||
|
|
|||
|
wordDiff.equals = function (left, right) {
|
|||
|
if (this.options.ignoreCase) {
|
|||
|
left = left.toLowerCase();
|
|||
|
right = right.toLowerCase();
|
|||
|
}
|
|||
|
|
|||
|
return left === right || this.options.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right);
|
|||
|
};
|
|||
|
|
|||
|
wordDiff.tokenize = function (value) {
|
|||
|
var tokens = value.split(/(\s+|[()[\]{}'"]|\b)/); // Join the boundary splits that we do not consider to be boundaries. This is primarily the extended Latin character set.
|
|||
|
|
|||
|
for (var i = 0; i < tokens.length - 1; i++) {
|
|||
|
// If we have an empty string in the next field and we have only word chars before and after, merge
|
|||
|
if (!tokens[i + 1] && tokens[i + 2] && extendedWordChars.test(tokens[i]) && extendedWordChars.test(tokens[i + 2])) {
|
|||
|
tokens[i] += tokens[i + 2];
|
|||
|
tokens.splice(i + 1, 2);
|
|||
|
i--;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
return tokens;
|
|||
|
};
|
|||
|
|
|||
|
function diffWords(oldStr, newStr, options) {
|
|||
|
options = generateOptions(options, {
|
|||
|
ignoreWhitespace: true
|
|||
|
});
|
|||
|
return wordDiff.diff(oldStr, newStr, options);
|
|||
|
}
|
|||
|
function diffWordsWithSpace(oldStr, newStr, options) {
|
|||
|
return wordDiff.diff(oldStr, newStr, options);
|
|||
|
}
|
|||
|
|
|||
|
var lineDiff = new Diff();
|
|||
|
|
|||
|
lineDiff.tokenize = function (value) {
|
|||
|
var retLines = [],
|
|||
|
linesAndNewlines = value.split(/(\n|\r\n)/); // Ignore the final empty token that occurs if the string ends with a new line
|
|||
|
|
|||
|
if (!linesAndNewlines[linesAndNewlines.length - 1]) {
|
|||
|
linesAndNewlines.pop();
|
|||
|
} // Merge the content and line separators into single tokens
|
|||
|
|
|||
|
|
|||
|
for (var i = 0; i < linesAndNewlines.length; i++) {
|
|||
|
var line = linesAndNewlines[i];
|
|||
|
|
|||
|
if (i % 2 && !this.options.newlineIsToken) {
|
|||
|
retLines[retLines.length - 1] += line;
|
|||
|
} else {
|
|||
|
if (this.options.ignoreWhitespace) {
|
|||
|
line = line.trim();
|
|||
|
}
|
|||
|
|
|||
|
retLines.push(line);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
return retLines;
|
|||
|
};
|
|||
|
|
|||
|
function diffLines(oldStr, newStr, callback) {
|
|||
|
return lineDiff.diff(oldStr, newStr, callback);
|
|||
|
}
|
|||
|
function diffTrimmedLines(oldStr, newStr, callback) {
|
|||
|
var options = generateOptions(callback, {
|
|||
|
ignoreWhitespace: true
|
|||
|
});
|
|||
|
return lineDiff.diff(oldStr, newStr, options);
|
|||
|
}
|
|||
|
|
|||
|
var sentenceDiff = new Diff();
|
|||
|
|
|||
|
sentenceDiff.tokenize = function (value) {
|
|||
|
return value.split(/(\S.+?[.!?])(?=\s+|$)/);
|
|||
|
};
|
|||
|
|
|||
|
function diffSentences(oldStr, newStr, callback) {
|
|||
|
return sentenceDiff.diff(oldStr, newStr, callback);
|
|||
|
}
|
|||
|
|
|||
|
var cssDiff = new Diff();
|
|||
|
|
|||
|
cssDiff.tokenize = function (value) {
|
|||
|
return value.split(/([{}:;,]|\s+)/);
|
|||
|
};
|
|||
|
|
|||
|
function diffCss(oldStr, newStr, callback) {
|
|||
|
return cssDiff.diff(oldStr, newStr, callback);
|
|||
|
}
|
|||
|
|
|||
|
function _typeof(obj) {
|
|||
|
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
|
|||
|
_typeof = function (obj) {
|
|||
|
return typeof obj;
|
|||
|
};
|
|||
|
} else {
|
|||
|
_typeof = function (obj) {
|
|||
|
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
|
|||
|
};
|
|||
|
}
|
|||
|
|
|||
|
return _typeof(obj);
|
|||
|
}
|
|||
|
|
|||
|
function _toConsumableArray(arr) {
|
|||
|
return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
|
|||
|
}
|
|||
|
|
|||
|
function _arrayWithoutHoles(arr) {
|
|||
|
if (Array.isArray(arr)) {
|
|||
|
for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
|
|||
|
|
|||
|
return arr2;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
function _iterableToArray(iter) {
|
|||
|
if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
|
|||
|
}
|
|||
|
|
|||
|
function _nonIterableSpread() {
|
|||
|
throw new TypeError("Invalid attempt to spread non-iterable instance");
|
|||
|
}
|
|||
|
|
|||
|
var objectPrototypeToString = Object.prototype.toString;
|
|||
|
var jsonDiff = new Diff(); // Discriminate between two lines of pretty-printed, serialized JSON where one of them has a
|
|||
|
// dangling comma and the other doesn't. Turns out including the dangling comma yields the nicest output:
|
|||
|
|
|||
|
jsonDiff.useLongestToken = true;
|
|||
|
jsonDiff.tokenize = lineDiff.tokenize;
|
|||
|
|
|||
|
jsonDiff.castInput = function (value) {
|
|||
|
var _this$options = this.options,
|
|||
|
undefinedReplacement = _this$options.undefinedReplacement,
|
|||
|
_this$options$stringi = _this$options.stringifyReplacer,
|
|||
|
stringifyReplacer = _this$options$stringi === void 0 ? function (k, v) {
|
|||
|
return typeof v === 'undefined' ? undefinedReplacement : v;
|
|||
|
} : _this$options$stringi;
|
|||
|
return typeof value === 'string' ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), stringifyReplacer, ' ');
|
|||
|
};
|
|||
|
|
|||
|
jsonDiff.equals = function (left, right) {
|
|||
|
return Diff.prototype.equals.call(jsonDiff, left.replace(/,([\r\n])/g, '$1'), right.replace(/,([\r\n])/g, '$1'));
|
|||
|
};
|
|||
|
|
|||
|
function diffJson(oldObj, newObj, options) {
|
|||
|
return jsonDiff.diff(oldObj, newObj, options);
|
|||
|
} // This function handles the presence of circular references by bailing out when encountering an
|
|||
|
// object that is already on the "stack" of items being processed. Accepts an optional replacer
|
|||
|
|
|||
|
function canonicalize(obj, stack, replacementStack, replacer, key) {
|
|||
|
stack = stack || [];
|
|||
|
replacementStack = replacementStack || [];
|
|||
|
|
|||
|
if (replacer) {
|
|||
|
obj = replacer(key, obj);
|
|||
|
}
|
|||
|
|
|||
|
var i;
|
|||
|
|
|||
|
for (i = 0; i < stack.length; i += 1) {
|
|||
|
if (stack[i] === obj) {
|
|||
|
return replacementStack[i];
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
var canonicalizedObj;
|
|||
|
|
|||
|
if ('[object Array]' === objectPrototypeToString.call(obj)) {
|
|||
|
stack.push(obj);
|
|||
|
canonicalizedObj = new Array(obj.length);
|
|||
|
replacementStack.push(canonicalizedObj);
|
|||
|
|
|||
|
for (i = 0; i < obj.length; i += 1) {
|
|||
|
canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, key);
|
|||
|
}
|
|||
|
|
|||
|
stack.pop();
|
|||
|
replacementStack.pop();
|
|||
|
return canonicalizedObj;
|
|||
|
}
|
|||
|
|
|||
|
if (obj && obj.toJSON) {
|
|||
|
obj = obj.toJSON();
|
|||
|
}
|
|||
|
|
|||
|
if (_typeof(obj) === 'object' && obj !== null) {
|
|||
|
stack.push(obj);
|
|||
|
canonicalizedObj = {};
|
|||
|
replacementStack.push(canonicalizedObj);
|
|||
|
|
|||
|
var sortedKeys = [],
|
|||
|
_key;
|
|||
|
|
|||
|
for (_key in obj) {
|
|||
|
/* istanbul ignore else */
|
|||
|
if (obj.hasOwnProperty(_key)) {
|
|||
|
sortedKeys.push(_key);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
sortedKeys.sort();
|
|||
|
|
|||
|
for (i = 0; i < sortedKeys.length; i += 1) {
|
|||
|
_key = sortedKeys[i];
|
|||
|
canonicalizedObj[_key] = canonicalize(obj[_key], stack, replacementStack, replacer, _key);
|
|||
|
}
|
|||
|
|
|||
|
stack.pop();
|
|||
|
replacementStack.pop();
|
|||
|
} else {
|
|||
|
canonicalizedObj = obj;
|
|||
|
}
|
|||
|
|
|||
|
return canonicalizedObj;
|
|||
|
}
|
|||
|
|
|||
|
var arrayDiff = new Diff();
|
|||
|
|
|||
|
arrayDiff.tokenize = function (value) {
|
|||
|
return value.slice();
|
|||
|
};
|
|||
|
|
|||
|
arrayDiff.join = arrayDiff.removeEmpty = function (value) {
|
|||
|
return value;
|
|||
|
};
|
|||
|
|
|||
|
function diffArrays(oldArr, newArr, callback) {
|
|||
|
return arrayDiff.diff(oldArr, newArr, callback);
|
|||
|
}
|
|||
|
|
|||
|
function parsePatch(uniDiff) {
|
|||
|
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|||
|
var diffstr = uniDiff.split(/\r\n|[\n\v\f\r\x85]/),
|
|||
|
delimiters = uniDiff.match(/\r\n|[\n\v\f\r\x85]/g) || [],
|
|||
|
list = [],
|
|||
|
i = 0;
|
|||
|
|
|||
|
function parseIndex() {
|
|||
|
var index = {};
|
|||
|
list.push(index); // Parse diff metadata
|
|||
|
|
|||
|
while (i < diffstr.length) {
|
|||
|
var line = diffstr[i]; // File header found, end parsing diff metadata
|
|||
|
|
|||
|
if (/^(\-\-\-|\+\+\+|@@)\s/.test(line)) {
|
|||
|
break;
|
|||
|
} // Diff index
|
|||
|
|
|||
|
|
|||
|
var header = /^(?:Index:|diff(?: -r \w+)+)\s+(.+?)\s*$/.exec(line);
|
|||
|
|
|||
|
if (header) {
|
|||
|
index.index = header[1];
|
|||
|
}
|
|||
|
|
|||
|
i++;
|
|||
|
} // Parse file headers if they are defined. Unified diff requires them, but
|
|||
|
// there's no technical issues to have an isolated hunk without file header
|
|||
|
|
|||
|
|
|||
|
parseFileHeader(index);
|
|||
|
parseFileHeader(index); // Parse hunks
|
|||
|
|
|||
|
index.hunks = [];
|
|||
|
|
|||
|
while (i < diffstr.length) {
|
|||
|
var _line = diffstr[i];
|
|||
|
|
|||
|
if (/^(Index:|diff|\-\-\-|\+\+\+)\s/.test(_line)) {
|
|||
|
break;
|
|||
|
} else if (/^@@/.test(_line)) {
|
|||
|
index.hunks.push(parseHunk());
|
|||
|
} else if (_line && options.strict) {
|
|||
|
// Ignore unexpected content unless in strict mode
|
|||
|
throw new Error('Unknown line ' + (i + 1) + ' ' + JSON.stringify(_line));
|
|||
|
} else {
|
|||
|
i++;
|
|||
|
}
|
|||
|
}
|
|||
|
} // Parses the --- and +++ headers, if none are found, no lines
|
|||
|
// are consumed.
|
|||
|
|
|||
|
|
|||
|
function parseFileHeader(index) {
|
|||
|
var fileHeader = /^(---|\+\+\+)\s+(.*)$/.exec(diffstr[i]);
|
|||
|
|
|||
|
if (fileHeader) {
|
|||
|
var keyPrefix = fileHeader[1] === '---' ? 'old' : 'new';
|
|||
|
var data = fileHeader[2].split('\t', 2);
|
|||
|
var fileName = data[0].replace(/\\\\/g, '\\');
|
|||
|
|
|||
|
if (/^".*"$/.test(fileName)) {
|
|||
|
fileName = fileName.substr(1, fileName.length - 2);
|
|||
|
}
|
|||
|
|
|||
|
index[keyPrefix + 'FileName'] = fileName;
|
|||
|
index[keyPrefix + 'Header'] = (data[1] || '').trim();
|
|||
|
i++;
|
|||
|
}
|
|||
|
} // Parses a hunk
|
|||
|
// This assumes that we are at the start of a hunk.
|
|||
|
|
|||
|
|
|||
|
function parseHunk() {
|
|||
|
var chunkHeaderIndex = i,
|
|||
|
chunkHeaderLine = diffstr[i++],
|
|||
|
chunkHeader = chunkHeaderLine.split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
|
|||
|
var hunk = {
|
|||
|
oldStart: +chunkHeader[1],
|
|||
|
oldLines: +chunkHeader[2] || 1,
|
|||
|
newStart: +chunkHeader[3],
|
|||
|
newLines: +chunkHeader[4] || 1,
|
|||
|
lines: [],
|
|||
|
linedelimiters: []
|
|||
|
};
|
|||
|
var addCount = 0,
|
|||
|
removeCount = 0;
|
|||
|
|
|||
|
for (; i < diffstr.length; i++) {
|
|||
|
// Lines starting with '---' could be mistaken for the "remove line" operation
|
|||
|
// But they could be the header for the next file. Therefore prune such cases out.
|
|||
|
if (diffstr[i].indexOf('--- ') === 0 && i + 2 < diffstr.length && diffstr[i + 1].indexOf('+++ ') === 0 && diffstr[i + 2].indexOf('@@') === 0) {
|
|||
|
break;
|
|||
|
}
|
|||
|
|
|||
|
var operation = diffstr[i].length == 0 && i != diffstr.length - 1 ? ' ' : diffstr[i][0];
|
|||
|
|
|||
|
if (operation === '+' || operation === '-' || operation === ' ' || operation === '\\') {
|
|||
|
hunk.lines.push(diffstr[i]);
|
|||
|
hunk.linedelimiters.push(delimiters[i] || '\n');
|
|||
|
|
|||
|
if (operation === '+') {
|
|||
|
addCount++;
|
|||
|
} else if (operation === '-') {
|
|||
|
removeCount++;
|
|||
|
} else if (operation === ' ') {
|
|||
|
addCount++;
|
|||
|
removeCount++;
|
|||
|
}
|
|||
|
} else {
|
|||
|
break;
|
|||
|
}
|
|||
|
} // Handle the empty block count case
|
|||
|
|
|||
|
|
|||
|
if (!addCount && hunk.newLines === 1) {
|
|||
|
hunk.newLines = 0;
|
|||
|
}
|
|||
|
|
|||
|
if (!removeCount && hunk.oldLines === 1) {
|
|||
|
hunk.oldLines = 0;
|
|||
|
} // Perform optional sanity checking
|
|||
|
|
|||
|
|
|||
|
if (options.strict) {
|
|||
|
if (addCount !== hunk.newLines) {
|
|||
|
throw new Error('Added line count did not match for hunk at line ' + (chunkHeaderIndex + 1));
|
|||
|
}
|
|||
|
|
|||
|
if (removeCount !== hunk.oldLines) {
|
|||
|
throw new Error('Removed line count did not match for hunk at line ' + (chunkHeaderIndex + 1));
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
return hunk;
|
|||
|
}
|
|||
|
|
|||
|
while (i < diffstr.length) {
|
|||
|
parseIndex();
|
|||
|
}
|
|||
|
|
|||
|
return list;
|
|||
|
}
|
|||
|
|
|||
|
// Iterator that traverses in the range of [min, max], stepping
|
|||
|
// by distance from a given start position. I.e. for [0, 4], with
|
|||
|
// start of 2, this will iterate 2, 3, 1, 4, 0.
|
|||
|
function distanceIterator (start, minLine, maxLine) {
|
|||
|
var wantForward = true,
|
|||
|
backwardExhausted = false,
|
|||
|
forwardExhausted = false,
|
|||
|
localOffset = 1;
|
|||
|
return function iterator() {
|
|||
|
if (wantForward && !forwardExhausted) {
|
|||
|
if (backwardExhausted) {
|
|||
|
localOffset++;
|
|||
|
} else {
|
|||
|
wantForward = false;
|
|||
|
} // Check if trying to fit beyond text length, and if not, check it fits
|
|||
|
// after offset location (or desired location on first iteration)
|
|||
|
|
|||
|
|
|||
|
if (start + localOffset <= maxLine) {
|
|||
|
return localOffset;
|
|||
|
}
|
|||
|
|
|||
|
forwardExhausted = true;
|
|||
|
}
|
|||
|
|
|||
|
if (!backwardExhausted) {
|
|||
|
if (!forwardExhausted) {
|
|||
|
wantForward = true;
|
|||
|
} // Check if trying to fit before text beginning, and if not, check it fits
|
|||
|
// before offset location
|
|||
|
|
|||
|
|
|||
|
if (minLine <= start - localOffset) {
|
|||
|
return -localOffset++;
|
|||
|
}
|
|||
|
|
|||
|
backwardExhausted = true;
|
|||
|
return iterator();
|
|||
|
} // We tried to fit hunk before text beginning and beyond text length, then
|
|||
|
// hunk can't fit on the text. Return undefined
|
|||
|
|
|||
|
};
|
|||
|
}
|
|||
|
|
|||
|
function applyPatch(source, uniDiff) {
|
|||
|
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
|||
|
|
|||
|
if (typeof uniDiff === 'string') {
|
|||
|
uniDiff = parsePatch(uniDiff);
|
|||
|
}
|
|||
|
|
|||
|
if (Array.isArray(uniDiff)) {
|
|||
|
if (uniDiff.length > 1) {
|
|||
|
throw new Error('applyPatch only works with a single input.');
|
|||
|
}
|
|||
|
|
|||
|
uniDiff = uniDiff[0];
|
|||
|
} // Apply the diff to the input
|
|||
|
|
|||
|
|
|||
|
var lines = source.split(/\r\n|[\n\v\f\r\x85]/),
|
|||
|
delimiters = source.match(/\r\n|[\n\v\f\r\x85]/g) || [],
|
|||
|
hunks = uniDiff.hunks,
|
|||
|
compareLine = options.compareLine || function (lineNumber, line, operation, patchContent) {
|
|||
|
return line === patchContent;
|
|||
|
},
|
|||
|
errorCount = 0,
|
|||
|
fuzzFactor = options.fuzzFactor || 0,
|
|||
|
minLine = 0,
|
|||
|
offset = 0,
|
|||
|
removeEOFNL,
|
|||
|
addEOFNL;
|
|||
|
/**
|
|||
|
* Checks if the hunk exactly fits on the provided location
|
|||
|
*/
|
|||
|
|
|||
|
|
|||
|
function hunkFits(hunk, toPos) {
|
|||
|
for (var j = 0; j < hunk.lines.length; j++) {
|
|||
|
var line = hunk.lines[j],
|
|||
|
operation = line.length > 0 ? line[0] : ' ',
|
|||
|
content = line.length > 0 ? line.substr(1) : line;
|
|||
|
|
|||
|
if (operation === ' ' || operation === '-') {
|
|||
|
// Context sanity check
|
|||
|
if (!compareLine(toPos + 1, lines[toPos], operation, content)) {
|
|||
|
errorCount++;
|
|||
|
|
|||
|
if (errorCount > fuzzFactor) {
|
|||
|
return false;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
toPos++;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
return true;
|
|||
|
} // Search best fit offsets for each hunk based on the previous ones
|
|||
|
|
|||
|
|
|||
|
for (var i = 0; i < hunks.length; i++) {
|
|||
|
var hunk = hunks[i],
|
|||
|
maxLine = lines.length - hunk.oldLines,
|
|||
|
localOffset = 0,
|
|||
|
toPos = offset + hunk.oldStart - 1;
|
|||
|
var iterator = distanceIterator(toPos, minLine, maxLine);
|
|||
|
|
|||
|
for (; localOffset !== undefined; localOffset = iterator()) {
|
|||
|
if (hunkFits(hunk, toPos + localOffset)) {
|
|||
|
hunk.offset = offset += localOffset;
|
|||
|
break;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
if (localOffset === undefined) {
|
|||
|
return false;
|
|||
|
} // Set lower text limit to end of the current hunk, so next ones don't try
|
|||
|
// to fit over already patched text
|
|||
|
|
|||
|
|
|||
|
minLine = hunk.offset + hunk.oldStart + hunk.oldLines;
|
|||
|
} // Apply patch hunks
|
|||
|
|
|||
|
|
|||
|
var diffOffset = 0;
|
|||
|
|
|||
|
for (var _i = 0; _i < hunks.length; _i++) {
|
|||
|
var _hunk = hunks[_i],
|
|||
|
_toPos = _hunk.oldStart + _hunk.offset + diffOffset - 1;
|
|||
|
|
|||
|
diffOffset += _hunk.newLines - _hunk.oldLines;
|
|||
|
|
|||
|
if (_toPos < 0) {
|
|||
|
// Creating a new file
|
|||
|
_toPos = 0;
|
|||
|
}
|
|||
|
|
|||
|
for (var j = 0; j < _hunk.lines.length; j++) {
|
|||
|
var line = _hunk.lines[j],
|
|||
|
operation = line.length > 0 ? line[0] : ' ',
|
|||
|
content = line.length > 0 ? line.substr(1) : line,
|
|||
|
delimiter = _hunk.linedelimiters[j];
|
|||
|
|
|||
|
if (operation === ' ') {
|
|||
|
_toPos++;
|
|||
|
} else if (operation === '-') {
|
|||
|
lines.splice(_toPos, 1);
|
|||
|
delimiters.splice(_toPos, 1);
|
|||
|
/* istanbul ignore else */
|
|||
|
} else if (operation === '+') {
|
|||
|
lines.splice(_toPos, 0, content);
|
|||
|
delimiters.splice(_toPos, 0, delimiter);
|
|||
|
_toPos++;
|
|||
|
} else if (operation === '\\') {
|
|||
|
var previousOperation = _hunk.lines[j - 1] ? _hunk.lines[j - 1][0] : null;
|
|||
|
|
|||
|
if (previousOperation === '+') {
|
|||
|
removeEOFNL = true;
|
|||
|
} else if (previousOperation === '-') {
|
|||
|
addEOFNL = true;
|
|||
|
}
|
|||
|
}
|
|||
|
}
|
|||
|
} // Handle EOFNL insertion/removal
|
|||
|
|
|||
|
|
|||
|
if (removeEOFNL) {
|
|||
|
while (!lines[lines.length - 1]) {
|
|||
|
lines.pop();
|
|||
|
delimiters.pop();
|
|||
|
}
|
|||
|
} else if (addEOFNL) {
|
|||
|
lines.push('');
|
|||
|
delimiters.push('\n');
|
|||
|
}
|
|||
|
|
|||
|
for (var _k = 0; _k < lines.length - 1; _k++) {
|
|||
|
lines[_k] = lines[_k] + delimiters[_k];
|
|||
|
}
|
|||
|
|
|||
|
return lines.join('');
|
|||
|
} // Wrapper that supports multiple file patches via callbacks.
|
|||
|
|
|||
|
function applyPatches(uniDiff, options) {
|
|||
|
if (typeof uniDiff === 'string') {
|
|||
|
uniDiff = parsePatch(uniDiff);
|
|||
|
}
|
|||
|
|
|||
|
var currentIndex = 0;
|
|||
|
|
|||
|
function processIndex() {
|
|||
|
var index = uniDiff[currentIndex++];
|
|||
|
|
|||
|
if (!index) {
|
|||
|
return options.complete();
|
|||
|
}
|
|||
|
|
|||
|
options.loadFile(index, function (err, data) {
|
|||
|
if (err) {
|
|||
|
return options.complete(err);
|
|||
|
}
|
|||
|
|
|||
|
var updatedContent = applyPatch(data, index, options);
|
|||
|
options.patched(index, updatedContent, function (err) {
|
|||
|
if (err) {
|
|||
|
return options.complete(err);
|
|||
|
}
|
|||
|
|
|||
|
processIndex();
|
|||
|
});
|
|||
|
});
|
|||
|
}
|
|||
|
|
|||
|
processIndex();
|
|||
|
}
|
|||
|
|
|||
|
function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
|
|||
|
if (!options) {
|
|||
|
options = {};
|
|||
|
}
|
|||
|
|
|||
|
if (typeof options.context === 'undefined') {
|
|||
|
options.context = 4;
|
|||
|
}
|
|||
|
|
|||
|
var diff = diffLines(oldStr, newStr, options);
|
|||
|
diff.push({
|
|||
|
value: '',
|
|||
|
lines: []
|
|||
|
}); // Append an empty value to make cleanup easier
|
|||
|
|
|||
|
function contextLines(lines) {
|
|||
|
return lines.map(function (entry) {
|
|||
|
return ' ' + entry;
|
|||
|
});
|
|||
|
}
|
|||
|
|
|||
|
var hunks = [];
|
|||
|
var oldRangeStart = 0,
|
|||
|
newRangeStart = 0,
|
|||
|
curRange = [],
|
|||
|
oldLine = 1,
|
|||
|
newLine = 1;
|
|||
|
|
|||
|
var _loop = function _loop(i) {
|
|||
|
var current = diff[i],
|
|||
|
lines = current.lines || current.value.replace(/\n$/, '').split('\n');
|
|||
|
current.lines = lines;
|
|||
|
|
|||
|
if (current.added || current.removed) {
|
|||
|
var _curRange;
|
|||
|
|
|||
|
// If we have previous context, start with that
|
|||
|
if (!oldRangeStart) {
|
|||
|
var prev = diff[i - 1];
|
|||
|
oldRangeStart = oldLine;
|
|||
|
newRangeStart = newLine;
|
|||
|
|
|||
|
if (prev) {
|
|||
|
curRange = options.context > 0 ? contextLines(prev.lines.slice(-options.context)) : [];
|
|||
|
oldRangeStart -= curRange.length;
|
|||
|
newRangeStart -= curRange.length;
|
|||
|
}
|
|||
|
} // Output our changes
|
|||
|
|
|||
|
|
|||
|
(_curRange = curRange).push.apply(_curRange, _toConsumableArray(lines.map(function (entry) {
|
|||
|
return (current.added ? '+' : '-') + entry;
|
|||
|
}))); // Track the updated file position
|
|||
|
|
|||
|
|
|||
|
if (current.added) {
|
|||
|
newLine += lines.length;
|
|||
|
} else {
|
|||
|
oldLine += lines.length;
|
|||
|
}
|
|||
|
} else {
|
|||
|
// Identical context lines. Track line changes
|
|||
|
if (oldRangeStart) {
|
|||
|
// Close out any changes that have been output (or join overlapping)
|
|||
|
if (lines.length <= options.context * 2 && i < diff.length - 2) {
|
|||
|
var _curRange2;
|
|||
|
|
|||
|
// Overlapping
|
|||
|
(_curRange2 = curRange).push.apply(_curRange2, _toConsumableArray(contextLines(lines)));
|
|||
|
} else {
|
|||
|
var _curRange3;
|
|||
|
|
|||
|
// end the range and output
|
|||
|
var contextSize = Math.min(lines.length, options.context);
|
|||
|
|
|||
|
(_curRange3 = curRange).push.apply(_curRange3, _toConsumableArray(contextLines(lines.slice(0, contextSize))));
|
|||
|
|
|||
|
var hunk = {
|
|||
|
oldStart: oldRangeStart,
|
|||
|
oldLines: oldLine - oldRangeStart + contextSize,
|
|||
|
newStart: newRangeStart,
|
|||
|
newLines: newLine - newRangeStart + contextSize,
|
|||
|
lines: curRange
|
|||
|
};
|
|||
|
|
|||
|
if (i >= diff.length - 2 && lines.length <= options.context) {
|
|||
|
// EOF is inside this hunk
|
|||
|
var oldEOFNewline = /\n$/.test(oldStr);
|
|||
|
var newEOFNewline = /\n$/.test(newStr);
|
|||
|
var noNlBeforeAdds = lines.length == 0 && curRange.length > hunk.oldLines;
|
|||
|
|
|||
|
if (!oldEOFNewline && noNlBeforeAdds) {
|
|||
|
// special case: old has no eol and no trailing context; no-nl can end up before adds
|
|||
|
curRange.splice(hunk.oldLines, 0, '\\ No newline at end of file');
|
|||
|
}
|
|||
|
|
|||
|
if (!oldEOFNewline && !noNlBeforeAdds || !newEOFNewline) {
|
|||
|
curRange.push('\\ No newline at end of file');
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
hunks.push(hunk);
|
|||
|
oldRangeStart = 0;
|
|||
|
newRangeStart = 0;
|
|||
|
curRange = [];
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
oldLine += lines.length;
|
|||
|
newLine += lines.length;
|
|||
|
}
|
|||
|
};
|
|||
|
|
|||
|
for (var i = 0; i < diff.length; i++) {
|
|||
|
_loop(i);
|
|||
|
}
|
|||
|
|
|||
|
return {
|
|||
|
oldFileName: oldFileName,
|
|||
|
newFileName: newFileName,
|
|||
|
oldHeader: oldHeader,
|
|||
|
newHeader: newHeader,
|
|||
|
hunks: hunks
|
|||
|
};
|
|||
|
}
|
|||
|
function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
|
|||
|
var diff = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
|
|||
|
var ret = [];
|
|||
|
|
|||
|
if (oldFileName == newFileName) {
|
|||
|
ret.push('Index: ' + oldFileName);
|
|||
|
}
|
|||
|
|
|||
|
ret.push('===================================================================');
|
|||
|
ret.push('--- ' + diff.oldFileName + (typeof diff.oldHeader === 'undefined' ? '' : '\t' + diff.oldHeader));
|
|||
|
ret.push('+++ ' + diff.newFileName + (typeof diff.newHeader === 'undefined' ? '' : '\t' + diff.newHeader));
|
|||
|
|
|||
|
for (var i = 0; i < diff.hunks.length; i++) {
|
|||
|
var hunk = diff.hunks[i];
|
|||
|
ret.push('@@ -' + hunk.oldStart + ',' + hunk.oldLines + ' +' + hunk.newStart + ',' + hunk.newLines + ' @@');
|
|||
|
ret.push.apply(ret, hunk.lines);
|
|||
|
}
|
|||
|
|
|||
|
return ret.join('\n') + '\n';
|
|||
|
}
|
|||
|
function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {
|
|||
|
return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options);
|
|||
|
}
|
|||
|
|
|||
|
function arrayEqual(a, b) {
|
|||
|
if (a.length !== b.length) {
|
|||
|
return false;
|
|||
|
}
|
|||
|
|
|||
|
return arrayStartsWith(a, b);
|
|||
|
}
|
|||
|
function arrayStartsWith(array, start) {
|
|||
|
if (start.length > array.length) {
|
|||
|
return false;
|
|||
|
}
|
|||
|
|
|||
|
for (var i = 0; i < start.length; i++) {
|
|||
|
if (start[i] !== array[i]) {
|
|||
|
return false;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
return true;
|
|||
|
}
|
|||
|
|
|||
|
function calcLineCount(hunk) {
|
|||
|
var _calcOldNewLineCount = calcOldNewLineCount(hunk.lines),
|
|||
|
oldLines = _calcOldNewLineCount.oldLines,
|
|||
|
newLines = _calcOldNewLineCount.newLines;
|
|||
|
|
|||
|
if (oldLines !== undefined) {
|
|||
|
hunk.oldLines = oldLines;
|
|||
|
} else {
|
|||
|
delete hunk.oldLines;
|
|||
|
}
|
|||
|
|
|||
|
if (newLines !== undefined) {
|
|||
|
hunk.newLines = newLines;
|
|||
|
} else {
|
|||
|
delete hunk.newLines;
|
|||
|
}
|
|||
|
}
|
|||
|
function merge(mine, theirs, base) {
|
|||
|
mine = loadPatch(mine, base);
|
|||
|
theirs = loadPatch(theirs, base);
|
|||
|
var ret = {}; // For index we just let it pass through as it doesn't have any necessary meaning.
|
|||
|
// Leaving sanity checks on this to the API consumer that may know more about the
|
|||
|
// meaning in their own context.
|
|||
|
|
|||
|
if (mine.index || theirs.index) {
|
|||
|
ret.index = mine.index || theirs.index;
|
|||
|
}
|
|||
|
|
|||
|
if (mine.newFileName || theirs.newFileName) {
|
|||
|
if (!fileNameChanged(mine)) {
|
|||
|
// No header or no change in ours, use theirs (and ours if theirs does not exist)
|
|||
|
ret.oldFileName = theirs.oldFileName || mine.oldFileName;
|
|||
|
ret.newFileName = theirs.newFileName || mine.newFileName;
|
|||
|
ret.oldHeader = theirs.oldHeader || mine.oldHeader;
|
|||
|
ret.newHeader = theirs.newHeader || mine.newHeader;
|
|||
|
} else if (!fileNameChanged(theirs)) {
|
|||
|
// No header or no change in theirs, use ours
|
|||
|
ret.oldFileName = mine.oldFileName;
|
|||
|
ret.newFileName = mine.newFileName;
|
|||
|
ret.oldHeader = mine.oldHeader;
|
|||
|
ret.newHeader = mine.newHeader;
|
|||
|
} else {
|
|||
|
// Both changed... figure it out
|
|||
|
ret.oldFileName = selectField(ret, mine.oldFileName, theirs.oldFileName);
|
|||
|
ret.newFileName = selectField(ret, mine.newFileName, theirs.newFileName);
|
|||
|
ret.oldHeader = selectField(ret, mine.oldHeader, theirs.oldHeader);
|
|||
|
ret.newHeader = selectField(ret, mine.newHeader, theirs.newHeader);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
ret.hunks = [];
|
|||
|
var mineIndex = 0,
|
|||
|
theirsIndex = 0,
|
|||
|
mineOffset = 0,
|
|||
|
theirsOffset = 0;
|
|||
|
|
|||
|
while (mineIndex < mine.hunks.length || theirsIndex < theirs.hunks.length) {
|
|||
|
var mineCurrent = mine.hunks[mineIndex] || {
|
|||
|
oldStart: Infinity
|
|||
|
},
|
|||
|
theirsCurrent = theirs.hunks[theirsIndex] || {
|
|||
|
oldStart: Infinity
|
|||
|
};
|
|||
|
|
|||
|
if (hunkBefore(mineCurrent, theirsCurrent)) {
|
|||
|
// This patch does not overlap with any of the others, yay.
|
|||
|
ret.hunks.push(cloneHunk(mineCurrent, mineOffset));
|
|||
|
mineIndex++;
|
|||
|
theirsOffset += mineCurrent.newLines - mineCurrent.oldLines;
|
|||
|
} else if (hunkBefore(theirsCurrent, mineCurrent)) {
|
|||
|
// This patch does not overlap with any of the others, yay.
|
|||
|
ret.hunks.push(cloneHunk(theirsCurrent, theirsOffset));
|
|||
|
theirsIndex++;
|
|||
|
mineOffset += theirsCurrent.newLines - theirsCurrent.oldLines;
|
|||
|
} else {
|
|||
|
// Overlap, merge as best we can
|
|||
|
var mergedHunk = {
|
|||
|
oldStart: Math.min(mineCurrent.oldStart, theirsCurrent.oldStart),
|
|||
|
oldLines: 0,
|
|||
|
newStart: Math.min(mineCurrent.newStart + mineOffset, theirsCurrent.oldStart + theirsOffset),
|
|||
|
newLines: 0,
|
|||
|
lines: []
|
|||
|
};
|
|||
|
mergeLines(mergedHunk, mineCurrent.oldStart, mineCurrent.lines, theirsCurrent.oldStart, theirsCurrent.lines);
|
|||
|
theirsIndex++;
|
|||
|
mineIndex++;
|
|||
|
ret.hunks.push(mergedHunk);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
return ret;
|
|||
|
}
|
|||
|
|
|||
|
function loadPatch(param, base) {
|
|||
|
if (typeof param === 'string') {
|
|||
|
if (/^@@/m.test(param) || /^Index:/m.test(param)) {
|
|||
|
return parsePatch(param)[0];
|
|||
|
}
|
|||
|
|
|||
|
if (!base) {
|
|||
|
throw new Error('Must provide a base reference or pass in a patch');
|
|||
|
}
|
|||
|
|
|||
|
return structuredPatch(undefined, undefined, base, param);
|
|||
|
}
|
|||
|
|
|||
|
return param;
|
|||
|
}
|
|||
|
|
|||
|
function fileNameChanged(patch) {
|
|||
|
return patch.newFileName && patch.newFileName !== patch.oldFileName;
|
|||
|
}
|
|||
|
|
|||
|
function selectField(index, mine, theirs) {
|
|||
|
if (mine === theirs) {
|
|||
|
return mine;
|
|||
|
} else {
|
|||
|
index.conflict = true;
|
|||
|
return {
|
|||
|
mine: mine,
|
|||
|
theirs: theirs
|
|||
|
};
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
function hunkBefore(test, check) {
|
|||
|
return test.oldStart < check.oldStart && test.oldStart + test.oldLines < check.oldStart;
|
|||
|
}
|
|||
|
|
|||
|
function cloneHunk(hunk, offset) {
|
|||
|
return {
|
|||
|
oldStart: hunk.oldStart,
|
|||
|
oldLines: hunk.oldLines,
|
|||
|
newStart: hunk.newStart + offset,
|
|||
|
newLines: hunk.newLines,
|
|||
|
lines: hunk.lines
|
|||
|
};
|
|||
|
}
|
|||
|
|
|||
|
function mergeLines(hunk, mineOffset, mineLines, theirOffset, theirLines) {
|
|||
|
// This will generally result in a conflicted hunk, but there are cases where the context
|
|||
|
// is the only overlap where we can successfully merge the content here.
|
|||
|
var mine = {
|
|||
|
offset: mineOffset,
|
|||
|
lines: mineLines,
|
|||
|
index: 0
|
|||
|
},
|
|||
|
their = {
|
|||
|
offset: theirOffset,
|
|||
|
lines: theirLines,
|
|||
|
index: 0
|
|||
|
}; // Handle any leading content
|
|||
|
|
|||
|
insertLeading(hunk, mine, their);
|
|||
|
insertLeading(hunk, their, mine); // Now in the overlap content. Scan through and select the best changes from each.
|
|||
|
|
|||
|
while (mine.index < mine.lines.length && their.index < their.lines.length) {
|
|||
|
var mineCurrent = mine.lines[mine.index],
|
|||
|
theirCurrent = their.lines[their.index];
|
|||
|
|
|||
|
if ((mineCurrent[0] === '-' || mineCurrent[0] === '+') && (theirCurrent[0] === '-' || theirCurrent[0] === '+')) {
|
|||
|
// Both modified ...
|
|||
|
mutualChange(hunk, mine, their);
|
|||
|
} else if (mineCurrent[0] === '+' && theirCurrent[0] === ' ') {
|
|||
|
var _hunk$lines;
|
|||
|
|
|||
|
// Mine inserted
|
|||
|
(_hunk$lines = hunk.lines).push.apply(_hunk$lines, _toConsumableArray(collectChange(mine)));
|
|||
|
} else if (theirCurrent[0] === '+' && mineCurrent[0] === ' ') {
|
|||
|
var _hunk$lines2;
|
|||
|
|
|||
|
// Theirs inserted
|
|||
|
(_hunk$lines2 = hunk.lines).push.apply(_hunk$lines2, _toConsumableArray(collectChange(their)));
|
|||
|
} else if (mineCurrent[0] === '-' && theirCurrent[0] === ' ') {
|
|||
|
// Mine removed or edited
|
|||
|
removal(hunk, mine, their);
|
|||
|
} else if (theirCurrent[0] === '-' && mineCurrent[0] === ' ') {
|
|||
|
// Their removed or edited
|
|||
|
removal(hunk, their, mine, true);
|
|||
|
} else if (mineCurrent === theirCurrent) {
|
|||
|
// Context identity
|
|||
|
hunk.lines.push(mineCurrent);
|
|||
|
mine.index++;
|
|||
|
their.index++;
|
|||
|
} else {
|
|||
|
// Context mismatch
|
|||
|
conflict(hunk, collectChange(mine), collectChange(their));
|
|||
|
}
|
|||
|
} // Now push anything that may be remaining
|
|||
|
|
|||
|
|
|||
|
insertTrailing(hunk, mine);
|
|||
|
insertTrailing(hunk, their);
|
|||
|
calcLineCount(hunk);
|
|||
|
}
|
|||
|
|
|||
|
function mutualChange(hunk, mine, their) {
|
|||
|
var myChanges = collectChange(mine),
|
|||
|
theirChanges = collectChange(their);
|
|||
|
|
|||
|
if (allRemoves(myChanges) && allRemoves(theirChanges)) {
|
|||
|
// Special case for remove changes that are supersets of one another
|
|||
|
if (arrayStartsWith(myChanges, theirChanges) && skipRemoveSuperset(their, myChanges, myChanges.length - theirChanges.length)) {
|
|||
|
var _hunk$lines3;
|
|||
|
|
|||
|
(_hunk$lines3 = hunk.lines).push.apply(_hunk$lines3, _toConsumableArray(myChanges));
|
|||
|
|
|||
|
return;
|
|||
|
} else if (arrayStartsWith(theirChanges, myChanges) && skipRemoveSuperset(mine, theirChanges, theirChanges.length - myChanges.length)) {
|
|||
|
var _hunk$lines4;
|
|||
|
|
|||
|
(_hunk$lines4 = hunk.lines).push.apply(_hunk$lines4, _toConsumableArray(theirChanges));
|
|||
|
|
|||
|
return;
|
|||
|
}
|
|||
|
} else if (arrayEqual(myChanges, theirChanges)) {
|
|||
|
var _hunk$lines5;
|
|||
|
|
|||
|
(_hunk$lines5 = hunk.lines).push.apply(_hunk$lines5, _toConsumableArray(myChanges));
|
|||
|
|
|||
|
return;
|
|||
|
}
|
|||
|
|
|||
|
conflict(hunk, myChanges, theirChanges);
|
|||
|
}
|
|||
|
|
|||
|
function removal(hunk, mine, their, swap) {
|
|||
|
var myChanges = collectChange(mine),
|
|||
|
theirChanges = collectContext(their, myChanges);
|
|||
|
|
|||
|
if (theirChanges.merged) {
|
|||
|
var _hunk$lines6;
|
|||
|
|
|||
|
(_hunk$lines6 = hunk.lines).push.apply(_hunk$lines6, _toConsumableArray(theirChanges.merged));
|
|||
|
} else {
|
|||
|
conflict(hunk, swap ? theirChanges : myChanges, swap ? myChanges : theirChanges);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
function conflict(hunk, mine, their) {
|
|||
|
hunk.conflict = true;
|
|||
|
hunk.lines.push({
|
|||
|
conflict: true,
|
|||
|
mine: mine,
|
|||
|
theirs: their
|
|||
|
});
|
|||
|
}
|
|||
|
|
|||
|
function insertLeading(hunk, insert, their) {
|
|||
|
while (insert.offset < their.offset && insert.index < insert.lines.length) {
|
|||
|
var line = insert.lines[insert.index++];
|
|||
|
hunk.lines.push(line);
|
|||
|
insert.offset++;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
function insertTrailing(hunk, insert) {
|
|||
|
while (insert.index < insert.lines.length) {
|
|||
|
var line = insert.lines[insert.index++];
|
|||
|
hunk.lines.push(line);
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
function collectChange(state) {
|
|||
|
var ret = [],
|
|||
|
operation = state.lines[state.index][0];
|
|||
|
|
|||
|
while (state.index < state.lines.length) {
|
|||
|
var line = state.lines[state.index]; // Group additions that are immediately after subtractions and treat them as one "atomic" modify change.
|
|||
|
|
|||
|
if (operation === '-' && line[0] === '+') {
|
|||
|
operation = '+';
|
|||
|
}
|
|||
|
|
|||
|
if (operation === line[0]) {
|
|||
|
ret.push(line);
|
|||
|
state.index++;
|
|||
|
} else {
|
|||
|
break;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
return ret;
|
|||
|
}
|
|||
|
|
|||
|
function collectContext(state, matchChanges) {
|
|||
|
var changes = [],
|
|||
|
merged = [],
|
|||
|
matchIndex = 0,
|
|||
|
contextChanges = false,
|
|||
|
conflicted = false;
|
|||
|
|
|||
|
while (matchIndex < matchChanges.length && state.index < state.lines.length) {
|
|||
|
var change = state.lines[state.index],
|
|||
|
match = matchChanges[matchIndex]; // Once we've hit our add, then we are done
|
|||
|
|
|||
|
if (match[0] === '+') {
|
|||
|
break;
|
|||
|
}
|
|||
|
|
|||
|
contextChanges = contextChanges || change[0] !== ' ';
|
|||
|
merged.push(match);
|
|||
|
matchIndex++; // Consume any additions in the other block as a conflict to attempt
|
|||
|
// to pull in the remaining context after this
|
|||
|
|
|||
|
if (change[0] === '+') {
|
|||
|
conflicted = true;
|
|||
|
|
|||
|
while (change[0] === '+') {
|
|||
|
changes.push(change);
|
|||
|
change = state.lines[++state.index];
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
if (match.substr(1) === change.substr(1)) {
|
|||
|
changes.push(change);
|
|||
|
state.index++;
|
|||
|
} else {
|
|||
|
conflicted = true;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
if ((matchChanges[matchIndex] || '')[0] === '+' && contextChanges) {
|
|||
|
conflicted = true;
|
|||
|
}
|
|||
|
|
|||
|
if (conflicted) {
|
|||
|
return changes;
|
|||
|
}
|
|||
|
|
|||
|
while (matchIndex < matchChanges.length) {
|
|||
|
merged.push(matchChanges[matchIndex++]);
|
|||
|
}
|
|||
|
|
|||
|
return {
|
|||
|
merged: merged,
|
|||
|
changes: changes
|
|||
|
};
|
|||
|
}
|
|||
|
|
|||
|
function allRemoves(changes) {
|
|||
|
return changes.reduce(function (prev, change) {
|
|||
|
return prev && change[0] === '-';
|
|||
|
}, true);
|
|||
|
}
|
|||
|
|
|||
|
function skipRemoveSuperset(state, removeChanges, delta) {
|
|||
|
for (var i = 0; i < delta; i++) {
|
|||
|
var changeContent = removeChanges[removeChanges.length - delta + i].substr(1);
|
|||
|
|
|||
|
if (state.lines[state.index + i] !== ' ' + changeContent) {
|
|||
|
return false;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
state.index += delta;
|
|||
|
return true;
|
|||
|
}
|
|||
|
|
|||
|
function calcOldNewLineCount(lines) {
|
|||
|
var oldLines = 0;
|
|||
|
var newLines = 0;
|
|||
|
lines.forEach(function (line) {
|
|||
|
if (typeof line !== 'string') {
|
|||
|
var myCount = calcOldNewLineCount(line.mine);
|
|||
|
var theirCount = calcOldNewLineCount(line.theirs);
|
|||
|
|
|||
|
if (oldLines !== undefined) {
|
|||
|
if (myCount.oldLines === theirCount.oldLines) {
|
|||
|
oldLines += myCount.oldLines;
|
|||
|
} else {
|
|||
|
oldLines = undefined;
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
if (newLines !== undefined) {
|
|||
|
if (myCount.newLines === theirCount.newLines) {
|
|||
|
newLines += myCount.newLines;
|
|||
|
} else {
|
|||
|
newLines = undefined;
|
|||
|
}
|
|||
|
}
|
|||
|
} else {
|
|||
|
if (newLines !== undefined && (line[0] === '+' || line[0] === ' ')) {
|
|||
|
newLines++;
|
|||
|
}
|
|||
|
|
|||
|
if (oldLines !== undefined && (line[0] === '-' || line[0] === ' ')) {
|
|||
|
oldLines++;
|
|||
|
}
|
|||
|
}
|
|||
|
});
|
|||
|
return {
|
|||
|
oldLines: oldLines,
|
|||
|
newLines: newLines
|
|||
|
};
|
|||
|
}
|
|||
|
|
|||
|
// See: http://code.google.com/p/google-diff-match-patch/wiki/API
|
|||
|
function convertChangesToDMP(changes) {
|
|||
|
var ret = [],
|
|||
|
change,
|
|||
|
operation;
|
|||
|
|
|||
|
for (var i = 0; i < changes.length; i++) {
|
|||
|
change = changes[i];
|
|||
|
|
|||
|
if (change.added) {
|
|||
|
operation = 1;
|
|||
|
} else if (change.removed) {
|
|||
|
operation = -1;
|
|||
|
} else {
|
|||
|
operation = 0;
|
|||
|
}
|
|||
|
|
|||
|
ret.push([operation, change.value]);
|
|||
|
}
|
|||
|
|
|||
|
return ret;
|
|||
|
}
|
|||
|
|
|||
|
function convertChangesToXML(changes) {
|
|||
|
var ret = [];
|
|||
|
|
|||
|
for (var i = 0; i < changes.length; i++) {
|
|||
|
var change = changes[i];
|
|||
|
|
|||
|
if (change.added) {
|
|||
|
ret.push('<ins>');
|
|||
|
} else if (change.removed) {
|
|||
|
ret.push('<del>');
|
|||
|
}
|
|||
|
|
|||
|
ret.push(escapeHTML(change.value));
|
|||
|
|
|||
|
if (change.added) {
|
|||
|
ret.push('</ins>');
|
|||
|
} else if (change.removed) {
|
|||
|
ret.push('</del>');
|
|||
|
}
|
|||
|
}
|
|||
|
|
|||
|
return ret.join('');
|
|||
|
}
|
|||
|
|
|||
|
function escapeHTML(s) {
|
|||
|
var n = s;
|
|||
|
n = n.replace(/&/g, '&');
|
|||
|
n = n.replace(/</g, '<');
|
|||
|
n = n.replace(/>/g, '>');
|
|||
|
n = n.replace(/"/g, '"');
|
|||
|
return n;
|
|||
|
}
|
|||
|
|
|||
|
/* See LICENSE file for terms of use */
|
|||
|
|
|||
|
export { Diff, diffChars, diffWords, diffWordsWithSpace, diffLines, diffTrimmedLines, diffSentences, diffCss, diffJson, diffArrays, structuredPatch, createTwoFilesPatch, createPatch, applyPatch, applyPatches, parsePatch, merge, convertChangesToDMP, convertChangesToXML, canonicalize };
|