@zohodesk/codestandard-validator 0.0.0-exp-1

package/build/utils/EslintConfigFileUtils/getEslintExecutablePath.js

@@ -0,0 +1,24 @@
+"use strict";
+
+const path = require('path');
+const {
+  readdirSync
+} = require('fs');
+const {
+  getNodeModulesPath
+} = require('../General/getNodeModulesPath');
+const {
+  executeSynchronizedCommands
+} = require('../General/executeSyncCommands');
+const {
+  getLibraryInstalledLocation
+} = require('../General/getLibraryInstalledLocation');
+function getEslintExecutablePath() {
+  let eslintLibraryName = 'eslint';
+  let librariesInNodeModulesOfProject = executeSynchronizedCommands(readdirSync, [path.join(getNodeModulesPath(), 'node_modules')], '', 'Unable to get the plugins inside node_modules', true, false);
+  let isEslintInstalledinProject = librariesInNodeModulesOfProject.some(library => library === eslintLibraryName);
+  return isEslintInstalledinProject ? path.join(getNodeModulesPath(), 'node_modules', eslintLibraryName, 'bin', 'eslint.js') : path.join(getLibraryInstalledLocation(), 'node_modules', eslintLibraryName, 'bin', 'eslint.js');
+}
+module.exports = {
+  getEslintExecutablePath
+};

package/build/utils/EslintConfigFileUtils/getLintConfiguration.js

@@ -0,0 +1,52 @@
+"use strict";
+
+const path = require('path');
+const {
+  existsSync
+} = require('fs');
+const {
+  endPoint,
+  commonLinterRepoName
+} = require("../../../jsonUtils/commonLinterRepoDetails.js");
+const {
+  getRepoName
+} = require('../GitActions/gitActions');
+const {
+  getLibraryInstalledLocation
+} = require('../General/getLibraryInstalledLocation');
+const {
+  executeMethodsThatMayThrowException
+} = require("../General/wrapperFunctionToExecuteAFunction");
+
+/**
+ * @function getLintConfiguration - returns eslint configuration file from common linters repo
+ * @returns {object} - containing properties of the eslint configuration file
+ */
+function getServicePathElseCommon() {
+  const repoName = getRepoName();
+  const libraryInstalledLocation = getLibraryInstalledLocation();
+  let commonConfigPath = path.join(libraryInstalledLocation, commonLinterRepoName, 'common', 'index.js');
+  const _configurationPath = repoName && existsSync(path.join(libraryInstalledLocation, commonLinterRepoName, 'services', repoName, 'index.js')) ? path.join(libraryInstalledLocation, commonLinterRepoName, 'services', repoName, 'index.js') : commonConfigPath;
+  let _pathOfServiceSpecificEslintConfigFile = repoName && existsSync(path.join(libraryInstalledLocation, commonLinterRepoName, 'services', repoName, '.eslintrc.js')) ? path.join(libraryInstalledLocation, commonLinterRepoName, 'services', repoName, '.eslintrc.js') : path.join(libraryInstalledLocation, commonLinterRepoName, 'common', '.eslintrc.js');
+  let _pluginVersionPath = repoName && existsSync(path.join(libraryInstalledLocation, commonLinterRepoName, 'services', repoName, 'pluginVersion.js')) ? path.join(libraryInstalledLocation, commonLinterRepoName, 'services', repoName, 'pluginVersion.js') : undefined;
+  return {
+    configurationPath: _configurationPath,
+    pathOfServiceSpecificEslintConfigFile: _pathOfServiceSpecificEslintConfigFile,
+    pluginVersionPath: _pluginVersionPath
+  };
+}
+function getLintConfigurationUtil() {
+  const {
+    configurationPath
+  } = getServicePathElseCommon();
+  const exceptionHandleObject = {
+    rulesConfig: [{}, {}],
+    plugins: [],
+    extendPlugins: []
+  };
+  return executeMethodsThatMayThrowException(exceptionHandleObject, `Kindly Ensure that Configuration is setup in Configuration repo \n ${endPoint}`, require, configurationPath);
+}
+module.exports = {
+  getLintConfigurationUtil,
+  getServicePathElseCommon
+};

package/build/utils/ExtensionInstallation/installEslintExtension.js

@@ -0,0 +1,25 @@
+"use strict";
+
+const {
+  execSync
+} = require('child_process');
+const {
+  executeSynchronizedCommands
+} = require('../General/executeSyncCommands');
+const {
+  Logger
+} = require('../Logger/Logger');
+
+/**
+ * @function installEslintExtension - installs eslint extension for vscode
+ * @returns {boolean} - indicating the success or failure of installing eslint extension for vscode
+ */
+function installEslintExtension() {
+  let eslintExtensionCode = 'dbaeumer.vscode-eslint';
+  Logger.log(Logger.INFO_TYPE, 'Installing eslint extension for Vscode....');
+  let isEslintExtensionInstalledSuccessfully = executeSynchronizedCommands(execSync, [`code --install-extension ${eslintExtensionCode}`], 'Eslint extension for vscode installed successfully! If eslint errors not being reported in editor, kindly restart Vscode', 'Unable to install eslint extension for vscode', false, true);
+  return isEslintExtensionInstalledSuccessfully;
+}
+module.exports = {
+  installEslintExtension
+};

package/build/utils/FileAndFolderOperations/deleteFile.js

@@ -0,0 +1,28 @@
+"use strict";
+
+const {
+  existsSync,
+  unlinkSync
+} = require('fs');
+const {
+  Logger
+} = require('../Logger/Logger');
+
+/**
+ * @function deleteFile - deletes the provided file
+ * @param {string} filePath - path of file to be deleted
+ */
+function deleteFile(filePath) {
+  if (existsSync(filePath)) {
+    try {
+      unlinkSync(filePath);
+      Logger.log(Logger.SUCCESS_TYPE, `${filePath} deleted successfully`);
+    } catch (err) {
+      Logger.log(Logger.FAILURE_TYPE, err);
+      throw new Error(`Error while deleting the file: ${filePath}`);
+    }
+  }
+}
+module.exports = {
+  deleteFile
+};

package/build/utils/FileAndFolderOperations/filterFiles.js

@@ -0,0 +1,41 @@
+"use strict";
+
+const {
+  Logger
+} = require('../Logger/Logger');
+
+/**
+ * @function filterFiles - removes certain files from set of source files
+ * @param {Array} arrayOfFilesToBeFiltered - array of files which must be filtered 
+ * @param {Array} filesToBeRemoved - array of files that need to be removed
+ * @param {boolean} isConfigFileNeedToBeRemoved - indicating whether eslint config file should be removed or not
+ * @returns {Array} - containing the resultant set of files after filtering
+ */
+function filterFiles(arrayOfFilesToBeFiltered, filesToBeRemoved, isConfigFileNeedToBeRemoved = false) {
+  if (filesToBeRemoved.length !== 0) {
+    if (isConfigFileNeedToBeRemoved) {
+      arrayOfFilesToBeFiltered.filter(file => {
+        let isConfigFileModified = filesToBeRemoved.some(fileToBeRemoved => file.includes(fileToBeRemoved));
+        if (isConfigFileModified) {
+          Logger.log(Logger.INFO_TYPE, 'The eslint config file should not be modified locally. Update the file in the common repo for linters.');
+          Logger.log(Logger.FAILURE_TYPE, 'Kindly revert the changes in eslint config file and commit the rest.');
+          process.exit(1);
+        }
+      });
+    }
+    let filteredArrayofFilesWithoutConfigFile = arrayOfFilesToBeFiltered.filter(file => {
+      let isFileToBeRemovedPresent = filesToBeRemoved.some(fileToBeRemoved => file.includes(fileToBeRemoved));
+      if (!isFileToBeRemovedPresent) {
+        return true;
+      } else {
+        return false;
+      }
+    });
+    return filteredArrayofFilesWithoutConfigFile;
+  } else if (filesToBeRemoved.length === 0) {
+    return arrayOfFilesToBeFiltered;
+  }
+}
+module.exports = {
+  filterFiles
+};

package/build/utils/FileAndFolderOperations/getFileContent.js

@@ -0,0 +1,23 @@
+"use strict";
+
+const fs = require('fs');
+const {
+  Logger
+} = require('../Logger/Logger');
+
+/**
+ * @function getFileContent - retrieves the content of a file 
+ * @param {string} utilsPath - path of file whose content must be retrieved 
+ * @param {string} defaultPath - path to default file whose content must be retrieved if actula file not present
+ * @returns {string} - content of the file provided
+ */
+function getFileContent(utilsPath, defaultPath = undefined) {
+  try {
+    return require(fs.existsSync(utilsPath) ? utilsPath : defaultPath);
+  } catch (err) {
+    Logger.log(Logger.FAILURE_TYPE, `path is not valid ...`);
+  }
+}
+module.exports = {
+  getFileContent
+};

package/build/utils/FileAndFolderOperations/grantExecutionPermission.js

@@ -0,0 +1,35 @@
+"use strict";
+
+/* eslint-disable no-console */
+const os = require('os');
+const fs = require('fs');
+const {
+  Logger
+} = require('../Logger/Logger');
+
+/**
+ * @function grantExecutionPermission - grnats execution permission to set of files
+ * @param {Array} filesToWhichExecutionPermissionToBeGiven 
+ * @returns {boolean} - indicating whether execution permission given to all provided files
+ * @note - this method gives execution permission only if operating system is either Mac or Linux
+ */
+function grantExecutionPermission(filesToWhichExecutionPermissionToBeGiven) {
+  let ostype = os.type();
+  if (ostype === 'Darwin' || ostype === 'Linux') {
+    let filesThatWereGivenExecutionPermission = filesToWhichExecutionPermissionToBeGiven.filter(file => {
+      try {
+        fs.chmodSync(file, '755');
+        Logger.log(Logger.SUCCESS_TYPE, `execution permission given to ${file}`);
+        return true;
+      } catch (error) {
+        Logger.log(Logger.FAILURE_TYPE, error);
+        Logger.log(Logger.FAILURE_TYPE, `Unable to give execution permission to ${file}`);
+        return false;
+      }
+    });
+    return filesThatWereGivenExecutionPermission.length === filesToWhichExecutionPermissionToBeGiven.length ? true : false;
+  } else {
+    return true;
+  }
+}
+module.exports = grantExecutionPermission;

package/build/utils/FileAndFolderOperations/removeFolder.js

@@ -0,0 +1,37 @@
+"use strict";
+
+const {
+  existsSync,
+  rmSync
+} = require('fs');
+const {
+  Logger
+} = require('../Logger/Logger');
+const {
+  executeSynchronizedCommands
+} = require('../General/executeSyncCommands');
+
+/**
+ * @function removeFolder - removes the given folder if it exists
+ * @param {string} folderPath - path to folder that must be removed
+ * @returns {void}
+ */
+function removeFolder(folderPath) {
+  try {
+    let isCommonConfigFolderPresent = existsSync(folderPath);
+    if (isCommonConfigFolderPresent) {
+      executeSynchronizedCommands(rmSync, [folderPath, {
+        recursive: true,
+        force: true
+      }], 'common linter configuration folder removed successfully', 'Unable to remove the common linter configuration folder', false, false);
+    } else {
+      Logger.log(Logger.SUCCESS_TYPE, 'Configuration folder not present');
+    }
+  } catch (error) {
+    Logger.log(Logger.FAILURE_TYPE, error);
+    Logger.log(Logger.FAILURE_TYPE, 'Unable to check if common linter configuration folder is present');
+  }
+}
+module.exports = {
+  removeFolder
+};

package/build/utils/General/RootDirectoryUtils/getRootDirectory.js

@@ -0,0 +1,23 @@
+"use strict";
+
+const {
+  spawnSync
+} = require('child_process');
+
+/**
+ * @function getRootDirectory - returns the root directory of the project
+ * @returns {string} - indicating the root diretory of the project
+ */
+function getRootDirectory() {
+  let rootDir = spawnSync('git', ["rev-parse", "--show-toplevel"], {
+    shell: true,
+    encoding: 'utf-8'
+  });
+  if (!(rootDir.status == 0)) {
+    return process.cwd();
+  }
+  return rootDir.stdout.toString().trim();
+}
+module.exports = {
+  getRootDirectory
+};

package/build/utils/General/RootDirectoryUtils/navigateToRootDirectory.js

@@ -0,0 +1,25 @@
+"use strict";
+
+const {
+  Logger
+} = require("../../Logger/Logger");
+
+/**
+ * @function navigateToRootDirectory - navigates to root directory of the project
+ * @param {string} rootDir - root directory of the project
+ * @returns {boolean} - indicating the success or failure of navigation to root directory of the project
+ */
+function navigateToRootDirectory(rootDir) {
+  Logger.log(Logger.INFO_TYPE, `rootDir:${rootDir}`);
+  try {
+    process.chdir(rootDir);
+    Logger.log(Logger.SUCCESS_TYPE, "Successfully navigated to root directory");
+    return true;
+  } catch (error) {
+    Logger.log(Logger.FAILURE_TYPE, "Couldn't navigate to root directory", error);
+    return false;
+  }
+}
+module.exports = {
+  navigateToRootDirectory
+};

package/build/utils/General/executeSyncCommands.js

@@ -0,0 +1,40 @@
+"use strict";
+
+const {
+  Logger
+} = require('../Logger/Logger');
+
+/**
+ * @function executeSynchronizedCommands - a wrapper function to execute synchronized command within try catch and return either the result of command or boolean value indicating the success or failure of command execution
+ * @param {Function} command - function to be executed
+ * @param {Array} commandArgs - arguments to be passed to the function to be executed
+ * @param {string} successMessage - success message to should be logged on successful execution of the provided function
+ * @param {string} errorMessage - failure message to be logged when the given function execution fails
+ * @param {boolean} shouldCommandResultBeReturned - indicates if output of command to be returned
+ * @param {boolean} shouldReturnBooleanValue - indicates if boolean value corresponding to command execution output be returned
+ * @returns {boolean | string} - returns either a boolean indicating the success or failure of the command executed or the result returned by the executed command 
+ */
+function executeSynchronizedCommands(command, commandArgs, successMessage = '', errorMessage = '', shouldCommandResultBeReturned = false, shouldReturnBooleanValue = false) {
+  try {
+    if (shouldCommandResultBeReturned) {
+      return command(...commandArgs);
+    } else if (!shouldCommandResultBeReturned) {
+      command(...commandArgs);
+    }
+    if (successMessage.trim() !== '') {
+      Logger.log(Logger.SUCCESS_TYPE, successMessage);
+    }
+    if (shouldReturnBooleanValue) {
+      return true;
+    }
+  } catch (error) {
+    Logger.log(Logger.FAILURE_TYPE, error);
+    Logger.log(Logger.FAILURE_TYPE, errorMessage);
+    if (shouldReturnBooleanValue) {
+      return false;
+    }
+  }
+}
+module.exports = {
+  executeSynchronizedCommands
+};

package/build/utils/General/getGeneralInfo.js

@@ -0,0 +1,31 @@
+"use strict";
+
+const os = require('os');
+
+/**
+ * @function getTimeStampInfo - to fetch various timestamp details
+ * @returns {object} - each property of the object denotes various timestamp details
+ */
+function getTimeStampInfo() {
+  const date = new Date();
+  return {
+    date: date.getDate(),
+    hours: date.getHours(),
+    minute: date.getMinutes(),
+    second: date.getSeconds(),
+    month: date.getMonth() + 1,
+    year: date.getFullYear()
+  };
+}
+
+/**
+ * @function getEnv - to fetch the os type
+ * @returns {string} - indicates the os
+ */
+function getEnv() {
+  return os.type();
+}
+module.exports = {
+  getTimeStampInfo,
+  getEnv
+};

package/build/utils/General/getLibraryInstalledLocation.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const path = require('path');
+const {
+  getNodeModulesPath
+} = require('./getNodeModulesPath');
+
+/**
+ * @function getLibraryInstalledLocation - fetches the absolute path where library is installed
+ * @returns {string} - path where library is installed
+ */
+function getLibraryInstalledLocation() {
+  const libraryInstalledLocation = path.join(getNodeModulesPath(), 'node_modules', '@zohodesk', 'codestandard-validator');
+  return libraryInstalledLocation;
+}
+module.exports = {
+  getLibraryInstalledLocation
+};

package/build/utils/General/getNodeModulesPath.js

@@ -0,0 +1,14 @@
+"use strict";
+
+const path = require('path');
+
+/**
+ * @function getNodeModulesPath - fetches the absolute path where node_modules of project is present
+ * @returns {string} - path where node_modules of the project is present
+ */
+function getNodeModulesPath() {
+  return require(path.join(__dirname, '..', '..', '..', 'jsonUtils', 'fsUtils.json')).nodeModulesPath;
+}
+module.exports = {
+  getNodeModulesPath
+};

package/build/utils/General/wrapperFunctionToExecuteAFunction.js

@@ -0,0 +1,39 @@
+"use strict";
+
+const {
+  Logger
+} = require('../Logger/Logger');
+
+/**
+ * @function executeMethodsThatReturnBooleanValue - wrapper method to execute certain commands/methods that return a boolean value
+ * @param {string} consoleMessage - message that must be printed on failure of the method to be executed
+ * @param {Function} _callback - the function to be executed
+ * @param  {...any} params - arguments to be passed to the method to be executed
+ */
+async function executeMethodsThatReturnBooleanValue(consoleMessage, _callback, ...params) {
+  if (!(await _callback(...params))) {
+    throw new Error(consoleMessage);
+  }
+}
+
+/**
+ * 
+ * @param {any} handleObject - default value to be retunred if the function to be executed encounters an exception
+ * @param {string} consoleMessage - message to be logged if the function to be executed fails
+ * @param {Function} _callback - method/command to be executed
+ * @param  {...any} params - arguments to be passed to the method/command to be executed
+ * @returns {any} - the result returned by the executed method/command or the default return value provided in argument
+ */
+function executeMethodsThatMayThrowException(handleObject, consoleMessage, _callback, ...params) {
+  try {
+    return _callback(...params);
+  } catch (err) {
+    Logger.log(Logger.FAILURE_TYPE, err);
+    Logger.log(Logger.FAILURE_TYPE, consoleMessage);
+    return handleObject;
+  }
+}
+module.exports = {
+  executeMethodsThatReturnBooleanValue,
+  executeMethodsThatMayThrowException
+};

package/build/utils/General/writeProjectDetailsToJson.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const path = require('path');
+const {
+  writeFileSync
+} = require('fs');
+const {
+  executeSynchronizedCommands
+} = require('./executeSyncCommands');
+function writeFsPaths() {
+  var fileContent = {
+    nodeModulesPath: path.resolve(process.cwd(), '..', '..', '..')
+  };
+  return executeSynchronizedCommands(writeFileSync, [path.join(process.cwd(), 'jsonUtils', 'fsUtils.json'), JSON.stringify(fileContent), 'utf-8'], 'node_modules path updated in json file', 'Unable to write node_modules path to json file', false, true);
+}
+module.exports = {
+  writeFsPaths
+};

package/build/utils/GitActions/gitActions.js

@@ -0,0 +1,88 @@
+"use strict";
+
+const {
+  spawnSync,
+  execSync
+} = require("child_process");
+const {
+  executeMethodsThatMayThrowException
+} = require("../General/wrapperFunctionToExecuteAFunction");
+const {
+  executeSynchronizedCommands
+} = require("../General/executeSyncCommands");
+
+/**
+ * @function getGitUserName - to get the git username
+ * @returns {string | null} - returns the username or null if command execution encounters an exception
+ */
+function getGitUserName() {
+  const userHandler = () => {
+    const userName = exeSpawnSync("git", ["config", "user.email"]);
+    if (userName == null) {
+      return null;
+    }
+    return userName.pop().split("@")[0];
+  };
+  return executeMethodsThatMayThrowException(null, 'kindly initialize git properly', userHandler, null);
+}
+
+/**
+ * @function getRepoName - to get the git repository name
+ * @returns {string | null} - returns the git reponame or null if command execution encounters an exception
+ */
+function getRepoName() {
+  const repoHandler = () => {
+    const repoName = exeSpawnSync("git", ["remote", "get-url", "origin"]);
+    if (repoName == null) {
+      return null;
+    }
+    return repoName.pop().split("/").pop().split(".")[0];
+  };
+  return executeMethodsThatMayThrowException(null, 'kindly initialize git properly', repoHandler, null);
+}
+
+/**
+ * @function getBranchName - to get the current branch name
+ * @returns {string | null} - returns the git reponame or null if command execution encounters an exception
+ */
+function getBranchName() {
+  const branchHandler = () => {
+    var branchName = exeSpawnSync("git", ["rev-parse", "--abbrev-ref", "HEAD"]); // to get current branch
+    if (branchName == null) {
+      return null;
+    }
+    return branchName.shift().trim();
+  };
+  return executeMethodsThatMayThrowException(null, 'kindly initialize git properly', branchHandler, null);
+}
+
+/**
+ * 
+ * @param {Function} command - comamnd/function to be executed
+ * @param {*} params - parameters to be passed to the command/function to be executed
+ * @returns {null | any}
+ */
+function exeSpawnSync(command, params = []) {
+  const demon_process = spawnSync(command, params, {
+    shell: true
+  });
+  if (!(demon_process.status == 0)) {
+    return null;
+  }
+  return demon_process.stdout.toString().split("\n").filter(Boolean);
+}
+
+/**
+ * @function isGitInitialized - to check if git is initialized
+ * @returns {boolean} - inidcating whether the repo is git initialized or not
+ */
+function isGitInitialized() {
+  const isGit = executeSynchronizedCommands(execSync, ['git status'], '', "Kindly initialize git using \"git init\" ", false, true);
+  return isGit;
+}
+module.exports = {
+  getBranchName,
+  getGitUserName,
+  getRepoName,
+  isGitInitialized
+};

package/build/utils/HuskySetup/configurePrecommitHook.js

@@ -0,0 +1,39 @@
+"use strict";
+
+const {
+  writeFileSync
+} = require("fs");
+const path = require("path");
+const grantExecutionPermission = require("../FileAndFolderOperations/grantExecutionPermission");
+const {
+  getRootDirectory
+} = require("../General/RootDirectoryUtils/getRootDirectory");
+const {
+  getLibraryInstalledLocation
+} = require("../General/getLibraryInstalledLocation");
+const {
+  executeSynchronizedCommands
+} = require("../General/executeSyncCommands");
+
+/**
+ * @function configurePrecommitHook - creates the link to custom pre commit hook file and husky precommit file 
+ * @returns {boolean} - indicates if custom precommit hook created successfully or not
+ */
+function configurePrecommitHook() {
+  let rootDirectory = getRootDirectory();
+  let customPrecomitHookPath = path.join(getLibraryInstalledLocation(), "bin", "execute.js");
+  let huskyPrecommitPath = path.join(rootDirectory, ".husky", "pre-commit");
+  let huskyPrecommitHookContent = `#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+"${customPrecomitHookPath}"
+`;
+  let isCustomPrecommitConfigurationSuccessful = executeSynchronizedCommands(writeFileSync, [huskyPrecommitPath, huskyPrecommitHookContent, 'utf-8'], '', 'Could not create and write pre-commit.sh inisde husky directory', false, true);
+  if (isCustomPrecommitConfigurationSuccessful) {
+    let isExecutionPermissionGivenSuccessfully = grantExecutionPermission([huskyPrecommitPath, customPrecomitHookPath]);
+    return isExecutionPermissionGivenSuccessfully;
+  } else {
+    return false;
+  }
+}
+module.exports = configurePrecommitHook;

package/build/utils/HuskySetup/initializeHusky.js

@@ -0,0 +1,35 @@
+"use strict";
+
+/* eslint-disable no-console */
+
+const {
+  execSync
+} = require('child_process');
+const {
+  navigateToRootDirectory
+} = require('../General/RootDirectoryUtils/navigateToRootDirectory');
+const {
+  getRootDirectory
+} = require('../General/RootDirectoryUtils/getRootDirectory');
+const {
+  Logger
+} = require('../Logger/Logger');
+
+/**
+ * @function initializeHusky - creates a .husky folder at the root of the project with the husky execution script file
+ * @returns {boolean} - indicating the success or failure of initializing husky process
+ */
+function initializeHusky() {
+  let isNavigationToRootDirectorySuccessful = navigateToRootDirectory(getRootDirectory());
+  if (isNavigationToRootDirectorySuccessful) {
+    try {
+      execSync('npx husky install');
+      return true;
+    } catch (error) {
+      Logger.log(Logger.FAILURE_TYPE, error.toString());
+      Logger.log(Logger.FAILURE_TYPE, 'Couldn\'t initialize husky');
+      return false;
+    }
+  }
+}
+module.exports = initializeHusky;