@sap/eslint-plugin-cds 2.2.1 → 2.2.2

package/lib/impl/ruleFactory.js

@@ -9,10 +9,15 @@
  *
  * Since we want to lint cds models without an AST, we adapted the context
  * object to explicitly pass some additional information:
- * - 'code':     code object based on ESLint getFromSourceCode()
- * - 'filePath': ESLint getFilename()
- * - 'model':    Loaded cds model (CSN)
- * - 'cds':      Proxy for cached cds calls
+ * - 'category'  : Rule category
+ * - 'cds'       : Proxy for cds object which also caches results
+ * - 'code'      : Code object based on ESLint getFromSourceCode()
+ * - 'ruleID'    : Rule ID ("@sap/cds/...")
+ * - 'filePath'  : ESLint's 'physical' filename
+ * - 'options'   : CDS Environment parameters
+ * - 'report'    : Proxy for ESLint's context.report() for lint filtering
+ * - 'ruleID'    : ESLint's rule ID
+ * - 'sourcecode': ESLint's SourceCode object
  *
  * @typedef { import('eslint').Rule.RuleModule } RuleModule
  * @typedef { import('eslint').Rule.RuleContext } RuleContext
@@ -23,297 +28,284 @@
  * @typedef { import("./types").CDSRuleTestOpts } CDSRuleTestOpts
  */
 
- const fs = require("fs");
- const path = require("path");
- const { RuleTester, SourceCode } = require("eslint");
- const { isEditor, isValidFile, hasCompilationError, isTest } = require("./utils/helpers");
- const { isValidModel, isValidEnv, isValidRule } = require("./utils/validate");
- const { Cache, getAST, updateCache } = require("./utils/model");
- const { checkDisabled, getRules } = require("./utils/rules");
- const { customRulesDir, categories } = require("./constants");
- 
- /**
-  * Wrapper for ESLint's Rule creator:
-  * https://eslint.org/docs/developer-guide/working-with-rules
-  * - Must follow the ESLint prescribed convention for all rule exports
-  * - ESLint uses 'create' function to traverse its AST nodes
-  * - Since we do not work with an AST for cds models, a dummy 'Programm'
-  *   node is used as an entry point
-  * - For all ESLint rules, we have two entry points for additional checks:
-  *     1. Before ESLint's rule creation via create()
-  *        (see below)
-  *     2. Before ESLint's report via context.report()
-  *        (see getProxyReport())
-  * @param {CDSRuleSpec} spec
-  * @returns {RuleModule}
-  */
- function createRule(spec) {
-   const { meta, create } = spec;
-   if (!meta.type) meta.type = "problem";
-   if (meta.docs && !meta.docs.category) meta.docs.category = categories["model"];
-   return {
-     meta,
-     create: function (context) {
-       return {
-         Program: function (node) {
-           // --- Checks before create() ---
-           // If plugin rules have been loaded
-           if (Cache.has("rulesInfo")) {
-             let { listEnvRules, listModelRules, listRules } = Cache.get("rulesInfo");
-             let cdscontext = createCDSContext(context, node, listEnvRules, listModelRules, listRules);
- 
-             // If file has plugin's allowed extension or a valid environment
-             if (isValidFile(cdscontext.filePath) || isValidEnv(cdscontext.options)) {
-               cdscontext = updateCache(cdscontext);
- 
-               // If rule has not already been evaluated for this model
-               if (!Cache.get(`done:${cdscontext.configPath}:${cdscontext.ruleID}` === cdscontext.filePath)) {
-                 let customRulesPath = path.join(Cache.get(`configpath`), customRulesDir, "rules");
-                 const stats = fs.statSync(Cache.get("configpath"));
-                 if (stats.isFile()) {
-                   customRulesPath = path.join(Cache.get('projectpath'), customRulesDir, "rules");
-                 }
-                 let customRulesInfo;
-                 if (fs.existsSync(customRulesPath)) {
-                   customRulesInfo = getRules(customRulesPath);
-                   listEnvRules = listEnvRules.concat(customRulesInfo.listEnvRules);
-                   listModelRules = listModelRules.concat(customRulesInfo.listModelRules);
-                 }
- 
-                 // If valid rule and model/env
-                 if (
-                   isValidRule(cdscontext, listEnvRules) ||
-                   (isValidRule(cdscontext, listModelRules) &&
-                     isValidModel(cdscontext) &&
-                     !hasCompilationError(cdscontext))
-                 ) {
-                   create(cdscontext);
-                   Cache.set(`done:${cdscontext.configPath}:${cdscontext.ruleID}`, cdscontext.filePath);
- 
-                 // If compilation error (only shown on console, not in editor)
-                 } else if (hasCompilationError(cdscontext) && !isEditor()) {
-                   create(cdscontext);
-                 }
-               }
-             }
-           }
-         },
-       };
-     },
-   };
- }
- 
- /**
-  * Generates proxy for ESLint's context object which adds caching
-  * @param obj ESLint's context object
-  * @returns Proxy for cds
-  */
- function getProxyReport(obj) {
-   const handler = {
-     get(target, prop, receiver) {
-       const value = Reflect.get(target, prop, receiver);
-       if (typeof value !== "object") {
-         return value;
-       }
-       /* eslint no-extra-boolean-cast: "off" */
-       if (!!value) {
-         return new Proxy(value, handler);
-       }
-       return {
-         err: `Property ${prop} prop does not exist on object ${obj}!`,
-       };
-     },
-     apply(target, thisArg, argumentsList) {
-       let report = false;
-       if (argumentsList.length > 0) {
-         argumentsList.forEach((lint) => {
-           if (lint) {
-             // --- Checks before context.report() ---
-             let { listEnvRules, listModelRules, listRules } = Cache.get("rulesInfo");
- 
-             // If rule/loc not disabled by ESLint disable comment
-             if (!checkDisabled(lint, thisArg, listRules, listEnvRules, listModelRules)) {
-               const fileRel = lint.file;
-               let fileAbs = lint.file || "";
-               if (!path.isAbsolute(fileAbs)) {
-                 fileAbs = fileRel ? path.join(Cache.get("configpath"), fileRel) : "";
-               }
-               const stats = fs.statSync(Cache.get("configpath"));
-               if (stats.isFile()) {
-                 fileAbs = Cache.get("configpath");
-               }
-               
-               // If environment rule, only report once per configPath
-               if (
-                 listEnvRules.includes(thisArg.ruleID) ||
-                 listEnvRules.includes(thisArg.ruleID.replace("@sap/cds/", ""))
-               ) {
-                 if (!isEditor()) {
-                   if (!Cache.has(`envChecks:${thisArg.configPath}`)) {
-                     report = true;
-                     Cache.set(`envChecks:${thisArg.configPath}`, [lint.message]);
-                   } else if (
-                     Cache.has(`envChecks:${thisArg.configPath}`) &&
-                     !Cache.get(`envChecks:${thisArg.configPath}`).includes(lint.message)
-                   ) {
-                     report = true;
-                     Cache.set(`envChecks:${thisArg.configPath}`, [lint.message]);
-                   }
-                 }
- 
-                 // If model rules, only report if file matches that of report
-               } else if (
-                 fileAbs === thisArg.filePath ||
-                 fileAbs === thisArg.configPath ||
-                 fileRel === "<stdin>.cds" ||
-                 isTest()
-               ) {
-                 report = true;
-               }
-               if (report) {
-                 return thisArg._context.report(lint);
-               }
-             }
-           }
-         });
-       }
-     },
-   };
-   return new Proxy(obj, handler);
- }
- 
- /**
-  * Experimental wrapper for 'createRule' to yield:
-  * - More eslint-like API
-  * - More convenience re error reports
-  * @param {CDSRuleSpec} spec
-  * @returns {RuleModule}
-  */
- function defineRule(spec) {
-   const { meta, create } = spec;
-   if (!meta.type) meta.type = "problem";
-   if (meta.docs && !meta.docs.category) meta.docs.category = "Model Validation";
-   return createRule({
-     meta,
-     create: (context) => {
-       const { cds, report } = context;
-       const handlers = create({
-         cds,
-         model: cds.model,
-         report: (r) => report(r),
-       });
-       if (cds.model) {
-         cds.model.forall((d) => {
-           for (let each in handlers)
-             if (d.is(each)) {
-               let r = handlers[each](d);
-               if (r) {
-                 if (typeof r === "string") r = { message: r };
-                 if (!r.loc) r.loc = cds.getLocation(d.name, d);
-                 if (!r.file) r.file = (d.$location && d.$location.file) || "unknown.cds";
-                 context.report(r);
-               }
-             }
-         });
-       }
-     },
-   });
- }
- 
- /**
-  * Expands CDS context object with some CDS properties
-  * We also retrieve the file contents cached by the preprocessor
-  * @param {RuleContext} context
-  * @param {RuleNode} node
-  * @returns cdscontext
-  */
- function createCDSContext(context, node, envRules, modelRules, rules) {
-   let sourcecode = context.getSourceCode();
-   let code = sourcecode.getText(node);
-   if (!code) {
-     code = Cache.get(`processed:${context.getPhysicalFilename()}`);
-   }
-   if (code) {
-     sourcecode = new SourceCode(code, getAST(code));
-   }
-   return {
-     _context: context,
-     ...context,
-     cds: context.parserServices.cdsProxy || Cache.get("cds"),
-     configPath: Cache.get("configpath"),
-     code,
-     filePath: context.getPhysicalFilename(),
-     options: context.options,
-     ruleID: context.id,
-     sourcecode,
-     envRules,
-     modelRules,
-     node,
-     rules,
-     report: getProxyReport(context.report),
-   };
- }
- 
- /**
-  * ESLint RuleTester (used by custom rule creator api)
-  * Calls ESLint's RuleTester with custom cds parser and input for
-  * valid/invalid checks:
-  * Model checks require input 'code' entries
-  * Env checks require input 'options' with selected parameters
-  * @param {CDSRuleTestOpts} options RuleTester input options
-  * @returns RuleTester results
-  */
- function runRuleTester(options) {
-   let parser;
-   let rule = {};
-   const rulename = path.basename(options.root);
-   const plugin = "eslint-plugin-cds";
-   if (options.root.includes(plugin)) {
-     // For plugin's internal tests, resolve parser from here
-     parser = require.resolve("./parser");
-     rule = require(`./rules/${path.basename(options.root)}`);
-     Cache.set("rulesInfo", getRules(path.join(path.dirname(options.root), "../../lib/impl/rules")));
-   } else {
-     // Otherwise from project root
-     const resolvedPlugin = require.resolve("@sap/eslint-plugin-cds", {
-       paths: [options.root],
-     });
-     parser = path.join(path.dirname(resolvedPlugin), "parser");
-     rule = require(path.join(options.root, `../../rules/${path.basename(options.root)}`));
-     Cache.set("rulesInfo", getRules(path.join(options.root, "../../rules")));
-   }
-   let category = categories["model"];
-   if (rule.meta) {
-     category = rule.meta.docs.category;
-   }
-   let tester = new RuleTester({});
-   if (parser) {
-     tester = new RuleTester({ parser });
-   }
-   const testerCases = {};
-   ["valid", "invalid"].forEach((type) => {
-     const filePath = path.join(options.root, `${type}/${options.filename}`);
-     testerCases[type] = [
-       {
-         filename: filePath,
-       },
-     ];
-     if (category === "Environment") {
-       testerCases[type][0].code = "";
-       testerCases[type][0].options = [{ environment: JSON.parse(fs.readFileSync(filePath, "utf8")) }];
-     } else if (!category || category === categories.model) {
-       testerCases[type][0].code = fs.readFileSync(filePath, "utf8");
-     }
-     if (type === "invalid") {
-       testerCases[type][0].errors = options.errors;
-       const fileFixed = path.join(options.root, `fixed/${options.filename}`);
-       if (fs.existsSync(fileFixed)) {
-         testerCases[type][0].output = fs.readFileSync(fileFixed, "utf8");
-       }
-     }
-   });
-   return tester.run(rulename, rule, testerCases);
- }
- 
- module.exports = { createRule, defineRule, runRuleTester };
- 
+const fs = require("fs");
+const path = require("path");
+const { RuleTester, SourceCode } = require("eslint");
+const { isEditor, isValidFile, styleText } = require("./utils/helpers");
+const { isValidEnv, isValidModel } = require("./utils/validate");
+const {
+  Cache,
+  populateModelAndEnv,
+  hasCompilationError,
+  getAST,
+  loadConfigPath,
+} = require("./utils/model");
+const { isRuleDisabled, getRules, populateRules } = require("./utils/rules");
+const { customRulesDir, categories } = require("./constants");
+
+/**
+ * Wrapper for ESLint's Rule creator:
+ * https://eslint.org/docs/developer-guide/working-with-rules
+ * - Must follow the ESLint prescribed convention for all rule exports
+ * - ESLint uses 'create' function to traverse its AST nodes
+ * - Since we do not work with an AST for cds models, a dummy 'Programm'
+ *   node is used as an entry point
+ * - For all ESLint rules, we have two entry points for additional checks:
+ *     1. Before ESLint's rule creation via create()
+ *        (see below)
+ *     2. Before ESLint's report via context.report()
+ *        (see getProxyReport())
+ * @param {CDSRuleSpec} spec
+ * @returns {RuleModule}
+ */
+function createRule(spec) {
+  const { meta, create } = spec;
+  if (!meta.type) meta.type = "problem";
+  if (meta.docs && !meta.docs.category)
+    meta.docs.category = categories["model"];
+  return {
+    meta,
+    create: function (context) {
+      return {
+        Program: function (node) {
+          // --- Checks before create() ---
+          let cdscontext = createCDSContext(context, node, meta);
+          // 1. Is file exension allowed?
+          // (i.e. when using globs + other plugins)
+          if (
+            isValidFile(cdscontext.filePath) ||
+            meta.docs.category === categories["env"]
+          ) {
+            // Update model/env contents and rules (at runtime)
+            populateModelAndEnv(cdscontext);
+            populateRules(cdscontext, customRulesDir);
+            // 2. Is rule allowed and model/env valid?
+            if (isValidEnv(cdscontext) || isValidModel(cdscontext)) {
+              try {
+                create(cdscontext);
+              } catch (err) {
+                // Do not throw to avoid ESLint VSCode editor pop-ups
+                styleText(
+                  `Rule ${cdscontext.ruleID} has failed unexpectedly - please report this error!\n`,
+                  ["bold", "red"]
+                );
+              }
+              // Show compilation error only on console
+            } else if (hasCompilationError(cdscontext) && !isEditor()) {
+              create(cdscontext);
+            }
+          }
+        },
+      };
+    },
+  };
+}
+
+/**
+ * Experimental wrapper for 'createRule' to yield:
+ * - More eslint-like API
+ * - More convenience re error reports
+ * @param {CDSRuleSpec} spec
+ * @returns {RuleModule}
+ */
+function defineRule(spec) {
+  const { meta, create } = spec;
+  if (!meta.type) meta.type = "problem";
+  if (meta.docs && !meta.docs.category) meta.docs.category = "Model Validation";
+  return createRule({
+    meta,
+    create: (context) => {
+      const { cds, report } = context;
+      const handlers = create({
+        cds,
+        model: cds.model,
+        report: (r) => report(r),
+      });
+      if (cds.model) {
+        cds.model.forall((d) => {
+          for (let each in handlers)
+            if (d.is(each)) {
+              let r = handlers[each](d);
+              if (r) {
+                if (typeof r === "string") r = { message: r };
+                if (!r.loc) r.loc = cds.getLocation(d.name, d);
+                if (!r.file)
+                  r.file = (d.$location && d.$location.file) || "unknown.cds";
+                context.report(r);
+              }
+            }
+        });
+      }
+    },
+  });
+}
+
+/**
+ * Generates proxy for ESLint's context object which adds caching
+ * @param obj ESLint's context object
+ * @returns Proxy for cds
+ */
+function getProxyReport(obj) {
+  const handler = {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value !== "object") {
+        return value;
+      }
+      /* eslint no-extra-boolean-cast: "off" */
+      if (!!value) {
+        return new Proxy(value, handler);
+      }
+      return {
+        err: `Property ${prop} prop does not exist on object ${obj}!`,
+      };
+    },
+    apply(target, thisArg, argumentsList) {
+      let report = false;
+      if (argumentsList.length > 0) {
+        argumentsList.forEach((lint) => {
+          if (lint) {
+            // --- Checks before context.report() ---
+            // 1. Is lint (loc) not disabled by ESLint disable comments?
+            if (!isRuleDisabled(lint, thisArg)) {
+              const fileRel = lint.file;
+              let fileAbs = lint.file || "";
+              if (!path.isAbsolute(fileAbs)) {
+                fileAbs = fileRel
+                  ? path.join(Cache.get("configpath"), fileRel)
+                  : "";
+              }
+              // Only show 'env' lints on console
+              if (thisArg.category === "env" && !isEditor()) {
+                lint["loc"] = {
+                  start: { line: 0, column: -1 },
+                  end: { line: 0, column: -1 },
+                };
+                report = true;
+                // Only show 'model' lints at corrsponding file
+              } else if (
+                fileAbs === thisArg.filePath ||
+                fileRel === "<stdin>.cds"
+              ) {
+                report = true;
+              }
+              if (report) {
+                return thisArg._context.report(lint);
+              }
+            }
+          }
+        });
+      }
+    },
+  };
+  return new Proxy(obj, handler);
+}
+
+/**
+ * Expands CDS context object with some CDS properties
+ * We also retrieve the file contents cached by the preprocessor
+ * @param {RuleContext} context
+ * @param {RuleNode} node
+ * @returns cdscontext
+ */
+function createCDSContext(context, node, meta) {
+  const filePath = context.getPhysicalFilename();
+  const configPath = loadConfigPath(filePath);
+  let category = "model";
+  if (meta.docs.category === categories["env"]) {
+    category = "env";
+  }
+  let sourcecode = context.getSourceCode();
+  let code = sourcecode.getText(node);
+  if (!code) {
+    code = Cache.get(`file:${context.getPhysicalFilename()}`);
+  }
+  if (code) {
+    sourcecode = new SourceCode(code, getAST(code));
+  }
+  return {
+    _context: context,
+    ...context,
+    category,
+    cds: context.parserServices.cdsProxy || Cache.get("cds"),
+    configPath,
+    code,
+    filePath,
+    options: context.options,
+    report: getProxyReport(context.report),
+    ruleID: context.id,
+    sourcecode,
+  };
+}
+
+/**
+ * ESLint RuleTester (used by custom rule creator api)
+ * Calls ESLint's RuleTester with custom cds parser and input for
+ * valid/invalid checks:
+ * Model checks require input 'code' entries
+ * Env checks require input 'options' with selected parameters
+ * @param {CDSRuleTestOpts} options RuleTester input options
+ * @returns RuleTester results
+ */
+function runRuleTester(options) {
+  process.env['RULE_TESTER'] = true;
+  let parser;
+  let rule = {};
+  const rulename = path.basename(options.root);
+  const plugin = "eslint-plugin-cds";
+  if (options.root.includes(plugin)) {
+    // For plugin's internal tests, resolve parser from here
+    parser = require.resolve("./parser");
+    rule = require(`./rules/${path.basename(options.root)}`);
+    Cache.set(
+      "rulesInfo",
+      getRules(path.join(path.dirname(options.root), "../../lib/impl/rules"))
+    );
+  } else {
+    // Otherwise from project root
+    const resolvedPlugin = require.resolve("@sap/eslint-plugin-cds", {
+      paths: [options.root],
+    });
+    parser = path.join(path.dirname(resolvedPlugin), "parser");
+    rule = require(path.join(
+      options.root,
+      `../../rules/${path.basename(options.root)}`
+    ));
+    Cache.set("rulesInfo", getRules(path.join(options.root, "../../rules")));
+  }
+  let category = categories["model"];
+  if (rule.meta) {
+    category = rule.meta.docs.category;
+  }
+  let tester = new RuleTester({});
+  if (parser) {
+    tester = new RuleTester({ parser });
+  }
+  const testerCases = {};
+  ["valid", "invalid"].forEach((type) => {
+    const filePath = path.join(options.root, `${type}/${options.filename}`);
+    testerCases[type] = [
+      {
+        filename: filePath,
+      },
+    ];
+    if (category === categories["env"]) {
+      testerCases[type][0].code = "";
+      testerCases[type][0].options = [
+        { environment: JSON.parse(fs.readFileSync(filePath, "utf8")) },
+      ];
+    } else if (!category || category === categories.model) {
+      testerCases[type][0].code = fs.readFileSync(filePath, "utf8");
+    }
+    if (type === "invalid") {
+      testerCases[type][0].errors = options.errors;
+      const fileFixed = path.join(options.root, `fixed/${options.filename}`);
+      if (fs.existsSync(fileFixed)) {
+        testerCases[type][0].output = fs.readFileSync(fileFixed, "utf8");
+      }
+    }
+  });
+  return tester.run(rulename, rule, testerCases);
+}
+
+module.exports = { createRule, defineRule, runRuleTester };