uxp-linter-test-app/bin/utils.js

UXP LINTER is useful for linting your code with ESLint rules and guidelines.

"use strict";

require("v8-compile-cache");

//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------

const fs = require('fs'),
    ScriptData = require('./script-data');
let spawn = require('child_process').spawn,
    path = require('path'),
    constants = require('./constants');

let uxpLinterrcPath = path.join(__dirname, './../../../.uxplinterrc.json');

const { uxplinterrcInitialConfig, noPackageJson, defaultLinterPath, safeNodeVersionForPeerDeps } = constants

//------------------------------------------------------------------------------
// Exports
//------------------------------------------------------------------------------
exports.installPackages = function installPackages(packages = [], isDev) {
    return new Promise(async function (resolve, reject) {
        let packageNames = packages.reduce((original, newData) => original + ' ' + newData);
        let installPkgCmd = `npm install ${isDev ? '--save-dev' : ''} ${packageNames}`;
        await executeCommand(installPkgCmd, true);
        resolve(true);
    });
};

function executeCommand(fullCommand, isErrThrow) {
    return new Promise(function (resolve, reject) {
        let ls = spawn(fullCommand, [], { shell: true, stdio: "inherit" });
        ls.on('error', (err) => {
            console.error('Failed: ', err);
            if (isErrThrow) {
                throw err;
            } else {
                resolve(true);
            }
        });
        ls.on('exit', function () {
            resolve(true);
        });
    });
};

exports.uninstallPackages = function uninstallPackages(packages = []) {
    return new Promise(async function (resolve, reject) {
        let packageNames = packages.reduce((original, newData) => original + ' ' + newData);
        let uninstallPkgCmd = `npm uninstall ${packageNames}`;
        await executeCommand(uninstallPkgCmd, true);
        resolve(true);
    });
};


exports.addConfigFile = function addConfigFile(filePath, fileName, force = true) {
    return new Promise(function (resolve, reject) {
        let ifFileExist = fs.existsSync(fileName);
        if (force || !ifFileExist) {
            try {
                fs.copyFileSync(filePath, fileName, fs.constants.COPYFILE_FICLONE);
                resolve(true);
            } catch (error) {
                throw error;
            }
        }
        else {
            resolve(true);
        }
    });
};

exports.removeConfigFile = function removeConfigFile(fileName) {
    return new Promise(function (resolve, reject) {
        let fileExist1 = fs.existsSync(fileName);
        if (fileExist1) {
            fs.unlink(fileName, function (err) {
                if (err) {
                    throw err;
                } else {
                    resolve(true);
                }
            });
        } else {
            resolve(true);
        }
    });
};

exports.addScriptPackageJSON = function addScriptPackageJSON(scripts = [new ScriptData('', '')], pkgJsonPath = 'package.json') {
    return new Promise(function (resolve, reject) {
        let rawdata = fs.readFileSync(pkgJsonPath);
        let loadDependancy = JSON.parse(rawdata);
        if (!loadDependancy.hasOwnProperty('scripts')) {
            loadDependancy['scripts'] = {}
        }
        scripts.forEach((script) => {
            loadDependancy.scripts[script.name] = script.value;
        });

        let data = JSON.stringify(loadDependancy, null, 4);
        fs.writeFileSync(pkgJsonPath, data);
        resolve(true);
    });
};

exports.removeScriptPackageJSON = function removeScriptPackageJSON(scripts = []) {
    return new Promise(function (resolve, reject) {
        let rawdata = fs.readFileSync('package.json');
        var loadDependancy = JSON.parse(rawdata);
        if (loadDependancy.hasOwnProperty('scripts')) {
            scripts.forEach((script) => {
                delete loadDependancy.scripts[script];
            });
        }
        var loadData = JSON.stringify(loadDependancy, null, 4);
        fs.writeFileSync('package.json', loadData);
        resolve(true);
    });
};


exports.createFileBackup = function createFileBackup(fileNameArray = [], suffix = '_backup') {
    return new Promise(function (resolve, reject) {
        for (let key in fileNameArray) {
            if (fs.existsSync(fileNameArray[key])) {
                fs.renameSync(fileNameArray[key], `${fileNameArray[key]}${suffix}`, (err) => {
                    if (err) {
                        throw err;
                    }
                });
            }
        }
        resolve(true);
    });
};

exports.restoreBackupFile = function restoreBackupFile(fileNameArray = [], suffix = '_backup') {
    return new Promise(function (resolve, reject) {
        for (let key in fileNameArray) {
            let backupFileName = fileNameArray[key] + suffix;
            if (fs.existsSync(backupFileName)) {
                let newFileName = backupFileName.replace(suffix, "");;
                fs.renameSync(backupFileName, newFileName, (err) => {
                    if (err) {
                        throw err;
                    }
                });
            }
        }
        resolve(true);
    });
};

exports.createNewDirectory = function createNewDirectory(directoryPath) {
    return new Promise(function (resolve, reject) {
        if (!fs.existsSync(directoryPath)) {
            fs.mkdirSync(directoryPath);
        }
        resolve(true);
    });
};

exports.extendValueIneslint = function (parsedRowData, option, entry) {
    return new Promise(function (resolve, reject) {
        if (parsedRowData.hasOwnProperty('extends')) {
            if (option === 0) {
                parsedRowData.extends = [];
            }
            if (!parsedRowData.extends.includes(entry)) {
                parsedRowData.extends.push(entry);
            }
        }
        resolve(parsedRowData);
    });
}

exports.isPackageInstalled = function (packageName) {
    return new Promise(function (resolve, reject) {
        let rawdata = fs.readFileSync('package.json');
        var loadDependency = JSON.parse(rawdata);
        if (loadDependency.hasOwnProperty('dependencies')
            && loadDependency.dependencies.hasOwnProperty(packageName)) {
            resolve(true);
        } else if (loadDependency.hasOwnProperty('devDependencies')
            && loadDependency.devDependencies.hasOwnProperty(packageName)) {
            resolve(true);
        } else {
            resolve(false);
        }
    });
}

function getLinterPath() {
    return new Promise(async function (resolve, reject) {
        let config = readLinterConfig();
        resolve(config.path || '');
    });
}
exports.getLinterPath = getLinterPath;

exports.getProjectType = function getProjectType() {
    return new Promise(async function (resolve, reject) {
        let config = readLinterConfig();
        resolve(config.projectType || '');
    });
}

exports.languageType = function languageType() {
    return new Promise(async function (resolve, reject) {
        let config = readLinterConfig();
        resolve(config.languageType || '');
    });
}

/**
 * For fetching Linting command from linterrc file
 */
exports.getLintCommand = function getLintCommand(linterType, runType) {
    return new Promise(async function (resolve, reject) {
        let config = readLinterConfig();
        let commandType = `${linterType}${runType}Command`;
        let command = config[commandType];
        if (linterType === 'css') {
            if (config.path !== '' && config.path.slice(-1) !== '/') {
                config.path = `${config.path}/`;
            }
        }
        if (command.indexOf('$path') > -1) {
            command = command.replace('$path', config.path);
        }
        resolve(command);
     });
}

function isPathAlreadySet() {
    return new Promise(async function (resolve, reject) {
        const currentPath = await getLinterPath();
        resolve(currentPath.length !== 0);
    });
}

function askPathToLint(rl, currentPath = '') {
    return new Promise(function (resolve, reject) {
        rl.question(`\nPlease provide path to lint ( or Press Enter for current path: ${currentPath || defaultLinterPath} ) : `, async function (pathName) {
            if (pathName.length === 0) {
                updateLinterConfig({'path': (currentPath || defaultLinterPath)});
            }
            else {
                pathName = pathName.trim()
                updateLinterConfig({'path': pathName});
                if (currentPath.length !== 0)
                    console.log('\x1b[32m%s\x1b[0m', '\nPath updated successfully!');
            }

            resolve(true);
        })
    })
}

exports.askPathIfNotExist = async function (rl) {
    if (!await isPathAlreadySet())
        await askPathToLint(rl);
}

exports.askPathToLint = askPathToLint;
exports.executeCommand = executeCommand;

exports.initializeLinterConfig = async function () {
    let initialData = uxplinterrcInitialConfig;
    initialData = JSON.stringify(initialData, null, 4);
    writeLinterConfig(initialData);
}

function readLinterConfig(key) {
    let configData = fs.readFileSync(uxpLinterrcPath);
    configData = JSON.parse(configData)
    if (key)
        return configData[key];
    return configData;
}
exports.readLinterConfig = readLinterConfig;

function writeLinterConfig(data) {
    fs.writeFileSync(uxpLinterrcPath, data);
    return;
}

function updateLinterConfig(updateData) {
    return new Promise(function (resolve, reject) {

        let configData = readLinterConfig();
        for (let data in updateData) {
            configData[data] = updateData[data];
        }

        configData = JSON.stringify(configData, null, 4);
        writeLinterConfig(configData);
        resolve(true);
    });
}
exports.updateLinterConfig = updateLinterConfig;

/**
 * For deleting keys from uxplinterrc file
 */
function deleteLinterConfig(deleteData) {
    return new Promise(function (resolve, reject) {

        let configData = readLinterConfig();
        for (let data of deleteData) {
            delete configData[data];
        }

        configData = JSON.stringify(configData, null, 4);
        writeLinterConfig(configData);
        resolve(true);
    });
}
exports.deleteLinterConfig = deleteLinterConfig;


/**
 * For creating Package Json file
 */
exports.initializePackageJson = async function () {
    let initialData = noPackageJson;
    initialData = JSON.stringify(initialData, null, 4);
    fs.writeFileSync(path.join(__dirname, './../../../package.json'), initialData);
}

/**
 * For checking required package version of user's project
 * @param key - Dependency for checking the versiom
 */
exports.getPackageVersion = function (key) {
    return new Promise(function (resolve, reject) {
        let rawdata = fs.readFileSync('package.json');
        var loadDependency = JSON.parse(rawdata);
        var keyVal = loadDependency.dependencies[key];
        var reqVersion = '';
        if (keyVal) {
            reqVersion = parseInt(keyVal.substring(1, keyVal.indexOf(".")));
        }
        resolve(reqVersion);
    });
}

exports.getProjectName = function () {
    return new Promise(function (resolve, reject) {
        let rawdata = fs.readFileSync('package.json');
        var loadDependency = JSON.parse(rawdata);
        var projName = loadDependency.name;
        resolve(projName);
    });
}

exports.getPackagesList = function (dependencies) {
    let packagesArr = [];
    if(dependencies.length){
        dependencies.forEach(pkg => {
            let { packageName, version } = pkg;
            let dependencyName = packageName;
            if (version && version.trim().length > 0) {
                dependencyName = dependencyName + '@' + version;
            }
            packagesArr.push(dependencyName);
        })
    }
    return packagesArr;
}

exports.isPeerDepsInstallationReqd = function () {
    return process.version && process.version.split('.')[0].slice(1,) < safeNodeVersionForPeerDeps;
}