@zohodesk/codestandard-validator 0.0.5 → 0.0.6-exp-2

package/bin/push.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+
+require('../build/hooks/PrePush/pre-push')

package/build/hooks/PrePush/pre-push.js

@@ -0,0 +1,243 @@
+"use strict";
+
+const {
+  exec
+} = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const {
+  getEslintExecutablePath
+} = require('../../utils/EslintConfigFileUtils/getEslintExecutablePath');
+const {
+  getNodeModulesPath
+} = require('../../utils/General/getNodeModulesPath');
+const {
+  filterFiles
+} = require('../../utils/FileAndFolderOperations/filterFiles');
+const {
+  Logger
+} = require('../../utils/Logger/Logger');
+const {
+  checkIfPluginsAreInstalled
+} = require('../../utils/PluginsInstallation/checkIfPluginsAreInstalled');
+const {
+  getBranchName
+} = require('../../utils/GitActions/gitActions');
+const {
+  getConfigurationPrecommit,
+  getSupportedLanguage
+} = require('../../utils/General/getGeneralInfo');
+const {
+  getRootDirectory
+} = require('../../utils/General/RootDirectoryUtils/getRootDirectory');
+const {
+  impactBasedPrecommit,
+  shouldWarningsAbortCommit
+} = getConfigurationPrecommit();
+
+/**
+ * Checks if the current commit is a merge commit
+ * @returns {Promise<boolean>} True if it's a merge commit
+ */
+async function isMergeCommit() {
+  return new Promise(resolve => {
+    exec('git rev-parse -q --verify MERGE_HEAD', error => {
+      resolve(!error);
+    });
+  });
+}
+
+/**
+ * Gets staged files while filtering out deleted files
+ * @returns {Promise<string[]>} Array of staged file paths
+ */
+async function getStagedFiles() {
+  return new Promise((resolve, reject) => {
+    exec('git diff --staged --name-only', (error, stdout) => {
+      if (error) {
+        return reject("Couldn't fetch staged files");
+      }
+      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 filterDeletedFiles(files) {
+  return files.filter(file => {
+    const absolutePath = path.resolve(getRootDirectory(), file);
+    return fs.existsSync(absolutePath);
+  });
+}
+
+/**
+ * Runs ESLint on a specific file
+ * @param {string} file - File path to lint
+ * @returns {Promise<string[]>} ESLint output lines
+ */
+async function runEslintOnFile(file) {
+  const nodeModulesPath = getNodeModulesPath();
+  const eslintPath = getEslintExecutablePath();
+  const configPath = `${nodeModulesPath}/.eslintrc.js`;
+  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');
+    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
+ */
+async function getGitDiff(branch, 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') : []);
+    });
+  });
+}
+
+/**
+ * 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 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
+    };
+  });
+}
+
+/**
+ * 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 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);
+  });
+}
+
+/**
+ * Checks if ESLint output contains only warnings
+ * @param {string[]} eslintErrors - ESLint output lines
+ * @returns {boolean} True if only warnings are present
+ */
+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;
+  try {
+    const eslintOutput = await runEslintOnFile(file);
+    if (eslintOutput.length < 3) return false; // No meaningful errors
+
+    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;
+      }
+      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;
+      }
+      return true;
+    }
+  } catch (error) {
+    Logger.log(Logger.FAILURE_TYPE, `Error processing ${file}: ${error}`);
+  }
+  return false;
+}
+
+/**
+ * Main pre-push hook execution logic
+ */
+async function prePushCheck() {
+  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');
+      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);
+  }
+}
+prePushCheck();

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

@@ -1,310 +1,29 @@
 "use strict";
 
 const {
-  exec
-} = require('child_process');
-const fs = require('fs');
-const path = require('path');
+  cloneViaCdt
+} = require("../../utils/CloneCommonLinterRepo/cloneViaCdt");
 const {
-  getEslintExecutablePath
-} = require('../../utils/EslintConfigFileUtils/getEslintExecutablePath');
+  createEslintConfigFile
+} = require("../../utils/EslintConfigFileUtils/createEslintConfigFile");
 const {
-  getNodeModulesPath
-} = require('../../utils/General/getNodeModulesPath');
+  getLastCommitHash,
+  getRequiredInfoPath
+} = require("../../utils/General/getGeneralInfo");
 const {
-  filterFiles,
-  filterWarningInFile
-} = require('../../utils/FileAndFolderOperations/filterFiles');
-const {
-  Logger
-} = require('../../utils/Logger/Logger');
-const {
-  checkIfPluginsAreInstalled
-} = require('../../utils/PluginsInstallation/checkIfPluginsAreInstalled');
-const {
-  getBranchName
-} = require('../../utils/GitActions/gitActions');
-const {
-  getConfigurationPrecommit,
-  getSupportedLanguage
-} = require('../../utils/General/getGeneralInfo');
-const {
-  getRootDirectory
-} = require('../../utils/General/RootDirectoryUtils/getRootDirectory');
-const {
-  impactBasedPrecommit,
-  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() {
-  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());
-      }
-    });
-  });
-}
-
-/**
- * @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, 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());
-      }
-    });
-  });
-}
-
-/**
- * @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 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 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 {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}`;
-  return new Promise((resolve, reject) => {
-    exec(gitDiffCommand, (error, stderr) => {
-      if (stderr) {
-        resolve(stderr.trim().split('\n'));
-      } else if (error) {
-        reject(error);
-      }
-    });
-  });
-}
-/**
- * @function {areAllPluginsInstalled} -  method whether plugin is installed or not
- * @returns {Boolean} - return boolean based on plugin installed or not
- */
-
-function areAllPluginsInstalled() {
-  let unInstalledPlugins = checkIfPluginsAreInstalled().uninstalledPlugins;
-  return unInstalledPlugins.length === 0 ? true : false;
-}
-
-/**
- * @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 {preCommitHook} - method execute pre commit hook
- * @returns {void}
- */
-
-async function preCommitHook() {
-  Logger.log(Logger.INFO_TYPE, 'Executing pre commit hook...');
-  Logger.log(Logger.INFO_TYPE, `working dir  : ${process.cwd()}`);
+  arePluginsInstalled
+} = require("../../utils/PluginsInstallation/arePluginsInstalled");
+async function validateRemotePackages() {
   try {
-    let isMerge = await isMergeCommit();
-    Logger.log(Logger.INFO_TYPE, 'Looks like you have merged. So skipping pre commit check');
-    process.exit(0);
+    const {
+      commitHash
+    } = JSON.parse(require(getRequiredInfoPath()));
+    if (!(commitHash == getLastCommitHash())) await executeMethodsThatReturnBooleanValue("Make sure zgit.csez.zohocorpin.com is accessible", cloneViaCdt, null);
+    await executeMethodsThatReturnBooleanValue("Some issue occurred in creating eslint config file.", createEslintConfigFile, null);
+    Logger.log(Logger.SUCCESS_TYPE, "Pre commit setup successfull");
+    arePluginsInstalled();
   } 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
-
-                        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');
-      }
-      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);
-      }
-    } 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.FAILURE_TYPE, `Kindly retry npm install. & ${error.message}`);
   }
 }
-preCommitHook();
+validateRemotePackages();

package/build/setup/sample.config.js

@@ -8,13 +8,14 @@ const path = require("path");
  * @property {boolean} impactBased - Indicates if the linting is impact-based.
  * @property {string} lintReportPath - The path to the lint report JSON file.
  * @property {string} metricServerHost - The URL of the SonarQube server.
- * @property {string} meticHandler_api_token -  The token for authentication with the SonarQube server.
- * @property {string} metric_token - The token for authentication with the SonarQube server.
+ * @property {string} meticHandler_api_token -  The token to authenticate sonarQube apis.
+ * @property {string} metric_token - The token to authenticate sonarQube.
  * @property {string} gitEndPoint - API EndPoint for Git Actions
  * @property {string} tsConfigurationPath - The path of the ts configuration Path
  * @property {number} projectId - project id of repository
  * @property {boolean} impactBasedPrecommit - Indicates if the linting is impact-based in pre commit
  * @property {boolean} shouldWarningsAbortCommit - Indicates if eslint warnings should abort the commit
+ * @property {string} pushMetricsOnPreCommit -  Indicates to push metrics to sonarQube or not
  * @property {string} token - Encrypted Authentication Token
  * @property {string} compareBranch - Branch to compare diff
  */
@@ -23,15 +24,17 @@ module.exports = {
   ruleConfigurationPath: path.resolve(process.cwd(), ".eslintrc.js"),
   impactBased: true,
   lintReportPath: path.resolve(process.cwd(), "lint-report", "lintReport.json"),
-  metricServerHost: "https://client-linters.zohodesk.csez.zohocorpin.com",
-  meticHandler_api_token: "oyRcKJZxm2RkXytfAzVtmyRlLIftou5anC==",
-  metric_token: "zxh_9737850jh2l53ml17223929ihii73072j54j2260",
+  metricServerHost: "https://client-linters.zdesk.csez.zohocorpin.com",
+  meticHandler_api_token: "KIDfmI46KIDfmI4kYPU1",
+  metric_token: "zxh_371336m636584i54m662j6495h46228mkj6hihh8",
   branchDiffPath: path.resolve(process.cwd(), "diffBranch.json"),
   gitEndPoint: "https://zgit.csez.zohocorpin.com",
   tsConfigurationPath: path.resolve(process.cwd(), 'tsconfig.json'),
   projectId: `project-id`,
   impactBasedPrecommit: true,
   shouldWarningsAbortCommit: false,
+  pushMetricsOnPreCommit: true,
   token: "w-OkG3f5OOM1Rkly8phZ",
-  compareBranch: 'release'
+  compareBranch: 'release',
+  supportedExtensions: ['.js', '.jsx', '.ts', '.tsx', '.properties']
 };

package/build/utils/General/getGeneralInfo.js

@@ -54,11 +54,10 @@ function getConfigurationPrecommit() {
  * @returns {Array<string>}
  */
 function getSupportedLanguage() {
-  const _language = [];
-  _language.push('.js');
-  _language.push('.jsx');
-  _language.push('.ts');
-  _language.push('.tsx');
+  const {
+    supportedExtensions
+  } = getConfigurationPrecommit();
+  const _language = supportedExtensions;
   return _language;
 }
 function getRunningEnv() {
@@ -67,10 +66,19 @@ function getRunningEnv() {
     shell: true
   }).toString().trim();
 }
+function getLastCommitHash() {
+  const cmd = `curl --header "PRIVATE-TOKEN: 4aexpjRkZG1LBDDsHf3C" --url https://zgit.csez.zohocorpin.com/api/v4/projects/19251/repository/commits`;
+  return JSON.parse(execSync(cmd))[0]["id"];
+}
+function getRequiredInfoPath() {
+  return path.join(process.cwd(), 'jsonUtils', 'fsUtils.json');
+}
 module.exports = {
   getSupportedLanguage,
   getTimeStampInfo,
   getEnv,
   getConfigurationPrecommit,
-  getRunningEnv
+  getRunningEnv,
+  getLastCommitHash,
+  getRequiredInfoPath
 };

package/build/utils/General/writeProjectDetailsToJson.js

@@ -7,11 +7,16 @@ const {
 const {
   executeSynchronizedCommands
 } = require('./executeSyncCommands');
+const {
+  getLastCommitHash,
+  getRequiredInfoPath
+} = require('./getGeneralInfo');
 function writeFsPaths() {
   var fileContent = {
-    nodeModulesPath: path.resolve(process.cwd(), '..', '..', '..')
+    nodeModulesPath: path.resolve(process.cwd(), '..', '..', '..'),
+    commitHash: getLastCommitHash()
   };
-  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);
+  return executeSynchronizedCommands(writeFileSync, [getRequiredInfoPath(), 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/HuskySetup/configurePrecommitHook.js

@@ -22,16 +22,27 @@ const {
 function configurePrecommitHook() {
   let rootDirectory = getRootDirectory();
   let customPrecomitHookPath = path.join(getLibraryInstalledLocation(), "bin", "execute.js");
+  let customPrePushHookPath = path.join(getLibraryInstalledLocation(), "bin", "push.js");
   let huskyPrecommitPath = path.join(rootDirectory, ".husky", "pre-commit");
+  let huskyPrePushPath = path.join(rootDirectory, ".husky", "pre-push");
   let huskyPrecommitHookContent = `#!/bin/sh
 . "$(dirname "$0")/_/husky.sh"
 
 "${customPrecomitHookPath}"
+`;
+  let huskyPrePushHookContent = `#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+"${customPrePushHookPath}"
 `;
   let isCustomPrecommitConfigurationSuccessful = executeSynchronizedCommands(writeFileSync, [huskyPrecommitPath, huskyPrecommitHookContent, 'utf-8'], '', 'Could not create and write pre-commit.sh inisde husky directory', false, true);
+  let isCustomPrePushConfigurationSuccessful = executeSynchronizedCommands(writeFileSync, [huskyPrePushPath, huskyPrePushHookContent, '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 if (isCustomPrePushConfigurationSuccessful) {
+    let isExecutionPermissionGivenSuccessfully = grantExecutionPermission([huskyPrePushPath, customPrePushHookPath]);
+    return isExecutionPermissionGivenSuccessfully;
   } else {
     return false;
   }

package/build/utils/PluginsInstallation/installPlugins.js

@@ -76,53 +76,6 @@ function restorePackageJsonContent(packageJsonContentBeforePluginsInstallation)
   let isPackageJsonRestored = executeSynchronizedCommands(writeFileSync, [packageJsonFilePath, JSON.stringify(packageJsonContentBeforePluginsInstallation, null, 2)], 'Package.json content restored successfully', 'Unable to restore package.json content', false, true);
   return isPackageJsonRestored;
 }
-
-// function appendInstalledPluginsToPackageJson(pluginsToBeAppendedInPackageJson){
-//     let packageJsonFilePath = `${nodeModulesPathOfProject}/package.json`
-//     let packageJsonContent = require(packageJsonFilePath)
-//     let devDependencies = packageJsonContent.devDependencies
-//     let pluginsToBeAddedInDevDependencies = {}
-
-//     executeSynchronizedCommands(process.chdir,[nodeModulesPathOfProject],'','Unable to navigate to node_modules path when trying to revert changes in package.json',false,false)
-
-//     let gitDiffOutput = executeSynchronizedCommands(execSync,['git diff --name-only'],'','Unable to execute git diff command while checking if package.json is changed',true,false).toString().trim()
-//     let isPackageJsonChanged = gitDiffOutput.includes('package.json') ? true : false
-
-//     if(isPackageJsonChanged){
-//         let packageJsonChangesRevertCommand = `git checkout "${packageJsonFilePath}"`
-//         isPackageJsonChangesRevertedSuccessfully = executeSynchronizedCommands(execSync,[packageJsonChangesRevertCommand,{stdio:'inherit'}],'Changes in package.json reverted successfully','Unable to revert the changes in package.json file',false,true)
-
-//         if(isPackageJsonChangesRevertedSuccessfully){
-//             pluginsToBeAppendedInPackageJson.map(uninstalledPlugin => {
-//                 if(uninstalledPlugin.startsWith('@')){
-//                     let indexOfAtCharacter = uninstalledPlugin.indexOf('@')
-//                     let indexOfSecondOccurenceOfAtCharacter = uninstalledPlugin.indexOf('@',indexOfAtCharacter + 1)
-//                     let unInstalledPluginName = uninstalledPlugin.slice(0,indexOfSecondOccurenceOfAtCharacter)
-//                     let unInstalledPluginVersion = uninstalledPlugin.slice(indexOfSecondOccurenceOfAtCharacter + 1)
-//                     pluginsToBeAddedInDevDependencies[unInstalledPluginName] = unInstalledPluginVersion
-//                 }
-//                 else{
-//                     pluginsToBeAddedInDevDependencies[uninstalledPlugin.split('@')[0]] = uninstalledPlugin.split('@')[1]
-//                 }
-//                 })
-//                 let updatedPluginsIndevDependencies = {
-//                     ...devDependencies,
-//                     ...pluginsToBeAddedInDevDependencies
-//                 }
-//                 packageJsonContent.devDependencies = updatedPluginsIndevDependencies
-
-//                 let modifiedPackageJson = {
-//                     ...packageJsonContent,
-//                 }
-//                 let isPluginsAddedInPackageJson = executeSynchronizedCommands(writeFileSync,[packageJsonFilePath,JSON.stringify(modifiedPackageJson,null,2)],'Newly installed plugins successfully added to package.json','Unable to append installed plugins to package.json',false,true)
-//                 return isPluginsAddedInPackageJson 
-//         }
-//         else{
-//             return true
-//         }
-//     }
-// }
-
 module.exports = {
   installPlugins
 };

package/changeLog.md

@@ -23,7 +23,10 @@
  3. Added configuration to abort commits if there are warnings or issues.
  4. Environment-specific clone configuration added.
 
- # 0.0.5 - auto plugin installtion and dependencies validation
+# 0.0.5 - Automatic eslint plugins installation
+ 1. The required eslint plugins configured for a repository will be automatically installed during the installation of the library
 
- 1. check plugin version in local with remote and auto install rules plugins.
- 2. plugin version log file.
+# 0.0.6 - Support extended for .properties file
+ 
+ 1. The file types that are supported by this library can now be configured using the configuration file "lint.config.js" 
+ 2. Support for .properties file is also extended in this version along with existing support for file types .js, .jsx, .ts, .tsx

package/package.json

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