@sap/eslint-plugin-cds 3.0.5 → 3.1.0

package/lib/utils/getProjectRootPath.js

@@ -1,25 +1,63 @@
+'use strict'
+
+const path = require('node:path')
+const cds = require('@sap/cds')
+const Cache = require('./Cache')
+const fs = require('node:fs')
+
+const commonCapProjectFiles = ['build.gradle', '.git', 'srv', 'db', 'app']
+
 /**
  * Searches for directory containing cds roots
+ *
+ * As of today, there is no unified way to find the root directory for a CDS project.
+ * ("The root is wherever the user typed `cds init`")
+ * We are therefore trying to resolve that path heuristically by ascending through the
+ * directory structure, looking for certain files.
+ *
+ * FIXME: Revisit and use a unified way once available, i.e. from @sap/cds
+ *
  * @param {string} currentDir start here and search until root dir
  * @returns {string} dir containing cds roots (empty if not exists)
  */
-
-const path = require('path')
-const cds = require('@sap/cds')
-const Cache = require('./Cache')
-
-module.exports = (currentDir = '.') => {
+module.exports = function getProjectRootPath(currentDir = '.') {
   let dir = path.resolve(currentDir)
-  while (dir !== path.resolve(dir, '..')) {
-    // @ts-ignore
-    cds.resolve.cache = {}
-    // @ts-ignore
-    const roots = cds.resolve('*', { root: dir })
-    if (roots && roots.length > 0) {
-      Cache.set(`roots:${dir}`, roots)
-      return dir
-    }
+
+  while (!couldBeProjectRoot(dir)) {
+    if (dir === path.resolve(dir, '..'))
+      return '' // we reached the file system root -> abort
     dir = path.join(dir, '..')
   }
+
+  cds.resolve.cache = {}
+  const roots = cds.resolve('*', { root: dir })
+  if (roots?.length > 0) {
+    Cache.set(`roots:${dir}`, roots)
+    return dir
+  }
   return ''
 }
+
+/**
+ * Checks whether the given directory could be a CDS project root.
+ *
+ * @param {string} dir
+ * @returns {boolean}
+ */
+function couldBeProjectRoot(dir) {
+  return isRootPackageJson(path.join(dir, 'package.json')) ||
+    commonCapProjectFiles.some(entry => fs.existsSync(path.join(dir, entry)))
+}
+
+function isRootPackageJson(filepath) {
+  const filename = path.basename(filepath)
+  if (filename !== 'package.json')
+    return false
+
+  try {
+    const config = JSON.parse(fs.readFileSync(filepath, 'utf8'))
+    return Object.keys(config?.dependencies ?? {}).some(dep => dep === '@sap/cds')
+  } catch {
+    return false
+  }
+}

package/lib/utils/isConfiguredFileType.js

@@ -1,3 +1,5 @@
+'use strict'
+
 const { FILES, MODEL_FILES } = require('../constants')
 
 const regexByFileType = {
@@ -8,13 +10,16 @@ const regexByFileType = {
 /**
  * Checks whether the given filePath matches a regex `files`
  * @param {string} filePath
+ * @param {string} fileType
  * @returns boolean
  */
 module.exports = (filePath, fileType) => {
-  const isValid = regexByFileType[fileType].test(filePath)
-  return isValid
+  return regexByFileType[fileType].test(filePath)
 }
 
+/**
+ * @param arr
+ */
 function globArrayToRegex (arr) {
-  return new RegExp(`${arr.map((e) => e.replace('*', '')).join('$|')}$`)
+  return new RegExp(`${arr.map(e => e.replace('*', '')).join('$|')}$`)
 }

package/lib/utils/rules.js

@@ -1,3 +1,5 @@
+'use strict'
+
 const SEP = '[,;\t]'
 const EOL = '\\r?\\n'
 
@@ -9,7 +11,7 @@ module.exports = {
    *
    * @param {*} e
    */
-  splitDefName: function (e) {
+  splitDefName(e) {
     // Entity names from CSN are of the form:
     // <namespace>.<service>.<def>.<'texts'|'localized'>|<composition value>
     let prefix = ''
@@ -22,7 +24,7 @@ module.exports = {
       // Managed composition get compiler tag `_up`
       let isManagedComposition = false
       if (e.elements) {
-        isManagedComposition = Object.keys(e.elements).some((k) => k === 'up_')
+        isManagedComposition = Object.keys(e.elements).some(k => k === 'up_')
       }
       // Check for compiler tags
       const compilerTagsToExclude = ['texts', 'localized']
@@ -51,11 +53,15 @@ module.exports = {
     return code.indexOf(miss)
   },
 
+  /**
+   * Returns true if the given string is non-empty. The string is trimmed, i.e. leading/trailing
+   * whitespace is removed prior to checking.
+   *
+   * @param {string} value
+   * @returns {boolean}
+   */
   isEmptyString: function (value) {
-    if (typeof value !== 'string' || (typeof value === 'string' && value && value.length > 0)) {
-      return false
-    }
-    return true
+    return value?.trim() === ''
   },
 
   isEmptyObject: function (value) {
@@ -96,7 +102,7 @@ module.exports = {
     const suggest = {
       messageId: 'ReplaceItemWith',
       data: { invalid, candidates },
-      fix: (fixer) => fixer.replaceTextRange([startIndex, startIndex + invalid.length] + 1, candidates)
+      fix: fixer => fixer.replaceTextRange([startIndex, startIndex + invalid.length] + 1, candidates)
     }
     return ({
       messageId: 'InvalidItem',

package/lib/utils/runRuleTester.js

@@ -1,11 +1,40 @@
-const fs = require('fs')
-const path = require('path')
+'use strict'
+
+/** @typedef {import('eslint').Rule.RuleModule} RuleModule */
+
+const fs = require('node:fs')
+const path = require('node:path')
 
 const { Linter, RuleTester } = require('eslint')
 const Cache = require('./Cache')
-const createRule = require('./createRule')
 const isConfiguredFileType = require('./isConfiguredFileType')
 const { compileModelFromDict } = require('../parser')
+const rules = require('../rules')
+
+/**
+ * A wrapper around the return value of `createRule()` that initializes the global
+ * cache only when the rule is actually executed.  This allows tests to be run
+ * with test runners that don't set up a new environment for each test, such as
+ * mocha or the Node test runner.
+ *
+ * @param {RuleModule} rule
+ * @returns {RuleModule}
+ */
+function testRuleWrapper(rule) {
+  return { ...rule, create: prepareAndRunRule }
+  function prepareAndRunRule(context) {
+    return {
+      Program: node => {
+        const filePath = context.getFilename()
+        _initModelRuleTester(filePath, rule.meta.model)
+        const createValue = rule.create(context)
+        const result = createValue.Program(node)
+        Cache.clear()
+        return result
+      }
+    }
+  }
+}
 
 /**
  * ESLint RuleTester (used by custom rule creator api)
@@ -13,51 +42,50 @@ const { compileModelFromDict } = require('../parser')
  * 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
  */
-module.exports = (options) => {
+module.exports = function runRuleTester(options) {
+  const pluginRootPath = path.resolve(__dirname, '../..')
   let parserPath
   let rule = {}
-  Cache.set('rules', require(path.join(__dirname, '../rules')))
   const rulename = path.basename(options.root)
-  if (options.root.startsWith(path.resolve(__dirname, '../..'))) {
+  if (options.root.startsWith(pluginRootPath)) {
     // For plugin's internal tests, resolve parser from here
     parserPath = require.resolve('../parser')
-    const pluginPath = path.join(path.dirname(options.root), '../..')
-    rule = createRule(require(`../rules/${path.basename(options.root)}`))
-    Cache.set('pluginpath', pluginPath)
+    rule = testRuleWrapper(rules[path.basename(options.root)]())
   } else {
     // Otherwise from project root
+    // eslint-disable-next-line
     const resolvedPlugin = require.resolve('@sap/eslint-plugin-cds', {
       paths: [options.root]
     })
     parserPath = 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('pluginpath', pluginPath)
+    rule = testRuleWrapper(require(path.join(options.root, `../../rules/${path.basename(options.root)}`)))
   }
-  let tester = new RuleTester({})
+
+  let tester
   if (parserPath) {
-    let options
-    if (Number(Linter.version.split('.')[0]) >= 9) {
-      options = { languageOptions: { parser: require(parserPath) } }
-    } else {
-      options = { parser: parserPath }
-    }
+    const options = _isEslint9OrLater()
+      ? { languageOptions: { parser: require(parserPath) } }
+      : { parser: parserPath }
     tester = new RuleTester(options)
+  } else {
+    tester = new RuleTester()
   }
 
   const testerCases = {};
-  ['valid', 'invalid'].forEach((type) => {
+  ['valid', 'invalid'].forEach(type => {
     const filePath = path.join(options.root, `${type}/${options.filename}`)
-    Cache.set('rootpath', path.dirname(filePath))
-    _initModelRuleTester(filePath, rule.meta?.model)
     testerCases[type] = [
       {
-        filename: filePath
+        filename: filePath,
       }
     ]
+    if (_isEslint9OrLater()) {
+      // property not supported for ESLint 8
+      testerCases[type][0].name = `${path.basename(options.root)}/${type}/${options.filename}`
+    }
     if (!isConfiguredFileType(options.filename, 'FILES')) {
       const fileContents = JSON.parse(fs.readFileSync(filePath, 'utf8'))
       testerCases[type][0].code = ''
@@ -77,22 +105,22 @@ module.exports = (options) => {
       }
     }
   })
-  if (Cache.get('testerCases')) {
-    Cache.set(`testerCases:${rulename}`, testerCases)
-  }
   return tester.run(rulename, rule, testerCases)
 }
 
 /**
  * Creates a model for ESLint unit tests
+ * @param {string} filePath
+ * @param {string} flavor
  */
 function _initModelRuleTester(filePath, flavor) {
+  Cache.set('rules', rules)
   Cache.set('test', true)
   const rootPath = path.dirname(filePath)
   Cache.set('rootpath', rootPath)
   if (flavor !== 'none') { // not for env rules
     const files = fs.readdirSync(rootPath)
-    const modelfiles = files.map((f) => path.join(rootPath, f)).filter((fp) => isConfiguredFileType(fp, 'MODEL_FILES'))
+    const modelfiles = files.map(f => path.join(rootPath, f)).filter(fp => isConfiguredFileType(fp, 'MODEL_FILES'))
     Cache.set(`modelfiles:${rootPath}`, modelfiles)
     const dictFiles = _getDictFiles(rootPath, modelfiles)
     Cache.set(`dictfiles:${rootPath}`, dictFiles)
@@ -102,18 +130,19 @@ function _initModelRuleTester(filePath, flavor) {
 }
 
 /**
-   * Creates or updates a dictionary of files/file contents for a given
-   * project path.
-   * @param input
-   * @param files
-   * @returns dictFiles
-   */
-function _getDictFiles(input, files) {
+ * Creates or updates a dictionary of files/file contents for a given
+ * project path.
+ *
+ * @param {string} input
+ * @param {string[]} filenames
+ * @returns {Record<string, string>} dictFiles
+ */
+function _getDictFiles(input, filenames) {
   let dictFiles = {}
   if (Cache.has(`dictfiles:${input}`)) {
     dictFiles = Cache.get(`dictfiles:${input}`)
   } else {
-    files.forEach((file) => {
+    filenames.forEach(file => {
       dictFiles[file] = Cache.has(`file:${file}`)
         ? Cache.get(`file:${file}`)
         : fs.readFileSync(file, 'utf8')
@@ -121,3 +150,7 @@ function _getDictFiles(input, files) {
   }
   return dictFiles
 }
+
+function _isEslint9OrLater() {
+  return Number(Linter.version.split('.')[0]) >= 9
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/eslint-plugin-cds",
-  "version": "3.0.5",
+  "version": "3.1.0",
   "description": "ESLint plugin including recommended SAP Cloud Application Programming model and environment rules",
   "homepage": "https://cap.cloud.sap/",
   "keywords": [

package/lib/utils/genDocs.js

@@ -1,346 +0,0 @@
-const fs = require('fs')
-const os = require('os')
-const path = require('path')
-const semver = require('semver')
-const cp = require('child_process')
-
-const cds = require('@sap/cds')
-const { mkdirp } = cds.utils
-
-const Cache = require('./Cache')
-const IS_WIN = os.platform() === 'win32'
-
-const { exit } = require('process')
-
-const constants = require('../constants')
-const LOG = process.env.SILENT ? undefined : constants.log
-
-/**
- * Generates custom rules documentation (markdown files)
- * for user according to contents of:
- * - Rule files
- * - Test files (with valid/invalid/fixed examples)
- */
-module.exports = async (projectPath, customRulesDir, registry, prepareRelease = false) => {
-  let docsPath, rulePath, testPath, release
-
-  Cache.set('testerCases', true)
-
-  if (!projectPath) {
-    docsPath = path.join(__dirname, '../../docs')
-    rulePath = path.join(__dirname, '../rules')
-    testPath = path.join(__dirname, '../../tests/lib/rules')
-    release = JSON.parse(fs.readFileSync(path.join(__dirname, '../../package.json')).toString()).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')).toString()).version
-      : getPackageVersion(registry)
-    if (versionInternal) {
-      LOG?.(`Updating internal rules from v>=${versionInternal}:\n${registry}\n`)
-      const rulesInternal = getRules(docsPath, rulePath, testPath, versionInternal)
-      genDocFiles(rulesInternal, 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')).toString()).version
-      : getPackageVersion(npmRegistry)
-    if (versionExternal) {
-      LOG?.(`Updating external rules from v>=${versionExternal}:\n${npmRegistry}\n`)
-      const rulesExternal = getRules(docsPath, rulePath, testPath, versionExternal, release)
-      genDocFiles(rulesExternal, docsPath, release)
-    }
-  } else {
-    // Get "custom" rules
-    const rules = getRules(docsPath, rulePath, testPath)
-    genDocFiles(rules, docsPath)
-  }
-  LOG?.('Done!')
-}
-
-/**
- * Generates markdown table of all rules with their respective properties based on input rules
- * @param rules array of rules with mandatory name, details properties
- * @param release
- * @returns markdown table of all rules
- */
-function genMdRules (rules, release = false) {
-  let mdRulesTable = ''
-  if (rules.length > 0) {
-    const emojiRecommended = '✔️'
-    const emojiFixable = '🔧'
-    const emojiSuggestions = '💡'
-    const emojiConstruction = '🚧'
-    let mdRulesHeader = 'Rules in ESLint are grouped by type to help you understand their purpose. Each rule has emojis denoting:\n\n'
-    mdRulesHeader += `${emojiRecommended} if the plugin's "recommended" configuration enables the rule\n\n`
-    mdRulesHeader += `${emojiFixable} if problems reported by the rule are automatically fixable (\`--fix\`)\n\n`
-    mdRulesHeader += `${emojiSuggestions}  if problems reported by the rule are manually fixable (editor)\n\n`
-    if (!release) {
-      mdRulesHeader += `${emojiConstruction} if rule exists in plugin (main branch) but is not yet released (artifactory)\n\n`
-      mdRulesHeader += '|   |   |   |   |  |  |  |\n'
-      mdRulesHeader += '|:-:|:-:|:-:|:-:|-:|:-|:-|\n'
-    } else {
-      mdRulesHeader += '|   |   |   |   |  |  |  |\n'
-      mdRulesHeader += '|:-:|:-:|:-:|:-:|-:|:-|:-|\n'
-    }
-    let mdRules = ''
-    rules.forEach((rule) => {
-      if (rule.name && rule.details) {
-        const isRecommended = rule.recommended ? emojiRecommended : ''
-        const isFixable = rule.fixable ? emojiFixable : ''
-        const hasSuggestions = rule.hasSuggestions ? emojiSuggestions : ''
-        const underConstruction = rule.construction ? emojiConstruction : ''
-        mdRules += release
-          ? `| ${isRecommended} | ${isFixable} | ${hasSuggestions} | |   | [${rule.name}](Rules-released.md#${rule.name}) | ${rule.details}|\n`
-          : `| ${isRecommended} | ${isFixable} | ${hasSuggestions} | ${underConstruction} |   | [${rule.name}](Rules.md#${rule.name}) | ${rule.details}|\n`
-      }
-    })
-    mdRulesTable = mdRules ? `${mdRulesHeader}${mdRules}\n` : ''
-  }
-  return mdRulesTable
-}
-
-/**
-    * 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 rules
-    * @param docsPath
-    * @param release
-    */
-function genDocFiles (rules, 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 header = '# @sap/eslint-plugin-cds [latest]\n\n'
-  const mdRuleList = genMdRules(rules, release)
-
-  // Get rule details
-  let mdRules = ''
-
-  rules.forEach(rule => {
-    mdRules += `${rule.contents}\n\n${rule.sources}\n\n---\n\n`
-  })
-
-  if (mdRuleListCur !== mdRuleList || mdRulesCur !== mdRules) {
-    fs.writeFileSync(ruleDocsPath, header + mdRules, 'utf8')
-    fs.writeFileSync(ruleListDocsPath, header + mdRuleList, 'utf8')
-  }
-}
-
-function getPackageVersion (registry) {
-  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) {
-    LOG?.(`Failed to connect to ${registry} - check your connection and try again.`)
-    exit(0)
-  }
-  const version = JSON.parse(result).version
-  if (!version) {
-    LOG?.(`Failed to get latest plugin version from ${registry} - check your connection and try again.`)
-    exit(0)
-  }
-  return version
-}
-
-function getRules (docsPath, rulePath, testPath, versionRequired = '0.0.0', release = false) {
-  let mdRule, mdRuleSources, mdRuleContents
-  const rules = []
-  const ruleVersionsPath = path.join(docsPath, '_data', 'rule_versions.json')
-  const ruleVersions = require(ruleVersionsPath)
-  let fileNumber = 0
-  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')
-      fileNumber++
-
-      // Get rule meta information
-      const ruleMeta = require(path.join(rulePath, file)).meta
-      let version = ruleVersions.added[rule]
-      if (!version) {
-        version = JSON.parse(fs.readFileSync(path.join(__dirname, '../../package.json')).toString()).version
-        ruleVersions.added[rule] = version
-        fs.writeFileSync(ruleVersionsPath, JSON.stringify(ruleVersions, null, 4), 'utf8')
-      }
-      if ((release && semver.satisfies(version, `<=${versionRequired}`)) || !release) {
-        LOG?.(`${fileNumber}> preparing docs for ${ruleTestPath}`)
-
-        const details = ruleMeta.docs.description
-        const flavor = ruleMeta.model ? ruleMeta.model : constants.DEFAULT_RULE_FLAVOR
-        const category = (flavor === 'none') ? 'Environment' : 'Model Validation'
-        const fixable = ruleMeta.fixable
-        const messages = ruleMeta.messages ? ruleMeta.messages : []
-        const recommended = ruleMeta.docs.recommended
-        const suggestions = ruleMeta.hasSuggestions
-
-        let underConstruction = ''
-        if (!release && (version === 'TBD' || semver.satisfies(version, `>${versionRequired}`))) {
-          underConstruction = '🚧'
-          LOG?.(`  > 🚧 Rule '${rule}' still under construction.\n`)
-        }
-
-        const isFixable = ['code', 'whitespace'].includes(fixable) ? '🔧' : ''
-        const isRecommended = recommended === true ? '✔️' : ''
-        const hasSuggestions = suggestions === true ? '💡' : ''
-
-        const rulesEntry = {
-          name: rule,
-          details,
-          recommended: isRecommended,
-          fixable: isFixable,
-          hasSuggestions,
-          construction: underConstruction,
-          messages,
-          version
-        }
-        try {
-          mdRule = getRuleExamples(rule, ruleTestPath, testPath, rulesEntry)
-        } catch (_err) {
-          // Just continue
-        }
-        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`
-
-        rulesEntry.contents = mdRuleContents
-        rulesEntry.sources = mdRuleSources
-        rules.push(rulesEntry)
-      }
-    }
-    return undefined
-  })
-  return rules
-}
-
-function getRuleExamples (rule, ruleTestPath, testPath, ruleDictEntry) {
-  // Get rule valid/invalid tests
-  let mdRule = ''
-  if (fs.existsSync(ruleTestPath)) {
-    require(`${ruleTestPath}`)
-    const testerCases = Cache.get(`testerCases:${rule}`)
-    const isEnvRule = testerCases.valid[0].filename === '<text>'
-    const valid = !isEnvRule ? fs.readFileSync(testerCases.valid[0].filename, 'utf8') : JSON.stringify(testerCases.valid[0].options[0].environment, null, 4)
-    const invalid = !isEnvRule ? fs.readFileSync(testerCases.invalid[0].filename, 'utf8') : JSON.stringify(testerCases.invalid[0].options[0].environment, null, 4)
-    let validString = ''
-    let invalidString = ''
-    if (!isEnvRule) {
-      const errors = testerCases.invalid[0].errors
-      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 {
-              if (err.messageId) {
-                errorsSorted[errorsSorted.length - 1].messageId += '\n' + err.messageId
-              }
-              if (err.message) {
-                errorsSorted[errorsSorted.length - 1].message += '\n' + err.message
-              }
-            }
-          }
-        }
-      })
-      const code = invalid.split('\n')
-      errorsSorted.forEach((err, i) => {
-        if (err.messageId && ruleDictEntry.messages) {
-          let msg = ruleDictEntry.messages[err.messageId]
-          let data
-          if (errorsSorted[i].suggestions && errorsSorted[i].suggestions[0]) {
-            data = errorsSorted[i].suggestions[0].data
-          }
-          if (data && msg) {
-            Object.keys(data).forEach((d) => {
-              msg = msg.replace(`{{${d}}}`, data[d])
-            })
-          }
-          err.message = msg
-        }
-        const msg = err.message && err.message.includes && err.message.includes('"') ? err.message.replace(/"/gm, '`') : err.message
-        if (err.line) {
-          const stringStart = errorsSorted[i - 1] ? errorsSorted[i - 1].line : 0
-          invalidString += code.slice(stringStart, err.line - 1).join('\n')
-          const errorString = err.line === err.endLine ? code[err.line - 1] : code.slice(err.line - 1, err.endLine - 1).join('\n')
-          const replacedErrorLine = errorString.substring(0, err.column - 1) +
-            `<span style="display:inline-block; position:relative; color:red; border-bottom:2pt dotted red" title="${msg}"><b><i>` +
-            errorString.substring(err.column - 1, err.endColumn - 1) +
-            '</i></b></span>' + errorString.substring(err.endColumn - 1)
-          invalidString += '\n' + replacedErrorLine
-          const stringEnd = errorsSorted[i + 1] ? code.slice(err.line, errorsSorted[i + 1].line - 1).join('\n') : code.slice(err.line).join('\n')
-          invalidString += errorsSorted[i + 1] ? stringEnd : '\n' + stringEnd
-        }
-      })
-    } else {
-      invalidString = invalid
-    }
-    validString = valid
-
-    mdRule +=
-      '<span>✔️&nbsp;&nbsp; Example of ' +
-      '<span style="color:green">correct</span> ' +
-      `code for this rule:</span>\n\n<pre><code>${validString.trim()}</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>${invalidString.trim()}</code></pre>`
-  }
-  return mdRule
-}