@sap/eslint-plugin-cds 2.1.1 → 2.3.2

package/lib/impl/ruleFactory.js

@@ -3,304 +3,283 @@
  * https://eslint.org/docs/developer-guide/working-with-rules
  *
  * Each ESLint rule module must be composed of a 'meta', 'create' object:
- * - 'meta': meta data for rule (docs, fixable, etc.)
- * - 'create': ingests rule context and returns object with nodes to visit
- *             while traversing the AST
+ * - 'meta':     meta data for rule (docs, fixable, etc.)
+ * - 'create':   ingests rule context and returns object with nodes to visit
+ *               while traversing the AST
  *
- * Since for the cds we want to lint without an AST, we simplified the context
- * object to explicitly pass a subset of ESLint's context arguments:
- * - 'code': code object based on ESLint getFromSourceCode()
- * - 'filePath': ESLint getFilename()
- * We add two custom properties to aid in model rule creation:
- * - 'model': Loaded cds model (CSN)
- * - 'cds': Proxy for cached cds calls
+ * Since we want to lint cds models without an AST, we adapted the context
+ * object to explicitly pass some additional information:
+ * - '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
+ * @typedef { import('eslint').Rule.Node } RuleNode
+ * @typedef { import("./types").CDSRuleSpec } CDSRuleSpec
+ * @typedef { import("./types").CDSRuleMetaData } CDSRuleMetaData
+ * @typedef { import("./types").CDSRuleContext } CDSRuleContext
+ * @typedef { import("./types").CDSRuleTestOpts } CDSRuleTestOpts
  */
 
 const fs = require("fs");
 const path = require("path");
-const { RuleTester } = require("eslint");
-const { isEditor } = require("./utils/helpers");
-const { Cache, getConfigPath, getSourcecode, loadModel, updateModel, updateConfigPath } = require("./utils/model");
-const { getFileExtensions, getDisabledFromComments, getEnvRules, getModelRules } = require("./utils/rules");
-const envRules = getEnvRules(path.join(__dirname, "rules"));
-const modelRules = getModelRules(path.join(__dirname, "rules"));
-const rules = envRules.concat(modelRules).map((rule) => `@sap/cds/${rule}`);
-
-const CONSTANTS = require("./constants");
-
-// Types:
-// Interface CDSRuleMetaData extends Rule.RuleMetaData {
-//      docs?: Rule.RuleMetaData['docs'] & {
-//          version?: string;
-//      }
-//  }
-// Interface CDSRuleContext {
-//      (cds: any,
-//          context: Rule.RuleContext,
-//          node: Rule.Node): Rule.ReportDescriptor[]
-//  }
-// CDSReport = Rule.ReportDescriptor & { file?: string };
-// RuleModule = Rule.RuleModule;
+const { RuleTester, SourceCode } = require("eslint");
+const { isEditor, isValidFile } = require("./utils/helpers");
+const { isValidEnv, isValidModel } = require("./utils/validate");
+const {
+  Cache,
+  populateModelAndEnv,
+  hasCompilationError,
+  getAST,
+  initModelRuleTester,
+  loadConfigPath,
+} = require("./utils/model");
+const { isRuleDisabled, getRules, populateRules } = require("./utils/rules");
+const { customRulesDir, categories } = require("./constants");
 
 /**
- * ESLint Rule creator:
+ * 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
- * - defineMeta:
- * - defineReport: Our wrapper for ESLint's 'create' rule function used by ESLint to traverse
- *   its AST nodes. Since we do not work with an AST, we just access our dummy Programm node
- *   and collect the required cds parameters for our rules
- *
- * @param defineMeta
- * @param defineReport
- * @returns
+ * - 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}
  */
-
-// Types: { defineMeta: CDSRuleMetaData, defineReport: CDSRuleContext): RuleModule }
-function createRule(defineMeta, defineReport) {
+function createRule(spec) {
+  const { meta, create } = spec;
   return {
-    meta: {
-      ...defineMeta,
-    },
-    // Types: { context: Rule.RuleContext }
-    create(context) {
-      {
-        return cbRuleFunctions(context, defineReport);
-      }
+    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) {
+                if (isEditor()) {  // Do not throw to avoid ESLint VSCode editor pop-ups
+                  console.error(`An error occurred while linting. Rule: ${cdscontext.ruleID}\n`, err);
+                } else {
+                  throw err;
+                }
+              }
+              // Show compilation error only on console
+            } else if (hasCompilationError(cdscontext) && !isEditor()) {
+              create(cdscontext);
+            }
+          }
+        },
+      };
     },
   };
 }
 
 /**
- * More eslint-like API with more convenience re error reports
+ * 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, (report, cds) => {
-    const handlers = create({ cds, model:cds.model, report:(r)=>report.push(r) })
-    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'
-        }
-        report.push (r)
+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);
+              }
+            }
+        });
       }
-    })
-    return report
-  })
+    },
+  });
 }
 
-
 /**
- * ESLint Rule creator callback object
- * - Must return an object with nodes ESLint can visit while traversing the AST
- *   (here, an empty Program node)
- * - Must ingest 'context' object which contains info in each rule's context
- * https://eslint.org/docs/developer-guide/working-with-rules#the-context-object
- *
- * @param context rule context info
- * @param defineReport rule report
- * @returns rule callback function
+ * Generates proxy for ESLint's context object which adds caching
+ * @param obj ESLint's context object
+ * @returns Proxy for cds
  */
-// Types: { context: Rule.RuleContext, defineReport: CDSRuleContext }
-function cbRuleFunctions(context, defineReport) {
-  return {
-    Program(node) {
-      let report = [];
-      const ruleID = context.id;
-      let cds = context.parserServices.cdsProxy || Cache.get('cds');
-      let sourcecode = context.getSourceCode()
-      let filePath = context.getFilename();
-
-      if (!filePath.endsWith('.js')) {
-        filePath = `${filePath.split('.cds')[0]}.cds`;
-        if (filePath.endsWith('.cds')) {
-          const code = sourcecode.getText(node) || Cache.get(`file:${filePath}`);
-          if (code) sourcecode = getSourcecode(code);
-
-          let category = CONSTANTS.categories.model;
-          if (envRules.includes(ruleID.replace("@sap/cds/", ""))) {
-            category = CONSTANTS.categories.env;
-          }
-
-          // Set configPath according to filePath
-          let configPath = path.dirname(getConfigPath(filePath));
-          Cache.set("configpath", configPath);
-
-          // Get cds model for current project
-          loadModel(code, configPath, filePath);
-
-          // Update config path (any files not part of the above model)
-          // Can only do this if model.$sources are known, otherwise no
-          // way to distinguish between 'model' vs 'outsider' files
-          if (cds && cds.model && !cds.model.err) {
-            updateConfigPath(code, configPath, filePath);
-            configPath = Cache.get("configpath");
-          }
-
-          // Update cds model on every 'type' event
-          if (
-            Cache.has(`file:${filePath}`) &&
-            code !== Cache.get(`file:${filePath}`)
-          ) {
-            // Update file contents in Cache
-            Cache.set(`file:${filePath}`, code);
-            updateModel(code, configPath, filePath);
-          }
-
-          // Get cds environment (when called from ruleTester)
-          if (context.options[0] && context.options[0].environment) {
-            Cache.set(`environment`, context.options[0].environment);
-          }
-
-          // Get report for triggered cds 'environment' and 'model' rules
-          const properties = { filePath, configPath, ruleID, code, sourcecode };
-          if (cds && isValidModel(cds, ruleID)) {
-            if (
-              (category === CONSTANTS.categories.model && cds.model &&
-                getFileExtensions().includes(`*${path.extname(filePath)}`)) ||
-              (category === CONSTANTS.categories.env && cds.environment)
-            ) {
-              report = defineReport(report, cds, sourcecode, node, filePath);
-            }
-            if (report.length > 0) {
-              reportErrors(report, context, properties);
-            }
-          } else {
-            // Add any compilation errors to ESLint report, except when plugin
-            // is used within VS Code ESLint extension editor as it would duplicate
-            // CDS compile messages
-            if (hasCompilationError(cds, ruleID) && !isEditor()) {
-              report = defineReport(report, cds, sourcecode, node);
-              if (report.length > 0) {
-                reportErrors(report, context, properties);
+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 },
+                };
+                if (!seenReport(lint, thisArg.ruleID)) {
+                  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);
 }
 
-/**
- * Checks whether the compiled cds model or environment
- * is eligible for performing the plugin's rule checks
- * @param cds cds object
- * @param ruleID rule name
- * @returns
- */
-function isValidModel(cds, ruleID) {
-  if (
-    (cds && cds.model && !cds.model.err) ||
-    (cds.environment &&
-      !(
-        ruleID === "@sap/cds/cds-compile-error" ||
-        ruleID === "cds-compile-error"
-      ))
-  ) {
+function seenReport(msg, ruleID) {
+  let seenReports = [];
+  if (Cache.has("reports")) {
+    seenReports = Cache.get("reports");
+  }
+  const lintString = `configpath:${Cache.get('configpath')}|rule:${ruleID}|` +
+    `message:${msg.message}|` +
+    `loc:${msg.loc.start.line},${msg.loc.start.column}-${msg.loc.end.line},${msg.loc.end.column}`;
+  if (!seenReports.includes(lintString)) {
+    seenReports.push(lintString);
+    Cache.set("reports", seenReports);
+    return false;
+  } else {
     return true;
   }
-  return false;
 }
 
 /**
- * Checks whether the compiled cds model contains compilation errors
- * which should only be reported via the 'cds-compile-error' rule
- * @param cds cds object
- * @param ruleID rule name
- * @returns
+ * 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 hasCompilationError(cds, ruleID) {
-  if (
-    cds &&
-    cds.model &&
-    cds.model.err &&
-    cds.model.err.message.startsWith("CDS compilation failed")
-  ) {
-    if (
-      ruleID === "@sap/cds/cds-compile-error" ||
-      ruleID === "cds-compile-error"
-    ) {
-      cds.model.err
-      return true;
-    }
+function createCDSContext(context, node, meta) {
+  const filePath = context.getPhysicalFilename();
+  let configPath;
+  if (!Cache.has("pluginpath")) {
+    configPath = loadConfigPath(filePath);
+  } else {
+    configPath = Cache.get("configpath")
+  }
+  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 false;
+  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
+  };
 }
 
-/**
- * Allows to pass on every ESLint error report only for its corresponding file
- * @param report rule report
- * @param context ESLint rule context
- * @param properties Current file/path/rule association
- * Only send report if:
- * - Rule is not disabled via comment
- * - Rule is an environment check
- * - Rule is a model check and:
- *   - Error/warning can be allocated to an actual file
- *   - File is <stdin>.cds from model rule test
- */
-// Types: { report: any[], context: Rule.RuleContext, properties: any }
-function reportErrors(report, context, properties) {
-  // Types: { entry: CDSReport, i: number }
-  report.forEach((entry) => {
-    if (entry) {
-      const ruleID = properties.ruleID;
-      const configPath = properties.configPath;
-      const fileRel = entry.file;
-      let fileAbs = entry.file || "";
-      if (!path.isAbsolute(fileAbs)) {
-        fileAbs = fileRel ? path.join(Cache.get("configpath"), fileRel) : "";
+function getProxyRun(obj) {
+  const handler = {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value !== "object") {
+        return value;
       }
-      let isDisabled = false;
-      if (entry.loc && entry.loc.start) {
-        const line = entry.loc.start.line;
-        const rulesDisabled = getDisabledFromComments(
-          rules,
-          properties.code,
-          properties.sourcecode,
-          line
-        );
-        if (
-          line &&
-          ruleID in rulesDisabled &&
-          rulesDisabled[ruleID] === "off"
-        ) {
-          isDisabled = true;
-        }
+      /* eslint no-extra-boolean-cast: "off" */
+      if (!!value) {
+        return new Proxy(value, handler);
       }
-      if (!isDisabled) {
-        if (
-          envRules.includes(ruleID) ||
-          envRules.includes(ruleID.replace("@sap/cds/", ""))
-        ) {
-          if (!isEditor()) {
-            if (!Cache.has(`envChecks:${configPath}`)) {
-              context.report(entry);
-              Cache.set(`envChecks:${configPath}`, [entry.message]);
-            } else if (
-              Cache.has(`envChecks:${configPath}`) &&
-              !Cache.get(`envChecks:${configPath}`).includes(entry.message)
-            ) {
-              context.report(entry);
-              Cache.set(`envChecks:${configPath}`, [entry.message]);
-            }
-          }
-        } else if (
-          fileRel &&
-          (fileAbs === properties.filePath || fileRel === "<stdin>.cds")
-        ) {
-          context.report(entry);
-        }
-      }
-    }
-  });
+      return {
+        err: `Property ${prop} prop does not exist on object ${obj}!`,
+      };
+    },
+    apply(target, thisArg, argumentsList) {
+      return thisArg.run();
+    },
+  };
+  return new Proxy(obj, handler);
 }
 
 /**
@@ -309,22 +288,25 @@ function reportErrors(report, context, properties) {
  * valid/invalid checks:
  * Model checks require input 'code' entries
  * Env checks require input 'options' with selected parameters
- * @param options RuleTester input options
+ * @param {CDSRuleTestOpts} options RuleTester input options
  * @returns RuleTester results
  */
-function runRuleTester(options) {
+function runRuleTester(options, dryRun=false) {
   let parser;
   let rule = {};
+  process.env.LINT_FLAVOR = "inferred";
   const rulename = path.basename(options.root);
   const plugin = "eslint-plugin-cds";
   if (options.root.includes(plugin)) {
-    // For internal plugin tests, resolve parser from here
-    try {
-      parser = options.parser;
-      rule = options.rule;
-    } catch (err) {
-      throw new Error(err);
-    }
+    // For plugin's internal tests, resolve parser from here
+    parser = require.resolve("./parser");
+    rule = require(`./rules/${path.basename(options.root)}`);
+    const pluginPath = path.join(path.dirname(options.root), "../..");
+    Cache.set(
+      "rulesInfo",
+      getRules(path.join(path.dirname(options.root), "../../lib/impl/rules"))
+    );
+    Cache.set("pluginpath", pluginPath);
   } else {
     // Otherwise from project root
     const resolvedPlugin = require.resolve("@sap/eslint-plugin-cds", {
@@ -332,13 +314,21 @@ function runRuleTester(options) {
     });
     parser = path.join(path.dirname(resolvedPlugin), "parser");
     rule = require(path.join(
-      path.dirname(resolvedPlugin),
-      `rules/${rulename}`
+      options.root,
+      `../../rules/${path.basename(options.root)}`
     ));
+    const pluginPath = path.join(path.dirname(options.root), "../../../..");
+    Cache.set("rulesInfo", getRules(path.join(options.root, "../../rules")));
+    Cache.set("pluginpath", pluginPath);
+  }
+  let category = categories["model"];
+  if (rule.meta) {
+    category = rule.meta.docs.category;
+  }
+  let tester = new RuleTester({});
+  if (parser) {
+    tester = new RuleTester({ parser });
   }
-
-  const category = rule.meta.docs.category;
-  const tester = new RuleTester({ parser });
   const testerCases = {};
   ["valid", "invalid"].forEach((type) => {
     const filePath = path.join(options.root, `${type}/${options.filename}`);
@@ -347,18 +337,19 @@ function runRuleTester(options) {
         filename: filePath,
       },
     ];
-    if (category === "Environment") {
+    if (category === categories["env"]) {
       testerCases[type][0].code = "";
       testerCases[type][0].options = [
         { environment: JSON.parse(fs.readFileSync(filePath, "utf8")) },
       ];
-    } else if (category === CONSTANTS.categories.model) {
+    } else if (!category || category === categories.model) {
       testerCases[type][0].code = fs.readFileSync(filePath, "utf8");
+      initModelRuleTester(filePath);
     }
     if (type === "invalid") {
       testerCases[type][0].errors = options.errors;
       const fileFixed = path.join(options.root, `fixed/${options.filename}`);
-      if (fs.existsSync(fileFixed)) {
+      if (fs.existsSync(fileFixed) && rule.meta.type !== "suggestion") {
         testerCases[type][0].output = fs.readFileSync(fileFixed, "utf8");
       }
     }
@@ -366,4 +357,4 @@ function runRuleTester(options) {
   return tester.run(rulename, rule, testerCases);
 }
 
-module.exports = { defineRule, createRule, runRuleTester };
+module.exports = { createRule, defineRule, runRuleTester };