@sap/eslint-plugin-cds 3.0.5 → 3.1.1

package/lib/utils/findFuzzy.js

@@ -1,15 +1,23 @@
+'use strict'
+
+const cache = new Map()
+
 /**
  * Levenshtein distance algorithm using recursive calls and cache
  *
  * @param input search the list for a best match for this string
  * @param list a list of strings to match input against
- * @param log logging method to use, might be null if no logging is wanted
- * @returns array with best matches, is never null but might be empty in case no search was possible
+ * @param {Function} [log] logging method to use, might be null if no logging is wanted
+ * @param {boolean} [keepCase]
+ * @param {Number} [threshold]
+ * @returns {string[]} array with best matches, is never null but might be empty in case no search was possible
+ *
+ * @todo: Describe in which range the threshold should be.
  */
+module.exports = function findFuzzy(input, list, log = null, keepCase = false, threshold = Number.MAX_SAFE_INTEGER) {
+  if (typeof input !== 'string')
+    return []
 
-const cache = {}
-
-module.exports = (input, list, log, keepCase = false, threshold = Number.MAX_SAFE_INTEGER) => {
   let minDistWords = []
 
   if (input.length > 50 || list.length > 50) {
@@ -56,10 +64,10 @@ module.exports = (input, list, log, keepCase = false, threshold = Number.MAX_SAF
   return minDistWords.sort()
 }
 
-const levDistance = (a, b) => {
-  if (cache[a] && cache[a][b]) {
-    return cache[a][b]
-  }
+function levDistance(a, b) {
+  const cachedObj = cache.get(a)?.get(b)
+  if (cachedObj)
+    return cachedObj
 
   if (a.length === 0) {
     return addToCache(a, b, b.length)
@@ -84,8 +92,9 @@ const levDistance = (a, b) => {
   return addToCache(a, b, levDist)
 }
 
-const addToCache = (a, b, value) => {
-  cache[a] = cache[a] || {}
-  cache[a][b] = value
+function addToCache(a, b, value) {
+  if (!cache.has(a))
+    cache.set(a, new Map())
+  cache.get(a).set(b, value)
   return value
 }

package/lib/utils/getConfigPath.js

@@ -1,3 +1,5 @@
+'use strict'
+
 /**
  * Searches for ESLint config file types (in order or precedence)
  * and returns corresponding directory (usually project's root dir)
@@ -6,8 +8,8 @@
  * @returns {string} dir containing ESLint config file (empty if not exists)
  */
 
-const fs = require('fs')
-const path = require('path')
+const fs = require('node:fs')
+const path = require('node:path')
 
 module.exports = (currentDir = '.', legacy=false) => {
   let configFiles = [

package/lib/utils/getConfiguredFileTypes.js

@@ -1,3 +1,5 @@
+'use strict'
+
 const { FILES } = require('../constants')
 
 /**

package/lib/utils/getFileExtensions.js

@@ -1,3 +1,5 @@
+'use strict'
+
 const constants = require('../constants')
 
 /**

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)
   },
 
-  isEmptyString: function (value) {
-    if (typeof value !== 'string' || (typeof value === 'string' && value && value.length > 0)) {
-      return false
-    }
-    return true
+  /**
+   * 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(value) {
+    return value?.trim() === ''
   },
 
   isEmptyObject: function (value) {
@@ -65,7 +71,7 @@ module.exports = {
       }
       return true
     }
-    if (typeof value !== 'object' || (typeof value === 'object' && !isEmpty(value)) ||
+    if (!value || typeof value !== 'object' || (typeof value === 'object' && !isEmpty(value)) ||
     (typeof value === 'object' && value && value.length > 0)) {
       return false
     }
@@ -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.1",
   "description": "ESLint plugin including recommended SAP Cloud Application Programming model and environment rules",
   "homepage": "https://cap.cloud.sap/",
   "keywords": [