@zohodesk/codestandard-validator 0.0.7 → 1.0.0-exp-2

package/.babelrc

@@ -4,7 +4,7 @@
       "@babel/preset-env",
       {
         "targets": {
-          "node": "14"
+          "node": "16"
         }
       }
     ]

package/bin/execute.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 
-require('../build/hooks/Precommit/pre-commit')
+require('../build/hooks/hook')

package/build/hooks/Precommit/commit.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+"use strict";
+
+const {
+  filterFiles
+} = require("../../utils/FileAndFolderOperations/filterFiles");
+const {
+  Logger
+} = require("../../utils/Logger/Logger");
+const {
+  handleMergeCommit,
+  ensurePluginsInstalled,
+  safeGetStagedFiles,
+  safeGetBranch
+} = require("./guard");
+const {
+  runLintWorkflow
+} = require("./lint");
+process.env.DECRYPT_SONARQUBE = 7;
+process.env.DECRYPT_TOKEN = 12;
+global.analytics = {
+  status: "SUCCESS",
+  sonarQubeStatus: false,
+  message: "No issues are found, your code adheres to the required standards.",
+  isExemptionApproved: false,
+  totalIssues: 0
+};
+async function preCommitHook() {
+  Logger.log(Logger.INFO_TYPE, "Executing pre commit hook...");
+  Logger.log(Logger.INFO_TYPE, `working dir: ${process.cwd()}`);
+  if (await handleMergeCommit()) return;
+  if (!(await ensurePluginsInstalled())) return;
+  const stagedFiles = await safeGetStagedFiles();
+  if (stagedFiles.length === 0) {
+    Logger.log(Logger.INFO_TYPE, "No staged files. Commit skipped.");
+    return;
+  }
+  const {
+    JsFiles
+  } = filterFiles(stagedFiles, [".eslintrc.js"], true);
+  const branch = await safeGetBranch();
+  const shouldAbort = await runLintWorkflow(JsFiles, branch);
+  if (shouldAbort) {
+    Logger.log(Logger.FAILURE_TYPE, "There are linter errors/warnings. Commit aborted.");
+    process.exit(1);
+  }
+  Logger.log(Logger.SUCCESS_TYPE, "Commit Successful");
+  process.exit(0);
+}
+preCommitHook();

package/build/hooks/Precommit/errorhelpers.js

@@ -0,0 +1,39 @@
+"use strict";
+
+const {
+  Logger
+} = require("../../utils/Logger/Logger");
+const {
+  calculateGitDiffForFile
+} = require("./lint");
+function parseDiffHunks(diff) {
+  return diff.filter(line => line.startsWith("@@")).map(hunk => {
+    const [start, count = 1] = hunk.split(" ")[2].slice(1).split(",").map(Number);
+    return [start, start + (count - 1)];
+  });
+}
+async function filterErrorsByChangedLines(errors, branch, file) {
+  const diff = await calculateGitDiffForFile(branch, file);
+  const changedRanges = parseDiffHunks(diff);
+  return errors.filter(err => {
+    const line = parseInt(err.split(" ")[0].split(":")[0], 10);
+    return changedRanges.some(([s, e]) => line >= s && line <= e);
+  });
+}
+async function createBranchDiff(diff) {
+  // const diff = await calculateGitDiffForFile(branch, file);
+  // const changeset = extractDiffHunks(diff)
+}
+function filterFileLevelErrors(errors) {
+  return errors.slice(1, -2); // strip ESLint summary lines
+}
+function logErrors(file, errors) {
+  Logger.log(Logger.FAILURE_TYPE, `\x1b[1m${file}\x1b[0m`);
+  errors.forEach(err => Logger.log(Logger.FAILURE_TYPE, `\x1b[37m${err.trimEnd()}\x1b[0m`));
+}
+module.exports = {
+  filterErrorsByChangedLines,
+  filterFileLevelErrors,
+  logErrors,
+  parseDiffHunks
+};

package/build/hooks/Precommit/guard.js

@@ -0,0 +1,50 @@
+"use strict";
+
+const {
+  getBranchName
+} = require("../../utils/GitActions/gitActions");
+const {
+  Logger
+} = require("../../utils/Logger/Logger");
+const {
+  isMergeCommit,
+  areAllPluginsInstalled,
+  getStagedFiles
+} = require("./utils");
+async function handleMergeCommit() {
+  if (await isMergeCommit()) {
+    Logger.log(Logger.INFO_TYPE, "Merge detected. Skipping pre-commit check.");
+    process.exit(0);
+    return true;
+  }
+  return false;
+}
+async function ensurePluginsInstalled() {
+  if (areAllPluginsInstalled()) return true;
+  Logger.log(Logger.FAILURE_TYPE, "Commit failed since some lint plugins are not installed");
+  Logger.log(Logger.INFO_TYPE, `Run \x1b[37mnpx ZDPrecommit setupPlugins \x1b[33m in the project root to install them.`);
+  process.exit(1);
+  return false;
+}
+async function safeGetStagedFiles() {
+  try {
+    return await getStagedFiles();
+  } catch {
+    Logger.log(Logger.INFO_TYPE, "Error fetching staged files");
+    process.exit(1);
+  }
+}
+async function safeGetBranch() {
+  try {
+    return await getBranchName();
+  } catch {
+    Logger.log(Logger.INFO_TYPE, "Error fetching current branch");
+    return "";
+  }
+}
+module.exports = {
+  safeGetBranch,
+  safeGetStagedFiles,
+  handleMergeCommit,
+  ensurePluginsInstalled
+};

package/build/hooks/Precommit/lint.js

@@ -3,209 +3,131 @@
 const {
   exec
 } = require('child_process');
+const {
+  promisify
+} = require('util');
 const fs = require('fs');
 const path = require('path');
+const {
+  getNodeModulesPath
+} = require('../../utils/General/getNodeModulesPath');
 const {
   getEslintExecutablePath
 } = require('../../utils/ConfigFileUtils/getEslintExecutablePath');
 const {
-  getNodeModulesPath
-} = require('../../utils/General/getNodeModulesPath');
+  getRootDirectory
+} = require('../../utils/General/RootDirectoryUtils/getRootDirectory');
 const {
-  filterFiles,
-  filterWarningInFile
-} = require('../../utils/FileAndFolderOperations/filterFiles');
+  getSupportedLanguage
+} = require('../../utils/General/getGeneralInfo');
 const {
-  Logger
-} = require('../../utils/Logger/Logger');
+  filterFileLevelErrors,
+  filterErrorsByChangedLines,
+  logErrors
+} = require('./errorhelpers');
 const {
-  checkIfPluginsAreInstalled
-} = require('../../utils/PluginsInstallation/checkIfPluginsAreInstalled');
+  Execution,
+  SonarQube,
+  EsLint
+} = require('@zohodesk/codestandard-analytics');
 const {
   getBranchName
 } = require('../../utils/GitActions/gitActions');
 const {
-  getConfigurationPrecommit,
-  getSupportedLanguage
-} = require('../../utils/General/getGeneralInfo');
-const {
-  getRootDirectory
-} = require('../../utils/General/RootDirectoryUtils/getRootDirectory');
-const {
-  impactBasedPrecommit,
-  shouldWarningsAbortCommit
-} = getConfigurationPrecommit();
-
-/* ------------------------------------------
-   Git Helpers
------------------------------------------- */
-
-function isMergeCommit() {
-  return new Promise((resolve, reject) => {
-    exec('git rev-parse -q --verify MERGE_HEAD', (err, stderr, stdout) => {
-      if (err) return reject(err.toString().trim());
-      resolve((stdout || stderr).trim());
-    });
-  });
-}
-function getStagedFiles() {
-  return new Promise((resolve, reject) => {
-    exec('git diff --staged --name-only', (err, stderr, stdout) => {
-      if (err) return reject("Couldn't fetch staged files");
-      const output = stderr || stdout;
-      if (!output.trim()) return resolve([]);
-      resolve(filterDeletedFiles(output.trim().split('\n')));
-    });
-  });
-}
-function filterDeletedFiles(files) {
-  return files.filter(file => fs.existsSync(path.resolve(getRootDirectory(), file)));
-}
-
-/* ------------------------------------------
-   Lint Helpers
------------------------------------------- */
-
-function lintFiles(filePath) {
+  extractDiffHunks
+} = require('./utils');
+const execAsync = promisify(exec);
+async function lintFiles(filePath) {
   const ext = path.extname(filePath);
-  if (['.js', '.ts', '.tsx', '.jsx'].includes(ext)) {
+  if (['.js', '.ts', '.tsx', '.jsx', '.properties'].includes(ext)) {
     return findEslintErrors(filePath);
   }
   if (['.css', '.scss'].includes(ext)) {
     return findStyleLintErrors(filePath);
   }
-  return Promise.resolve([]);
+  return [];
 }
-function findStyleLintErrors(filePath) {
-  const config = path.resolve(getNodeModulesPath(), '.stylelintrc.js');
-  const absolutePath = path.join(getRootDirectory(), filePath);
-  return new Promise((resolve, reject) => {
-    exec(`npx stylelint ${absolutePath} --config ${config}`, {
-      cwd: getNodeModulesPath()
-    }, (err, stderr) => {
-      if (stderr) return resolve(stderr.trim().split('\n'));
-      if (err) {
-        Logger.log(Logger.FAILURE_TYPE, err);
-        return reject('Error executing stylelint command');
-      }
-      resolve([]);
-    });
-  }).catch(err => {
-    Logger.log(Logger.FAILURE_TYPE, 'Issue linting CSS files');
-    return [];
-  });
-}
-function findEslintErrors(filePath) {
-  const eslintPath = getEslintExecutablePath();
+async function findEslintErrors(file) {
   const nodeModulesPath = getNodeModulesPath();
+  const eslintPath = getEslintExecutablePath();
   const eslintConfig = `${nodeModulesPath}/.eslintrc.js`;
+  var rulesArrayReport = [];
+  if (!fs.existsSync(nodeModulesPath)) {
+    Logger.log(Logger.INFO_TYPE, 'node_modules not found');
+    return [];
+  }
   if (!fs.existsSync(eslintPath)) {
-    Logger.log(Logger.INFO_TYPE, 'Eslint executable not found. Ensure eslint plugin is installed.');
-    return Promise.resolve([]);
+    Logger.log(Logger.INFO_TYPE, 'Eslint executable not found. Make sure eslint plugin is installed');
+    return [];
   }
-  return new Promise((resolve, reject) => {
-    const cmd = `npx --ignore-existing "${eslintPath}" --config "${eslintConfig}" --no-inline-config --resolve-plugins-relative-to="${nodeModulesPath}/node_modules" ${filePath}`;
-    exec(cmd, (err, stderr) => {
-      if (stderr) return resolve(stderr.trim().split('\n'));
-      if (err) {
-        Logger.log(Logger.FAILURE_TYPE, err);
-        return reject('Error executing eslint command');
-      }
-      resolve([]);
-    });
+  return execAsync(`npx --ignore-existing "${eslintPath}" --config "${eslintConfig}" --no-inline-config --resolve-plugins-relative-to="${nodeModulesPath}/node_modules" ${file}`).then(({
+    stderr
+  }) => stderr ? stderr.trim().split('\n') : []).catch(err => {
+    Logger.log(Logger.FAILURE_TYPE, err);
+    throw new Error('Error executing eslint command');
   });
 }
-function calculateGitDiffForFile(branch, file) {
-  return new Promise((resolve, reject) => {
-    exec(`git diff -U0 ${branch.trim()} ${file}`, (err, stderr) => {
-      if (stderr) return resolve(stderr.trim().split('\n'));
-      if (err) return reject(err);
-    });
+function findStyleLintErrors(filePath) {
+  const configFile = path.resolve(getNodeModulesPath(), '.stylelintrc.js');
+  const absolutePath = path.join(getRootDirectory(), filePath);
+  return execAsync(`npx stylelint ${absolutePath} --config ${configFile}`, {
+    cwd: getNodeModulesPath()
+  }).then(({
+    stdout
+  }) => stdout ? stdout.trim().split('\n') : []).catch(err => {
+    Logger.log(Logger.FAILURE_TYPE, err);
+    return [];
   });
 }
-
-/* ------------------------------------------
-   Utility
------------------------------------------- */
-
-function areAllPluginsInstalled() {
-  const {
-    uninstalledPlugins
-  } = checkIfPluginsAreInstalled();
-  console.log('unInstalledPlugins', uninstalledPlugins);
-  return uninstalledPlugins.length === 0;
-}
-function isOnlyWarningsPresent(errors) {
-  const severities = errors.map(e => e.split(' ').find(w => w === 'error' || w === 'warning'));
-  return !severities.includes('error');
+async function calculateGitDiffForFile(branch, file) {
+  try {
+    const {
+      stdout
+    } = await execAsync(`git diff -U0 ${branch.trim()} ${file}`);
+    return stdout;
+  } catch (err) {
+    throw err;
+  }
 }
+async function runLintWorkflow(files, branch) {
+  const branchDiff = {
+    diffs: []
+  };
+  let shouldAbort = false;
+  var branchName = getBranchName();
+  for (const file of files) {
+    if (!getSupportedLanguage().includes(path.extname(file))) continue;
+    const changeset = extractDiffHunks(await calculateGitDiffForFile(branchName, file));
+    const diff = {
+      old_path: file,
+      new_path: file,
+      diff: changeset
+    };
+    branchDiff.diffs.push(diff);
+    // const filteredErrors = impactBasedPrecommit
+    //   ? await filterErrorsByChangedLines(errors, branch, file)
+    //   : filterFileLevelErrors(errors);
 
-/* ------------------------------------------
-   Main Execution
------------------------------------------- */
-
-async function preCommitHook() {
-  Logger.log(Logger.INFO_TYPE, 'Executing pre commit hook...');
-  Logger.log(Logger.INFO_TYPE, `Working directory: ${process.cwd()}`);
-  try {
-    await isMergeCommit();
-    Logger.log(Logger.INFO_TYPE, 'Looks like you have merged. So skipping pre-commit check');
-    process.exit(0);
-  } catch {
-    if (!areAllPluginsInstalled()) {
-      Logger.log(Logger.FAILURE_TYPE, 'Commit failed due to missing eslint plugins');
-      Logger.log(Logger.INFO_TYPE, `Run \x1b[37mnpx ZDPrecommit setupPlugins\x1b[33m in the project root`);
-      process.exit(1);
-    }
-    let files = await getStagedFiles();
-    if (files.length === 0) {
-      Logger.log(Logger.INFO_TYPE, 'No files staged. Stage files before committing.');
-      return;
-    }
-    const currentBranch = await getBranchName().catch(() => '');
-    const filteredFiles = filterFiles(files, ['.eslintrc.js'], true);
-    let shouldAbort = false;
-    for (const file of filteredFiles) {
-      if (!getSupportedLanguage().includes(path.extname(file))) continue;
-      try {
-        const lintResults = await lintFiles(file);
-        if (lintResults.length === 0) continue;
-        let relevantErrors = [];
-        if (impactBasedPrecommit) {
-          const gitDiff = await calculateGitDiffForFile(currentBranch, file);
-          const changeHunks = gitDiff.filter(line => line.startsWith('@@'));
-          const ranges = changeHunks.map(h => {
-            const start = parseInt(h.split(' ')[2].split(',')[0]);
-            const len = parseInt(h.split(' ')[2].split(',')[1]) || 1;
-            return [start, start + len - 1];
-          });
-          for (const error of lintResults.slice(1, -2)) {
-            const lineNum = parseInt(error.trim().split(' ')[0].split(':')[0]);
-            if (ranges.some(([start, end]) => lineNum >= start && lineNum <= end)) {
-              relevantErrors.push(error);
-            }
-          }
-        } else {
-          relevantErrors = lintResults.slice(1, -2);
-        }
-        if (relevantErrors.length) {
-          const onlyWarnings = isOnlyWarningsPresent(relevantErrors);
-          Logger.log(Logger.FAILURE_TYPE, `\x1b[1m${file}\x1b[0m`);
-          relevantErrors.forEach(e => Logger.log(Logger.FAILURE_TYPE, `\x1b[37m${e.trimEnd()}\x1b[0m`));
-          if (shouldWarningsAbortCommit || !onlyWarnings) {
-            shouldAbort = true;
-          }
-        }
-      } catch (err) {
-        Logger.log(Logger.FAILURE_TYPE, err);
-      }
-    }
-    if (shouldAbort) {
-      Logger.log(Logger.FAILURE_TYPE, 'There are eslint errors/warnings. Aborting commit.');
-      process.exit(1);
-    }
-    Logger.log(Logger.SUCCESS_TYPE, 'Commit Successful');
-    process.exit(0);
+    // if (filteredErrors.length > 0) {
+    //   logErrors(file, filteredErrors);
+    //   shouldAbort ||= shouldWarningsAbortCommit || !isOnlyWarnings(filteredErrors);
+    // }
   }
+  const diffPath = path.resolve(getNodeModulesPath(), 'diffBranch.json');
+  fs.writeFileSync(diffPath, JSON.stringify(diffPath));
+  const cliobj = {
+    env: 'ci',
+    cmdExecuted: 'dev-ci'
+  };
+  const execute = new Execution(EsLint, SonarQube, cliobj);
+  await execute.executeLintHandler();
+  await execute.executeMetricHandler();
+  return global.analytics.status == 'FAILURE' ? true : false;
 }
-preCommitHook();
+module.exports = {
+  runLintWorkflow,
+  lintFiles,
+  findEslintErrors,
+  findStyleLintErrors,
+  calculateGitDiffForFile
+};

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

@@ -7,13 +7,12 @@ const fs = require('fs');
 const path = require('path');
 const {
   getEslintExecutablePath
-} = require('../../utils/EslintConfigFileUtils/getEslintExecutablePath');
+} = require('../../utils/ConfigFileUtils/getEslintExecutablePath');
 const {
   getNodeModulesPath
 } = require('../../utils/General/getNodeModulesPath');
 const {
-  filterFiles,
-  filterWarningInFile
+  filterFiles
 } = require('../../utils/FileAndFolderOperations/filterFiles');
 const {
   Logger
@@ -87,6 +86,27 @@ function filterDeltedFileFromStagedFiles(files) {
     return false;
   });
 }
+async function lintFiles(filePath) {
+  switch (String(path.extname(filePath))) {
+    case '.js':
+    case '.ts':
+    case '.tsx':
+    case '.jsx':
+    case '.properties':
+      {
+        return await findEslintErrors(filePath);
+      }
+    case '.css':
+    case '.scss':
+      {
+        return await findStyleLintErrors(filePath);
+      }
+    default:
+      {
+        return [];
+      }
+  }
+}
 
 /**
  * @function findEslintErrors - method  Lint given file based on given configuration
@@ -94,7 +114,7 @@ function filterDeltedFileFromStagedFiles(files) {
  * @returns {Array<string>} -  array of command line report as a string 
  */
 
-async function findEslintErrors(file) {
+function findEslintErrors(file) {
   let nodeModulesPathOfProject = `${getNodeModulesPath()}`;
   let eslintExecutablePath = getEslintExecutablePath();
   let eslintConfigurationFilePath = `${nodeModulesPathOfProject}/.eslintrc.js`;
@@ -121,6 +141,39 @@ async function findEslintErrors(file) {
     Logger.log(Logger.INFO_TYPE, 'node_modules not found');
   }
 }
+
+/**
+ * 
+ * @param {*} params 
+ */
+function findStyleLintErrors(filePath) {
+  const configFilePath = path.resolve(getNodeModulesPath(), '.stylelintrc.js');
+  const absolutePath = path.join(getRootDirectory(), filePath);
+  try {
+    return new Promise((resolve, reject) => {
+      exec(`npx stylelint ${absolutePath} --config ${configFilePath}`, {
+        cwd: getNodeModulesPath()
+      }, (error, stderr, stdout) => {
+        if (stdout) {
+          resolve(stdout.trim().split('\n'));
+        }
+        // if(stderr){
+        //     resolve(stderr.trim().split('\n'))
+        // }
+        else if (error) {
+          Logger.log(Logger.FAILURE_TYPE, error);
+          reject("Error executing stylelint command");
+        } else {
+          resolve([]);
+        }
+      });
+    });
+  } catch (error) {
+    Logger.log(Logger.FAILURE_TYPE, `Issue is lint css files`);
+    return [];
+  }
+}
+
 /**
  * @function {calculateGitDiffForFile} -  method calculate diff of file
  * @param {*} branch_name - branch name
@@ -157,10 +210,10 @@ function isOnlyWarningsPresentInFile(eslintErrorsPresent) {
   let severityOfEachErrorInFile = [];
   eslintErrorsPresent.map(error => {
     let partsInString = error.split(" ");
-    let severityOfError = partsInString.find(word => word === 'error' || word === 'warning');
+    let severityOfError = partsInString.find(word => word === 'error' || word === 'warning' || word === '✖');
     severityOfEachErrorInFile.push(severityOfError);
   });
-  return !severityOfEachErrorInFile.includes('error');
+  return !(severityOfEachErrorInFile.includes('✖') || severityOfEachErrorInFile.includes('error'));
 }
 
 /**
@@ -193,29 +246,35 @@ async function preCommitHook() {
       try {
         staged_files = await getStagedFiles();
         if (!staged_files.length == 0) {
-          staged_files = filterFiles(staged_files, eslintConfigFiles, true);
+          const {
+            JsFiles: staged_filesJS,
+            CssFiles
+          } = 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){
+          // staged_filesJS = filterFiles(staged_filesJS,exemptionFiles) //this is the code for giving exemption to a file during pre commit
+          // if(staged_filesJS.length === 0){
           //     Logger.log(Logger.SUCCESS_TYPE,`Commit Successful`)
           //     process.exit(0)
           // }
+
+          // CssFiles not Enabled For while 
           areFilesStaged = true;
-          for (let file in staged_files) {
-            let currentFileName = staged_files[file];
+          var stagedFiles = [...staged_filesJS];
+          for (let file in stagedFiles) {
+            let currentFileName = stagedFiles[file];
             let changedLinesArray = [];
             let eslintErrorsInChangedLines = [];
             let isOnlyEslintWarningsPresentInFile = false;
-            if (getSupportedLanguage().includes(path.extname(staged_files[file]))) {
+            if (getSupportedLanguage().includes(path.extname(stagedFiles[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) {
+                var errorsInFile = await lintFiles(stagedFiles[file]);
+                // eslintErrorsInFile = impactBasedPrecommit == false ? filterWarningInFile(errorsInFile) : errorsInFile
+                if (stagedFiles[file] && typeof stagedFiles[file] == 'string') {
+                  if (!errorsInFile.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]);
+                      let git_diff = await calculateGitDiffForFile(current_branch, stagedFiles[file]);
                       changedLinesArray = git_diff.filter(line => line.startsWith('@@'));
                       let changedLinesStartArray = [];
                       let changedLinesEndArray = [];
@@ -229,15 +288,15 @@ async function preCommitHook() {
                           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
+                      for (let error = 1; error < errorsInFile.length - 2; error++) {
+                        //errorsInFile[error].trim() - 69:26  error => Do not hardcode content. Use I18N key instead  no-hardcoding/no-hardcoding, 
+                        //errorsInFile[error].trim().split(' ')[0] => 69:26
+                        //errorsInFile[error].trim().split(' ')[0].split(':')[0] => 69
 
-                        let eslintErrorLineNumber = eslintErrorsInFile[error].trim().split(' ')[0].split(':')[0];
+                        let eslintErrorLineNumber = errorsInFile[error].trim().split(' ')[0].split(':')[0];
                         for (let lineNumber in changedLinesStartArray) {
                           if (eslintErrorLineNumber >= changedLinesStartArray[lineNumber] && eslintErrorLineNumber <= changedLinesEndArray[lineNumber]) {
-                            eslintErrorsInChangedLines.push(eslintErrorsInFile[error]);
+                            eslintErrorsInChangedLines.push(errorsInFile[error]);
                           }
                         }
                       }
@@ -258,10 +317,10 @@ async function preCommitHook() {
                         }
                       }
                     } else {
-                      if (eslintErrorsInFile.length > 0) {
+                      if (errorsInFile.length > 0) {
                         let startIndex = 1;
-                        let endIndex = eslintErrorsInFile.length - 2;
-                        let listOsEslintErrors = eslintErrorsInFile.slice(startIndex, endIndex);
+                        let endIndex = errorsInFile.length - 2;
+                        let listOsEslintErrors = errorsInFile.slice(startIndex, endIndex);
                         isOnlyEslintWarningsPresentInFile = isOnlyWarningsPresentInFile(listOsEslintErrors);
                         Logger.log(Logger.FAILURE_TYPE, `\x1b[1m${currentFileName}\x1b[0m`);
                         for (let eslintError of listOsEslintErrors) {
@@ -282,7 +341,7 @@ async function preCommitHook() {
                 }
               } catch (err) {
                 Logger.log(Logger.FAILURE_TYPE, err);
-                Logger.log(Logger.FAILURE_TYPE, "Error in executing eslint command");
+                Logger.log(Logger.FAILURE_TYPE, "Error in executing lint command");
               }
             }
           }
@@ -293,14 +352,14 @@ async function preCommitHook() {
         Logger.log(Logger.INFO_TYPE, 'Error executing pre commit hook');
       }
       if (shouldAbortCommit) {
-        Logger.log(Logger.FAILURE_TYPE, `There are eslint errors/warnings present. So commit is aborted.`);
+        Logger.log(Logger.FAILURE_TYPE, `There are linter 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);
       }
     } else {
-      Logger.log(Logger.FAILURE_TYPE, 'Commit failed since some eslint plugins are not installed');
+      Logger.log(Logger.FAILURE_TYPE, 'Commit failed since some lint 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);