@sap/cds-dk 6.0.4 → 6.1.1

package/lib/lint/Linter.js

@@ -1,41 +1,37 @@
-const os = require("os");
-const fs = require("fs");
-const commandUtil = require("../init/util/commandUtil");
-const path = require("path");
-const glob = require("glob");
 const term = require("../util/term");
 
 const io = require("./io");
 const checks = require("./checks");
 const generators = require("./generators");
-const {
-  getConfigPath,
-  getFileExtensions,
-} = require("@sap/eslint-plugin-cds/lib/api");
 
-const IS_WIN = os.platform() === "win32";
-const ALLOWED_FILE_EXTENSIONS = getFileExtensions();
+const cds = require("../../lib/cds");
+const { path, exists, isdir, isfile, readdir } = cds.utils
+const { exit } = require("process");
+const LOG = cds.debug("lint");
+const LOG_CONFIG = cds.debug("lint:config");
 
 class Linter {
   constructor() {
     this.eslintCmd = "";
     this.eslintCmdShort = "eslint";
-    this.eslintCmdOpts = {};
-    this.eslintCmdOptsIndex = 0;
     this.eslintCmdFileExpr = "";
     this.isFile = false;
     this.help = "";
     this.debug = "";
     this.flags = [];
     this.configPath = "";
-    this.configGlobalPath = path.join(__dirname, ".eslintrc.js");
     this.configContents = {};
     this.projectPath = "";
     this.cdsdkPath = path.join(__dirname, "../..");
     this.globalPath = path.join(this.cdsdkPath, "../..");
     this.extendsPlugin = false;
+    this.fileExtensions = [];
     this.pluginPath = "";
+    this.pluginApi = {};
     this.lintType = "global";
+    this.ruleOpts = {};
+    this.customRulesOpts = [];
+    this.pluginRules = [];
     this.init = this.init.bind(this);
     this.lint = this.lint.bind(this);
   }
@@ -50,16 +46,11 @@ class Linter {
     if (this.eslintCmd) {
       help = generators.genEslintHelp(this.eslintCmd);
       flags = generators.genEslintFlags(help);
-      [help, options, shortcuts, flags] = generators.genEslintShortcutsAndOpts(
-        help,
-        flags
-      );
+      [help, options, shortcuts, flags] = generators.genEslintShortcutsAndOpts(help, flags);
       this.help = help;
       this.flags = flags;
     } else {
-      console.log(
-        `${term.error("Cannot call 'eslint -h', install and try again.")}\n`
-      );
+      console.log(`${term.error("Cannot call 'eslint -h', install and try again.")}\n`);
     }
     return { help, options, flags, shortcuts };
   }
@@ -72,30 +63,24 @@ class Linter {
    */
   async lint(args, options) {
     this.eslintCmdOpts = this._sanitizeUserOpts(options);
-    this.eslintCmdFileExpr = args.length ? args : ['.']
+    this.eslintCmdFileExpr = args.length ? args : ["."];
     if (this.eslintCmdOpts.help) {
       this._printHelp();
     } else {
       // Determine if case "local" or "global" and resolve plugin accordingly
       await this._getConfigFileAndSetProjectPath(args);
 
-      if (this.lintType === "local") {
-        await this._addRulePaths();
-      }
+      // Add custom rules
+      await this._addRulePaths();
 
-      if (this.lintType === "global") {
-        this._addConfig();
-        const overwriteRules = checks.hasEslintConfigContent(
-          this.configContents,
-          "rules"
-        );
-        if (overwriteRules) {
-          await this._overwriteRuleSeverities();
-        }
+      const overwriteRules = checks.hasEslintConfigContent(this.configContents, "rules");
+      if (overwriteRules) {
+        await this._overwriteRuleSeverities();
       }
 
       // Limit to CDS file extensions
       this._addExtensions();
+
       // Run ESLint with collected options
       try {
         await this._runEslint();
@@ -106,12 +91,7 @@ class Linter {
   }
 
   _printHelp() {
-    console.log(
-      this.help.replace(
-        / \*([^*]+)\*/g,
-        ` ${term.codes.bold}$1${term.codes.reset}`
-      )
-    );
+    console.log(this.help.replace(/ \*([^*]+)\*/g, ` ${term.codes.bold}$1${term.codes.reset}`));
     return;
   }
 
@@ -127,139 +107,146 @@ class Linter {
 
   async _addRulePaths() {
     const rulesPath = path.relative(".", ".eslint/rules");
-    if (fs.existsSync(rulesPath) && fs.statSync(rulesPath).isDirectory()) {
-      this.esllintCmdOpts = io.mergeWithUserOpts(
-        this.eslintCmdOpts,
-        "rulesdir",
-        path.relative(".", rulesPath)
-      );
+    if (await exists(rulesPath) && await isdir(rulesPath)) {
+      const opts = io.mergeWithUserOpts(this.eslintCmdOpts, "rulesdir", path.relative(".", rulesPath));
+      this.customRulesOpts = opts.rulesdir;
       await generators.genDocs(this.projectPath.replace(rulesPath, ""));
     }
     return;
   }
 
+  /**
+   * Searches for ESLint config file types (in order or precedence)
+   * and returns corresponding directory (usually project's root dir)
+   * https://eslint.org/docs/user-guide/configuring#configuration-file-formats
+   * @param {string} currentDir start here and search until root dir
+   * @returns {string} dir containing ESLint config file (empty if not exists)
+   */
+  async _getConfigPath(currentDir = ".") {
+    const configFiles = [
+      ".eslintrc.js",
+      ".eslintrc.cjs",
+      ".eslintrc.yaml",
+      ".eslintrc.yml",
+      ".eslintrc.json",
+      ".eslintrc",
+      "package.json",
+    ];
+    let configDir = path.resolve(currentDir);
+    while (configDir !== path.resolve(configDir, "..")) {
+      for (let i = 0; i < configFiles.length; i++) {
+        const configPath = path.join(configDir, configFiles[i]);
+        if (await exists(configPath) && await isfile(configPath)) {
+          return configPath;
+        }
+      }
+      configDir = path.join(configDir, "..");
+    }
+    return "";
+  }
+
   _addExtensions() {
     // Add CDS file extensions to lint
-    const extensions = ALLOWED_FILE_EXTENSIONS.map((ext) => path.extname(ext));
-    this.eslintCmdOpts = io.mergeWithUserOpts(
-      this.eslintCmdOpts,
-      "ext",
-      extensions.join(',')
-    );
-    // Enable colored output
-    this.eslintCmdOpts = io.mergeWithUserOpts(this.eslintCmdOpts, "color");
+    this.fileExtensions = this.pluginApi.getFileExtensions().map((ext) => path.extname(ext));
+    // Only lint file extensions prescribed by plugin
+    this.ignorePatterns = [];
+    this.fileExtensions.forEach((ext) => {
+      this.ignorePatterns.push(`!${ext}`);
+    });
     return;
   }
 
-  async _runEslint(dryRun = false) {
-    const eslintCmdOpts = [];
-    // Collect cmd line options
+  async _runEslint() {
     try {
-      for (let key in this.eslintCmdOpts) {
-        let value = this.eslintCmdOpts[key];
-        if (this.flags.includes(`--${key}`)) {
-          eslintCmdOpts.push(`--${key}`);
-        } else {
-          if (value) {
-            eslintCmdOpts.push(`--${key}`);
-            // Always quote args which are not paths
-            if (!fs.existsSync(value)) {
-              eslintCmdOpts.push(`"${value}"`);
-              // Paths are quoted according on os
-            } else {
-              if (IS_WIN) {
-                eslintCmdOpts.push(`"${value}"`);
-              } else {
-                eslintCmdOpts.push(value);
-              }
-            }
-          }
-        }
-      }
-      // Only lint file extensions prescribed by plugin
-      eslintCmdOpts.push("--ignore-pattern");
-      let ignorePattern = "*.*";
-      if (IS_WIN) {
-        ignorePattern = `"${ignorePattern}"`;
-      } else {
-        ignorePattern = `'${ignorePattern}'`;
+      const currentDir = process.cwd();
+
+      const { ESLint } = require("eslint");
+
+      let eslintOpts = {
+        cwd: currentDir,
+        extensions: this.fileExtensions,
+        overrideConfig: {
+          ...this.configContents,
+        },
+        useEslintrc: false,
+      };
+
+      if (this.lintType === "global") {
+        eslintOpts = {
+          cwd: process.cwd(),
+          extensions: this.fileExtensions,
+          overrideConfig: {
+            plugins: ["@sap/eslint-plugin-cds"],
+            extends: "plugin:@sap/cds/recommended"
+          },
+          useEslintrc: false,
+          resolvePluginsRelativeTo: this.cdsdkPath
+        };
       }
-      eslintCmdOpts.push(ignorePattern);
-      ALLOWED_FILE_EXTENSIONS.forEach((ext) => {
-        eslintCmdOpts.push("--ignore-pattern");
-        ignorePattern = `!${ext}`;
-        if (IS_WIN) {
-          ignorePattern = `"${ignorePattern}"`;
-        } else {
-          ignorePattern = `'${ignorePattern}'`;
-        }
-        eslintCmdOpts.push(ignorePattern);
-      });
-      let input = "";
-      if (IS_WIN) {
-        // Braucht es diese unterscheidung wirklich? Unterstützt Windows nicht auch single quotes?
-        input = `"${this.eslintCmdFileExpr.join('" "')}"`;
-      } else {
-        input = `'${this.eslintCmdFileExpr.join("' '")}'`;
+
+      if (this.customRulesOpts && this.customRulesOpts.length > 0) {
+        eslintOpts.rulePaths = [this.customRulesOpts]
       }
-      // Run ESLint with given cmd line options
-      // - Show 'eslint' instead of actual eslint cmd ('node .../.eslint.js')
-      // - Remove debug flag for printed cmd line
-      if (this.eslintCmdOpts.debug) {
-        eslintCmdOpts.splice(eslintCmdOpts.indexOf('--debug'), 1);
-        console.log(
-          `Linting:\n ${term.info(`eslint ${eslintCmdOpts.concat(input).join(' ')}`)}\n`
-        );
-        eslintCmdOpts.push('--debug');
+
+      LOG_CONFIG && LOG_CONFIG(eslintOpts);
+
+      let lintString = `eslint`;
+      if (this.fileExtensions) { lintString += ` --ext "${this.fileExtensions.join(",")}"`};
+      for (const ruleOpt of Object.entries(this.ruleOpts)) {
+        lintString += ` --rule ${ruleOpt[0]}:${ruleOpt[1]}`;
       }
-      if (!dryRun) {
-        return commandUtil.spawnCommand(this.eslintCmd, eslintCmdOpts.concat(input), {
-          cwd: process.cwd(),
-          shell: true,
-          stdio: process.env.NODE_ENV === 'test' ? 'pipe' : 'inherit',
-        });
-      } else {
-        return Promise.resolve("");
+      if (this.customRulesOpts && this.customRulesOpts.length > 0) {
+        lintString += ` --rulesdir "${this.customRulesOpts}"`
+      };
+
+      LOG && LOG(lintString);
+
+      if (!process.env.isTest) {
+        const eslint = new ESLint(eslintOpts);
+        const formatter = await eslint.loadFormatter("stylish");
+
+        let results = (await eslint.lintText("")).map((result) => {
+          result.filePath = path.resolve(currentDir);
+          return result;
+        }).filter(result => result.messages.length > 0);
+
+        const files = await readdir(currentDir);
+        const hasFiles = files.some(file => isfile(file));
+        if (hasFiles) {
+          const resultsModel = await eslint.lintFiles(this.eslintCmdFileExpr);
+          results = results.concat(resultsModel);
+        }
+
+        if (results && results.length > 0) {
+          console.log(formatter.format(results));
+        }
       }
     } catch (err) {
-      return Promise.resolve(err);
+      console.log(err);
+      exit(1)
     }
   }
 
-  _addConfig() {
-    this.esllintCmdOpts = io.mergeWithUserOpts(
-      this.eslintCmdOpts,
-      "config",
-      path.relative(".", this.configGlobalPath)
-    );
-    return;
-  }
-
   async _getConfigFileAndSetProjectPath(args) {
     let input;
-    // Only resolve the first input argument
-    //
+    // Get config path
     if (args.length > 0) {
-      let stats;
-      try {
-        stats = fs.statSync(args[0]);
-      } catch (err) {
-        // Do nothing
-      }
-      if (
-        args[0] === "." ||
-        (stats && (stats.isFile() || stats.isDirectory()))
-      ) {
+      const firstArg = args[0];
+      if (firstArg === "." || (isfile(firstArg) || isdir(firstArg))) {
         this.isFile = true;
       }
-      input = glob.sync(args[0])[0];
+      input = args.join(" ");
+      if (!input) {
+        input = ".";
+      }
     }
-    this.configPath = getConfigPath(input);
+    this.configPath = await this._getConfigPath(process.cwd());
     if (!this.configPath) {
-      this.configPath = this.configGlobalPath;
       this.lintType === "global";
+      this.configContents = await io.sanitizeEslintConfig({}, false, LOG);
     } else {
-      this.configContents = await io.readEslintConfig(this.configPath);
+      const configContents = await io.readEslintConfig(this.configPath);
+      this.configContents = await io.sanitizeEslintConfig(configContents, false, LOG);
       if (this.configContents) {
         if ("extends" in this.configContents) {
           this.extendsPlugin = checks.hasEslintConfigContent(
@@ -268,9 +255,14 @@ class Linter {
           );
           if (this.extendsPlugin) {
             this.lintType = "local";
-            this.pluginPath = require.resolve("@sap/eslint-plugin-cds", {
-              paths: [path.dirname(this.configPath)],
-            });
+            try {
+              this.pluginPath = require.resolve("@sap/eslint-plugin-cds", {
+                paths: [path.dirname(this.configPath)],
+              });
+            } catch (err) {
+              // Do nothing
+            }
+            this.pluginApi = require(this.pluginPath.replace("index.js", "api"));
           }
         }
       }
@@ -279,6 +271,7 @@ class Linter {
       this.pluginPath = require.resolve("@sap/eslint-plugin-cds", {
         paths: [this.cdsdkPath],
       });
+      this.pluginApi = require(this.pluginPath.replace("index.js", "api"));
     }
     // Project path is directory of ESLint config file
     this.projectPath = path.dirname(this.configPath);
@@ -286,21 +279,25 @@ class Linter {
   }
 
   async _overwriteRuleSeverities() {
-    let configContents = (await io.readEslintConfig(this.configPath)) || {};
+    let configContents = {};
+    if (this.configPath) {
+      configContents = await io.readEslintConfig(this.configPath);
+    } else {
+      configContents = await io.readEslintConfig(await this._getConfigPath(this.cdsdkPath));
+    }
     let rules = configContents.rules;
     // Allow recommended plugin rules in cds-dk to be overwritten
     // by user by adding rule to cmd line (because of precedence)
-    const pluginRules = require(this.pluginPath).rules;
+    const pluginRules = require(this.pluginPath).configs.recommended.rules;
     if (rules && pluginRules) {
-      Object.keys(rules).forEach((rule) => {
-        if (Object.keys(pluginRules).includes(rule.replace("@sap/cds/", ""))) {
-          this.esllintCmdOpts = io.mergeWithUserOpts(
-            this.eslintCmdOpts,
-            "rule",
-            `${rule}:${rules[rule]}`
-          );
+      for (const rule of Object.keys(rules)) {
+        if (typeof rules[rule] !== "undefined" && rules[rule] != pluginRules[rule] ||
+          isfile(path.relative(".", ".eslint", "rules", rule))) {
+          pluginRules[rule] = rules[rule];
+          this.ruleOpts[rule] = rules[rule];
+          this.pluginRules = pluginRules;
         }
-      });
+      }
     }
     return;
   }

package/lib/lint/io.js

@@ -58,10 +58,16 @@ module.exports = {
    * @param {*} configPath ESLint config file
    * @returns {void}
    */
-  async sanitizeEslintConfig(configPath, customRuleExample = false, logger = console) {
+  async sanitizeEslintConfig(configIn, customRuleExample = false, logger = console) {
     let configContents = {};
-    if (await fsUtil.pathExists(configPath)) {
-      configContents = (await this.readEslintConfig(configPath)) || {};
+    const isFilePath = typeof configIn === "string";
+    if (isFilePath) {
+      if (await fsUtil.pathExists(configIn)) {
+        console.log('+++', configIn)
+        configContents = (await this.readEslintConfig(configIn)) || {};
+      }
+    } else {
+      configContents = { ...configIn };
     }
     const configType = "recommended";
     const extendsValue = `plugin:@sap/cds/${configType}`;
@@ -90,8 +96,10 @@ module.exports = {
         configContents["rules"] = { [ruleName]: ruleValue };
       }
     }
-    await this.writeEslintConfig(configPath, configContents, logger);
-    return;
+    if (isFilePath) {
+      await this.writeEslintConfig(configIn, configContents, logger);
+    }
+    return configContents;
   },
 
   /**