blob: bf31673c488e6a6c9d84b920dca13cd68d43017d [file] [log] [blame] [raw]
var fs = require('fs'),
child_process = require('child_process'),
temp = require('temp'),
path = require('path'),
Promise = require('promise');
function cleanAndGetIndexes(text) {
var addRules = {
name: "add",
openTag: "{+",
replaceOpenTag: "",
closeTag: "+}",
replaceCloseTag: ""
};
var delRules = {
name: "del",
openTag: "[-",
replaceOpenTag: "",
closeTag: "-]",
replaceCloseTag: ""
};
var rules = [addRules, delRules];
var TagTypeEnum = {
OPENING: 1,
CLOSING: 2
};
function tagLookup(rules, text, pos) {
var seen = false;
var type = null;
var rule = null;
for (var i = 0; i < rules.length; i++) {
var candidateTag = text.slice(pos, pos + rules[i].openTag.length);
if (rules[i].openTag == candidateTag) {
seen = true;
type = TagTypeEnum.OPENING;
rule = i;
break;
}
candidateTag = text.slice(pos, pos + rules[i].closeTag.length);
if (rules[i].closeTag == candidateTag) {
seen = true;
type = TagTypeEnum.CLOSING;
rule = i;
break;
}
}
return {
seen: seen,
rule: rule,
type: type
};
}
var finalText = "";
var posInFinalText = 0; // character that is going to be treated
// The position in the original text:
var posInText = 0; // character that is going to be treated
var StateEnum = {
OUTSIDE_TAG: 1,
INSIDE_TAG: 2
};
var state = StateEnum.OUTSIDE_TAG;
var zones = [[], []];
var currentTextBeginPos = 0;
var currentTextEndPos = null;
var currentTagBeginPos = null;
var currentTagEndPos = null;
var currentTag = null;
function forward() {
posInFinalText = posInFinalText + 1;
posInText = posInText + 1;
}
function seenOpeningTag() {
memorizeText();
currentTagBeginPos = posInFinalText;
finalText = finalText.concat(rules[currentTag].replaceOpenTag);
posInFinalText = posInFinalText + rules[currentTag].replaceOpenTag.length;
posInText = posInText + rules[currentTag].openTag.length;
currentTextBeginPos = posInText;
}
function seenClosingTag() {
memorizeText();
finalText = finalText.concat(rules[currentTag].replaceCloseTag);
posInFinalText = posInFinalText + rules[currentTag].replaceCloseTag.length;
posInText = posInText + rules[currentTag].closeTag.length;
currentTagEndPos = posInFinalText - 1;
zones[currentTag].push({begin: currentTagBeginPos, end: currentTagEndPos});
currentTextBeginPos = posInText;
}
function memorizeText() {
currentTextEndPos = posInText - 1;
if (currentTextEndPos >= currentTextBeginPos) {
finalText = finalText.concat(text.slice(currentTextBeginPos, currentTextEndPos + 1));
}
}
function end() {
memorizeText();
}
function log_error(string) {
console.log(string);
}
while (posInText < text.length) {
var tag = tagLookup(rules, text, posInText);
if (tag.seen && tag.type == TagTypeEnum.OPENING) {
if (state != StateEnum.OUTSIDE_TAG) {
log_error("Opening tag while not outside tag (tags cannot be nested)");
return null;
}
currentTag = tag.rule;
seenOpeningTag();
state = StateEnum.INSIDE_TAG;
} else if (tag.seen && tag.type == TagTypeEnum.CLOSING) {
if (state != StateEnum.INSIDE_TAG) {
log_error("Closing tag while not inside tag.");
return null;
}
if (currentTag != tag.rule) {
log_error("Closing tag, but not of the same type as previously opened.");
return null;
}
seenClosingTag();
state = StateEnum.OUTSIDE_TAG;
} else {
forward();
}
}
end();
return {text: finalText, zones: zones};
}
function newTempDir() {
return new Promise(function (resolve, reject) {
temp.mkdir('gcc-explorer-diff', function (err, dirPath) {
if (err)
reject("Unable to open temp file: " + err);
else
resolve(dirPath);
});
});
}
var writeFile = Promise.denodeify(fs.writeFile);
function buildDiffHandler(config) {
var maxFileSize = config.maxOutput;
return function diffHandler(req, res) {
var before = req.body.before;
var after = req.body.after;
var error;
if (before === undefined) {
error = 'Warning : Bad request : wrong "before"';
console.log(error);
return next(new Error(error));
}
if (after === undefined) {
error = 'Warning : Bad request : wrong "after"';
console.log(error);
return next(new Error(error));
}
var tempBeforePath, tempAfterPath;
newTempDir()
.then(function (tmpDir) {
tempBeforePath = path.join(tmpDir, "gcc-explorer-wdiff-before");
tempAfterPath = path.join(tmpDir, "gcc-explorer-wdiff-after");
return Promise.all(
writeFile(tempBeforePath, before),
writeFile(tempAfterPath, after)
);
})
.then(function () {
var truncated = false;
var stdout = "";
var child = child_process.spawn(config.wdiffExe, [tempBeforePath, tempAfterPath],
{maxBuffer: maxFileSize, detached: true});
child.stdout.on('data', function (data) {
if (truncated) return;
if (stdout.length > maxFileSize) {
stdout += "\n[Truncated]";
truncated = true;
child.kill();
resolve(stdout);
}
stdout += data;
});
return new Promise(function (resolve, reject) {
child.on('error', function (e) {
reject(e);
});
child.on('exit', function () {
// See comment in compile.js - seems needed if the child has immediately exited
setTimeout(function () {
resolve(stdout);
}, 0);
});
});
})
.then(function (output) {
var cleaned = cleanAndGetIndexes(output);
res.set('Content-Type', 'application/json');
if (cleaned === null) {
res.end(JSON.stringify({
computedDiff: "Failed to clean the diff",
zones: null
}));
} else {
res.end(JSON.stringify({
computedDiff: cleaned.text,
zones: cleaned.zones
}));
}
})
.catch(function (err) {
res.end(JSON.stringify({
computedDiff: "Failed to diff: " + err,
zones: null
}));
});
};
}
module.exports = {
buildDiffHandler: buildDiffHandler
};