@zohodesk/codestandard-validator 0.0.6-exp-7 → 0.0.6-exp-9

package/build/hooks/Precommit/lint.js

@@ -1,9 +1,5 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
 const {
   exec
 } = require('child_process');
@@ -40,208 +36,274 @@ const {
 } = getConfigurationPrecommit();
 
 /**
- * Checks if the current commit is a merge commit
- * @returns {Promise<boolean>} True if it's a merge commit
+ * @function isMergeCommit - This method check whether it is merge or not
+ * @returns {Boolean} -  return boolean based on latest merge changes
  */
 async function isMergeCommit() {
-  return new Promise(resolve => {
-    exec('git rev-parse -q --verify MERGE_HEAD', error => {
-      resolve(!error);
+  return new Promise((resolve, reject) => {
+    exec('git rev-parse -q --verify MERGE_HEAD', (error, stderr, stdout) => {
+      if (error) {
+        reject(error.toString().trim());
+      } else if (stderr) {
+        resolve(stderr.trim());
+      } else if (stdout) {
+        resolve(stdout.trim());
+      }
     });
   });
 }
 
 /**
- * Gets staged files while filtering out deleted files
- * @returns {Promise<string[]>} Array of staged file paths
+ * @function {getStagedFiles} - methods return staged files
+ * @returns {Array<string>} -  array of  files
  */
+
 async function getStagedFiles() {
   return new Promise((resolve, reject) => {
-    exec('git diff --staged --name-only', (error, stdout) => {
+    exec("git diff --staged --name-only", (error, stderr, stdout) => {
       if (error) {
-        return reject("Couldn't fetch staged files");
+        if (error != null) reject("Couldn't fetch staged files");
+      } else if (stderr) {
+        resolve(filterDeltedFileFromStagedFiles(stderr.trim().split('\n')));
+      } else if (stdout.trim() === '') {
+        resolve(stdout.trim());
       }
-      const files = stdout.trim().split('\n').filter(Boolean);
-      resolve(filterDeletedFiles(files));
     });
   });
 }
 
 /**
- * Filters out deleted files from the staged files list
- * @param {string[]} files - Array of file paths
- * @returns {string[]} Filtered array of existing files
+ * @function {filterDeltedFileFromStagedFiles} - filter deleted staged files
+ * @param {Array<string>} files - staged files
+ * @returns 
  */
-function filterDeletedFiles(files) {
+function filterDeltedFileFromStagedFiles(files) {
   return files.filter(file => {
     const absolutePath = path.resolve(getRootDirectory(), file);
-    return fs.existsSync(absolutePath);
+    if (fs.existsSync(absolutePath)) {
+      return true;
+    }
+    return false;
   });
 }
 
 /**
- * Runs ESLint on a specific file
- * @param {string} file - File path to lint
- * @returns {Promise<string[]>} ESLint output lines
+ * @function findEslintErrors - method  Lint given file based on given configuration
+ * @param {*} file - path of file to lint
+ * @returns {Array<string>} -  array of command line report as a string 
  */
-async function runEslintOnFile(file) {
-  const nodeModulesPath = getNodeModulesPath();
-  const eslintPath = getEslintExecutablePath();
-  const configPath = `${nodeModulesPath}/.eslintrc.js`;
-  if (!fs.existsSync(nodeModulesPath)) {
+
+async function findEslintErrors(file) {
+  let nodeModulesPathOfProject = `${getNodeModulesPath()}`;
+  let eslintExecutablePath = getEslintExecutablePath();
+  let eslintConfigurationFilePath = `${nodeModulesPathOfProject}/.eslintrc.js`;
+  let isEslintExecutablePresent = fs.existsSync(eslintExecutablePath) ? true : false;
+  let isNodeModulesPresent = fs.existsSync(nodeModulesPathOfProject);
+  if (isNodeModulesPresent) {
+    if (isEslintExecutablePresent) {
+      return new Promise((resolve, reject) => {
+        exec(`npx --ignore-existing "${eslintExecutablePath}" --config "${eslintConfigurationFilePath}" --no-inline-config --resolve-plugins-relative-to="${nodeModulesPathOfProject}/node_modules" ${file}`, (error, stderr, stdout) => {
+          if (stderr) {
+            resolve(stderr.trim().split('\n'));
+          } else if (error) {
+            Logger.log(Logger.FAILURE_TYPE, error);
+            reject("Error executing eslint command");
+          } else {
+            resolve([]);
+          }
+        });
+      });
+    } else {
+      Logger.log(Logger.INFO_TYPE, 'Eslint executable not found. make sure eslint plugin is installed');
+    }
+  } else {
     Logger.log(Logger.INFO_TYPE, 'node_modules not found');
-    return [];
-  }
-  if (!fs.existsSync(eslintPath)) {
-    Logger.log(Logger.INFO_TYPE, 'Eslint executable not found');
-    return [];
   }
-  return new Promise(resolve => {
-    const command = `npx --ignore-existing "${eslintPath}" --config "${configPath}" --no-inline-config --resolve-plugins-relative-to="${nodeModulesPath}/node_modules" ${file}`;
-    exec(command, (error, stderr) => {
-      if (stderr) {
-        resolve(stderr.trim().split('\n'));
-      } else {
-        resolve([]);
-      }
-    });
-  });
 }
-
 /**
- * Computes git diff for a file against current branch
- * @param {string} branch - Current branch name
- * @param {string} file - File path
- * @returns {Promise<string[]>} Git diff output lines
+ * @function {calculateGitDiffForFile} -  method calculate diff of file
+ * @param {*} branch_name - branch name
+ * @param {*} file - path of file
+ * @returns {Promise<Array<string>>} - array of command line report as a string 
  */
-async function getGitDiff(branch, file) {
+async function calculateGitDiffForFile(branch_name, file) {
+  let gitDiffCommand = `git diff -U0 ${branch_name.trim()} ${file}`;
   return new Promise((resolve, reject) => {
-    exec(`git diff -U0 ${branch.trim()} ${file}`, (error, stderr) => {
-      if (error) return reject(error);
-      resolve(stderr ? stderr.trim().split('\n') : []);
+    exec(gitDiffCommand, (error, stderr) => {
+      if (stderr) {
+        resolve(stderr.trim().split('\n'));
+      } else if (error) {
+        reject(error);
+      }
     });
   });
 }
-
 /**
- * Extracts changed line ranges from git diff output
- * @param {string[]} diffLines - Git diff output
- * @returns {Array<{start: number, end: number}>} Array of changed line ranges
+ * @function {areAllPluginsInstalled} -  method whether plugin is installed or not
+ * @returns {Boolean} - return boolean based on plugin installed or not
  */
-function parseChangedLines(diffLines) {
-  return diffLines.filter(line => line.startsWith('@@')).map(line => {
-    const parts = line.split(' ')[2].split(',');
-    const start = parseInt(parts[0]);
-    const end = parts[1] ? start + parseInt(parts[1]) - 1 : start;
-    return {
-      start,
-      end
-    };
-  });
+
+function areAllPluginsInstalled() {
+  let unInstalledPlugins = checkIfPluginsAreInstalled().uninstalledPlugins;
+  return unInstalledPlugins.length === 0 ? true : false;
 }
 
 /**
- * Filters ESLint errors to only include those in changed lines
- * @param {string[]} eslintErrors - ESLint output lines
- * @param {Array<{start: number, end: number}>} changedRanges - Changed line ranges
- * @returns {string[]} Filtered ESLint errors
+ * @function {isOnlyWarningsPresentInFile} - method that checks if only eslint warnings are present in a file
+ * @returns {Boolean} - returns boolean based on only warnings present or not in file
  */
-function filterErrorsToChangedLines(eslintErrors, changedRanges) {
-  return eslintErrors.filter(error => {
-    const match = error.match(/^(\d+):/);
-    if (!match) return false;
-    const line = parseInt(match[1]);
-    return changedRanges.some(({
-      start,
-      end
-    }) => line >= start && line <= end);
+function isOnlyWarningsPresentInFile(eslintErrorsPresent) {
+  let severityOfEachErrorInFile = [];
+  eslintErrorsPresent.map(error => {
+    let partsInString = error.split(" ");
+    let severityOfError = partsInString.find(word => word === 'error' || word === 'warning');
+    severityOfEachErrorInFile.push(severityOfError);
   });
+  return !severityOfEachErrorInFile.includes('error');
 }
 
 /**
- * Checks if ESLint output contains only warnings
- * @param {string[]} eslintErrors - ESLint output lines
- * @returns {boolean} True if only warnings are present
+ * @function {preCommitHook} - method execute pre commit hook
+ * @returns {void}
  */
-function hasOnlyWarnings(eslintErrors) {
-  return eslintErrors.every(error => error.includes('warning'));
-}
 
-/**
- * Processes a file based on impact-based precommit configuration
- * @param {string} file - File path to process
- * @param {string} branch - Current branch name
- * @returns {Promise<boolean>} True if errors should abort commit
- */
-async function processFile(file, branch) {
-  if (!getSupportedLanguage().includes(path.extname(file))) return false;
+async function preCommitHook() {
+  Logger.log(Logger.INFO_TYPE, 'Executing pre commit hook...');
+  Logger.log(Logger.INFO_TYPE, `working dir  : ${process.cwd()}`);
   try {
-    const eslintOutput = await runEslintOnFile(file);
-    if (eslintOutput.length < 3) return false; // No meaningful errors
+    let isMerge = await isMergeCommit();
+    Logger.log(Logger.INFO_TYPE, 'Looks like you have merged. So skipping pre commit check');
+    process.exit(0);
+  } catch (error) {
+    if (areAllPluginsInstalled()) {
+      let staged_files = [];
+      let eslintConfigFiles = ['.eslintrc.js'];
+      let exemptionFiles = [];
+      let current_branch = '';
+      let hasEslintErrorsInChangedLines = false;
+      let hasEslintErrorsInFiles = false;
+      let areFilesStaged = false;
+      let shouldAbortCommit = false;
+      try {
+        current_branch = await getBranchName();
+      } catch {
+        Logger.log(Logger.INFO_TYPE, "Error fetching current branch");
+      }
+      try {
+        staged_files = await getStagedFiles();
+        if (!staged_files.length == 0) {
+          staged_files = filterFiles(staged_files, eslintConfigFiles, true);
+
+          // staged_files = filterFiles(staged_files,exemptionFiles) //this is the code for giving exemption to a file during pre commit
+          // if(staged_files.length === 0){
+          //     Logger.log(Logger.SUCCESS_TYPE,`Commit Successful`)
+          //     process.exit(0)
+          // }
+          areFilesStaged = true;
+          for (let file in staged_files) {
+            let currentFileName = staged_files[file];
+            let changedLinesArray = [];
+            let eslintErrorsInChangedLines = [];
+            let isOnlyEslintWarningsPresentInFile = false;
+            if (getSupportedLanguage().includes(path.extname(staged_files[file]))) {
+              try {
+                var eslintErrorsInFile = await findEslintErrors(staged_files[file]);
+                // eslintErrorsInFile = impactBasedPrecommit == false ? filterWarningInFile(eslintErrorsInFile) : eslintErrorsInFile
+                if (staged_files[file] && typeof staged_files[file] == 'string') {
+                  if (!eslintErrorsInFile.length == 0) {
+                    //Calculating changed lines in a file and storing them in respective arrays
+                    if (impactBasedPrecommit) {
+                      //git diff is computed and stored in an array
+                      let git_diff = await calculateGitDiffForFile(current_branch, staged_files[file]);
+                      changedLinesArray = git_diff.filter(line => line.startsWith('@@'));
+                      let changedLinesStartArray = [];
+                      let changedLinesEndArray = [];
+                      for (let number of changedLinesArray) {
+                        let changesStartLine = parseInt(number.split(' ')[2].split(',')[0]);
+                        changedLinesStartArray.push(changesStartLine);
+                        let changesEndLine = number.split(' ')[2].split(',')[1];
+                        if (changesEndLine === undefined) {
+                          changedLinesEndArray.push(changesStartLine);
+                        } else {
+                          changedLinesEndArray.push(changesStartLine + parseInt(changesEndLine) - 1);
+                        }
+                      }
+                      for (let error = 1; error < eslintErrorsInFile.length - 2; error++) {
+                        //eslintErrorsInFile[error].trim() - 69:26  error => Do not hardcode content. Use I18N key instead  no-hardcoding/no-hardcoding, 
+                        //eslintErrorsInFile[error].trim().split(' ')[0] => 69:26
+                        //eslintErrorsInFile[error].trim().split(' ')[0].split(':')[0] => 69
 
-    const errors = eslintOutput.slice(1, -2);
-    if (!impactBasedPrecommit) {
-      Logger.log(Logger.FAILURE_TYPE, `\x1b[1m${file}\x1b[0m`);
-      errors.forEach(err => Logger.log(Logger.FAILURE_TYPE, `\x1b[37m${err.trimEnd()}\x1b[0m`));
-      if (!shouldWarningsAbortCommit && hasOnlyWarnings(errors)) {
-        return false;
+                        let eslintErrorLineNumber = eslintErrorsInFile[error].trim().split(' ')[0].split(':')[0];
+                        for (let lineNumber in changedLinesStartArray) {
+                          if (eslintErrorLineNumber >= changedLinesStartArray[lineNumber] && eslintErrorLineNumber <= changedLinesEndArray[lineNumber]) {
+                            eslintErrorsInChangedLines.push(eslintErrorsInFile[error]);
+                          }
+                        }
+                      }
+                      if (eslintErrorsInChangedLines.length > 0) {
+                        isOnlyEslintWarningsPresentInFile = isOnlyWarningsPresentInFile(eslintErrorsInChangedLines);
+                        Logger.log(Logger.FAILURE_TYPE, `\x1b[1m${currentFileName}\x1b[0m`);
+                        for (let eslintError of eslintErrorsInChangedLines) {
+                          Logger.log(Logger.FAILURE_TYPE, `\x1b[37m${eslintError.trimEnd()}\x1b[0m`);
+                        }
+                        if (shouldWarningsAbortCommit) {
+                          hasEslintErrorsInChangedLines = true;
+                          shouldAbortCommit = true;
+                        } else if (!shouldWarningsAbortCommit && isOnlyEslintWarningsPresentInFile) {
+                          hasEslintErrorsInChangedLines = false;
+                        } else if (!shouldWarningsAbortCommit && !isOnlyEslintWarningsPresentInFile) {
+                          hasEslintErrorsInChangedLines = true;
+                          shouldAbortCommit = true;
+                        }
+                      }
+                    } else {
+                      if (eslintErrorsInFile.length > 0) {
+                        let startIndex = 1;
+                        let endIndex = eslintErrorsInFile.length - 2;
+                        let listOsEslintErrors = eslintErrorsInFile.slice(startIndex, endIndex);
+                        isOnlyEslintWarningsPresentInFile = isOnlyWarningsPresentInFile(listOsEslintErrors);
+                        Logger.log(Logger.FAILURE_TYPE, `\x1b[1m${currentFileName}\x1b[0m`);
+                        for (let eslintError of listOsEslintErrors) {
+                          Logger.log(Logger.FAILURE_TYPE, `\x1b[37m${eslintError.trimEnd()}\x1b[0m`);
+                        }
+                        if (shouldWarningsAbortCommit) {
+                          hasEslintErrorsInFiles = true;
+                          shouldAbortCommit = true;
+                        } else if (!shouldWarningsAbortCommit && isOnlyEslintWarningsPresentInFile) {
+                          hasEslintErrorsInFiles = false;
+                        } else if (!shouldWarningsAbortCommit && !isOnlyEslintWarningsPresentInFile) {
+                          hasEslintErrorsInFiles = true;
+                          shouldAbortCommit = true;
+                        }
+                      }
+                    }
+                  }
+                }
+              } catch (err) {
+                Logger.log(Logger.FAILURE_TYPE, err);
+                Logger.log(Logger.FAILURE_TYPE, "Error in executing eslint command");
+              }
+            }
+          }
+        } else if (staged_files.length === 0) {
+          Logger.log(Logger.INFO_TYPE, 'No files have been staged. Stage your files before committing');
+        }
+      } catch {
+        Logger.log(Logger.INFO_TYPE, 'Error executing pre commit hook');
       }
-      return true;
-    }
-    const diffOutput = await getGitDiff(branch, file);
-    const changedRanges = parseChangedLines(diffOutput);
-    const changedLineErrors = filterErrorsToChangedLines(errors, changedRanges);
-    if (changedLineErrors.length > 0) {
-      Logger.log(Logger.FAILURE_TYPE, `\x1b[1m${file}\x1b[0m`);
-      changedLineErrors.forEach(err => Logger.log(Logger.FAILURE_TYPE, `\x1b[37m${err.trimEnd()}\x1b[0m`));
-      if (!shouldWarningsAbortCommit && hasOnlyWarnings(changedLineErrors)) {
-        return false;
+      if (shouldAbortCommit) {
+        Logger.log(Logger.FAILURE_TYPE, `There are eslint errors/warnings present. So commit is aborted.`);
+        process.exit(1);
+      } else if (shouldAbortCommit === false && staged_files.length !== 0) {
+        Logger.log(Logger.SUCCESS_TYPE, `Commit Successful`);
+        process.exit(0);
       }
-      return true;
-    }
-  } catch (error) {
-    Logger.log(Logger.FAILURE_TYPE, `Error processing ${file}: ${error}`);
-  }
-  return false;
-}
-
-/**
- * Main pre-push hook execution logic
- */
-async function preCommitCheck() {
-  Logger.log(Logger.INFO_TYPE, 'Executing pre commit hook...');
-  if (await isMergeCommit()) {
-    Logger.log(Logger.INFO_TYPE, 'Merge commit detected. Skipping checks.');
-    process.exit(0);
-  }
-  const pluginsStatus = checkIfPluginsAreInstalled();
-  if (pluginsStatus.uninstalledPlugins.length > 0) {
-    Logger.log(Logger.FAILURE_TYPE, 'Commit failed: Required plugins missing');
-    Logger.log(Logger.INFO_TYPE, 'Run: npx ZDPrecommit setupPlugins');
-    process.exit(1);
-  }
-  try {
-    const stagedFiles = await getStagedFiles();
-    if (stagedFiles.length === 0) {
-      Logger.log(Logger.INFO_TYPE, 'No staged files found');
-      process.exit(0);
-    }
-    const filteredFiles = filterFiles(stagedFiles, ['.eslintrc.js'], true);
-    const currentBranch = await getBranchName();
-    let shouldAbort = false;
-    for (const file of filteredFiles) {
-      const fileShouldAbort = await processFile(file, currentBranch);
-      if (fileShouldAbort) shouldAbort = true;
-    }
-    if (shouldAbort) {
-      Logger.log(Logger.FAILURE_TYPE, 'Commit aborted due to ESLint issues');
+    } else {
+      Logger.log(Logger.FAILURE_TYPE, 'Commit failed since some eslint plugins are not installed');
+      Logger.log(Logger.INFO_TYPE, `Kindly execute the command \x1b[37mnpx ZDPrecommit setupPlugins \x1b[33mfrom the location where package.json is present to install the plugins`);
+      Logger.log(Logger.INFO_TYPE, 'Execute the command and kindly try committing again.');
       process.exit(1);
     }
-    Logger.log(Logger.SUCCESS_TYPE, 'Commit successful');
-    process.exit(0);
-  } catch (error) {
-    Logger.log(Logger.FAILURE_TYPE, `Pre-commit hook failed: ${error}`);
-    process.exit(1);
   }
 }
-var _default = exports.default = preCommitCheck;
+preCommitHook();

package/build/hooks/Precommit/pre-commit.js

@@ -19,9 +19,6 @@ const {
 const {
   arePluginsInstalled
 } = require("../../utils/PluginsInstallation/arePluginsInstalled");
-const {
-  default: preCommitCheck
-} = require("./lint");
 async function validateRemotePackages() {
   try {
     if (!(getStoredCommitHash() == getLastCommitHash())) {
@@ -36,5 +33,5 @@ async function validateRemotePackages() {
 }
 (async function () {
   await validateRemotePackages();
-  await preCommitCheck();
+  require('./lint');
 })();

package/build/utils/FileAndFolderOperations/versionControl.js

@@ -16,14 +16,13 @@ const {
 function createVersionControlFile(uninstalledPlugins) {
   Logger.log(Logger.INFO_TYPE, `Rule Plugin Versions are Noted in pluginVersionControl.js`);
   const versionfilePath = path.join(getNodeModulesPath(), 'node_modules', '@zohodesk', 'codestandard-validator', 'pluginVersionControl.js');
-  if (existsSync(versionfilePath)) {
-    writeFileSync(versionfilePath, `module.exports.plugins = [${uninstalledPlugins.map(plugin => {
-      return JSON.stringify({
-        plugin: `${plugin}`,
-        time: `${new Date()}`
-      });
-    }).join(',')}]`);
-  }
+  existsSync(versionfilePath) && writeFileSync(versionfilePath, '');
+  writeFileSync(versionfilePath, `module.exports.plugins = [${uninstalledPlugins.map(plugin => {
+    return JSON.stringify({
+      plugin: `${plugin}`,
+      time: `${new Date()}`
+    });
+  }).join(',')}]`);
 }
 module.exports = {
   createVersionControlFile

package/build/utils/PluginsInstallation/checkIfPluginsAreInstalled.js

@@ -1,22 +1,15 @@
 "use strict";
 
 const {
-  readdirSync,
   existsSync
 } = require('fs');
 const path = require('path');
-const {
-  getNodeModulesPath
-} = require('../General/getNodeModulesPath');
 const {
   Logger
 } = require('../Logger/Logger');
 const {
   getLibraryInstalledLocation
 } = require('../General/getLibraryInstalledLocation');
-const {
-  executeSynchronizedCommands
-} = require('../General/executeSyncCommands');
 const {
   endPoint,
   commonLinterRepoName
@@ -27,32 +20,6 @@ const {
 const {
   getServicePathElseCommon
 } = require('../EslintConfigFileUtils/getLintConfiguration');
-function getUnInstalledPlugins(pluginsForCurrentRepo, pluginNamesOfDevDependencyPlugins, devDependencies) {
-  let pluginsInNodeModules = executeSynchronizedCommands(readdirSync, [path.join(getNodeModulesPath(), 'node_modules')], '', 'Unable to get the plugins inside node_modules', true, false);
-  let pluginsToBeInstalled = [];
-  pluginsForCurrentRepo.filter(plugin => {
-    if (plugin.packageName.startsWith('@')) {
-      let scope = plugin.packageName.split('/')[0];
-      let pluginName = plugin.packageName.split('/')[1];
-      let scopedPlugins = executeSynchronizedCommands(readdirSync, [path.join(getNodeModulesPath(), 'node_modules', scope)], '', 'Unable to get the plugins inside the scope inside node_modules', true, false);
-      let isPluginInstalled = scopedPlugins.includes(pluginName) ? true : false;
-      if (!isPluginInstalled) {
-        pluginsToBeInstalled.push(`${plugin.packageName}@${plugin.version}`);
-      }
-    } else {
-      let isPluginInstalled = pluginsInNodeModules.includes(plugin.packageName) ? true : false;
-      if (!isPluginInstalled) {
-        pluginsToBeInstalled.push(`${plugin.packageName}@${plugin.version}`);
-      }
-    }
-    if (pluginNamesOfDevDependencyPlugins.includes(plugin.packageName)) {
-      if (plugin.version !== devDependencies[plugin.packageName]) {
-        pluginsToBeInstalled.push(`${plugin.packageName}@${plugin.version}`);
-      }
-    }
-  });
-  return pluginsToBeInstalled;
-}
 function getAllPlugins() {
   let serviceSpecificPlugins = [];
   const pathToCommonPluginsFile = path.join(getLibraryInstalledLocation(), commonLinterRepoName, 'common', 'pluginVersion.js');
@@ -79,29 +46,6 @@ function checkIfPluginsAreInstalled() {
     noPluginMessage: '',
     uninstalledPlugins: []
   };
-  // let pluginsIndevDependencies = {}
-  // let pluginNamesOfDevDependencyPlugins = []
-  // let arePluginsPresentIndevDependencies = false
-  // var arePluginsPresentForCurrentRepo = false
-
-  // if(existsSync(path.join(getNodeModulesPath(),'package.json'))){
-  //     let packageJsonContent = require(path.join(getNodeModulesPath(),'package.json'))
-  //     pluginsIndevDependencies = packageJsonContent.devDependencies
-
-  //     if(pluginsIndevDependencies !== undefined){
-  //         arePluginsPresentIndevDependencies = true
-  //         pluginNamesOfDevDependencyPlugins = Object.keys(pluginsIndevDependencies)
-  //     }
-  //     else if(pluginsIndevDependencies === undefined){
-  //         Logger.log(Logger.INFO_TYPE,'No devDependencies present!')
-  //     }
-  // }
-  // else{
-  //     arePluginsPresentIndevDependencies = false
-  // }
-
-  // arePluginsPresentForCurrentRepo = pluginsForCurrentRepo.length !== 0 ? true : false
-
   uninstalledPlugins = pluginsForCurrentRepo.map(plugin => {
     const {
       packageName,
@@ -117,7 +61,6 @@ function checkIfPluginsAreInstalled() {
     return `${packageName}@${version}`;
   }).filter(Boolean);
   if (uninstalledPlugins.length > 0) {
-    // uninstalledPlugins = getUnInstalledPlugins(pluginsForCurrentRepo, pluginNamesOfDevDependencyPlugins, pluginsIndevDependencies);
     plugin.noPluginMessage = '';
     plugin.uninstalledPlugins = uninstalledPlugins;
     return plugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zohodesk/codestandard-validator",
-  "version": "0.0.6-exp-7",
+  "version": "0.0.6-exp-9",
   "description": "library to enforce code standard using eslint",
   "main": "index.js",
   "scripts": {