@sap/eslint-plugin-cds 2.2.2 → 2.3.0

package/lib/impl/utils/model.js

@@ -101,20 +101,22 @@ module.exports = {
     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) ||
+
+    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);
-      }
+    ) {
+      module.exports.initModel(context.configPath, context.filePath);
+    }
+    // Trigger model updates for:
+    // - Changed 'model' files
+    // - Any 'outsider' files
+    if (
+      isValidFile(context.filePath, "model") &&
+      module.exports.hasFileChanged(context)
+    ) {
+      module.exports.updateModel(context);
     }
 
     // Get cds environment (for internal ruleTester)
@@ -146,6 +148,7 @@ module.exports = {
   isNewConfigPath: function (configPath) {
     let update = false;
     if (
+      !module.exports.Cache.has("pluginpath") ||
       !module.exports.Cache.has("configpath") ||
       configPath !== module.exports.Cache.get("configpath")
     ) {
@@ -426,6 +429,30 @@ module.exports = {
     }
   },
 
+  initModelRuleTester: function (filePath) {
+    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")) {
+        modelfiles.push(filePath);
+      }
+    });
+    module.exports.Cache.set(`modelfiles:${configPath}`, files);
+    const dictFiles = module.exports.getDictFiles(configPath, modelfiles);
+    module.exports.Cache.set(`dictfiles:${configPath}`, dictFiles);
+    const compiledModel = module.exports.compileModelFromDict(dictFiles);
+    let reflectedModel;
+    if (compiledModel) {
+      reflectedModel = cds.linked(compiledModel);
+    }
+    if (reflectedModel) {
+      module.exports.Cache.set(`model:${filePath}`, reflectedModel);
+    }
+  },
+
   /**
    * Creates or updates a dictionary of files/file contents for a given
    * project path.
@@ -433,7 +460,7 @@ module.exports = {
    * @param files
    * @returns dictFiles
    */
-  getDictFiles: function (configPath, files) {
+  getDictFiles: function (configPath, files=[]) {
     let dictFiles = {};
     if (module.exports.Cache.has(`dictfiles:${configPath}`)) {
       dictFiles = module.exports.Cache.get(`dictfiles:${configPath}`);
@@ -455,11 +482,10 @@ module.exports = {
    * @returns boolean
    */
   hasFileChanged: function (context) {
-    let dictFiles = {};
     const files = module.exports.Cache.get(`modelfiles:${context.configPath}`);
+    const dictFiles = module.exports.getDictFiles(context.configPath, files);
     // If incoming file is a 'model' file
     if (module.exports.isFileInModel(context, files)) {
-      dictFiles = module.exports.getDictFiles(context.configPath, files);
       // Only update on detected changes
       if (dictFiles[context.filePath] !== context.code) {
         dictFiles[context.filePath] = context.code;
@@ -467,7 +493,9 @@ module.exports = {
         return true;
       }
     } else {
-      return true;
+      if (dictFiles[context.filePath] !== context.code) {
+        return true;
+      }
     }
     return false;
   },
@@ -478,8 +506,8 @@ module.exports = {
    * @param files
    * @returns boolean
    */
-  isFileInModel(context, files) {
-    if (files && files.length > 0 && files.includes(context.filePath)) {
+  isFileInModel(filePath, files) {
+    if (files && files.length > 0 && files.includes(filePath)) {
       return true;
     }
     return false;
@@ -498,7 +526,10 @@ module.exports = {
       files = [];
     }
     // If incoming file is a 'model' file
-    if (!process.env["LINT_FLAVOR"] === "parsed" || module.exports.isFileInModel(context, files)) {
+    if (
+      !process.env["LINT_FLAVOR"] === "parsed" ||
+      module.exports.isFileInModel(context, files)
+    ) {
       const dictFiles = module.exports.Cache.get(
         `dictfiles:${context.configPath}`
       );
@@ -514,15 +545,10 @@ module.exports = {
       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
+        flavor,
       });
       module.exports.Cache.set(`model:${context.filePath}`, reflectedModel);
     }
   },
-
 };

package/lib/impl/utils/rules.js

@@ -3,12 +3,16 @@
  */
 
 const fs = require("fs");
+const os = require("os");
+const cp = require("child_process");
+const semver = require("semver");
 const path = require("path");
 const { mkdirp } = require("@sap/cds/lib/utils");
 const { Cache, getLastLine } = require("./model");
 
 const JSONC = require("./jsonc");
-const { categories, recommended } = require("../constants");
+const { categories } = require("../constants");
+const IS_WIN = os.platform() === "win32";
 const REGEX_COMMENT_START = "(/\\*|(.+)?//)(\\s?)+eslint-";
 const REGEX_COMMENTS = `${REGEX_COMMENT_START}(enable|disable)(-next)?(-line)?(.+)?`;
 
@@ -195,6 +199,27 @@ module.exports = {
     }
   },
 
+  getPackageVersion: function (registry) {
+    let version;
+    try {
+      const result = cp.execSync(
+        `npm show @sap/eslint-plugin-cds --@sap:registry=${registry} --json`,
+        {
+          cwd: process.cwd(),
+          shell: IS_WIN,
+          stdio: "pipe",
+        })
+        .toString();
+      version = JSON.parse(result)["version"];
+    } catch (err) {
+      // Do not throw
+    }
+    if (!version) {
+      console.err(`Failed to get latest plugin version from ${registry} - check your connection and try again.`);
+    }
+    return version;
+  },
+
   /**
    * Gets value for a given key in allowed keys for input of runRuleTester api
    * @param {string} text test input for ruleTester
@@ -225,6 +250,12 @@ module.exports = {
       if (matchTestKey) {
         result = matchTestKey[0];
       }
+    } else if (key === "data") {
+      const regexTestKey = new RegExp(`${key}:.*}`, "gm");
+      const matchTestKey = regexTestKey.exec(text);
+      if (matchTestKey) {
+        result = matchTestKey[0];
+      }
     } else {
       result = `No parameter \\'${key}\\' found in ruleTest`;
     }
@@ -239,26 +270,27 @@ module.exports = {
    * @returns Markdown table
    */
   genMdRules: function (ruleDict, release, table = true) {
-    let version = "latest";
-    if (release) {
-      version = release;
-    }
-
-    let mdRules = `# @sap/eslint-plugin-cds [${version}]\n\n`;
+    let mdRules = `# @sap/eslint-plugin-cds [latest]\n\n`;
     if (table) {
       mdRules += `Rules in ESLint are grouped by type to help you understand their purpose. Each rule has emojis denoting:\n\n`;
       mdRules += `✔️ if the plugin's "recommended" configuration enables the rule\n\n`;
       mdRules += `🔧 if problems reported by the rule are automatically fixable (\`--fix\`)\n\n`;
       mdRules += `💡  if problems reported by the rule are manually fixable (editor)\n\n`;
-      mdRules += "|  |   |   |   |  |\n";
-      mdRules += "|:-:|:-:|:-:|:-:|:-|\n";
+      if (!release) {
+        mdRules += `🚧 if rule exists in plugin (main branch) but is not yet released (artifactory)\n\n`;
+        mdRules += "|   |   |   |   |  |  |  |\n";
+        mdRules += "|:-:|:-:|:-:|:-:|-:|:-|:-|\n";
+      } else {
+        mdRules += "|   |   |   |   |  |  |  |\n";
+        mdRules += "|:-:|:-:|:-:|:-:|-:|:-|:-|\n";
+      }
       /* eslint-disable-next-line no-unused-vars */
       Object.entries(ruleDict).forEach(([, rules]) => {
         rules.forEach(function (rule) {
           if (release) {
-            mdRules += `| ${rule.recommended} | ${rule.fixable} | ${rule.hasSuggestions} | [${rule.name}](Rules-released.md#${rule.name}) | ${rule.details}|\n`;
+            mdRules += `| ${rule.recommended} | ${rule.fixable} | ${rule.hasSuggestions} | |   | [${rule.name}](Rules-released.md#${rule.name}) | ${rule.details}|\n`;
           } else {
-            mdRules += `| ${rule.recommended} | ${rule.fixable} | ${rule.hasSuggestions} | [${rule.name}](Rules.md#${rule.name}) | ${rule.details}|\n`;
+            mdRules += `| ${rule.recommended} | ${rule.fixable} | ${rule.hasSuggestions} | ${rule.construction} |   | [${rule.name}](Rules.md#${rule.name}) | ${rule.details}|\n`;
           }
         });
       });
@@ -278,7 +310,7 @@ module.exports = {
    * @param docsPath
    * @param release
    */
-  genDocFiles: function (ruleDict, docsPath, release) {
+  genDocFiles: function (ruleDict, docsPath, release=false) {
     let suffix = "";
     if (release) {
       suffix = "-released";
@@ -295,8 +327,11 @@ module.exports = {
     const mdRulesCur = fs.readFileSync(ruleDocsPath, "utf8");
     const mdRuleListCur = fs.readFileSync(ruleListDocsPath, "utf8");
 
+    // Get rules table
+    let mdRuleList = module.exports.genMdRules(ruleDict, release, true);
+
+    // Get rule details
     let mdRules = module.exports.genMdRules(ruleDict, release, false);
-    let mdRuleList = module.exports.genMdRules(ruleDict);
     /* eslint-disable-next-line no-unused-vars */
     Object.entries(ruleDict).forEach(([category, rules]) => {
       rules.forEach(function (rule) {
@@ -318,8 +353,7 @@ module.exports = {
    * @param {string} projectPath
    * @param {string} customRulesDir
    */
-  async genDocs(projectPath, customRulesDir) {
-    let mdRule, mdRuleSources, mdRuleContents;
+  async genDocs(projectPath, customRulesDir, registry) {
     let docsPath, rulePath, testPath, release;
 
     if (!projectPath) {
@@ -333,19 +367,40 @@ module.exports = {
       docsPath = path.join(projectPath, `${customRulesDir}/docs`);
       rulePath = path.join(projectPath, `${customRulesDir}/rules`);
       testPath = path.join(projectPath, `${customRulesDir}/tests`);
+      if (!fs.existsSync(docsPath)) {
+        await mkdirp(docsPath);
+      }
+      if (!fs.existsSync(rulePath)) {
+        await mkdirp(rulePath);
+      }
+      if (!fs.existsSync(testPath)) {
+        await mkdirp(testPath);
+      }
     }
 
-    if (!fs.existsSync(docsPath)) {
-      await mkdirp(docsPath);
-    }
-    if (!fs.existsSync(rulePath)) {
-      await mkdirp(rulePath);
-    }
-    if (!fs.existsSync(testPath)) {
-      await mkdirp(testPath);
+    if (registry) {
+      // Get rules (internal on artifactory)
+      const versionInternal = module.exports.getPackageVersion(registry);
+      if (versionInternal) {
+        const ruleDictInternal = module.exports.getRuleDict(docsPath, rulePath, testPath, versionInternal);
+        module.exports.genDocFiles(ruleDictInternal, docsPath);
+      }
+      // Get rules released (external on npm)
+      const versionExternal = module.exports.getPackageVersion("https://registry.npmjs.org");
+      if (versionExternal) {
+        const ruleDictExternal = module.exports.getRuleDict(docsPath, rulePath, testPath, versionExternal, release);
+        module.exports.genDocFiles(ruleDictExternal, docsPath, release);
+      }
+    } else {
+      // Get "custom" rules
+      const ruleDict = module.exports.getRuleDict(docsPath, rulePath, testPath);
+      module.exports.genDocFiles(ruleDict, docsPath);
     }
+  },
 
-    const ruleDict = {};
+  getRuleDict: function (docsPath, rulePath, testPath, versionRequired='0.0.0', release=false) {
+    let mdRule, mdRuleSources, mdRuleContents;
+    let ruleDict = {};
     fs.readdirSync(rulePath).filter(function (file) {
       if (path.extname(file).toLowerCase() === ".js" && file !== "index.js") {
         const rule = path.basename(file).replace(path.extname(file), "");
@@ -353,138 +408,181 @@ module.exports = {
           const ruleTestPath = path.join(testPath, rule, "rule.test.js");
 
           // Get rule meta information
-          const ruleMeta = fs.readFileSync(path.join(rulePath, file), "utf8");
-          const details = module.exports.getKeyFromMeta(
-            ruleMeta,
-            "description"
-          );
-          const category = module.exports.getKeyFromMeta(ruleMeta, "category");
-          const fixable = module.exports.getKeyFromMeta(ruleMeta, "fixable");
-          const suggestions = module.exports.getKeyFromMeta(
-            ruleMeta,
-            "hasSuggestions"
-          );
+          const ruleMeta = require(path.join(rulePath, file)).meta;
+          const version = ruleMeta.docs.version;
 
-          let isFixable = "";
-          if (["code", "whitespace"].includes(fixable)) {
-            isFixable = "🔧";
-          }
+          if ((release && semver.satisfies(version, `<=${versionRequired}`))
+          || (!release)) {
+            const details = ruleMeta.docs.description;
+            const category = ruleMeta.docs.category;
+            const fixable = ruleMeta.fixable;
+            const messages = ruleMeta.messages;
+            const recommended = ruleMeta.docs.recommended;
+            const suggestions = ruleMeta.hasSuggestions;
 
-          let isRecommended = "";
-          if (Object.keys(recommended).includes(`@sap/cds/${rule}`)) {
-            isRecommended = "✔️";
-          }
-
-          let hasSuggestions = "";
-          if (suggestions === true) {
-            hasSuggestions = "💡";
-          }
-
-          const version = module.exports.getKeyFromMeta(ruleMeta, "version");
+            let underConstruction = "";
+            if (!release && semver.satisfies(version, `>${versionRequired}`)) {
+              underConstruction = "🚧";
+            }
 
-          // Get rule valid/invalid tests
-          mdRule = "";
-          if (fs.existsSync(ruleTestPath)) {
-            const ruleTest = fs.readFileSync(ruleTestPath, "utf8");
-            const filename = module.exports.getKeyFromTest(
-              ruleTest,
-              "filename"
-            );
-            let errorsString = module.exports.getKeyFromTest(
-              ruleTest,
-              "errors"
-            );
-            const re = /(\S+):/gm;
-            errorsString = errorsString
-              .replace(re, `"$&`)
-              .replace(/:/gm, '":')
-              .replace(/`/gm, '"');
-            const errors = JSONC.parse(`{${errorsString}}`).errors;
-            const valid = fs.readFileSync(
-              path.join(testPath, rule, "valid", filename),
-              "utf8"
-            );
-            let invalid = fs.readFileSync(
-              path.join(testPath, rule, "invalid", filename),
-              "utf8"
-            );
-            const insertAt = (str, sub, pos) =>
-              `${str.slice(0, pos)}${sub}${str.slice(pos)}`;
-            errors.forEach((err) => {
-              if (err.messageId) {
-                err.message = err.messageId;
-              }
-              const msg = err.message.replace(/"/gm, "`");
-              if (err.line) {
-                const code = invalid.split("\n");
-                code[err.line - 1] = insertAt(
-                  code[err.line - 1],
-                  "</span>",
-                  err.endColumn - 1
-                );
-                code[err.line - 1] = insertAt(
-                  code[err.line - 1],
-                  `<span style="text-decoration-line:underline; text-decoration-style:wavy; text-decoration-color:red;" title="${msg}">`,
-                  err.column - 1
-                );
-                invalid = code.join("\n");
-              }
-            });
+            let isFixable = "";
+            if (["code", "whitespace"].includes(fixable)) {
+              isFixable = "🔧";
+            }
 
-            mdRule +=
-              `<span>✔️&nbsp;&nbsp; Example of ` +
-              `<span style="color:green">correct</span> ` +
-              `code for this rule:</span>\n\n<pre><code>\n${valid}\n</code></pre>\n\n`;
-            mdRule +=
-              `<span>❌&nbsp;&nbsp; Example of ` +
-              `<span style="color:red">incorrect</span> ` +
-              `code for this rule:</span>\n\n<pre><code>\n${invalid}\n</code></pre>`;
-          }
+            let isRecommended = "";
+            if (recommended === true) {
+              isRecommended = "✔️";
+            }
 
-          mdRuleContents = `## ${rule}\n`;
-          mdRuleContents += `<span class='label shifted'>${category}</span>\n\n`;
-          mdRuleContents += `### Rule Details\n${details}\n\n`;
-          if (mdRule) {
-            mdRuleContents += `### Examples\n${mdRule}\n\n`;
-          }
-          mdRuleContents += `### Version\nThis rule was introduced in \`@sap/eslint-plugin-cds ${version}\`.\n\n`;
-          mdRuleSources = `### Resources\n[Rule & Documentation source](${path
-            .relative(docsPath, path.join(rulePath, `${rule}.js`))
-            .replace(/\\/g, "/")})\n\n`;
+            let hasSuggestions = "";
+            if (suggestions === true) {
+              hasSuggestions = "💡";
+            }
 
-          if (Object.keys(ruleDict).includes(category)) {
-            ruleDict[category].push({
+            const ruleDictEntry = {
               name: rule,
               details,
               recommended: isRecommended,
               fixable: isFixable,
               hasSuggestions,
+              construction: underConstruction,
+              messages,
               version: version,
-              contents: mdRuleContents,
-              sources: mdRuleSources,
-            });
-          } else {
-            ruleDict[category] = [
-              {
-                name: rule,
-                details,
-                recommended: isRecommended,
-                fixable: isFixable,
-                hasSuggestions,
-                version: version,
-                contents: mdRuleContents,
-                sources: mdRuleSources,
-              },
-            ];
+            };
+            mdRule = module.exports.getRuleExamples(ruleTestPath, testPath, ruleDictEntry);
+            mdRuleContents = "";
+            if (!release && underConstruction) {
+              mdRuleContents += `## ${rule}\n<span class='shifted'>${underConstruction}&nbsp;&nbsp;<span class='label'>${category}</span></span>\n\n`;
+            } else {
+              mdRuleContents += `## ${rule}\n<span class='shifted label'>${category}</span>\n\n`;
+            }
+            mdRuleContents += `### Rule Details\n${details}\n\n`;
+            if (mdRule) {
+              mdRuleContents += `### Examples\n${mdRule}\n\n`;
+            }
+            mdRuleContents += `### Version\nThis rule was introduced in \`@sap/eslint-plugin-cds ${version}\`.\n\n`;
+            mdRuleSources = `### Resources\n[Rule & Documentation source](${path
+              .relative(docsPath, path.join(rulePath, `${rule}.js`))
+              .replace(/\\/g, "/")})\n\n`;
+
+            ruleDictEntry.contents = mdRuleContents;
+            ruleDictEntry.sources = mdRuleSources;
+            if (Object.keys(ruleDict).includes(category)) {
+              ruleDict[category].push(ruleDictEntry);
+            } else {
+              ruleDict[category] = [
+                {
+                  name: rule,
+                  details,
+                  recommended: isRecommended,
+                  fixable: isFixable,
+                  hasSuggestions,
+                  version: version,
+                  contents: mdRuleContents,
+                  sources: mdRuleSources,
+                  construction: underConstruction
+                },
+              ];
+            }
           }
         }
       }
     });
+    return ruleDict;
+  },
 
-    module.exports.genDocFiles(ruleDict, docsPath);
-    if (release) {
-      module.exports.genDocFiles(ruleDict, docsPath, release);
+  getRuleExamples: function (ruleTestPath, testPath, ruleDictEntry) {
+    // Get rule valid/invalid tests
+    let mdRule = "";
+    if (fs.existsSync(ruleTestPath)) {
+      const ruleTest = fs.readFileSync(ruleTestPath, "utf8");
+      const filename = module.exports.getKeyFromTest(
+        ruleTest,
+        "filename"
+      );
+      let errorsString = module.exports.getKeyFromTest(
+        ruleTest,
+        "errors"
+      );
+      const re = /(\S+):/gm;
+      errorsString = errorsString
+        .replace(re, `"$&`)
+        .replace(/:/gm, '":')
+        .replace(/`/gm, '"');
+      const errors = JSONC.parse(`{${errorsString}}`).errors;
+      const valid = fs.readFileSync(
+        path.join(testPath, ruleDictEntry.name, "valid", filename),
+        "utf8"
+      );
+      let invalid = fs.readFileSync(
+        path.join(testPath, ruleDictEntry.name, "invalid", filename),
+        "utf8"
+      );
+      const insertAt = (str, sub, pos) =>
+        `${str.slice(0, pos)}${sub}${str.slice(pos)}`;
+      let errorsSorted = []
+      errors.forEach((err) => {
+        if (errorsSorted.length === 0) {
+          errorsSorted = [err];
+        } else {
+          const errLast = errorsSorted[errorsSorted.length - 1];
+          if (err.line > errLast.line) {
+            errorsSorted.push(err)
+          } else if (err.line < errLast.line) {
+            errorsSorted.unshift(err);
+          } else {
+            if (err.column > errLast.column) {
+              errorsSorted.push(err)
+            } else if (err.line < errLast.line) {
+              errorsSorted.unshift(err)
+            } else {
+              errorsSorted.push(err)
+            }
+          }
+        }
+      })
+      errorsSorted.reverse().forEach((err, i) => {
+        if (err.messageId) {
+          let msg = ruleDictEntry.messages[err.messageId];
+          let data;
+          if (errorsSorted[i].suggestions && errorsSorted[i].suggestions[0]) {
+            data = errorsSorted[i].suggestions[0].data;
+          }
+          if (data) {
+            Object.keys(data).forEach((d) => {
+              msg = msg.replace(`{{${d}}}`, data[d]);
+            })
+          }
+          err.message = msg;
+        }
+        const msg = err.message.replace(/"/gm, "`");
+        if (err.line) {
+          const code = invalid.split("\n");
+          code[err.line - 1] = insertAt(
+            code[err.line - 1],
+            "</span>",
+            err.endColumn - 1
+          );
+          code[err.line - 1] = insertAt(
+            code[err.line - 1],
+            `<span style="display:inline-block; position:relative; border-bottom:2pt dotted red" title="${msg}">`,
+            err.column - 1
+          );
+          invalid = code.join("\n");
+        }
+      });
+
+      mdRule +=
+        `<span>✔️&nbsp;&nbsp; Example of ` +
+        `<span style="color:green">correct</span> ` +
+        `code for this rule:</span>\n\n<pre><code>\n${valid}\n</code></pre>\n\n`;
+      mdRule +=
+        `<span>❌&nbsp;&nbsp; Example of ` +
+        `<span style="color:red">incorrect</span> ` +
+        `code for this rule:</span>\n\n<pre><code>\n${invalid}\n</code></pre>`;
     }
+    return mdRule;
   },
 
   /**
@@ -501,10 +599,14 @@ module.exports = {
     fs.readdirSync(dirname).forEach((file) => {
       if (path.extname(file) === ".js" && file !== "index.js") {
         const rulename = file.replace(".js", "");
-        const ruleID = `${rulename}`;
-        rules[ruleID] = require(path.join(dirname, file));
+        let rule = require(path.join(dirname, file));
+        if (!rule.meta) {
+          return;
+        }
+        rule = module.exports.applyRuleDefaults(rule);
+        rules[rulename] = rule;
         const category =
-          rules[ruleID].meta.docs.category || categories["model"];
+          rules[rulename].meta.docs.category || categories["model"];
         if (
           !listEnvRules.includes(rulename) &&
           category === categories["env"]
@@ -523,6 +625,32 @@ module.exports = {
     return { rules, listRules, listEnvRules, listModelRules };
   },
 
+  /**
+   * Sets defaults for rule meta data for missing required
+   * propeties:
+   * - Rule is of type "problem"
+   * - Rule is in model category
+   * - Rule severity is "error"
+   * @param {*} rule
+   * @returns
+   */
+  applyRuleDefaults(rule) {
+    let ruleSanitized;
+    if (rule.meta) {
+      ruleSanitized = { ...rule };
+      if (!rule.meta.type) {
+        ruleSanitized.meta.type = "problem";
+      }
+      if (rule.meta.docs && !rule.meta.docs.category) {
+        ruleSanitized.meta.docs.category = categories["model"];
+      }
+      if (rule.meta.docs.recommended && !rule.meta.severity) {
+        ruleSanitized.meta.severity = "error";
+      }
+    }
+    return ruleSanitized;
+  },
+
   populateRules: function (context, customRulesDir) {
     const configPath = Cache.get("configpath") || "";
     // Allow for custom rules