@zohodesk/codestandard-validator 0.0.6-exp-18 → 0.0.6-exp-21

package/build/hooks/Precommit/lint.js

@@ -7,12 +7,13 @@ 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
+  filterFiles,
+  filterWarningInFile
 } = require('../../utils/FileAndFolderOperations/filterFiles');
 const {
   Logger
@@ -35,276 +36,176 @@ const {
   shouldWarningsAbortCommit
 } = getConfigurationPrecommit();
 
-/**
- * @function isMergeCommit - This method check whether it is merge or not
- * @returns {Boolean} -  return boolean based on latest merge changes
- */
-async function isMergeCommit() {
+/* ------------------------------------------
+   Git Helpers
+------------------------------------------ */
+
+function isMergeCommit() {
   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());
-      }
+    exec('git rev-parse -q --verify MERGE_HEAD', (err, stderr, stdout) => {
+      if (err) return reject(err.toString().trim());
+      resolve((stdout || stderr).trim());
     });
   });
 }
-
-/**
- * @function {getStagedFiles} - methods return staged files
- * @returns {Array<string>} -  array of  files
- */
-
-async function getStagedFiles() {
+function getStagedFiles() {
   return new Promise((resolve, reject) => {
-    exec("git diff --staged --name-only", (error, stderr, stdout) => {
-      if (error) {
-        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());
-      }
+    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 {filterDeltedFileFromStagedFiles} - filter deleted staged files
- * @param {Array<string>} files - staged files
- * @returns 
- */
-function filterDeltedFileFromStagedFiles(files) {
-  return files.filter(file => {
-    const absolutePath = path.resolve(getRootDirectory(), file);
-    if (fs.existsSync(absolutePath)) {
-      return true;
-    }
-    return false;
-  });
+function filterDeletedFiles(files) {
+  return files.filter(file => fs.existsSync(path.resolve(getRootDirectory(), file)));
 }
 
-/**
- * @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 
- */
+/* ------------------------------------------
+   Lint Helpers
+------------------------------------------ */
 
-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');
+function lintFiles(filePath) {
+  const ext = path.extname(filePath);
+  if (['.js', '.ts', '.tsx', '.jsx'].includes(ext)) {
+    return findEslintErrors(filePath);
+  }
+  if (['.css', '.scss'].includes(ext)) {
+    return findStyleLintErrors(filePath);
   }
+  return Promise.resolve([]);
 }
-/**
- * @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 calculateGitDiffForFile(branch_name, file) {
-  let gitDiffCommand = `git diff -U0 ${branch_name.trim()} ${file}`;
+function findStyleLintErrors(filePath) {
+  const config = path.resolve(getNodeModulesPath(), '.stylelintrc.js');
+  const absolutePath = path.join(getRootDirectory(), filePath);
   return new Promise((resolve, reject) => {
-    exec(gitDiffCommand, (error, stderr) => {
-      if (stderr) {
-        resolve(stderr.trim().split('\n'));
-      } else if (error) {
-        reject(error);
+    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();
+  const nodeModulesPath = getNodeModulesPath();
+  const eslintConfig = `${nodeModulesPath}/.eslintrc.js`;
+  if (!fs.existsSync(eslintPath)) {
+    Logger.log(Logger.INFO_TYPE, 'Eslint executable not found. Ensure eslint plugin is installed.');
+    return Promise.resolve([]);
+  }
+  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([]);
+    });
+  });
+}
+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 {areAllPluginsInstalled} -  method whether plugin is installed or not
- * @returns {Boolean} - return boolean based on plugin installed or not
- */
+
+/* ------------------------------------------
+   Utility
+------------------------------------------ */
 
 function areAllPluginsInstalled() {
-  let unInstalledPlugins = checkIfPluginsAreInstalled().uninstalledPlugins;
-  console.log("unInstalledPlugins", unInstalledPlugins);
-  return unInstalledPlugins.length === 0 ? true : false;
+  const {
+    uninstalledPlugins
+  } = checkIfPluginsAreInstalled();
+  console.log('unInstalledPlugins', uninstalledPlugins);
+  return uninstalledPlugins.length === 0;
 }
-
-/**
- * @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 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');
+function isOnlyWarningsPresent(errors) {
+  const severities = errors.map(e => e.split(' ').find(w => w === 'error' || w === 'warning'));
+  return !severities.includes('error');
 }
 
-/**
- * @function {preCommitHook} - method execute pre commit hook
- * @returns {void}
- */
+/* ------------------------------------------
+   Main Execution
+------------------------------------------ */
 
 async function preCommitHook() {
   Logger.log(Logger.INFO_TYPE, 'Executing pre commit hook...');
-  Logger.log(Logger.INFO_TYPE, `working dir  : ${process.cwd()}`);
+  Logger.log(Logger.INFO_TYPE, `Working directory: ${process.cwd()}`);
   try {
-    let isMerge = await isMergeCommit();
-    Logger.log(Logger.INFO_TYPE, 'Looks like you have merged. So skipping pre commit check');
+    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");
-      }
+  } 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 {
-        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
-
-                        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");
-              }
+        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 if (staged_files.length === 0) {
-          Logger.log(Logger.INFO_TYPE, 'No files have been staged. Stage your files before committing');
+        } else {
+          relevantErrors = lintResults.slice(1, -2);
         }
-      } catch {
-        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.`);
-        process.exit(1);
-      } else if (shouldAbortCommit === false && staged_files.length !== 0) {
-        Logger.log(Logger.SUCCESS_TYPE, `Commit Successful`);
-        process.exit(0);
+        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);
       }
-    } 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.');
+    }
+    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);
   }
 }
 preCommitHook();