@zohodesk/codestandard-validator 0.0.1 → 0.0.2-exp-2

package/build/grafana-config/grafana-config.js

@@ -0,0 +1,16 @@
+"use strict";
+
+const {
+  getRepoName
+} = require("../utils/GitActions/gitActions");
+module.exports = {
+  apiEndPoint: "",
+  path: "/",
+  requestHostDomain: "",
+  auth_token_noExpired: "",
+  type: "application/json",
+  metricName: `${getRepoName()}_precommit_metrics`,
+  metricType: "Counter",
+  metricValue: "1.0",
+  sleepTime: "600"
+};

package/build/grafana-config/grfanaAPI.js

@@ -0,0 +1,72 @@
+"use strict";
+
+var https = require("http");
+const {
+  apiEndPoint,
+  path,
+  requestHostDomain,
+  auth_token_noExpired,
+  type,
+  metricName,
+  metricType,
+  metricValue,
+  sleepTime
+} = require("./grafana-config");
+// const { getTimeStampInfo } = require("../utils/General/getGeneralInfo");
+const {
+  Logger
+} = require("../utils/Logger/Logger");
+function pushInfoToGrafana() {
+  var options = {
+    method: "POST",
+    hostname: apiEndPoint,
+    path: path,
+    headers: {
+      RequestHostDomain: requestHostDomain,
+      Authorization: auth_token_noExpired,
+      "Content-Type": type
+    },
+    maxRedirects: 20
+  };
+  var req = https.request(options, function (res) {
+    var chunks = [];
+    res.on("data", function (chunk) {
+      chunks.push(chunk);
+    });
+    res.on("end", function () {
+      var body = Buffer.concat(chunks);
+      Logger.log(Logger.INFO_TYPE, body.toString());
+    });
+    res.on("error", function (error) {
+      Logger.error(Logger.INFO_TYPE, error);
+    });
+  });
+  var metrics = JSON.stringify({
+    service_name: requestHostDomain,
+    metric_name: metricName,
+    metric_type: metricType,
+    metric_value: metricValue,
+    sleep_time: sleepTime,
+    labels: {
+      test: "precommit metric"
+    }
+  });
+  req.write(metrics);
+  req.end();
+}
+//comments
+
+/**
+ * username,
+ * branch,
+ * repo,
+ * [{
+ *  file:"",
+ *   rule:""
+ * }],
+ * passed | failed
+ */
+
+module.exports = {
+  pushInfoToGrafana
+};

package/build/hooks/Precommit/filterUtils.js

@@ -0,0 +1,42 @@
+"use strict";
+
+const path = require('path');
+const {
+  existsSync
+} = require('fs');
+
+// this file code implementation will be removed a
+
+function filterStagedFilesError(files) {
+  // first index pop for file name
+  if ((files === null || files === void 0 ? void 0 : files.length) == 0) {
+    return [];
+  }
+  const fileName = files[0];
+  if (existsSync(fileName)) {
+    if (fileName.includes('uat')) {
+      return [...filterByErrorMessage(files, 'Do not hardcode content. Use I18N key instead'), ...files.slice(files.length - 2)];
+    }
+    if (fileName.includes('src')) {
+      return [...filterByErrorMessage(files, 'playwright'), ...files.slice(files.length - 2)];
+    }
+  }
+}
+function filterByErrorMessage(files, errorMessage) {
+  return files.filter(fileContent => {
+    if (errorMessage == 'Do not hardcode content. Use I18N key instead' && fileContent.includes('warning')) {
+      return false;
+    }
+    if (fileContent.includes(errorMessage)) {
+      return false;
+    }
+    return true;
+  });
+}
+function allowedFiles(file) {
+  return file.includes('uat') || file.includes('jsapps/supportapp/src') && !file.includes('jsapps/supportapp/src/__testsutils__/') && !file.includes('jsapps/supportapp/src/_actions/') && !file.includes('jsapps/supportapp/src/_doubts/') && !file.includes('jsapps/supportapp/src/_integration/') && !file.includes('jsapps/supportapp/src/_middleware/') && !file.includes('jsapps/supportapp/src/_pubSub/') && !file.includes('jsapps/supportapp/src/_reducers/') && !file.includes('jsapps/supportapp/src/_selectors/') && !file.includes('jsapps/supportapp/src/_store/') && !file.includes('jsapps/supportapp/src/_url/') && !file.includes('jsapps/supportapp/src/_utils/') && !file.includes('.docs.js') && !file.includes('.spec.js') && !file.includes('.specs.js') && !file.includes('.test.js');
+}
+module.exports = {
+  filterStagedFilesError,
+  allowedFiles
+};

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

@@ -0,0 +1,235 @@
+"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');
+
+/**
+ * @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(stderr.trim().split('\n'));
+      } else if (stdout.trim() === '') {
+        resolve(stdout.trim());
+      }
+    });
+  });
+}
+
+/**
+ * @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 {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()}`);
+  try {
+    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 areFilesStaged = 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 = [];
+            if (path.extname(staged_files[file]) === '.js') {
+              try {
+                let eslintErrorsInFile = await findEslintErrors(staged_files[file]);
+                if (staged_files[file] && typeof staged_files[file] == 'string') {
+                  if (!eslintErrorsInFile.length == 0) {
+                    //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 = [];
+
+                    //Calculating changed lines in a file and storing them in respective arrays
+                    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) {
+                      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`);
+                      }
+                      hasEslintErrorsInChangedLines = 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 (hasEslintErrorsInChangedLines) {
+        Logger.log(Logger.FAILURE_TYPE, `There are eslint errors present. So commit is aborted`);
+        process.exit(1);
+      } else if (!hasEslintErrorsInChangedLines && areFilesStaged) {
+        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);
+    }
+  }
+}
+preCommitHook();

package/build/lib/cli.js

@@ -0,0 +1,47 @@
+"use strict";
+
+const {
+  setupHusky
+} = require("../utils/HuskySetup/setupHusky");
+const {
+  initialSetup
+} = require("../setup/initialSetup");
+const {
+  executeMethodsThatReturnBooleanValue
+} = require("../utils/General/wrapperFunctionToExecuteAFunction");
+const {
+  installEslintExtension
+} = require("../utils/ExtensionInstallation/installEslintExtension");
+const {
+  installPlugins
+} = require("../utils/PluginsInstallation/installPlugins");
+const [,, action, ...options] = process.argv;
+async function run() {
+  switch (action) {
+    case "setup":
+      {
+        await executeMethodsThatReturnBooleanValue("Some issue occurred in setting up husky.", setupHusky, null);
+        break;
+      }
+    case "init":
+      {
+        initialSetup();
+        break;
+      }
+    case "setupPlugins":
+      {
+        await executeMethodsThatReturnBooleanValue("Some issue occurred in installing plugins", installPlugins, null);
+        break;
+      }
+    case "setupExtension":
+      {
+        await executeMethodsThatReturnBooleanValue("Kindly install eslint extension for Vscode manually.", installEslintExtension, null);
+        break;
+      }
+    default:
+      {
+        break;
+      }
+  }
+}
+run();

package/build/lib/postinstall.js

@@ -0,0 +1,44 @@
+"use strict";
+
+const {
+  cloneViaCdt
+} = require("../utils/CloneCommonLinterRepo/cloneViaCdt");
+const {
+  setupHusky
+} = require("../utils/HuskySetup/setupHusky");
+const {
+  createEslintConfigFile
+} = require("../utils/EslintConfigFileUtils/createEslintConfigFile");
+const {
+  Logger
+} = require("../utils/Logger/Logger");
+const {
+  executeMethodsThatReturnBooleanValue
+} = require("../utils/General/wrapperFunctionToExecuteAFunction");
+const {
+  arePluginsInstalled
+} = require("../utils/PluginsInstallation/arePluginsInstalled");
+const {
+  isGitInitialized
+} = require("../utils/GitActions/gitActions");
+const {
+  writeFsPaths
+} = require("../utils/General/writeProjectDetailsToJson");
+
+/**
+ *  @function {postInstall} -  This methods setup husky and configuration for executing project
+ *  @returns {void}
+ */
+async function postInstall() {
+  try {
+    await executeMethodsThatReturnBooleanValue("Some issue in writing node_modules path to json", writeFsPaths, null);
+    isGitInitialized() ? await executeMethodsThatReturnBooleanValue("Some issue occurred in setting up husky.", setupHusky, null) : null;
+    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 successful");
+    arePluginsInstalled();
+  } catch (error) {
+    Logger.log(Logger.FAILURE_TYPE, `Kindly retry npm install. & ${error.message}`);
+  }
+}
+postInstall();

package/build/setup/initialSetup.js

@@ -0,0 +1,60 @@
+"use strict";
+
+const {
+  existsSync,
+  writeFileSync
+} = require("fs");
+const path = require("path");
+const {
+  Logger
+} = require("../utils/Logger/Logger");
+
+/**
+ * @function initialSetup -  Initialize prerequisite setup For Library
+ * @requires {void} 
+ */
+
+function initialSetup() {
+  const package_json_path = path.resolve(process.cwd(), "package.json");
+  updatePackageJSON(package_json_path, 'scripts', getSetupScript());
+}
+
+/**
+ * @function {getSetupScript} - get setup commands 
+ * @returns  {JSON | Object}  - returns script command as key and value as executable command
+ */
+
+function getSetupScript() {
+  return {
+    installRulePlugins: "ZDPrecommit setupPlugins",
+    setupVSCodeExtension: "ZDPrecommit setupExtension"
+  };
+}
+
+/**
+ * @function {updatePackageJSON} -  method is updated scripts in package.json
+ * @param {string} packageJsonPath - path of package.json
+ * @param {string | Object} partToUpdate - param passed which part of package.json to update
+ * @param {string} updateObject - script to be updated in package.json
+ * @returns {void} 
+ */
+function updatePackageJSON(packageJsonPath, partToUpdate, updateObject) {
+  if (existsSync(packageJsonPath)) {
+    const packageContents = require(packageJsonPath);
+    const existingJSON = packageContents[partToUpdate] || {};
+    const modifiedScripts = {
+      ...existingJSON,
+      ...updateObject
+    };
+    const modifiedConfigJSON = {
+      ...packageContents,
+      scripts: modifiedScripts
+    };
+    writeFileSync(packageJsonPath, JSON.stringify(modifiedConfigJSON, null, 2));
+  } else {
+    Logger.log(Logger.FAILURE_TYPE, "Unable to find package json. Run init command in the root path of the project.");
+  }
+}
+module.exports = {
+  initialSetup
+};

package/build/utils/CloneCommonLinterRepo/HelperFunctions/helpers.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const path = require('path');
+const {
+  getLibraryInstalledLocation
+} = require('../../General/getLibraryInstalledLocation');
+const {
+  commonLinterRepoName
+} = require('../../../../jsonUtils/commonLinterRepoDetails');
+function getClonedDirPath() {
+  return getLibraryInstalledLocation();
+}
+function getDeleteDirPath() {
+  return path.resolve(getLibraryInstalledLocation(), commonLinterRepoName);
+}
+module.exports = {
+  getClonedDirPath,
+  getDeleteDirPath
+};

package/build/utils/CloneCommonLinterRepo/cloneViaCdt.js

@@ -0,0 +1,41 @@
+"use strict";
+
+const {
+  execSync
+} = require("child_process");
+const {
+  getClonedDirPath,
+  getDeleteDirPath
+} = require('./HelperFunctions/helpers');
+const {
+  getRepoName
+} = require("../GitActions/gitActions");
+const {
+  removeFolder
+} = require("../FileAndFolderOperations/removeFolder");
+const {
+  executeSynchronizedCommands
+} = require('../General/executeSyncCommands');
+const {
+  type,
+  endPoint,
+  branch,
+  cacheDirectory,
+  commonLinterRepoName
+} = require('../../../jsonUtils/commonLinterRepoDetails');
+/**
+ * @function cloneViaCdt - Using the "clint development tool" clones the common linter_configuration repo into precommit library
+ * @returns {boolean} - indicating the success or failure of the cloning process
+ */
+
+function cloneViaCdt() {
+  removeFolder(getDeleteDirPath());
+  const commandToCloneCommonConfigRepo = `npx cdt clone --clone:type=${type} --clone:url=${endPoint} --clone:branch=${branch} --clone:cacheDir=${cacheDirectory} --clone:proj:name=${commonLinterRepoName}`;
+  let isCommonConfigurationClonedSuccessfully = executeSynchronizedCommands(execSync, [commandToCloneCommonConfigRepo, {
+    cwd: getClonedDirPath()
+  }], `Lint Configuration Cloned Successfully - ${getRepoName() || 'common'}`, 'Could not clone the linters common repo', false, true);
+  return isCommonConfigurationClonedSuccessfully;
+}
+module.exports = {
+  cloneViaCdt
+};

package/build/utils/EslintConfigFileUtils/createEslintConfigFile.js

@@ -0,0 +1,54 @@
+"use strict";
+
+const path = require('path');
+const {
+  writeFileSync,
+  existsSync,
+  unlinkSync,
+  readFileSync
+} = require('fs');
+const {
+  getNodeModulesPath
+} = require('../General/getNodeModulesPath.js');
+const {
+  Logger
+} = require('../Logger/Logger.js');
+const {
+  executeSynchronizedCommands
+} = require('../General/executeSyncCommands.js');
+const {
+  getServicePathElseCommon
+} = require('./getLintConfiguration.js');
+let eslintConfiguration = ``;
+
+/**
+ * @function createEslintConfigFile - creates a eslint configuration file based on the configuration file in the common linters repo
+ * @returns {boolean} - indicating the success or failure in creating the eslint configuration file
+ */
+function createEslintConfigFile() {
+  const eslintConfigFilePath = path.join(getNodeModulesPath(), '.eslintrc.js');
+  const {
+    pathOfServiceSpecificEslintConfigFile
+  } = getServicePathElseCommon();
+  eslintConfiguration = executeSynchronizedCommands(readFileSync, [pathOfServiceSpecificEslintConfigFile, 'utf-8'], '', 'Unable to read content of eslint config file.', true, false);
+  try {
+    let isEslintConfigFilePresent = existsSync(eslintConfigFilePath);
+    if (isEslintConfigFilePresent) {
+      executeSynchronizedCommands(unlinkSync, [eslintConfigFilePath], 'Eslint configuration file removed successfully!', 'Unable to remove the eslint config file.', false, false);
+      return createEslintConfigurationFile();
+    } else if (!isEslintConfigFilePresent) {
+      return createEslintConfigurationFile();
+    }
+  } catch (error) {
+    Logger.log(Logger.FAILURE_TYPE, error);
+    Logger.log(Logger.FAILURE_TYPE, 'Issue occured while checking if eslint config file exists');
+  }
+}
+function createEslintConfigurationFile() {
+  const eslintConfigFilePath = path.join(getNodeModulesPath(), '.eslintrc.js');
+  let isEslintConfigFileCreated = executeSynchronizedCommands(writeFileSync, [eslintConfigFilePath, eslintConfiguration, 'utf-8'], 'Eslint configuration file created successfully!', 'Unable to create and write an eslint configuration file.', false, true);
+  return isEslintConfigFileCreated;
+}
+module.exports = {
+  createEslintConfigFile
+};

package/build/utils/EslintConfigFileUtils/getEslintExecutablePath.js

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