sl-cia/lib/instrumentation/markup-file-instrumenter.js

var util = require('util');
var fs = require('fs');
var FileInstrumenter = require("./file-instrumenter");
var MarkupFileParser = require("../markup-files-parser");
var FILE_INSTRUMENTATION_ERROR_MESSAGE = "Failed during instrumentation file  ";
var FILE_WRITING_ERROR_MESSAGE = "Failed while writing instrumented file.";
var FILE_READING_ERROR_MESSAGE = "Failed reading file contents.";

function MarkupFileInstrumenter() {
    FileInstrumenter.apply(this, arguments);
    this.originalFile = "";
    this.instrumentedFile = "";
    this.scriptTags = [];
    this.errorLoggingMessage = "";
    this.fiileHandler = null;
}

util.inherits(MarkupFileInstrumenter, FileInstrumenter);
module.exports = MarkupFileInstrumenter;

/*
    This class used for instrumenting markup files (i.e: html, ftl).
    The instrumentation works by combine all the js code in the file, instrument it in one piece, then split it back to original script tags
*/
MarkupFileInstrumenter.prototype._instrumentFile = function (inputFile, outputFile, name, preambleHeader, callback) {
    this.logger.debug("Instrumenting file '" + inputFile + "'.");
    try {
        this._extractScripts(inputFile);
        if(!this._hasJsInFile()) {
            return this._handleFileWithoutJS(outputFile, name, callback);
        }
        this._markScripts();
        return this._instrumentAndReplace(name, inputFile, outputFile, callback);
    } catch (err) {
        return this._handleInstrumentationError(this.errorLoggingMessage, err, name, callback);
    }
};

MarkupFileInstrumenter.prototype._extractScripts = function(inputFile) {
    this.errorLoggingMessage = FILE_READING_ERROR_MESSAGE;
    var fileContents = fs.readFileSync(inputFile, 'utf8');
    fileContents = this._onBeforeInstrumentation(fileContents);
    this.originalFile = fileContents;
    this.instrumentedFile = fileContents;
    this.fileParser = getFileParser(fileContents, inputFile, this.logger);
    this.scriptTags = cloneTagsArray(this.fileParser.scriptTags);
}

MarkupFileInstrumenter.prototype.instrumentationCallback = function (err, instrumentedContent, outputFile, name, callback) {
    if (err) {
        throw err;
    }
    this._replaceOldJsByInstrumented(instrumentedContent);
    this._insertCoverageCodeTag(instrumentedContent);
    this._insertPreambleTag();
    this.instrumentedFile = this._onAfterInstrumentation(this.instrumentedFile);
    return this._saveFileContent(outputFile, name, callback);
}

MarkupFileInstrumenter.prototype._instrumentAndReplace = function(name, inputFile, outputFile, callback) {
    var _this = this;
    var jsCode = this.fileParser.getAllJsInFile();
    this.errorLoggingMessage = FILE_INSTRUMENTATION_ERROR_MESSAGE + name;
    this.instrumenter.instrument(jsCode, inputFile, function (err, instrumentedContent) {
        return _this.instrumentationCallback(err, instrumentedContent, outputFile, name, callback);
    }, {
        filename: name,
        inputSourceMap: null
    });
}

MarkupFileInstrumenter.prototype._replaceOldJsByInstrumented = function(instrumentedContent){
    for (var i = 0; i < this.scriptTags.length; i++) {
        var currentTag = this.scriptTags[i];
        var scriptMarker = createScriptMarker(i);
        var scriptStartIndex = instrumentedContent.indexOf(scriptMarker);
        scriptStartIndex += scriptMarker.length;
        var scriptEndIndex = instrumentedContent.lastIndexOf(scriptMarker);
        var instrumentedScript = instrumentedContent.substring(scriptStartIndex, scriptEndIndex);
        this.instrumentedFile = this.instrumentedFile.replace(currentTag.content, instrumentedScript);
    }
}

MarkupFileInstrumenter.prototype._saveFileContent = function(outputFile, name, callback) {
    if (this.opts.onFileInstrumented != null) {
        this.opts.onFileInstrumented(name);
    }
    this.errorLoggingMessage = FILE_WRITING_ERROR_MESSAGE;
    fs.writeFileSync(outputFile, this.instrumentedFile, 'utf8');
    return callback(null, name);
}

MarkupFileInstrumenter.prototype._handleFileWithoutJS = function (outputFile, name, callback) {
    if (this.opts.onFileCopied != null) {
        this.opts.onFileCopied(name);
    }
    return this._saveFileContent(outputFile, name, callback);
}

MarkupFileInstrumenter.prototype._hasJsInFile = function() {
    return this.scriptTags.length !== 0 && isJSEmbeddedInFile(this.fileParser);
}

MarkupFileInstrumenter.prototype._insertCoverageCodeTag = function(instrumentedCode){
    var firstTagMarker = createScriptMarker(0);
    var firstTagStart = instrumentedCode.indexOf(firstTagMarker);
    var istanbulCoverageCode = instrumentedCode.substring(0, firstTagStart);
    var coverageCodeTag =  "<script>\n\t" + istanbulCoverageCode + "\n</script>\n";
    this.instrumentedFile = this._insertTagAtBeginning(coverageCodeTag);
}

MarkupFileInstrumenter.prototype._insertPreambleTag = function() {
    var preambleTag =  "<script>\n\t" + this.preambleHeader.join("\n") + "\n</script>\n";
    this.instrumentedFile = this._insertTagAtBeginning(preambleTag);
};

MarkupFileInstrumenter.prototype._markScripts = function(){
    var marked = [];
    for (var i = 0; i < this.fileParser.scriptTags.length; i++) {
        var slComment = createScriptMarker(i);
        var currentTag = this.fileParser.scriptTags[i];
        currentTag.content = slComment + currentTag.content + slComment;
        marked.push(currentTag);
    }
    this.fileParser.scriptTags = marked;
}

MarkupFileInstrumenter.prototype._insertTagAtBeginning = function(newTag) {
    var firstScriptTagIndex = this.instrumentedFile.search(/<script[\s\S]*?>/);
    return this.instrumentedFile.slice(0, firstScriptTagIndex) + newTag +
        this.instrumentedFile.slice(firstScriptTagIndex);
};

function getFileParser(fileContents, inputFile, logger) {
    var handler = new MarkupFileParser(fileContents, inputFile, logger);
    handler.extractScriptTags();
    return handler;
}


// Checks if the js code is inside file or loaded from external js file (ie <script src="..."></script>).
function isJSEmbeddedInFile(fileParser) {
    return fileParser.getAllJsInFile() !== "";
}


function createScriptMarker(index) {
    return "/********** SL tag no " + index + " **********/"
}

/*
    Because we add mark comments to tag scripts we want to save the original without any changes so we implement deep copy.
 */
function cloneTagsArray(tagsArray){
    return JSON.parse(JSON.stringify( tagsArray));
}