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

var path = require('path');
var mkdirp = require('mkdirp');
var once = require('once');
var fs = require('fs');
var SlJsInfra = require('sl-js-infra').SlJsInfra;
var fileAndFolderUtils = require('../file-and-folder-utils');
var ValidationUtils = SlJsInfra.Utils.ValidationUtils;

/**
 * This class responsible to instrument a single file with Sealights information.
 * @param {* Instrumentation options} opts
 * @param {* Header with Sealights config to inject inside a single file} preambleHeader
 * @param {* An instance of Istanbul's instrumenter} instrumenter
 * @param {* The file name} name
 * @param {* A logger} logger
 */
function FileInstrumenter(opts, preambleHeader, instrumenter, name, IgnoredFilesHandler, logger) {
    ValidationUtils.verifyNotNullOrEmpty(opts, "opts");
    ValidationUtils.verifyNotNullOrEmpty(preambleHeader, "preambleHeader");
    ValidationUtils.verifyNotNullOrEmpty(instrumenter, "instrumenter");
    ValidationUtils.verifyNotNullOrEmpty(name, "name");
    ValidationUtils.verifyNotNullOrEmpty(IgnoredFilesHandler, "IgnoredFilesHandler");
    ValidationUtils.verifyNotNullOrEmpty(logger, "logger");

    this.opts = opts;
    this.preambleHeader = preambleHeader;
    this.instrumenter = instrumenter;
    this.name = name;
    this.IgnoredFilesHandler = IgnoredFilesHandler;
    this.logger = logger;
}


FileInstrumenter.prototype.processSingleFile = function (callback) {
    ValidationUtils.verifyNotNullOrEmpty(callback, "callback");

    this.logger.debug("Processing single file. File: '" + this.name + "'.");

    var inputFile = this._getInputFile()
    var outputFile = this._getOutputFile();
    var inputFileExtension = path.extname(inputFile);
    var isValidExtension = this.opts.extensionsToInstrument[inputFileExtension];
    var shouldInstrumentFile = isValidExtension && this._isFileAcceptedBySlIgnore();
    var outputDir = path.dirname(outputFile);
    var _this = this;

    callback = once(callback);
    mkdirp.sync(outputDir);

    if (fs.statSync(inputFile).isDirectory()) {
        this.logger.info("Input file is a directory. No need to process");
        return callback(null, this.name);
    }

    if (shouldInstrumentFile) {
        return this._instrumentFile(inputFile, outputFile, this.name, this.preambleHeader, callback);
    }else{
        fileAndFolderUtils.copyFileAsIs(inputFile, outputFile, this.name, this.logger, function (err, name) {
            if(err && name && _this.opts.onFileCopyError != null){
                _this.opts.onFileCopyError(name, err);
            }
            else if (!err && name && _this.opts.onFileCopied != null) {
                //We have a file name. Notify.
                    _this.opts.onFileCopied(name);
            }
            return callback(err, name);
        });
    }
}


FileInstrumenter.prototype._onBeforeInstrumentation = function (fileContent) {
    fileContent = this._removeWebpackComments(fileContent);
    return fileContent;
}

FileInstrumenter.prototype._onAfterInstrumentation = function (instrumentedFileContent) {
    instrumentedFileContent = this._fixMissingSpaceAfterReturnStatement(instrumentedFileContent);
    return instrumentedFileContent;
}

FileInstrumenter.prototype._handleInstrumentationError = function (message, err, name, callback) {
    this.logger.error(message + " File: '" + name + "'. Error:", err);
    if (this.opts.onFileWithInstrumentationError != null){
        this.opts.onFileWithInstrumentationError({ file: name, error: err });
    }

    return callback(err, name);
}

FileInstrumenter.prototype._instrumentFile = function (inputFile, outputFile, name, preambleHeader, callback) {
    this.logger.debug("Instrumenting file '" + inputFile + "'.");
    var _this = this;
    fs.readFile(inputFile, 'utf8', function (err, fileContents) {
        if (err) {
            return _this._handleInstrumentationError("Failed reading file contents.", err, name, callback);
        }

        fileContents = _this._onBeforeInstrumentation(fileContents);

        _this.instrumenter.instrument(fileContents, inputFile, function (err, instrumentedContent){
            return _this.instrumentationCallback(err, instrumentedContent, preambleHeader, name, outputFile, callback);
        }, {
                filename: name,
                inputSourceMap: null
            });
    });
}



FileInstrumenter.prototype.instrumentationCallback = function (err, instrumentedContent, preambleHeader, name,
                                                               outputFile, callback) {
    var _this = this;
    if (err) {
        return _this._handleInstrumentationError("Failed during instrumentation.", err, name, callback);
    }
    var newContents = preambleHeader.concat([instrumentedContent]).join("\n");
    newContents = _this._onAfterInstrumentation(newContents)
    fs.writeFile(outputFile, newContents, 'utf8', function (err) {
        if (err) {
            return _this._handleInstrumentationError("Failed while writing instrumented file.", err, name,
                callback);
        }
        if (_this.opts.onFileInstrumented != null) {
            _this.opts.onFileInstrumented(name);
        }
        return callback(null, name);
    });
}


//**********************************************************/
// Bug Fix: When instrumenting a 'React' based page, page loading breaks due to a missing space after a 'return' statement.
//
// Instead of having " return</div>" which breaks the page, we change it to
// " return </div>"
//**********************************************************/
FileInstrumenter.prototype._fixMissingSpaceAfterReturnStatement = function (input) {
    return input.replace(/;return</g, ";return <");
}

//**********************************************************/
// Bug Fix: Webpack plugin breaks JavaScript code when require.ensure() is used (Duda Mobile)
// See https://sealights.atlassian.net/browse/SLDEV-2115
//
// Basically this is a workaround for:
// https://github.com/estools/escodegen/issues/336
//**********************************************************/
FileInstrumenter.prototype._removeWebpackComments = function (input) {
    //	This regex should capture block comment filled with stars, globally.
    //	Good:
    //	    /**/
    //	    /***/
    //	    /*****************/
    //	Bad:
    //	    /*/
    //      //
    //	    /***a*/
    //
    var regex = new RegExp("\/[\*]{2,}\/", "g");

    while (true) {
        //Execute the regex, each time on a different part of the input string.
        var currentMatch = regex.exec(input);
        if (!currentMatch)
            break;
        var matchIndex = currentMatch.index;
        var matchLength = currentMatch[0].length;
        var whiteSpace = this._createWhiteSpace(matchLength);

        //Replace the matching comment with whitespace.
        input = this._replaceAt(input, matchIndex, whiteSpace);
    }

    return input;
}

FileInstrumenter.prototype._replaceAt = function (string, index, replacement) {
    return string.substr(0, index) + replacement + string.substr(index + replacement.length);
}

FileInstrumenter.prototype._createWhiteSpace = function (length) {
    var arr = new Array(++length);
    return arr.join(" ")
}

FileInstrumenter.prototype._isFileAcceptedBySlIgnore = function () {
    if (this.IgnoredFilesHandler.denies(this.name)){
        this.logger.info("File '%s' ignored by .slignore, will be copied as is", this.name);
        return false;
    }
    return true;
}


FileInstrumenter.prototype._getInputFile = function() {
    var folder = this.opts.sourceRoot;
    return path.resolve(folder, this.name);
}

FileInstrumenter.prototype._getOutputFile = function() {
    var folder = this.opts.outputPath;
    return path.resolve(folder, this.name);
}


module.exports = FileInstrumenter;