@sap/eslint-plugin-cds 2.2.2 → 2.3.3

package/lib/{impl/utils → utils}/model.js

@@ -7,7 +7,6 @@ const path = require("path");
 const cds = require("@sap/cds");
 const { SourceCode } = require("eslint");
 const { isValidFile } = require("./helpers");
-const { isValidEnv } = require("./validate");
 
 const cache = new Map();
 
@@ -50,93 +49,6 @@ module.exports = {
     },
   },
 
-  hasModelError: function (filePath) {
-    if (module.exports.Cache.has(`model:${filePath}`)) {
-      const model = module.exports.Cache.get(`model:${filePath}`);
-      if (model.err) {
-        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
-   */
-  hasCompilationError: function (context) {
-    const cds = context.cds;
-    const ruleID = context.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;
-      }
-    }
-    return false;
-  },
-
-  /**
-   * Takes care of all of the cds modeling:
-   * - Loads the model and assigns relevant files to it
-   * - Updates the model (according to 'type' events in the editor)
-   * - Updates the ESLint configuration file path (i.e. mono-repo with
-   *   multiple models)
-   * @param context
-   * @returns
-   */
-  populateModelAndEnv: function (context) {
-    // Update file and config paths
-    module.exports.Cache.set("filepath", context.filePath);
-
-    // Get CDS reflected model
-    if (isValidFile(context.filePath, "model")) {
-      if (
-        process.env["LINT_FLAVOR"] !== "parsed" &&
-        (module.exports.isNewFile(context.filePath) ||
-        module.exports.isNewConfigPath(context.configPath))
-      ) {
-        module.exports.initModel(context.configPath, context.filePath);
-      }
-      // Trigger model updates for:
-      // - Changed 'model' files
-      // - Any 'outsider' files
-      if (module.exports.hasFileChanged(context) || process.env["LINT_FLAVOR"] === "parsed") {
-        module.exports.updateModel(context);
-      }
-    }
-
-    // Get cds environment (for internal ruleTester)
-    if (isValidEnv(context)) {
-      module.exports.Cache.set("environment", context.options[0].environment);
-    }
-  },
-
-  /**
-   * Checks whether a file is new or has already been
-   * part of an existing cds model
-   * @param {*} filePath
-   * @returns boolean
-   */
-  isNewFile: function (filePath) {
-    if (!module.exports.Cache.has(`model:${filePath}`)) {
-      return true;
-    } else {
-      return false;
-    }
-  },
-
   /**
    * Checks whether the path where the nearest ESLint configuration
    * file has changed
@@ -144,24 +56,11 @@ module.exports = {
    * @returns boolean
    */
   isNewConfigPath: function (configPath) {
-    let update = false;
-    if (
-      !module.exports.Cache.has("configpath") ||
-      configPath !== module.exports.Cache.get("configpath")
-    ) {
-      update = true;
-    }
-    // Keep track of all config paths visited
-    // - Used in formatter to group lint reports
-    // - Dirnames are used to assign any 'env' lints
-    if (!module.exports.Cache.has("configpaths")) {
-      module.exports.Cache.set("configpaths", [configPath]);
-    } else {
-      const configPaths = module.exports.Cache.get("configpaths");
-      configPaths.push(configPath);
-      module.exports.Cache.set("configpaths", configPaths);
+    if (!module.exports.Cache.has("configpath") &&
+      (configPath !== module.exports.Cache.get("configpath"))) {
+      return true;
     }
-    return update;
+    return false;
   },
 
   /**
@@ -173,7 +72,7 @@ module.exports = {
   loadConfigPath: function (filePath) {
     let configPath = path.dirname(module.exports.getConfigPath(filePath));
     if (configPath) {
-      module.exports.Cache.set("projectpath", configPath);
+      module.exports.Cache.set("configpath", configPath);
     } else {
       throw new Error("Failed to find an ESLint configuration file!");
     }
@@ -206,40 +105,6 @@ module.exports = {
     };
   },
 
-  /**
-   * Generates proxy for cds object which adds caching
-   * @param obj cds object
-   * @returns Proxy for cds
-   */
-  getCDSProxy: function (obj) {
-    const handler = {
-      get(target, prop, receiver) {
-        const value = Reflect.get(target, prop, receiver);
-        if (["model", "environment"].includes(prop)) {
-          if (prop === "model") {
-            prop = `model:${module.exports.Cache.get("filepath")}`;
-          }
-          return module.exports.Cache.get(prop);
-        }
-        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) {
-        const result = Reflect.apply(target, this, argumentsList);
-        return result;
-      },
-    };
-    return new Proxy(obj, handler);
-  },
-
   /**
    * Converts code with {line, column} to ESLint's 'range' property:
    * https://eslint.org/docs/developer-guide/working-with-custom-parsers#all-nodes
@@ -296,23 +161,35 @@ module.exports = {
    * @param {SoureLocation} obj
    * @returns ESLint's 'loc' object
    */
-  getLocation: function (name, obj) {
-    const loc = {
+  getLocation: function (name, obj, model) {
+    let loc;
+    const defaultLoc = {
       start: { line: 0, column: 0 },
       end: { line: 1, column: 0 },
     };
     if (obj.$location) {
       const nameloc = obj.$location;
-      // CSN entry with column 0 is equivalent to 'undefined'
-      // It means that the column in that line cannot be determined,
-      // so we assign a value 1 so as not to get a negative value
-      if (nameloc.col === 0) {
-        nameloc.col = 1;
+      if (nameloc) {
+        // CSN entry with column 0 is equivalent to 'undefined'
+        // It means that the column in that line cannot be determined,
+        // so we assign a value 1 to get a column location of 0
+        if (nameloc.col === 0) {
+          nameloc.col = 1;
+        }
+        loc = defaultLoc;
+        loc.start.column = nameloc.col - 1;
+        loc.start.line = nameloc.line;
+        loc.end.column = nameloc.col - 1 + name.length;
+        loc.end.line = nameloc.line;
+      } else {
+        if (obj.parent) {
+          this.getLocation(name, obj.parent, model);
+        }
       }
-      loc.start.column = nameloc.col - 1;
-      loc.start.line = nameloc.line;
-      loc.end.column = nameloc.col - 1 + name.length;
-      loc.end.line = nameloc.line;
+    }
+    // Empty locations default to line 0, column 0
+    if (!loc) {
+      loc = defaultLoc;
     }
     return loc;
   },
@@ -355,22 +232,22 @@ module.exports = {
    * @returns reflected model
    */
   compileModelFromPath: function (configPath) {
-    let compiledModel;
     let reflectedModel;
     cds.resolve.cache = {};
     const roots = cds.resolve("*", { root: configPath });
+    const messages = [];
     if (roots) {
-      try {
-        compiledModel = cds.load(roots, {
-          cwd: configPath,
-          sync: true,
-          locations: true,
-        });
-        if (compiledModel) {
-          reflectedModel = cds.linked(compiledModel);
+      const compiledModel = cds.load(roots, {
+        cwd: configPath,
+        sync: true,
+        locations: true,
+        messages,
+      });
+      if (compiledModel) {
+        reflectedModel = cds.linked(compiledModel);
+        if (messages) {
+          reflectedModel.messages = messages;
         }
-      } catch (err) {
-        reflectedModel = { err };
       }
     }
     return reflectedModel;
@@ -388,17 +265,37 @@ module.exports = {
    */
   compileModelFromDict: function (dictFiles, options) {
     let reflectedModel;
+    const messages = [];
+    const compiledModel = cds.compile(dictFiles, {
+      sync: true,
+      locations: true,
+      messages,
+      ...options,
+    });
+    if (compiledModel) {
+      reflectedModel = cds.linked(compiledModel);
+      if (messages) {
+        reflectedModel.messages = messages;
+      }
+    }
+    return reflectedModel;
+  },
+
+  compileModelFromFile: function (code, filePath) {
+    let compiledModel;
+    let reflectedModel;
+    const dictFiles = {};
+    dictFiles[filePath] = code;
+    let flavor = "inferred";
     try {
-      const compiledModel = cds.compile(dictFiles, {
-        sync: true,
-        locations: true,
-        ...options,
+      compiledModel = module.exports.compileModelFromDict(dictFiles, {
+        flavor,
       });
-      if (compiledModel) {
-        reflectedModel = cds.linked(compiledModel);
-      }
     } catch (err) {
-      reflectedModel = { err };
+      // Supress errors from parked files
+    }
+    if (compiledModel) {
+      reflectedModel = cds.linked(compiledModel);
     }
     return reflectedModel;
   },
@@ -409,12 +306,12 @@ module.exports = {
    * @param configPath
    * @param filePath
    */
-  initModel: function (configPath, filePath) {
+  initRootModel: function (configPath) {
     module.exports.Cache.set("configpath", configPath);
     const reflectedModel = module.exports.compileModelFromPath(configPath);
+    module.exports.Cache.set(`model:${configPath}`, reflectedModel);
     let files;
-    if (reflectedModel && !reflectedModel.err && reflectedModel.$sources) {
-      module.exports.Cache.set(`model:${filePath}`, reflectedModel);
+    if (reflectedModel && reflectedModel.$sources) {
       files = reflectedModel.$sources;
       if (files) {
         module.exports.Cache.set(`modelfiles:${configPath}`, files);
@@ -424,6 +321,29 @@ module.exports = {
       const dictFiles = module.exports.getDictFiles(configPath, files);
       module.exports.Cache.set(`dictfiles:${configPath}`, dictFiles);
     }
+    return reflectedModel;
+  },
+
+  /** 
+   * Creates a model for ESLint unit tests
+   */
+  initModelRuleTester: function (filePath) {
+    module.exports.Cache.set("test", true);
+    const configPath = path.dirname(filePath);
+    module.exports.Cache.set('configpath', configPath);
+    let files = fs.readdirSync(configPath);
+    const modelfiles = [];
+    files.forEach((file) => {
+      const filePath = path.join(configPath, file);
+      if (isValidFile(filePath, 'MODEL_FILES')) {
+        modelfiles.push(filePath);
+      }
+    });
+    module.exports.Cache.set(`modelfiles:${configPath}`, modelfiles);
+    const dictFiles = module.exports.getDictFiles(configPath, modelfiles);
+    module.exports.Cache.set(`dictfiles:${configPath}`, dictFiles);
+    const reflectedModel = module.exports.compileModelFromDict(dictFiles);
+    module.exports.Cache.set(`model:${configPath}`, reflectedModel);
   },
 
   /**
@@ -433,10 +353,10 @@ module.exports = {
    * @param files
    * @returns dictFiles
    */
-  getDictFiles: function (configPath, files) {
+  getDictFiles: function (input, files = []) {
     let dictFiles = {};
-    if (module.exports.Cache.has(`dictfiles:${configPath}`)) {
-      dictFiles = module.exports.Cache.get(`dictfiles:${configPath}`);
+    if (module.exports.Cache.has(`dictfiles:${input}`)) {
+      dictFiles = module.exports.Cache.get(`dictfiles:${input}`);
     } else {
       files.forEach((file) => {
         if (module.exports.Cache.has(`file:${file}`)) {
@@ -454,20 +374,22 @@ module.exports = {
    * @param context cds context object
    * @returns boolean
    */
-  hasFileChanged: function (context) {
-    let dictFiles = {};
-    const files = module.exports.Cache.get(`modelfiles:${context.configPath}`);
+  hasFileChanged: function (code, filePath, configPath) {
+    const files = module.exports.Cache.get(`modelfiles:${configPath}`);
+    const dictFiles = module.exports.getDictFiles(configPath, files);
+    const isFileInModel = module.exports.isFileInModel(filePath, configPath);
     // If incoming file is a 'model' file
-    if (module.exports.isFileInModel(context, files)) {
-      dictFiles = module.exports.getDictFiles(context.configPath, files);
+    if (isFileInModel) {
       // Only update on detected changes
-      if (dictFiles[context.filePath] !== context.code) {
-        dictFiles[context.filePath] = context.code;
-        module.exports.Cache.set(`dictfiles:${context.configPath}`, dictFiles);
+      if (dictFiles[filePath] !== code) {
+        dictFiles[filePath] = code;
+        module.exports.Cache.set(`dictfiles:${configPath}`, dictFiles);
         return true;
       }
     } else {
-      return true;
+      if (dictFiles[filePath] !== code) {
+        return true;
+      }
     }
     return false;
   },
@@ -478,8 +400,12 @@ module.exports = {
    * @param files
    * @returns boolean
    */
-  isFileInModel(context, files) {
-    if (files && files.length > 0 && files.includes(context.filePath)) {
+  isFileInModel(filePath, configPath) {
+    let files = module.exports.Cache.get(`modelfiles:${configPath}`);
+    if (!files) {
+      files = [];
+    }
+    if (files && files.length > 0 && files.includes(filePath)) {
       return true;
     }
     return false;
@@ -491,38 +417,18 @@ module.exports = {
    * files.
    * @param context cds context object
    */
-  updateModel: function (context) {
+  updateModel: function (code, filePath, configPath) {
     let reflectedModel;
-    let files = module.exports.Cache.get(`modelfiles:${context.configPath}`);
+    let files = module.exports.Cache.get(`modelfiles:${configPath}`);
     if (!files) {
       files = [];
     }
-    // If incoming file is a 'model' file
-    if (!process.env["LINT_FLAVOR"] === "parsed" || module.exports.isFileInModel(context, files)) {
-      const dictFiles = module.exports.Cache.get(
-        `dictfiles:${context.configPath}`
-      );
-      dictFiles[context.filePath] = context.code;
-      reflectedModel = module.exports.compileModelFromDict(dictFiles, {
-        flavor: "inferred",
-      });
-      files.forEach((file) => {
-        module.exports.Cache.set(`model:${file}`, reflectedModel);
-      });
-    } else {
-      // If incoming file is an 'outsider' file
-      const dictFiles = {};
-      dictFiles[context.filePath] = context.code;
-      let flavor = "parsed";
-      // Fully resolve model for ESLint's ruleTester
-      if (process.env["RULE_TESTER"]) {
-        flavor = "inferred"
-      }
-      reflectedModel = module.exports.compileModelFromDict(dictFiles, {
-        flavor
-      });
-      module.exports.Cache.set(`model:${context.filePath}`, reflectedModel);
-    }
-  },
+    const dictFiles = module.exports.Cache.get(`dictfiles:${configPath}`);
+    dictFiles[filePath] = code;
+    module.exports.Cache.set(`dictfiles:${configPath}`, dictFiles);
+    reflectedModel = module.exports.compileModelFromDict(dictFiles, { flavor: "inferred" });
+    module.exports.Cache.set(`model:${configPath}`, reflectedModel);
+    return reflectedModel;
+  }
 
 };

package/lib/utils/ruleHelpers.js

@@ -0,0 +1,56 @@
+const SEP = "[,;\t]";
+const EOL = "\\r?\\n";
+
+const findFuzzy = require("./fuzzySearch");
+
+module.exports = {
+  /**
+   *
+   * @param {*} e
+   */
+  splitEntityName: function (e) {
+    // Entity names from CSN are of the form:
+    // <namespace>.<service>.<entity>.<'texts'|'localized'>|<composition value>
+    let prefix = "";
+    let suffix = "";
+    let entityName = e.name;
+    const names = entityName.split(".");
+    entityName = names[names.length - 1];
+
+    if (entityName) {
+      // Managed composition get compiler tag `_up`
+      let isManagedComposition = false;
+      if (e.elements) {
+        isManagedComposition = Object.keys(e.elements).some((k) => k === "up_");
+      }
+      // Check for compiler tags
+      let compilerTagsToExclude = ["texts", "localized"];
+      const isCompilerTag = compilerTagsToExclude.includes(entityName);
+
+      if (isManagedComposition || isCompilerTag) {
+        suffix = names[names.length - 1];
+        entityName = names[names.length - 2];
+      }
+      prefix = e.name.split(`.${entityName}`)[0];
+    }
+    return { prefix, entity: entityName, suffix };
+  },
+
+
+
+  _findInCode: function (miss, code) {
+    // middle
+    let match = new RegExp(SEP + miss + SEP).exec(code);
+    if (match) return match.index + 1;
+    // end of line
+    match = new RegExp(SEP + miss + EOL).exec(code);
+    if (match) return match.index + 1;
+    // start of doc
+    match = new RegExp("^" + miss + SEP).exec(code);
+    if (match) return match.index;
+    // somewhere (fallback)
+    return code.indexOf(miss);
+  },
+
+
+};

package/lib/utils/ruleTester.js

@@ -0,0 +1,79 @@
+const fs = require("fs");
+const path = require("path");
+
+const { RuleTester } = require("eslint");
+const { Cache, initModelRuleTester } = require("./model");
+const { createRule, getRules } = require("./rules");
+const { isValidFile } = require("./helpers");
+
+module.exports = {
+/**
+ * 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
+ */
+runRuleTester: function(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");
+      const pluginPath = path.join(path.dirname(options.root), "../..");
+      rule = createRule(require(`../rules/${path.basename(options.root)}`));
+      Cache.set(
+        "rulesInfo",
+        getRules(path.join(path.dirname(options.root), "../../lib/rules"), rulename)
+      );
+      Cache.set("pluginpath", pluginPath);
+    } 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)}`
+      ));
+      const pluginPath = path.join(path.dirname(options.root), "../../../..");
+      Cache.set("rulesInfo", getRules(path.join(options.root, "../../rules", rulename)));
+      Cache.set("pluginpath", pluginPath);
+    }
+    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}`);
+      const model = initModelRuleTester(filePath);
+      testerCases[type] = [
+        {
+          filename: filePath,
+        },
+      ];
+      if (!isValidFile(options.filename, 'FILES')) {
+        const fileContents = JSON.parse(fs.readFileSync(filePath, "utf8"));
+        testerCases[type][0].code = "";
+        testerCases[type][0].options = [{ environment: fileContents }];
+      } else {
+        testerCases[type][0].code = fs.readFileSync(filePath, "utf8");
+        testerCases[type][0].options = [{ model }];
+      }
+      if (type === "invalid") {
+        testerCases[type][0].errors = options.errors;
+        const fileFixed = path.join(options.root, `fixed/${options.filename}`);
+        if (fs.existsSync(fileFixed) && rule.meta.type !== "suggestion") {
+          testerCases[type][0].output = fs.readFileSync(fileFixed, "utf8");
+        }
+      }
+    });
+    return tester.run(rulename, rule, testerCases);
+  }
+}