diff --git a/diff.js b/diff.js
new file mode 100644
index 0000000..0815aeb
--- /dev/null
+++ b/diff.js
@@ -0,0 +1,565 @@
+/* See LICENSE file for terms of use */
+
+/*
+ * Text diff implementation.
+ *
+ * This library supports the following APIS:
+ * JsDiff.diffChars: Character by character diff
+ * JsDiff.diffWords: Word (as defined by \b regex) diff which ignores whitespace
+ * JsDiff.diffLines: Line based diff
+ *
+ * JsDiff.diffCss: Diff targeted at CSS content
+ *
+ * These methods are based on the implementation proposed in
+ * "An O(ND) Difference Algorithm and its Variations" (Myers, 1986).
+ * http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.4.6927
+ *
+ * AUTHOR: https://github.com/kpdecker/jsdiff
+ */
+(function(global, undefined) {
+
+ 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);
+ }
+
+ 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);
+ }
+ 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, '"');
+
+ return n;
+ }
+
+ 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;
+ });
+
+ 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('');
+ oldPos += component.count;
+ }
+ }
+
+ return components;
+ }
+
+ var Diff = function(ignoreWhitespace) {
+ this.ignoreWhitespace = ignoreWhitespace;
+ };
+ Diff.prototype = {
+ diff: function(oldString, newString, callback) {
+ var self = this;
+
+ function done(value) {
+ if (callback) {
+ setTimeout(function() { callback(undefined, value); }, 0);
+ return true;
+ } else {
+ return value;
+ }
+ }
+
+ // 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 }]);
+ }
+
+ newString = this.tokenize(newString);
+ oldString = this.tokenize(oldString);
+
+ var newLen = newString.length, oldLen = oldString.length;
+ 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: 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;
+ }
+
+ 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;
+ }
+
+ // 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);
+
+ // 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++;
+ }
+
+ // 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();
+ }
+
+ if (!execEditLength()) {
+ exec();
+ }
+ }, 0);
+ })();
+ } else {
+ while(editLength <= maxEditLength) {
+ var ret = execEditLength();
+ if (ret) {
+ return ret;
+ }
+ }
+ }
+ },
+
+ 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,
+
+ 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(left, right) {
+ var reWhitespace = /\S/;
+ return left === right || (this.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right));
+ },
+ tokenize: function(value) {
+ return value.split('');
+ }
+ };
+
+ var CharDiff = new Diff();
+
+ var WordDiff = new Diff(true);
+ var WordWithSpaceDiff = new Diff();
+ WordDiff.tokenize = WordWithSpaceDiff.tokenize = function(value) {
+ return removeEmpty(value.split(/(\s+|\b)/));
+ };
+
+ var CssDiff = new Diff(true);
+ CssDiff.tokenize = function(value) {
+ return removeEmpty(value.split(/([{}:;,]|\s+)/));
+ };
+
+ var LineDiff = new Diff();
+
+ var TrimmedLineDiff = new Diff();
+ TrimmedLineDiff.ignoreTrim = true;
+
+ 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 (line) {
+ 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);
+ }
+ }
+
+ return retLines;
+ };
+
+
+ var SentenceDiff = new Diff();
+ SentenceDiff.tokenize = function (value) {
+ return removeEmpty(value.split(/(\S.+?[.!?])(?=\s+|$)/));
+ };
+
+ 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'));
+ };
+
+ var objectPrototypeToString = Object.prototype.toString;
+
+ // 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 (var 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);
+ }
+ 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;
+ }
+
+ return {
+ Diff: Diff,
+
+ 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); },
+
+ diffSentences: function(oldStr, newStr, callback) { return SentenceDiff.diff(oldStr, newStr, callback); },
+
+ 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
+ );
+ },
+
+ createPatch: function(fileName, oldStr, newStr, oldHeader, newHeader) {
+ var ret = [];
+
+ ret.push('Index: ' + fileName);
+ ret.push('===================================================================');
+ ret.push('--- ' + fileName + (typeof oldHeader === 'undefined' ? '' : '\t' + oldHeader));
+ ret.push('+++ ' + fileName + (typeof newHeader === 'undefined' ? '' : '\t' + newHeader));
+
+ var diff = LineDiff.diff(oldStr, newStr);
+ if (!diff[diff.length-1].value) {
+ diff.pop(); // Remove trailing newline add
+ }
+ 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);
+
+ // 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');
+ }
+ }
+
+ 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;
+
+ 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;
+ }
+ }
+ 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;
+ }
+ } 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;
+ }
+ }
+
+ return ret.join('\n') + '\n';
+ },
+
+ applyPatch: function(oldStr, uniDiff) {
+ var diffstr = uniDiff.split('\n');
+ var diff = [];
+ var i = 0,
+ remEOFNL = false,
+ addEOFNL = false;
+
+ // Skip to the first change chunk
+ while (i < diffstr.length && !/^@@/.test(diffstr[i])) {
+ i++;
+ }
+
+ 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;
+ }
+ }
+ }
+
+ 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;
+ }
+ }
+ Array.prototype.splice.apply(str,[d.start-1,+d.oldlength].concat(d.newlines));
+ }
+
+ if (remEOFNL) {
+ while (!str[str.length-1]) {
+ str.pop();
+ }
+ } else if (addEOFNL) {
+ str.push('');
+ }
+ return str.join('\n');
+ },
+
+ convertChangesToXML: function(changes){
+ var ret = [];
+ for ( var i = 0; i < changes.length; i++) {
+ var change = changes[i];
+ if (change.added) {
+ ret.push('');
+ } else if (change.removed) {
+ ret.push('');
+ }
+
+ ret.push(escapeHTML(change.value));
+
+ if (change.added) {
+ ret.push('');
+ } else if (change.removed) {
+ ret.push('');
+ }
+ }
+ 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]);
+ }
+ return ret;
+ },
+
+ canonicalize: canonicalize
+ };
+ })();
+
+ /*istanbul ignore next */
+ if (typeof module !== 'undefined' && module.exports) {
+ module.exports = JsDiff;
+ }
+ else if (typeof define === 'function' && define.amd) {
+ /*global define */
+ define([], function() { return JsDiff; });
+ }
+ else if (typeof global.JsDiff === 'undefined') {
+ global.JsDiff = JsDiff;
+ }
+})(this);
\ No newline at end of file
diff --git a/diff2html.js b/diff2html.js
index 435a6cf..b023506 100644
--- a/diff2html.js
+++ b/diff2html.js
@@ -8,10 +8,10 @@
*/
var LINE_TYPE = {
- INSERTS: "d2h-ins",
- DELETES: "d2h-del",
- CONTEXT: "d2h-cntx",
- INFO: "d2h-info"
+ INSERTS: "d2h-ins",
+ DELETES: "d2h-del",
+ CONTEXT: "d2h-cntx",
+ INFO: "d2h-info"
};
function Diff2Html() {
@@ -21,157 +21,164 @@ function Diff2Html() {
* Generates pretty html from string diff input
*/
Diff2Html.prototype.getPrettyHtmlFromDiff = function (diffInput) {
- var diffJson = generateDiffJson(diffInput);
- return generateJsonHtml(diffJson);
+ var diffJson = generateDiffJson(diffInput);
+ return generateJsonHtml(diffJson);
};
/*
* Generates json object from string diff input
*/
Diff2Html.prototype.getJsonFromDiff = function (diffInput) {
- return generateDiffJson(diffInput);
+ return generateDiffJson(diffInput);
};
/*
* Generates pretty html from a json object
*/
Diff2Html.prototype.getPrettyHtmlFromJson = function (diffJson) {
- return generateJsonHtml(diffJson);
+ return generateJsonHtml(diffJson);
};
/*
* Generates pretty side by side html from string diff input
*/
Diff2Html.prototype.getPrettySideBySideHtmlFromDiff = function (diffInput) {
- var diffJson = generateDiffJson(diffInput);
- return generateSideBySideJsonHtml(diffJson);
+ var diffJson = generateDiffJson(diffInput);
+ return generateSideBySideJsonHtml(diffJson);
};
/*
* Generates pretty side by side html from a json object
*/
Diff2Html.prototype.getPrettySideBySideHtmlFromJson = function (diffJson) {
- return generateSideBySideJsonHtml(diffJson);
+ return generateSideBySideJsonHtml(diffJson);
};
var generateDiffJson = function (diffInput) {
- var files = [],
- currentFile = null,
- currentBlock = null,
- oldLine = null,
- newLine = null;
+ var files = [],
+ currentFile = null,
+ currentBlock = null,
+ oldLine = null,
+ newLine = null;
- var saveBlock = function () {
- /* add previous block(if exists) before start a new file */
- if (currentBlock) {
- currentFile.blocks.push(currentBlock);
- currentBlock = null;
- }
- };
+ var saveBlock = function () {
+ /* add previous block(if exists) before start a new file */
+ if (currentBlock) {
+ currentFile.blocks.push(currentBlock);
+ currentBlock = null;
+ }
+ };
- var saveFile = function () {
- /*
- * add previous file(if exists) before start a new one
- * if it has name (to avoid binary files errors)
- */
- if (currentFile && currentFile.newName) {
- files.push(currentFile);
- currentFile = null;
- }
- };
-
- var startFile = function () {
- saveBlock();
- saveFile();
-
- /* create file structure */
- currentFile = {};
- currentFile.blocks = [];
- currentFile.deletedLines = 0;
- currentFile.addedLines = 0;
- };
-
- var startBlock = function (line) {
- saveBlock();
-
- var values = /^@@ -(\d+),\d+ \+(\d+),\d+ @@.*/.exec(line) ||
- /^@@@ -(\d+),\d+ -\d+,\d+ \+(\d+),\d+ @@@.*/.exec(line) ||
- [0, 0, 0];
-
- oldLine = values[1];
- newLine = values[2];
-
- /* create block metadata */
- currentBlock = {};
- currentBlock.lines = [];
- currentBlock.oldStartLine = oldLine;
- currentBlock.newStartLine = newLine;
- currentBlock.header = line;
- };
-
- var createLine = function (line) {
- var currentLine = {};
- currentLine.content = line;
-
- /* fill the line data */
- if (startsWith(line, "+") || startsWith(line, " +")) {
- currentFile.addedLines++;
-
- currentLine.type = LINE_TYPE.INSERTS;
- currentLine.oldNumber = null;
- currentLine.newNumber = newLine++;
-
- currentBlock.lines.push(currentLine);
-
- } else if (startsWith(line, "-") || startsWith(line, " -")) {
- currentFile.deletedLines++;
-
- currentLine.type = LINE_TYPE.DELETES;
- currentLine.oldNumber = oldLine++;
- currentLine.newNumber = null;
-
- currentBlock.lines.push(currentLine);
-
- } else {
- currentLine.type = LINE_TYPE.CONTEXT;
- currentLine.oldNumber = oldLine++;
- currentLine.newNumber = newLine++;
-
- currentBlock.lines.push(currentLine);
- }
- };
-
- var diffLines = diffInput.split("\n");
- diffLines.forEach(function (line) {
- // Unmerged paths, and possibly other non-diffable files
- // https://github.com/scottgonzalez/pretty-diff/issues/11
- // Also, remove some useless lines
- if (!line || startsWith(line, "*") ||
- startsWith(line, "new") || startsWith(line, "index")) {
- return;
- }
-
- var values = [];
- if (startsWith(line, "diff")) {
- startFile();
- } else if (currentFile && !currentFile.oldName && (values = /^--- a\/(\S+).*$/.exec(line))) {
- currentFile.oldName = values[1];
- } else if (currentFile && !currentFile.newName && (values = /^\+\+\+ [b]?\/(\S+).*$/.exec(line))) {
- currentFile.newName = values[1];
-
- var fileSplit = currentFile.newName.split(".");
- currentFile.language = fileSplit[fileSplit.length - 1];
- } else if (currentFile && startsWith(line, "@@")) {
- startBlock(line);
- } else if (currentBlock) {
- createLine(line);
- }
- });
+ var saveFile = function () {
+ /*
+ * add previous file(if exists) before start a new one
+ * if it has name (to avoid binary files errors)
+ */
+ if (currentFile && currentFile.newName) {
+ files.push(currentFile);
+ currentFile = null;
+ }
+ };
+ var startFile = function () {
saveBlock();
saveFile();
- return files;
+ /* create file structure */
+ currentFile = {};
+ currentFile.blocks = [];
+ currentFile.deletedLines = 0;
+ currentFile.addedLines = 0;
+ };
+
+ var startBlock = function (line) {
+ saveBlock();
+
+ var values;
+
+ if (values = /^@@ -(\d+),\d+ \+(\d+),\d+ @@.*/.exec(line)) {
+ currentFile.isTripleDiff = false;
+ } else if (values = /^@@@ -(\d+),\d+ -\d+,\d+ \+(\d+),\d+ @@@.*/.exec(line)) {
+ currentFile.isTripleDiff = true;
+ } else {
+ values = [0, 0];
+ currentFile.isTripleDiff = false;
+ }
+
+ oldLine = values[1];
+ newLine = values[2];
+
+ /* create block metadata */
+ currentBlock = {};
+ currentBlock.lines = [];
+ currentBlock.oldStartLine = oldLine;
+ currentBlock.newStartLine = newLine;
+ currentBlock.header = line;
+ };
+
+ var createLine = function (line) {
+ var currentLine = {};
+ currentLine.content = line;
+
+ /* fill the line data */
+ if (startsWith(line, "+") || startsWith(line, " +")) {
+ currentFile.addedLines++;
+
+ currentLine.type = LINE_TYPE.INSERTS;
+ currentLine.oldNumber = null;
+ currentLine.newNumber = newLine++;
+
+ currentBlock.lines.push(currentLine);
+
+ } else if (startsWith(line, "-") || startsWith(line, " -")) {
+ currentFile.deletedLines++;
+
+ currentLine.type = LINE_TYPE.DELETES;
+ currentLine.oldNumber = oldLine++;
+ currentLine.newNumber = null;
+
+ currentBlock.lines.push(currentLine);
+
+ } else {
+ currentLine.type = LINE_TYPE.CONTEXT;
+ currentLine.oldNumber = oldLine++;
+ currentLine.newNumber = newLine++;
+
+ currentBlock.lines.push(currentLine);
+ }
+ };
+
+ var diffLines = diffInput.split("\n");
+ diffLines.forEach(function (line) {
+ // Unmerged paths, and possibly other non-diffable files
+ // https://github.com/scottgonzalez/pretty-diff/issues/11
+ // Also, remove some useless lines
+ if (!line || startsWith(line, "*") ||
+ startsWith(line, "new") || startsWith(line, "index")) {
+ return;
+ }
+
+ var values = [];
+ if (startsWith(line, "diff")) {
+ startFile();
+ } else if (currentFile && !currentFile.oldName && (values = /^--- a\/(\S+).*$/.exec(line))) {
+ currentFile.oldName = values[1];
+ } else if (currentFile && !currentFile.newName && (values = /^\+\+\+ [b]?\/(\S+).*$/.exec(line))) {
+ currentFile.newName = values[1];
+
+ var fileSplit = currentFile.newName.split(".");
+ currentFile.language = fileSplit[fileSplit.length - 1];
+ } else if (currentFile && startsWith(line, "@@")) {
+ startBlock(line);
+ } else if (currentBlock) {
+ createLine(line);
+ }
+ });
+
+ saveBlock();
+ saveFile();
+
+ return files;
};
/*
@@ -179,82 +186,91 @@ var generateDiffJson = function (diffInput) {
*/
var generateJsonHtml = function (diffFiles) {
- return "\n" +
- diffFiles.map(function (file) {
- return "
\n" +
- " \n" +
- "
\n" +
- "
\n" +
- "
\n" +
- " \n" +
- " " + generateFileHtml(file) +
- " \n" +
- "
\n" +
- "
\n" +
- "
\n" +
- "
\n";
- }).join("\n") +
- "
\n" +
+ diffFiles.map(function (file) {
+ return "
\n" +
+ " \n" +
+ "
\n" +
+ "
\n" +
+ "
\n" +
+ " \n" +
+ " " + generateFileHtml(file) +
+ " \n" +
+ "
\n" +
+ "
\n" +
+ "
\n" +
+ "
\n";
+ }).join("\n") +
+ "
\n" +
- " | \n" +
- " " +
- " " + escape(block.header) + " " +
- " | \n" +
- "
\n";
+ var lines = "\n" +
+ " | \n" +
+ " " +
+ " " + escape(block.header) + " " +
+ " | \n" +
+ "
\n";
- for (var i = 0; i < block.lines.length; i++) {
- var prevLine = block.lines[i - 1];
- var line = block.lines[i];
- var newLine = block.lines[i + 1];
- var nextNewLine = block.lines[i + 2];
- var isOppositeTypeTwoLineBlock =
- line.type == LINE_TYPE.DELETES &&
- newLine && newLine.type == LINE_TYPE.INSERTS &&
- (!nextNewLine || nextNewLine && nextNewLine.type != LINE_TYPE.INSERTS) &&
- (!prevLine || prevLine && prevLine.type != LINE_TYPE.DELETES);
+ var oldLines = [], newLines = [];
+ var processedOldLines = [], processedNewLines = [];
- var escapedLine = escape(line.content);
+ for (var i = 0; i < block.lines.length; i++) {
+ var line = block.lines[i];
- if (isOppositeTypeTwoLineBlock) {
- var nextEscapedLine = escape(newLine.content);
+ if (line.type == LINE_TYPE.DELETES && !newLines.length) {
+ oldLines.push(line);
+ } else if (line.type == LINE_TYPE.INSERTS && oldLines.length > newLines.length) {
+ newLines.push(line);
+ } else {
+ if (oldLines.length === newLines.length) {
+ for (var j = 0; j < oldLines.length; j++) {
+ var oldLine = oldLines[j];
+ var newLine = newLines[j];
+ var oldEscapedLine = escape(oldLine.content);
+ var newEscapedLine = escape(newLine.content);
- var diff = diffHighlight(escapedLine, nextEscapedLine);
+ var diff = diffHighlight(oldEscapedLine, newEscapedLine, file.isTripleDiff);
- lines += generateLineHtml(line.type, line.oldNumber, line.newNumber, diff.o) +
- generateLineHtml(newLine.type, newLine.oldNumber, newLine.newNumber, diff.n);
+ processedOldLines += generateLineHtml(oldLine.type, oldLine.oldNumber, oldLine.newNumber, diff.o);
+ processedNewLines += generateLineHtml(newLine.type, newLine.oldNumber, newLine.newNumber, diff.n);
+ }
- i++;
- } else {
- lines += generateLineHtml(line.type, line.oldNumber, line.newNumber, escapedLine);
- }
+ lines += processedOldLines + processedNewLines;
+
+ oldLines = [];
+ newLines = [];
+ processedOldLines = [];
+ processedNewLines = []
+ } else {
+ lines += generateLineHtml(line.type, line.oldNumber, line.newNumber, escape(line.content));
}
+ }
+ }
- return lines;
- }).join("\n");
+ return lines;
+ }).join("\n");
};
var generateLineHtml = function (type, oldNumber, newNumber, content) {
- return "\n" +
- " | " +
- " " + valueOrEmpty(oldNumber) + " " +
- " " + valueOrEmpty(newNumber) + " " +
- " | \n" +
- " " +
- " " + content + " " +
- " | \n" +
- "
\n";
+ return "\n" +
+ " | " +
+ " " + valueOrEmpty(oldNumber) + " " +
+ " " + valueOrEmpty(newNumber) + " " +
+ " | \n" +
+ " " +
+ " " + content + " " +
+ " | \n" +
+ "
\n";
};
/*
@@ -262,109 +278,109 @@ var generateLineHtml = function (type, oldNumber, newNumber, content) {
*/
var generateSideBySideJsonHtml = function (diffFiles) {
- return "\n" +
- diffFiles.map(function (file) {
- var diffs = generateSideBySideFileHtml(file);
+ return "
\n" +
+ diffFiles.map(function (file) {
+ var diffs = generateSideBySideFileHtml(file);
- return "
\n" +
- " \n" +
- "
\n" +
- "
\n" +
- "
\n" +
- "
\n" +
- " \n" +
- " " + diffs.left +
- " \n" +
- "
\n" +
- "
\n" +
- "
\n" +
- "
\n" +
- "
\n" +
- "
\n" +
- " \n" +
- " " + diffs.right +
- " \n" +
- "
\n" +
- "
\n" +
- "
\n" +
- "
\n" +
- "
\n";
- }).join("\n") +
- "
\n";
+ return "
\n" +
+ " \n" +
+ "
\n" +
+ "
\n" +
+ "
\n" +
+ "
\n" +
+ " \n" +
+ " " + diffs.left +
+ " \n" +
+ "
\n" +
+ "
\n" +
+ "
\n" +
+ "
\n" +
+ "
\n" +
+ "
\n" +
+ " \n" +
+ " " + diffs.right +
+ " \n" +
+ "
\n" +
+ "
\n" +
+ "
\n" +
+ "
\n" +
+ "
\n";
+ }).join("\n") +
+ "
\n" +
- " | \n" +
- " " +
- " " + escape(block.header) + " " +
- " | \n" +
- "
\n";
+ fileHtml.left += "\n" +
+ " | \n" +
+ " " +
+ " " + escape(block.header) + " " +
+ " | \n" +
+ "
\n";
- fileHtml.right += "\n" +
- " | \n" +
- " " +
- " " +
- " | \n" +
- "
\n";
+ fileHtml.right += "\n" +
+ " | \n" +
+ " " +
+ " " +
+ " | \n" +
+ "
\n";
- for (var i = 0; i < block.lines.length; i++) {
- var prevLine = block.lines[i - 1];
- var line = block.lines[i];
- var newLine = block.lines[i + 1];
- var nextNewLine = block.lines[i + 2];
+ for (var i = 0; i < block.lines.length; i++) {
+ var prevLine = block.lines[i - 1];
+ var line = block.lines[i];
+ var newLine = block.lines[i + 1];
+ var nextNewLine = block.lines[i + 2];
- var isOpositeTypeTwoLineBlock = line.type == LINE_TYPE.DELETES && newLine && newLine.type == LINE_TYPE.INSERTS &&
- (!nextNewLine || nextNewLine && nextNewLine.type != LINE_TYPE.INSERTS) &&
- (!prevLine || prevLine && prevLine.type != LINE_TYPE.DELETES);
+ var isOpositeTypeTwoLineBlock = line.type == LINE_TYPE.DELETES && newLine && newLine.type == LINE_TYPE.INSERTS &&
+ (!nextNewLine || nextNewLine && nextNewLine.type != LINE_TYPE.INSERTS) &&
+ (!prevLine || prevLine && prevLine.type != LINE_TYPE.DELETES);
- var escapedLine = escape(line.content);
+ var escapedLine = escape(line.content);
- if (isOpositeTypeTwoLineBlock) {
- var nextEscapedLine = escape(newLine.content);
+ if (isOpositeTypeTwoLineBlock) {
+ var nextEscapedLine = escape(newLine.content);
- var diff = diffHighlight(escapedLine, nextEscapedLine);
+ var diff = diffHighlight(escapedLine, nextEscapedLine, file.isTripleDiff);
- fileHtml.left += generateSingleLineHtml(line.type, line.oldNumber, diff.o);
- fileHtml.right += generateSingleLineHtml(newLine.type, newLine.newNumber, diff.n);
+ fileHtml.left += generateSingleLineHtml(line.type, line.oldNumber, diff.o);
+ fileHtml.right += generateSingleLineHtml(newLine.type, newLine.newNumber, diff.n);
- i++;
- } else if (line.type == LINE_TYPE.DELETES) {
- fileHtml.left += generateSingleLineHtml(line.type, line.oldNumber, escapedLine);
- fileHtml.right += generateSingleLineHtml(LINE_TYPE.CONTEXT, "", "", "");
- } else if (line.type == LINE_TYPE.INSERTS) {
- fileHtml.left += generateSingleLineHtml(LINE_TYPE.CONTEXT, "", "", "");
- fileHtml.right += generateSingleLineHtml(line.type, line.newNumber, escapedLine);
- } else {
- fileHtml.left += generateSingleLineHtml(line.type, line.oldNumber, escapedLine);
- fileHtml.right += generateSingleLineHtml(line.type, line.newNumber, escapedLine);
- }
- }
+ i++;
+ } else if (line.type == LINE_TYPE.DELETES) {
+ fileHtml.left += generateSingleLineHtml(line.type, line.oldNumber, escapedLine);
+ fileHtml.right += generateSingleLineHtml(LINE_TYPE.CONTEXT, "", "", "");
+ } else if (line.type == LINE_TYPE.INSERTS) {
+ fileHtml.left += generateSingleLineHtml(LINE_TYPE.CONTEXT, "", "", "");
+ fileHtml.right += generateSingleLineHtml(line.type, line.newNumber, escapedLine);
+ } else {
+ fileHtml.left += generateSingleLineHtml(line.type, line.oldNumber, escapedLine);
+ fileHtml.right += generateSingleLineHtml(line.type, line.newNumber, escapedLine);
+ }
+ }
- });
+ });
- return fileHtml;
+ return fileHtml;
};
var generateSingleLineHtml = function (type, number, content) {
- return "\n" +
- " | " + number + " | \n" +
- " " +
- " " + content + " " +
- " | \n" +
- "
\n";
+ return "\n" +
+ " | " + number + " | \n" +
+ " " +
+ " " + content + " " +
+ " | \n" +
+ "
\n";
};
/*
@@ -372,23 +388,23 @@ var generateSingleLineHtml = function (type, number, content) {
*/
var getDiffName = function (oldFilename, newFilename) {
- if (oldFilename && newFilename && oldFilename !== newFilename) {
- return oldFilename + " -> " + newFilename;
- } else if (newFilename) {
- return newFilename;
- } else if (oldFilename) {
- return oldFilename;
- } else {
- return "Unknown filename";
- }
+ if (oldFilename && newFilename && oldFilename !== newFilename) {
+ return oldFilename + " -> " + newFilename;
+ } else if (newFilename) {
+ return newFilename;
+ } else if (oldFilename) {
+ return oldFilename;
+ } else {
+ return "Unknown filename";
+ }
};
var removeIns = function (line) {
- return line.replace(/(((.|\n)*?)<\/ins>)/g, "");
+ return line.replace(/(((.|\n)*?)<\/ins>)/g, "");
};
var removeDel = function (line) {
- return line.replace(/(((.|\n)*?)<\/del>)/g, "");
+ return line.replace(/(((.|\n)*?)<\/del>)/g, "");
};
/*
@@ -396,27 +412,47 @@ var removeDel = function (line) {
*/
function escape(str) {
- return str.slice(0)
- .replace(/&/g, "&")
- .replace(//g, ">")
- .replace(/\t/g, " ");
+ return str.slice(0)
+ .replace(/&/g, "&")
+ .replace(//g, ">")
+ .replace(/\t/g, " ");
}
function startsWith(str, start) {
- return str.indexOf(start) === 0;
+ return str.indexOf(start) === 0;
}
function valueOrEmpty(value) {
- return value ? value : "";
+ return value ? value : "";
}
-function diffHighlight(diffLine1, diffLine2) {
- /* remove the initial -/+ to avoid always having diff in the first char */
- var highlightedLine = JsDiff(diffLine1.substr(1), diffLine2.substr(1));
+function diffHighlight(diffLine1, diffLine2, isTripleDiff) {
+ var lineStart1, lineStart2;
- return {
- o: diffLine1.charAt(0) + removeIns(highlightedLine),
- n: diffLine2.charAt(0) + removeDel(highlightedLine)
- }
+ var prefixSize = 1;
+
+ if (isTripleDiff) prefixSize = 2;
+
+ lineStart1 = diffLine1.substr(0, prefixSize);
+ lineStart2 = diffLine2.substr(0, prefixSize);
+
+ diffLine1 = diffLine1.substr(prefixSize);
+ diffLine2 = diffLine2.substr(prefixSize);
+
+ var diff = JsDiff.diffChars(diffLine1, diffLine2);
+
+ var highlightedLine = "";
+
+ diff.forEach(function (part) {
+ var elemType = part.added ? 'ins' : part.removed ? 'del' : null;
+
+ if (elemType !== null) highlightedLine += "<" + elemType + ">" + part.value + "";
+ else highlightedLine += part.value;
+ });
+
+ return {
+ o: lineStart1 + removeIns(highlightedLine),
+ n: lineStart2 + removeDel(highlightedLine)
+ }
}
diff --git a/index.html b/index.html
index f788c02..e8d77e2 100644
--- a/index.html
+++ b/index.html
@@ -17,7 +17,8 @@
-
+
+