@sap/eslint-plugin-cds 2.4.1 → 2.5.0

package/lib/utils/createRule.js

@@ -0,0 +1,304 @@
+/**
+ * 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
+ * - More eslint-like API
+ * - More convenience for error reports
+ * @param {CDSRuleSpec} spec
+ * @returns {RuleModule}
+ */
+
+const { SourceCode } = require("eslint");
+const path = require("path");
+const Cache = require("./Cache");
+const constants = require("../constants");
+const isConfiguredFileType = require("./isConfiguredFileType");
+const cds = require("@sap/cds");
+const LOG = cds.debug("lint:plugin");
+let filePrev = "";
+
+const REGEX_COMMENT_START = "(/\\*|(.+)?//)(\\s?)+eslint-";
+const REGEX_COMMENTS = `${REGEX_COMMENT_START}(enable|disable)(-next)?(-line)?(.+)?`;
+
+module.exports = (spec) => {
+  let { meta, create } = spec;
+  meta = setMetaDefaults(meta);
+
+  return {
+    meta,
+    create: (context) => ({
+      Program: (node) => {
+        try {
+          const file = context.getFilename();
+          if (file !== filePrev) {
+            LOG && LOG(`File: ${context.getFilename()}`);
+          }
+          const cdscontext = extendContext(node, context, meta);
+          const { isTest, isValidFile, doEnvironmentChecks, doRootModelChecks } = checkEntryCriteria(meta, cdscontext);
+
+          switch (meta.model) {
+            case "none":
+              if (doEnvironmentChecks) {
+                if (isTest || !Cache.has(`rule:${cdscontext.id}`)) {
+                  LOG && LOG(`  Model: "${meta.model}" Rule: ${context.id}`);
+                  Cache.set(`rule:${cdscontext.id}`, "done");
+                  createReport(node, cdscontext, meta, create);
+                }
+              }
+              break;
+
+            case "inferred":
+              if (isValidFile && doRootModelChecks) {
+                if (isTest || !Cache.has(`rule:${context.id}`)) {
+                  LOG && LOG(`  Model: "${meta.model}" Rule: ${context.id}`);
+                  Cache.set(`rule:${cdscontext.id}`, "done");
+                  createReport(node, cdscontext, meta, create);
+                } else {
+                  if (Cache.has(`report:${context.getFilename()}:${context.id}`)) {
+                    const reports = Cache.get(`report:${context.getFilename()}:${context.id}`);
+                    for (const r of Array.from(reports)) {
+                      context.report(r);
+                    }
+                    Cache.remove(`report:${context.getFilename()}:${context.id}`);
+                  }
+                }
+              }
+              break;
+
+            default:
+              if (isValidFile) {
+                LOG && LOG(`  Model: "${meta.model}" Rule: ${context.id}`);
+                createReport(node, cdscontext, meta, create);
+              }
+              break;
+          }
+          filePrev = file;
+        } catch (err) {
+          LOG && LOG(err);
+        }
+      }
+    })
+  };
+};
+
+function isRunningWithCDSLint() {
+  return process.argv[0].endsWith("node") && process.argv[1].endsWith("cds") && process.argv[2] === "lint";
+}
+
+function checkEntryCriteria(meta, cdscontext) {
+  const isTest = Cache.has("test");
+  cds.resolve.cache = {};
+  const roots = cds.resolve("*", { root: process.cwd() });
+  const isProjectRoot = roots && roots.length > 0 ? true : false;
+  const isValidFile = isConfiguredFileType(cdscontext.getFilename(), "FILES");
+  const isRunningWithCdsLint = isRunningWithCDSLint();
+  const doRootModelChecks = isTest || (isProjectRoot && (isRunningWithCdsLint || cdscontext.options.includes("show")));
+  // Also lint empty folders (i.e. lintText "" API)
+  const doEnvironmentChecks =
+    isTest || (isProjectRoot && isRunningWithCdsLint && cdscontext.getSourceCode().lines[0] === "");
+  return { isTest, isValidFile, doRootModelChecks, doEnvironmentChecks };
+}
+
+function setMetaDefaults(meta) {
+  if (!meta.severity) meta.severity = constants.DEFAULT_RULE_SEVERITY;
+  if (meta.docs && !meta.docs.category) meta.docs.category = constants.DEFAULT_RULE_CATEGORY;
+  if (!meta.model) meta.model = "parsed";
+  return meta;
+}
+
+/**
+ * Get report descriptors from created rules. These can take varios forms,
+ * from minimal return, up to fully defined ESLint report descriptors values,
+ * with or without visitor keys:
+ * - String is interpreted as the 'message' property
+ * - Object with known CDS Visitor keys and ESLint report descriptor values
+ * - Object with ESLint report dedscriptor keys/ values
+ * @param {*} cdscontext
+ * @param {*} create
+ * @returns
+ */
+function createReport(node, cdscontext, meta, create) {
+  const handlers = create(cdscontext);
+
+  /**
+   * TODO: Can these be rewritten to have a visitor? Note, that so far,
+   * rules without a visitor cannot use eslint disable comments
+   * A rule have no visitors and just return a single check:
+   *  - Model Validation rules which have no well-defined CSN entry point
+   *  - Environment rules
+   */
+  switch (typeof handlers) {
+    case "function":
+      handlers();
+      break;
+
+    case "object": {
+      if (meta.model !== "none") {
+        const model = cdscontext.getModel();
+        if (model) {
+          model.forall((d) => {
+            Object.entries(handlers)
+              .filter(([type, lazy]) => d.is(type))
+              .forEach(([lazy, handler]) => {
+                try {
+                  handler(d);
+                } catch (err) {
+                  console.log(`Error in rule "${cdscontext.id}" at ${d.name}`, err);
+                }
+              });
+          });
+        }
+      }
+      break;
+    }
+  }
+}
+
+function extendContext(node, context, meta) {
+  if (!Cache.has("test") && !Cache.has("rootpath")) {
+    Cache.set("rootpath", path.resolve("."));
+  }
+
+  const reportWrapper = (r) => {
+    const line = r.loc ? r.loc.start.line : r.node.loc.start.line;
+    if (!isRuleDisabled(line, context)) {
+
+      if (meta.model === "inferred") {
+        const file = resolveFilePath(r.file);
+        if (cdscontext.getFilename() === file) {
+          delete r.file;
+          context.report(r);
+        } else {
+          delete r.file;
+          if (r.messageId) {
+            r.message = meta.messages[r.messageId];
+            delete r.message;
+          }
+          if (r) {
+            let reports = new Set();
+            if (Cache.has(`report:${file}:${context.id}`)) {
+              reports = Cache.get(`report:${file}:${context.id}`);
+            }
+            reports.add(r);
+            Cache.set(`report:${file}:${context.id}`, reports);
+          }
+        }
+
+      } else {
+        context.report(r);
+      }
+    }
+  };
+
+  const descriptors = Object.getOwnPropertyDescriptors(context);
+  descriptors.report = {
+    value: reportWrapper,
+    writable: false,
+    enumerable: true,
+    configurable: false
+  };
+
+  const cdscontext = Object.create(Object.getPrototypeOf(context), descriptors);
+  cdscontext.getModel =
+    meta.model === "inferred" ? context.parserServices.getInferredCsn : context.parserServices.getParsedCsn;
+  cdscontext.getEnvironment = () => {
+    const options = context.options;
+    return options && options[0] && options[0].environment ? options[0].environment : undefined;
+  };
+  cdscontext.getLocation = context.parserServices.getLocation;
+  cdscontext.getNode = Object.keys(context.parserServices).length > 0 ? context.parserServices.getNode : () => node;
+  return cdscontext;
+}
+
+function isRuleDisabled(line, cdscontext) {
+  let isDisabled = false;
+  if (cdscontext) {
+    const sourcecode = cdscontext.getSourceCode();
+    const rulesDisabled = getDisabled(sourcecode.getText(), sourcecode, line);
+    const id = cdscontext.id;
+    isDisabled = line && id in rulesDisabled && rulesDisabled[id] === "off";
+  }
+  return isDisabled;
+}
+
+function getDisabled(code, sourcecode, line) {
+  const listDisabled = [];
+  let rules = Cache.get("rules");
+  const rulesDisabled = Object.keys(rules).reduce((o, key) => ({ ...o, [key]: "on" }), {});
+  let matches = [];
+  if (code) {
+    matches = [...code.matchAll(REGEX_COMMENTS)];
+    if (matches.length > 0) {
+      matches.forEach((match) => {
+        if (match) {
+          const index = match.index;
+          match = match[0];
+          if (match.includes("*/")) {
+            match = match.split("*/")[0].replace("/*", "");
+          } else if (match.includes("//")) {
+            match = match.split("//")[1];
+          }
+          if (match) {
+            match = match.trim();
+          }
+          ["disable", "enable"].forEach((keyword) => {
+            const loc = sourcecode.getLocFromIndex(index);
+            const disableType = match.split(" ")[0];
+            let disableRules = match.split(`${disableType} `)[1];
+            disableRules = disableRules
+              ? disableRules.split(",").map((rule) => rule.trim())
+              : Object.keys(rules).map((rule) => `@sap/cds/${rule}`);
+            let comment = {};
+            if ([`eslint-${keyword}`, `eslint-${keyword}-line`, `eslint-${keyword}-next-line`].includes(disableType)) {
+              comment = disableType.includes("-next-line")
+                ? {
+                    lineComment: loc.line,
+                    lineDisabled: loc.line + 1,
+                    rules: disableRules,
+                    type: keyword
+                  }
+                : {
+                    lineComment: loc.line,
+                    lineDisabled: loc.line,
+                    rules: disableRules,
+                    type: keyword
+                  };
+              if (!disableType.includes("-line")) {
+                comment.lineDisabled = "EOF";
+              }
+            }
+            listDisabled.push(comment);
+          });
+        }
+      });
+      for (const el of listDisabled.filter(
+        (d) => d.lineComment > line && (d.lineDisabled === "EOF" || d.lineDisabled === line)
+      )) {
+        if (el.lineDisabled === "EOF") {
+          el.lineDisabled = getLastLine(code);
+        }
+        if (el.rules) {
+          el.rules.forEach((rule) => {
+            if (el.type === "disable") {
+              rulesDisabled[rule] = "off";
+            } else if (el.type === "enable") {
+              rulesDisabled[rule] = "on";
+            }
+          });
+        }
+      }
+    }
+  }
+  return rulesDisabled;
+}
+
+function getLastLine(code) {
+  const lines = typeof code === "string" ? SourceCode.splitLines(code) : code;
+  return lines.length - 1;
+}
+
+function resolveFilePath(file) {
+  return path.isAbsolute(file) ? file : path.join(Cache.get("rootpath"), file);
+}

package/lib/utils/createRuleDocs.js

@@ -0,0 +1,361 @@
+/**
+ * Generates custom rules documentation (markdown files)
+ * for user according to contents of:
+ * - Rule files
+ * - Test files (with valid/invalid/fixed examples)
+ * @param {string} projectPath
+ * @param {string} customRulesDir
+ */
+
+const os = require("os");
+const fs = require("fs");
+const path = require("path");
+const { exit } = require("process");
+const cp = require("child_process");
+const semver = require("semver");
+
+const { mkdirp } = require("@sap/cds/lib/utils");
+const JSONC = require("./jsoncParser");
+const IS_WIN = os.platform() === "win32";
+
+module.exports = async (projectPath, customRulesDir, registry, prepareRelease = false) => {
+  let docsPath, rulePath, testPath, release;
+
+  if (!projectPath) {
+    docsPath = path.join(__dirname, "../../docs");
+    rulePath = path.join(__dirname, "../rules");
+    testPath = path.join(__dirname, "../../test/rules");
+    release = JSON.parse(fs.readFileSync(path.join(__dirname, "../../package.json"))).version;
+  } else {
+    docsPath = path.join(projectPath, `${customRulesDir}/docs`);
+    rulePath = path.join(projectPath, `${customRulesDir}/rules`);
+    testPath = path.join(projectPath, `${customRulesDir}/tests`);
+    await Promise.all(
+      [docsPath, rulePath, testPath].filter((path) => !fs.existsSync(path)).map((path) => mkdirp(path))
+    );
+  }
+  if (registry) {
+    // Get rules (internal on artifactory)
+    const versionInternal = prepareRelease
+      ? JSON.parse(fs.readFileSync(path.join(__dirname, "../../package.json"))).version
+      : _getPackageVersion(registry);
+    if (versionInternal) {
+      console.log(`Updating internal rules from v>=${versionInternal}:\n${registry}\n`);
+      const ruleDictInternal = _getRuleDict(docsPath, rulePath, testPath, versionInternal);
+      _genDocFiles(ruleDictInternal, docsPath);
+    }
+    // Get rules released (external on npm)
+    const npmRegistry = "https://registry.npmjs.org";
+    const versionExternal = prepareRelease
+      ? JSON.parse(fs.readFileSync(path.join(__dirname, "../../package.json"))).version
+      : _getPackageVersion(npmRegistry);
+    if (versionExternal) {
+      console.log(`Updating external rules from v>=${versionExternal}:\n${npmRegistry}\n`);
+      const ruleDictExternal = _getRuleDict(docsPath, rulePath, testPath, versionExternal, release);
+      _genDocFiles(ruleDictExternal, docsPath, release);
+    }
+  } else {
+    // Get "custom" rules
+    const ruleDict = _getRuleDict(docsPath, rulePath, testPath);
+    _genDocFiles(ruleDict, docsPath);
+  }
+  console.log("Done!");
+};
+
+/**
+ * Generates markdown documentation files for:
+ * - Overview of all rules in form of markdown table (RuleList)
+ * - List of all rules details in form of markdown page (Rules)
+ * If used internally within the @sap/eslint-plugin-cds, this
+ * also generates 'released' files, which only contain information
+ * on rules published until the currently released version.
+ * @param ruleDict
+ * @param docsPath
+ * @param release
+ */
+function _genDocFiles(ruleDict, docsPath, release = false) {
+  let suffix = "";
+  if (release) {
+    suffix = "-released";
+  }
+  const ruleDocsPath = path.join(docsPath, `Rules${suffix}.md`);
+  const ruleListDocsPath = path.join(docsPath, `RuleList${suffix}.md`);
+
+  if (!fs.existsSync(ruleDocsPath)) {
+    fs.writeFileSync(ruleDocsPath, "", "utf8");
+  }
+  if (!fs.existsSync(ruleListDocsPath)) {
+    fs.writeFileSync(ruleListDocsPath, "", "utf8");
+  }
+  const mdRulesCur = fs.readFileSync(ruleDocsPath, "utf8");
+  const mdRuleListCur = fs.readFileSync(ruleListDocsPath, "utf8");
+
+  // Get rules table
+  const mdRuleList = _genMdRules(ruleDict, release, true);
+
+  // Get rule details
+  let mdRules = _genMdRules(ruleDict, release, false);
+  /* eslint-disable-next-line no-unused-vars */
+  Object.entries(ruleDict).forEach(([category, rules]) => {
+    rules.forEach(function (rule) {
+      mdRules += `${rule.contents}\n\n${rule.sources}\n\n---\n\n`;
+    });
+  });
+
+  if (mdRuleListCur !== mdRuleList || mdRulesCur !== mdRules) {
+    fs.writeFileSync(ruleDocsPath, mdRules, "utf8");
+    fs.writeFileSync(ruleListDocsPath, mdRuleList, "utf8");
+  }
+}
+
+function _getPackageVersion(registry) {
+  let version;
+  let result;
+  try {
+    result = cp
+      .execSync(`npm show @sap/eslint-plugin-cds --@sap:registry=${registry} --json`, {
+        cwd: process.cwd(),
+        shell: IS_WIN,
+        stdio: "pipe",
+      })
+      .toString();
+  } catch (err) {
+    console.err(`Failed to connect to ${registry} - check your connection and try again.`);
+    exit(0);
+  }
+  version = JSON.parse(result)["version"];
+  if (!version) {
+    console.err(`Failed to get latest plugin version from ${registry} - check your connection and try again.`);
+    exit(0);
+  }
+  return version;
+}
+
+/**
+ * Generates overview table of all rules based on rule dictionary.
+ * @param ruleDict
+ * @param release
+ * @param table
+ * @returns Markdown table
+ */
+function _genMdRules(ruleDict, release, table = true) {
+  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`;
+    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) {
+        mdRules += release
+          ? `| ${rule.recommended} | ${rule.fixable} | ${rule.hasSuggestions} | |   | [${rule.name}](Rules-released.md#${rule.name}) | ${rule.details}|\n`
+          : `| ${rule.recommended} | ${rule.fixable} | ${rule.hasSuggestions} | ${rule.construction} |   | [${rule.name}](Rules.md#${rule.name}) | ${rule.details}|\n`;
+      });
+    });
+    mdRules += "\n";
+  }
+  return mdRules;
+}
+
+function _getRuleDict(docsPath, rulePath, testPath, versionRequired = "0.0.0", release = false) {
+  let mdRule, mdRuleSources, mdRuleContents;
+  const ruleDict = {};
+  fs.readdirSync(rulePath).filter((file) => {
+    if (path.extname(file).toLowerCase() === ".js" && file !== "index.js") {
+      const rule = path.basename(file).replace(path.extname(file), "");
+      const ruleTestPath = path.join(testPath, rule, "rule.test.js");
+
+      // Get rule meta information
+      const ruleMeta = require(path.join(rulePath, file)).meta;
+      const version = ruleMeta.docs.version;
+
+      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 underConstruction = "";
+        if (!release && (version === "TBD" || semver.satisfies(version, `>${versionRequired}`))) {
+          underConstruction = "🚧";
+          console.log(`  > 🚧 Rule '${rule}' still under construction.\n`);
+        }
+
+        const isFixable = ["code", "whitespace"].includes(fixable) ? "🔧" : "";
+        const isRecommended = recommended === true ? "✔️" : "";
+        const hasSuggestions = suggestions === true ? "💡" : "";
+
+        const ruleDictEntry = {
+          name: rule,
+          details,
+          recommended: isRecommended,
+          fixable: isFixable,
+          hasSuggestions,
+          construction: underConstruction,
+          messages,
+          version: version,
+        };
+        mdRule = _getRuleExamples(ruleTestPath, testPath, ruleDictEntry);
+        mdRuleContents = "";
+
+        mdRuleContents +=
+          !release && underConstruction
+            ? `## ${rule}\n<span class='shifted'>${underConstruction}&nbsp;&nbsp;<span class='label'>${category}</span></span>\n\n`
+            : `## ${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;
+}
+
+  /**
+   * Gets value for a given key in allowed keys for input of runRuleTester api
+   * @param {string} text test input for ruleTester
+   * @param {string} key key to get value for
+   * @returns Value for given key
+   */
+   function _getKeyFromTest(text, key) {
+    let result = "";
+    if (["root", "rule", "filename", "parser"].includes(key)) {
+      const regexTestKey = new RegExp(`${key}:.*$`, "gm");
+      const matchTestKey = regexTestKey.exec(text);
+      if (matchTestKey) {
+        const quote = matchTestKey[0].replace(",", "").slice(-1);
+        const regexTestValue = new RegExp(`${quote}[\\s\\S]*?(\\${quote},?)`, "gm");
+        const matchValue = regexTestValue.exec(matchTestKey[0]);
+        if (matchValue) {
+          const regex = new RegExp(`${quote},`, "gm");
+          const regex2 = new RegExp(`${quote}`, "gm");
+          result = matchValue[0].replace(regex, "").replace(regex2, "");
+        }
+      }
+    } else if (key === "errors") {
+      const regexTestKey = new RegExp(`${key}:.*$(([\\s]+.+)+])?`, "gm");
+      const matchTestKey = regexTestKey.exec(text);
+      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`;
+    }
+    return result;
+  }
+
+function _getRuleExamples(ruleTestPath, testPath, ruleDictEntry) {
+  // Get rule valid/invalid tests
+  let mdRule = "";
+  if (fs.existsSync(ruleTestPath)) {
+    const ruleTest = fs.readFileSync(ruleTestPath, "utf8");
+    const filename = _getKeyFromTest(ruleTest, "filename");
+    let errorsString = _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], "</i></b></span>", err.endColumn - 1);
+        code[err.line - 1] = insertAt(
+          code[err.line - 1],
+          `<span style="display:inline-block; position:relative; color:red; border-bottom:2pt dotted red" title="${msg}"><b><i>`,
+          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;
+}

package/lib/utils/{fuzzySearch.js → findFuzzy.js}

@@ -56,7 +56,6 @@ module.exports = (input, list, log, keepCase=false) => {
   return minDistWords.sort();
 }
 
-
 const levDistance = (a, b) => {
 
   if (cache[a] && cache[a][b]) {
@@ -86,7 +85,6 @@ const levDistance = (a, b) => {
   return addToCache(a, b, levDist);
 }
 
-
 const addToCache = (a, b, value) => {
   cache[a] = cache[a] || {};
   cache[a][b] = value;