diff - npm Package Compare versions
Comparing version 1.3.2 to 1.4.0
942
diff.js
@@ -18,547 +18,603 @@ /* See LICENSE file for terms of use */ | ||
| (function(global, undefined) { | ||
| var objectPrototypeToString = Object.prototype.toString; | ||
| var JsDiff = (function() { | ||
| /*jshint maxparams: 5*/ | ||
| /*istanbul ignore next*/ | ||
| function map(arr, mapper, that) { | ||
| if (Array.prototype.map) { | ||
| return Array.prototype.map.call(arr, mapper, that); | ||
| } | ||
| /*istanbul ignore next*/ | ||
| function map(arr, mapper, that) { | ||
| if (Array.prototype.map) { | ||
| return Array.prototype.map.call(arr, mapper, that); | ||
| } | ||
| var other = new Array(arr.length); | ||
| var other = new Array(arr.length); | ||
| for (var i = 0, n = arr.length; i < n; i++) { | ||
| other[i] = mapper.call(that, arr[i], i, arr); | ||
| for (var i = 0, n = arr.length; i < n; i++) { | ||
| other[i] = mapper.call(that, arr[i], i, arr); | ||
| } | ||
| return other; | ||
| } | ||
| function clonePath(path) { | ||
| return { newPos: path.newPos, components: path.components.slice(0) }; | ||
| } | ||
| function removeEmpty(array) { | ||
| var ret = []; | ||
| for (var i = 0; i < array.length; i++) { | ||
| if (array[i]) { | ||
| ret.push(array[i]); | ||
| } | ||
| return other; | ||
| } | ||
| function clonePath(path) { | ||
| return { newPos: path.newPos, components: path.components.slice(0) }; | ||
| } | ||
| function removeEmpty(array) { | ||
| var ret = []; | ||
| for (var i = 0; i < array.length; i++) { | ||
| if (array[i]) { | ||
| ret.push(array[i]); | ||
| } | ||
| return ret; | ||
| } | ||
| function escapeHTML(s) { | ||
| var n = s; | ||
| n = n.replace(/&/g, '&'); | ||
| n = n.replace(/</g, '<'); | ||
| n = n.replace(/>/g, '>'); | ||
| n = n.replace(/"/g, '"'); | ||
| return n; | ||
| } | ||
| // 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. | ||
| function canonicalize(obj, stack, replacementStack) { | ||
| stack = stack || []; | ||
| replacementStack = replacementStack || []; | ||
| var i; | ||
| for (i = 0; i < stack.length; i += 1) { | ||
| if (stack[i] === obj) { | ||
| return replacementStack[i]; | ||
| } | ||
| return ret; | ||
| } | ||
| function escapeHTML(s) { | ||
| var n = s; | ||
| n = n.replace(/&/g, '&'); | ||
| n = n.replace(/</g, '<'); | ||
| n = n.replace(/>/g, '>'); | ||
| n = n.replace(/"/g, '"'); | ||
| return n; | ||
| 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); | ||
| } | ||
| stack.pop(); | ||
| replacementStack.pop(); | ||
| } else if (typeof obj === 'object' && obj !== null) { | ||
| stack.push(obj); | ||
| canonicalizedObj = {}; | ||
| replacementStack.push(canonicalizedObj); | ||
| var sortedKeys = [], | ||
| key; | ||
| for (key in obj) { | ||
| sortedKeys.push(key); | ||
| } | ||
| sortedKeys.sort(); | ||
| for (i = 0; i < sortedKeys.length; i += 1) { | ||
| key = sortedKeys[i]; | ||
| canonicalizedObj[key] = canonicalize(obj[key], stack, replacementStack); | ||
| } | ||
| stack.pop(); | ||
| replacementStack.pop(); | ||
| } else { | ||
| canonicalizedObj = obj; | ||
| } | ||
| return canonicalizedObj; | ||
| } | ||
| function buildValues(components, newString, oldString, useLongestToken) { | ||
| var componentPos = 0, | ||
| componentLen = components.length, | ||
| newPos = 0, | ||
| oldPos = 0; | ||
| function buildValues(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 = map(value, function(value, i) { | ||
| var oldValue = oldString[oldPos + i]; | ||
| return oldValue.length > value.length ? oldValue : value; | ||
| }); | ||
| for (; componentPos < componentLen; componentPos++) { | ||
| var component = components[componentPos]; | ||
| if (!component.removed) { | ||
| if (!component.added && useLongestToken) { | ||
| var value = newString.slice(newPos, newPos + component.count); | ||
| value = map(value, function(value, i) { | ||
| var oldValue = oldString[oldPos + i]; | ||
| return oldValue.length > value.length ? oldValue : value; | ||
| }); | ||
| component.value = value.join(''); | ||
| } else { | ||
| component.value = newString.slice(newPos, newPos + component.count).join(''); | ||
| } | ||
| newPos += component.count; | ||
| component.value = value.join(''); | ||
| } else { | ||
| component.value = newString.slice(newPos, newPos + component.count).join(''); | ||
| } | ||
| newPos += component.count; | ||
| // Common case | ||
| if (!component.added) { | ||
| oldPos += component.count; | ||
| } | ||
| } else { | ||
| component.value = oldString.slice(oldPos, oldPos + component.count).join(''); | ||
| // Common case | ||
| if (!component.added) { | ||
| oldPos += component.count; | ||
| } | ||
| } else { | ||
| component.value = oldString.slice(oldPos, oldPos + component.count).join(''); | ||
| 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; | ||
| } | ||
| } | ||
| return components; | ||
| } | ||
| var Diff = function(ignoreWhitespace) { | ||
| this.ignoreWhitespace = ignoreWhitespace; | ||
| }; | ||
| Diff.prototype = { | ||
| diff: function(oldString, newString, callback) { | ||
| var self = this; | ||
| return components; | ||
| } | ||
| function done(value) { | ||
| if (callback) { | ||
| setTimeout(function() { callback(undefined, value); }, 0); | ||
| return true; | ||
| } else { | ||
| return value; | ||
| } | ||
| } | ||
| function Diff(ignoreWhitespace) { | ||
| this.ignoreWhitespace = ignoreWhitespace; | ||
| } | ||
| Diff.prototype = { | ||
| diff: function(oldString, newString, callback) { | ||
| var self = this; | ||
| // Handle the identity case (this is due to unrolling editLength == 0 | ||
| if (newString === oldString) { | ||
| return done([{ value: newString }]); | ||
| } | ||
| if (!newString) { | ||
| return done([{ value: oldString, removed: true }]); | ||
| } | ||
| if (!oldString) { | ||
| return done([{ value: newString, added: true }]); | ||
| } | ||
| function done(value) { | ||
| if (callback) { | ||
| setTimeout(function() { callback(undefined, value); }, 0); | ||
| return true; | ||
| } else { | ||
| return value; | ||
| } | ||
| } | ||
| newString = this.tokenize(newString); | ||
| oldString = this.tokenize(oldString); | ||
| // Handle the identity case (this is due to unrolling editLength == 0 | ||
| if (newString === oldString) { | ||
| return done([{ value: newString }]); | ||
| } | ||
| if (!newString) { | ||
| return done([{ value: oldString, removed: true }]); | ||
| } | ||
| if (!oldString) { | ||
| return done([{ value: newString, added: true }]); | ||
| } | ||
| var newLen = newString.length, oldLen = oldString.length; | ||
| var maxEditLength = newLen + oldLen; | ||
| var bestPath = [{ newPos: -1, components: [] }]; | ||
| newString = this.tokenize(newString); | ||
| oldString = this.tokenize(oldString); | ||
| // 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: newString.join('')}]); | ||
| } | ||
| var newLen = newString.length, oldLen = oldString.length; | ||
| var editLength = 1; | ||
| var maxEditLength = newLen + oldLen; | ||
| var bestPath = [{ newPos: -1, components: [] }]; | ||
| // 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; | ||
| var addPath = bestPath[diagonalPath-1], | ||
| removePath = bestPath[diagonalPath+1]; | ||
| // 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: newString.join('')}]); | ||
| } | ||
| // 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; | ||
| 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; | ||
| } | ||
| 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; | ||
| var canRemove = removePath && 0 <= oldPos && oldPos < oldLen; | ||
| if (!canAdd && !canRemove) { | ||
| // If this path is a terminal then prune | ||
| bestPath[diagonalPath] = undefined; | ||
| continue; | ||
| } | ||
| 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); | ||
| } | ||
| // 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); | ||
| } | ||
| var oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath); | ||
| 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(basePath.components, newString, oldString, self.useLongestToken)); | ||
| } else { | ||
| // Otherwise track this path as a potential candidate and continue. | ||
| bestPath[diagonalPath] = basePath; | ||
| } | ||
| } | ||
| editLength++; | ||
| // If we have hit the end of both strings, then we are done | ||
| if (basePath.newPos + 1 >= newLen && oldPos + 1 >= oldLen) { | ||
| return done(buildValues(basePath.components, newString, oldString, self.useLongestToken)); | ||
| } else { | ||
| // Otherwise track this path as a potential candidate and continue. | ||
| bestPath[diagonalPath] = basePath; | ||
| } | ||
| } | ||
| // 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. | ||
| var editLength = 1; | ||
| if (callback) { | ||
| (function exec() { | ||
| setTimeout(function() { | ||
| // This should not happen, but we want to be safe. | ||
| /*istanbul ignore next */ | ||
| if (editLength > maxEditLength) { | ||
| return callback(); | ||
| } | ||
| editLength++; | ||
| } | ||
| if (!execEditLength()) { | ||
| exec(); | ||
| } | ||
| }, 0); | ||
| })(); | ||
| } else { | ||
| while(editLength <= maxEditLength) { | ||
| var ret = execEditLength(); | ||
| if (ret) { | ||
| return ret; | ||
| } | ||
| // 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(); | ||
| } | ||
| } | ||
| }, | ||
| pushComponent: function(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 }); | ||
| if (!execEditLength()) { | ||
| exec(); | ||
| } | ||
| }, 0); | ||
| }()); | ||
| } else { | ||
| while (editLength <= maxEditLength) { | ||
| var ret = execEditLength(); | ||
| if (ret) { | ||
| return ret; | ||
| } | ||
| }, | ||
| extractCommon: function(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++; | ||
| } | ||
| pushComponent: function(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(basePath, newString, oldString, diagonalPath) { | ||
| var newLen = newString.length, | ||
| oldLen = oldString.length, | ||
| newPos = basePath.newPos, | ||
| oldPos = newPos - diagonalPath, | ||
| if (commonCount) { | ||
| basePath.components.push({count: commonCount}); | ||
| } | ||
| commonCount = 0; | ||
| while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) { | ||
| newPos++; | ||
| oldPos++; | ||
| commonCount++; | ||
| } | ||
| basePath.newPos = newPos; | ||
| return oldPos; | ||
| }, | ||
| if (commonCount) { | ||
| basePath.components.push({count: commonCount}); | ||
| } | ||
| equals: function(left, right) { | ||
| var reWhitespace = /\S/; | ||
| return left === right || (this.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right)); | ||
| }, | ||
| tokenize: function(value) { | ||
| return value.split(''); | ||
| } | ||
| }; | ||
| basePath.newPos = newPos; | ||
| return oldPos; | ||
| }, | ||
| var CharDiff = new Diff(); | ||
| equals: function(left, right) { | ||
| var reWhitespace = /\S/; | ||
| return left === right || (this.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right)); | ||
| }, | ||
| tokenize: function(value) { | ||
| return value.split(''); | ||
| } | ||
| }; | ||
| var WordDiff = new Diff(true); | ||
| var WordWithSpaceDiff = new Diff(); | ||
| WordDiff.tokenize = WordWithSpaceDiff.tokenize = function(value) { | ||
| return removeEmpty(value.split(/(\s+|\b)/)); | ||
| }; | ||
| var CharDiff = new Diff(); | ||
| var CssDiff = new Diff(true); | ||
| CssDiff.tokenize = function(value) { | ||
| return removeEmpty(value.split(/([{}:;,]|\s+)/)); | ||
| }; | ||
| var WordDiff = new Diff(true); | ||
| var WordWithSpaceDiff = new Diff(); | ||
| WordDiff.tokenize = WordWithSpaceDiff.tokenize = function(value) { | ||
| return removeEmpty(value.split(/(\s+|\b)/)); | ||
| }; | ||
| var LineDiff = new Diff(); | ||
| var CssDiff = new Diff(true); | ||
| CssDiff.tokenize = function(value) { | ||
| return removeEmpty(value.split(/([{}:;,]|\s+)/)); | ||
| }; | ||
| var TrimmedLineDiff = new Diff(); | ||
| TrimmedLineDiff.ignoreTrim = true; | ||
| var LineDiff = new Diff(); | ||
| LineDiff.tokenize = TrimmedLineDiff.tokenize = function(value) { | ||
| var retLines = [], | ||
| lines = value.split(/^/m); | ||
| for(var i = 0; i < lines.length; i++) { | ||
| var line = lines[i], | ||
| lastLine = lines[i - 1], | ||
| lastLineLastChar = lastLine ? lastLine[lastLine.length - 1] : ''; | ||
| var TrimmedLineDiff = new Diff(); | ||
| TrimmedLineDiff.ignoreTrim = true; | ||
| // Merge lines that may contain windows new lines | ||
| if (line === '\n' && lastLineLastChar === '\r') { | ||
| retLines[retLines.length - 1] = retLines[retLines.length - 1].slice(0,-1) + '\r\n'; | ||
| } else if (line) { | ||
| if (this.ignoreTrim) { | ||
| line = line.trim(); | ||
| //add a newline unless this is the last line. | ||
| if (i < lines.length - 1) { | ||
| line += '\n'; | ||
| } | ||
| LineDiff.tokenize = TrimmedLineDiff.tokenize = function(value) { | ||
| var retLines = [], | ||
| lines = value.split(/^/m); | ||
| for (var i = 0; i < lines.length; i++) { | ||
| var line = lines[i], | ||
| lastLine = lines[i - 1], | ||
| lastLineLastChar = lastLine && lastLine[lastLine.length - 1]; | ||
| // Merge lines that may contain windows new lines | ||
| if (line === '\n' && lastLineLastChar === '\r') { | ||
| retLines[retLines.length - 1] = retLines[retLines.length - 1].slice(0, -1) + '\r\n'; | ||
| } else { | ||
| if (this.ignoreTrim) { | ||
| line = line.trim(); | ||
| // add a newline unless this is the last line. | ||
| if (i < lines.length - 1) { | ||
| line += '\n'; | ||
| } | ||
| retLines.push(line); | ||
| } | ||
| retLines.push(line); | ||
| } | ||
| } | ||
| return retLines; | ||
| }; | ||
| return retLines; | ||
| }; | ||
| var PatchDiff = new Diff(); | ||
| PatchDiff.tokenize = function(value) { | ||
| var ret = [], | ||
| linesAndNewlines = value.split(/(\n|\r\n)/); | ||
| var SentenceDiff = new Diff(); | ||
| SentenceDiff.tokenize = function (value) { | ||
| return removeEmpty(value.split(/(\S.+?[.!?])(?=\s+|$)/)); | ||
| }; | ||
| // Ignore the final empty token that occurs if the string ends with a new line | ||
| if (!linesAndNewlines[linesAndNewlines.length - 1]) { | ||
| linesAndNewlines.pop(); | ||
| } | ||
| 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.equals = function(left, right) { | ||
| return LineDiff.equals(left.replace(/,([\r\n])/g, '$1'), right.replace(/,([\r\n])/g, '$1')); | ||
| }; | ||
| // Merge the content and line separators into single tokens | ||
| for (var i = 0; i < linesAndNewlines.length; i++) { | ||
| var line = linesAndNewlines[i]; | ||
| var objectPrototypeToString = Object.prototype.toString; | ||
| if (i % 2) { | ||
| ret[ret.length - 1] += line; | ||
| } else { | ||
| ret.push(line); | ||
| } | ||
| } | ||
| return ret; | ||
| }; | ||
| // 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. | ||
| function canonicalize(obj, stack, replacementStack) { | ||
| stack = stack || []; | ||
| replacementStack = replacementStack || []; | ||
| var SentenceDiff = new Diff(); | ||
| SentenceDiff.tokenize = function(value) { | ||
| return removeEmpty(value.split(/(\S.+?[.!?])(?=\s+|$)/)); | ||
| }; | ||
| var i; | ||
| 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.equals = function(left, right) { | ||
| return LineDiff.equals(left.replace(/,([\r\n])/g, '$1'), right.replace(/,([\r\n])/g, '$1')); | ||
| }; | ||
| for (var i = 0 ; i < stack.length ; i += 1) { | ||
| if (stack[i] === obj) { | ||
| return replacementStack[i]; | ||
| } | ||
| } | ||
| var JsDiff = { | ||
| Diff: Diff, | ||
| var canonicalizedObj; | ||
| diffChars: function(oldStr, newStr, callback) { return CharDiff.diff(oldStr, newStr, callback); }, | ||
| diffWords: function(oldStr, newStr, callback) { return WordDiff.diff(oldStr, newStr, callback); }, | ||
| diffWordsWithSpace: function(oldStr, newStr, callback) { return WordWithSpaceDiff.diff(oldStr, newStr, callback); }, | ||
| diffLines: function(oldStr, newStr, callback) { return LineDiff.diff(oldStr, newStr, callback); }, | ||
| diffTrimmedLines: function(oldStr, newStr, callback) { return TrimmedLineDiff.diff(oldStr, newStr, callback); }, | ||
| 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); | ||
| } | ||
| stack.pop(); | ||
| replacementStack.pop(); | ||
| } else if (typeof obj === 'object' && obj !== null) { | ||
| stack.push(obj); | ||
| canonicalizedObj = {}; | ||
| replacementStack.push(canonicalizedObj); | ||
| var sortedKeys = []; | ||
| for (var key in obj) { | ||
| sortedKeys.push(key); | ||
| } | ||
| sortedKeys.sort(); | ||
| for (i = 0 ; i < sortedKeys.length ; i += 1) { | ||
| var key = sortedKeys[i]; | ||
| canonicalizedObj[key] = canonicalize(obj[key], stack, replacementStack); | ||
| } | ||
| stack.pop(); | ||
| replacementStack.pop(); | ||
| } else { | ||
| canonicalizedObj = obj; | ||
| } | ||
| return canonicalizedObj; | ||
| } | ||
| diffSentences: function(oldStr, newStr, callback) { return SentenceDiff.diff(oldStr, newStr, callback); }, | ||
| return { | ||
| Diff: Diff, | ||
| diffCss: function(oldStr, newStr, callback) { return CssDiff.diff(oldStr, newStr, callback); }, | ||
| diffJson: function(oldObj, newObj, callback) { | ||
| return JsonDiff.diff( | ||
| typeof oldObj === 'string' ? oldObj : JSON.stringify(canonicalize(oldObj), undefined, ' '), | ||
| typeof newObj === 'string' ? newObj : JSON.stringify(canonicalize(newObj), undefined, ' '), | ||
| callback | ||
| ); | ||
| }, | ||
| diffChars: function(oldStr, newStr, callback) { return CharDiff.diff(oldStr, newStr, callback); }, | ||
| diffWords: function(oldStr, newStr, callback) { return WordDiff.diff(oldStr, newStr, callback); }, | ||
| diffWordsWithSpace: function(oldStr, newStr, callback) { return WordWithSpaceDiff.diff(oldStr, newStr, callback); }, | ||
| diffLines: function(oldStr, newStr, callback) { return LineDiff.diff(oldStr, newStr, callback); }, | ||
| diffTrimmedLines: function(oldStr, newStr, callback) { return TrimmedLineDiff.diff(oldStr, newStr, callback); }, | ||
| createTwoFilesPatch: function(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader) { | ||
| var ret = []; | ||
| diffSentences: function(oldStr, newStr, callback) { return SentenceDiff.diff(oldStr, newStr, callback); }, | ||
| if (oldFileName == newFileName) { | ||
| ret.push('Index: ' + oldFileName); | ||
| } | ||
| ret.push('==================================================================='); | ||
| ret.push('--- ' + oldFileName + (typeof oldHeader === 'undefined' ? '' : '\t' + oldHeader)); | ||
| ret.push('+++ ' + newFileName + (typeof newHeader === 'undefined' ? '' : '\t' + newHeader)); | ||
| diffCss: function(oldStr, newStr, callback) { return CssDiff.diff(oldStr, newStr, callback); }, | ||
| diffJson: function(oldObj, newObj, callback) { | ||
| return JsonDiff.diff( | ||
| typeof oldObj === 'string' ? oldObj : JSON.stringify(canonicalize(oldObj), undefined, ' '), | ||
| typeof newObj === 'string' ? newObj : JSON.stringify(canonicalize(newObj), undefined, ' '), | ||
| callback | ||
| ); | ||
| }, | ||
| var diff = PatchDiff.diff(oldStr, newStr); | ||
| diff.push({value: '', lines: []}); // Append an empty value to make cleanup easier | ||
| createPatch: function(fileName, oldStr, newStr, oldHeader, newHeader) { | ||
| var ret = []; | ||
| // Formats a given set of lines for printing as context lines in a patch | ||
| function contextLines(lines) { | ||
| return map(lines, function(entry) { return ' ' + entry; }); | ||
| } | ||
| ret.push('Index: ' + fileName); | ||
| ret.push('==================================================================='); | ||
| ret.push('--- ' + fileName + (typeof oldHeader === 'undefined' ? '' : '\t' + oldHeader)); | ||
| ret.push('+++ ' + fileName + (typeof newHeader === 'undefined' ? '' : '\t' + newHeader)); | ||
| // Outputs the no newline at end of file warning if needed | ||
| function eofNL(curRange, i, current) { | ||
| var last = diff[diff.length - 2], | ||
| isLast = i === diff.length - 2, | ||
| isLastOfType = i === diff.length - 3 && current.added !== last.added; | ||
| var diff = LineDiff.diff(oldStr, newStr); | ||
| if (!diff[diff.length-1].value) { | ||
| diff.pop(); // Remove trailing newline add | ||
| // Figure out if this is the last line for the given file and missing NL | ||
| if (!(/\n$/.test(current.value)) && (isLast || isLastOfType)) { | ||
| curRange.push('\\ No newline at end of file'); | ||
| } | ||
| diff.push({value: '', lines: []}); // Append an empty value to make cleanup easier | ||
| } | ||
| function contextLines(lines) { | ||
| return map(lines, function(entry) { return ' ' + entry; }); | ||
| } | ||
| function eofNL(curRange, i, current) { | ||
| var last = diff[diff.length-2], | ||
| isLast = i === diff.length-2, | ||
| isLastOfType = i === diff.length-3 && (current.added !== last.added || current.removed !== last.removed); | ||
| var oldRangeStart = 0, newRangeStart = 0, curRange = [], | ||
| oldLine = 1, newLine = 1; | ||
| for (var i = 0; i < diff.length; i++) { | ||
| var current = diff[i], | ||
| lines = current.lines || current.value.replace(/\n$/, '').split('\n'); | ||
| current.lines = lines; | ||
| // Figure out if this is the last line for the given file and missing NL | ||
| if (!/\n$/.test(current.value) && (isLast || isLastOfType)) { | ||
| curRange.push('\\ No newline at end of file'); | ||
| if (current.added || current.removed) { | ||
| // If we have previous context, start with that | ||
| if (!oldRangeStart) { | ||
| var prev = diff[i - 1]; | ||
| oldRangeStart = oldLine; | ||
| newRangeStart = newLine; | ||
| if (prev) { | ||
| curRange = contextLines(prev.lines.slice(-4)); | ||
| oldRangeStart -= curRange.length; | ||
| newRangeStart -= curRange.length; | ||
| } | ||
| } | ||
| } | ||
| var oldRangeStart = 0, newRangeStart = 0, curRange = [], | ||
| oldLine = 1, newLine = 1; | ||
| for (var i = 0; i < diff.length; i++) { | ||
| var current = diff[i], | ||
| lines = current.lines || current.value.replace(/\n$/, '').split('\n'); | ||
| current.lines = lines; | ||
| // Output our changes | ||
| curRange.push.apply(curRange, map(lines, function(entry) { | ||
| return (current.added ? '+' : '-') + entry; | ||
| })); | ||
| eofNL(curRange, i, current); | ||
| if (current.added || current.removed) { | ||
| if (!oldRangeStart) { | ||
| var prev = diff[i-1]; | ||
| oldRangeStart = oldLine; | ||
| newRangeStart = newLine; | ||
| if (prev) { | ||
| curRange = contextLines(prev.lines.slice(-4)); | ||
| oldRangeStart -= curRange.length; | ||
| newRangeStart -= curRange.length; | ||
| // 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 <= 8 && i < diff.length - 2) { | ||
| // Overlapping | ||
| curRange.push.apply(curRange, contextLines(lines)); | ||
| } else { | ||
| // end the range and output | ||
| var contextSize = Math.min(lines.length, 4); | ||
| ret.push( | ||
| '@@ -' + oldRangeStart + ',' + (oldLine - oldRangeStart + contextSize) | ||
| + ' +' + newRangeStart + ',' + (newLine - newRangeStart + contextSize) | ||
| + ' @@'); | ||
| ret.push.apply(ret, curRange); | ||
| ret.push.apply(ret, contextLines(lines.slice(0, contextSize))); | ||
| if (lines.length <= 4) { | ||
| eofNL(ret, i, current); | ||
| } | ||
| } | ||
| curRange.push.apply(curRange, map(lines, function(entry) { return (current.added?'+':'-') + entry; })); | ||
| eofNL(curRange, i, current); | ||
| if (current.added) { | ||
| newLine += lines.length; | ||
| } else { | ||
| oldLine += lines.length; | ||
| oldRangeStart = 0; | ||
| newRangeStart = 0; | ||
| curRange = []; | ||
| } | ||
| } else { | ||
| if (oldRangeStart) { | ||
| // Close out any changes that have been output (or join overlapping) | ||
| if (lines.length <= 8 && i < diff.length-2) { | ||
| // Overlapping | ||
| curRange.push.apply(curRange, contextLines(lines)); | ||
| } else { | ||
| // end the range and output | ||
| var contextSize = Math.min(lines.length, 4); | ||
| ret.push( | ||
| '@@ -' + oldRangeStart + ',' + (oldLine-oldRangeStart+contextSize) | ||
| + ' +' + newRangeStart + ',' + (newLine-newRangeStart+contextSize) | ||
| + ' @@'); | ||
| ret.push.apply(ret, curRange); | ||
| ret.push.apply(ret, contextLines(lines.slice(0, contextSize))); | ||
| if (lines.length <= 4) { | ||
| eofNL(ret, i, current); | ||
| } | ||
| oldRangeStart = 0; newRangeStart = 0; curRange = []; | ||
| } | ||
| } | ||
| oldLine += lines.length; | ||
| newLine += lines.length; | ||
| } | ||
| oldLine += lines.length; | ||
| newLine += lines.length; | ||
| } | ||
| } | ||
| return ret.join('\n') + '\n'; | ||
| }, | ||
| return ret.join('\n') + '\n'; | ||
| }, | ||
| applyPatch: function(oldStr, uniDiff) { | ||
| var diffstr = uniDiff.split('\n'); | ||
| var diff = []; | ||
| var i = 0, | ||
| remEOFNL = false, | ||
| addEOFNL = false; | ||
| createPatch: function(fileName, oldStr, newStr, oldHeader, newHeader) { | ||
| return JsDiff.createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader); | ||
| }, | ||
| // Skip to the first change chunk | ||
| while (i < diffstr.length && !/^@@/.test(diffstr[i])) { | ||
| i++; | ||
| } | ||
| applyPatch: function(oldStr, uniDiff) { | ||
| var diffstr = uniDiff.split('\n'), | ||
| hunks = [], | ||
| i = 0, | ||
| remEOFNL = false, | ||
| addEOFNL = false; | ||
| for (; i < diffstr.length; i++) { | ||
| if (diffstr[i][0] === '@') { | ||
| var meh = diffstr[i].split(/@@ -(\d+),(\d+) \+(\d+),(\d+) @@/); | ||
| diff.unshift({ | ||
| start:meh[3], | ||
| oldlength:meh[2], | ||
| oldlines:[], | ||
| newlength:meh[4], | ||
| newlines:[] | ||
| }); | ||
| } else if (diffstr[i][0] === '+') { | ||
| diff[0].newlines.push(diffstr[i].substr(1)); | ||
| } else if (diffstr[i][0] === '-') { | ||
| diff[0].oldlines.push(diffstr[i].substr(1)); | ||
| } else if (diffstr[i][0] === ' ') { | ||
| diff[0].newlines.push(diffstr[i].substr(1)); | ||
| diff[0].oldlines.push(diffstr[i].substr(1)); | ||
| } else if (diffstr[i][0] === '\\') { | ||
| if (diffstr[i-1][0] === '+') { | ||
| remEOFNL = true; | ||
| } else if (diffstr[i-1][0] === '-') { | ||
| addEOFNL = true; | ||
| } | ||
| // Skip to the first change hunk | ||
| while (i < diffstr.length && !(/^@@/.test(diffstr[i]))) { | ||
| i++; | ||
| } | ||
| // Parse the unified diff | ||
| for (; i < diffstr.length; i++) { | ||
| if (diffstr[i][0] === '@') { | ||
| var chnukHeader = diffstr[i].split(/@@ -(\d+),(\d+) \+(\d+),(\d+) @@/); | ||
| hunks.unshift({ | ||
| start: chnukHeader[3], | ||
| oldlength: +chnukHeader[2], | ||
| removed: [], | ||
| newlength: chnukHeader[4], | ||
| added: [] | ||
| }); | ||
| } else if (diffstr[i][0] === '+') { | ||
| hunks[0].added.push(diffstr[i].substr(1)); | ||
| } else if (diffstr[i][0] === '-') { | ||
| hunks[0].removed.push(diffstr[i].substr(1)); | ||
| } else if (diffstr[i][0] === ' ') { | ||
| hunks[0].added.push(diffstr[i].substr(1)); | ||
| hunks[0].removed.push(diffstr[i].substr(1)); | ||
| } else if (diffstr[i][0] === '\\') { | ||
| if (diffstr[i - 1][0] === '+') { | ||
| remEOFNL = true; | ||
| } else if (diffstr[i - 1][0] === '-') { | ||
| addEOFNL = true; | ||
| } | ||
| } | ||
| } | ||
| var str = oldStr.split('\n'); | ||
| for (var i = diff.length - 1; i >= 0; i--) { | ||
| var d = diff[i]; | ||
| for (var j = 0; j < d.oldlength; j++) { | ||
| if (str[d.start-1+j] !== d.oldlines[j]) { | ||
| return false; | ||
| } | ||
| // Apply the diff to the input | ||
| var lines = oldStr.split('\n'); | ||
| for (i = hunks.length - 1; i >= 0; i--) { | ||
| var hunk = hunks[i]; | ||
| // Sanity check the input string. Bail if we don't match. | ||
| for (var j = 0; j < hunk.oldlength; j++) { | ||
| if (lines[hunk.start - 1 + j] !== hunk.removed[j]) { | ||
| return false; | ||
| } | ||
| Array.prototype.splice.apply(str,[d.start-1,+d.oldlength].concat(d.newlines)); | ||
| } | ||
| Array.prototype.splice.apply(lines, [hunk.start - 1, hunk.oldlength].concat(hunk.added)); | ||
| } | ||
| if (remEOFNL) { | ||
| while (!str[str.length-1]) { | ||
| str.pop(); | ||
| } | ||
| } else if (addEOFNL) { | ||
| str.push(''); | ||
| // Handle EOFNL insertion/removal | ||
| if (remEOFNL) { | ||
| while (!lines[lines.length - 1]) { | ||
| lines.pop(); | ||
| } | ||
| return str.join('\n'); | ||
| }, | ||
| } else if (addEOFNL) { | ||
| lines.push(''); | ||
| } | ||
| return lines.join('\n'); | ||
| }, | ||
| convertChangesToXML: function(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>'); | ||
| } | ||
| convertChangesToXML: function(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)); | ||
| ret.push(escapeHTML(change.value)); | ||
| if (change.added) { | ||
| ret.push('</ins>'); | ||
| } else if (change.removed) { | ||
| ret.push('</del>'); | ||
| } | ||
| if (change.added) { | ||
| ret.push('</ins>'); | ||
| } else if (change.removed) { | ||
| ret.push('</del>'); | ||
| } | ||
| return ret.join(''); | ||
| }, | ||
| } | ||
| return ret.join(''); | ||
| }, | ||
| // See: http://code.google.com/p/google-diff-match-patch/wiki/API | ||
| convertChangesToDMP: function(changes){ | ||
| var ret = [], change; | ||
| for ( var i = 0; i < changes.length; i++) { | ||
| change = changes[i]; | ||
| ret.push([(change.added ? 1 : change.removed ? -1 : 0), change.value]); | ||
| // See: http://code.google.com/p/google-diff-match-patch/wiki/API | ||
| convertChangesToDMP: function(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; | ||
| } | ||
| return ret; | ||
| }, | ||
| canonicalize: canonicalize | ||
| }; | ||
| })(); | ||
| ret.push([operation, change.value]); | ||
| } | ||
| return ret; | ||
| }, | ||
| canonicalize: canonicalize | ||
| }; | ||
| /*istanbul ignore next */ | ||
| /*global module */ | ||
| if (typeof module !== 'undefined' && module.exports) { | ||
| module.exports = JsDiff; | ||
| } | ||
| else if (typeof define === 'function' && define.amd) { | ||
| } else if (typeof define === 'function' && define.amd) { | ||
| /*global define */ | ||
| define([], function() { return JsDiff; }); | ||
| } | ||
| else if (typeof global.JsDiff === 'undefined') { | ||
| } else if (typeof global.JsDiff === 'undefined') { | ||
| global.JsDiff = JsDiff; | ||
| } | ||
| })(this); | ||
| }(this)); |
| { | ||
| "name": "diff", | ||
| "version": "1.3.2", | ||
| "version": "1.4.0", | ||
| "description": "A javascript text diff implementation.", | ||
@@ -31,10 +31,10 @@ "keywords": [ | ||
| "scripts": { | ||
| "test": "istanbul cover node_modules/.bin/_mocha test/*.js" | ||
| "test": "istanbul cover node_modules/.bin/_mocha test/*.js && istanbul check-coverage --statements 100 --functions 100 --branches 100 --lines 100 coverage/coverage.json" | ||
| }, | ||
| "dependencies": {}, | ||
| "devDependencies": { | ||
| "colors": "~0.6.2", | ||
| "colors": "^1.1.0", | ||
| "istanbul": "^0.3.2", | ||
| "mocha": "~1.6", | ||
| "should": "~1.2" | ||
| "mocha": "^2.2.4", | ||
| "should": "^6.0.1" | ||
| }, | ||
@@ -41,0 +41,0 @@ "optionalDependencies": {}, |
@@ -56,6 +56,7 @@ # jsdiff | ||
| * `JsDiff.createPatch(fileName, oldStr, newStr, oldHeader, newHeader)` - creates a unified diff patch. | ||
| * `JsDiff.createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader)` - creates a unified diff patch. | ||
| Parameters: | ||
| * `fileName` : String to be output in the filename sections of the patch | ||
| * `oldFileName` : String to be output in the filename section of the patch for the removals | ||
| * `newFileName` : String to be output in the filename section of the patch for the additions | ||
| * `oldStr` : Original string value | ||
@@ -66,2 +67,6 @@ * `newStr` : New string value | ||
| * `JsDiff.createPatch(fileName, oldStr, newStr, oldHeader, newHeader)` - creates a unified diff patch. | ||
| Just like JsDiff.createTwoFilesPatch, but with oldFileName being equal to newFileName. | ||
| * `JsDiff.applyPatch(oldStr, diffStr)` - applies a unified diff patch. | ||
@@ -68,0 +73,0 @@ |
New alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Fixed alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Improved metrics
- Total package byte prevSize
- increased by4.76%
28277
- Lines of code
- increased by9.98%
540
- Number of lines in readme file
- increased by2.82%
182
No dependency changes