@sap/eslint-plugin-cds 2.5.0 → 2.6.0

package/lib/utils/createRule.js

@@ -10,102 +10,103 @@
  * @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 { SourceCode } = require('eslint')
+const fs = require('fs')
+const path = require('path')
+const Cache = require('./Cache')
+const constants = require('../constants')
+const isConfiguredFileType = require('./isConfiguredFileType')
+const getProjectRootPath = require('./getProjectRootPath')
+const cds = require('@sap/cds')
+const { exit } = require('process')
+const LOG = cds.debug('lint:plugin')
+let filePrev = ''
 
-const REGEX_COMMENT_START = "(/\\*|(.+)?//)(\\s?)+eslint-";
-const REGEX_COMMENTS = `${REGEX_COMMENT_START}(enable|disable)(-next)?(-line)?(.+)?`;
+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);
+  let { meta, create } = spec
+  meta = setMetaDefaults(meta)
 
   return {
     meta,
     create: (context) => ({
       Program: (node) => {
         try {
-          const file = context.getFilename();
+          const file = context.getFilename()
           if (file !== filePrev) {
-            LOG && LOG(`File: ${context.getFilename()}`);
+            LOG && LOG(`File: ${context.getFilename()}`)
           }
-          const cdscontext = extendContext(node, context, meta);
-          const { isTest, isValidFile, doEnvironmentChecks, doRootModelChecks } = checkEntryCriteria(meta, cdscontext);
-
+          const cdscontext = extendContext(node, context, meta)
+          Cache.set('context', cdscontext)
+          const { isTest, isValidFile, doEnvironmentChecks, doRootModelChecks } = checkEntryCriteria(meta, cdscontext)
           switch (meta.model) {
-            case "none":
+            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);
+                  LOG && LOG(`  Model: "${meta.model}" Rule: ${context.id}`)
+                  Cache.set(`rule:${cdscontext.id}:${Cache.get('rootpath')}`, 'done')
+                  createReport(node, cdscontext, meta, create)
                 }
               }
-              break;
+              break
 
-            case "inferred":
+            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);
+                if (isTest || !Cache.has(`rule:${cdscontext.id}:${Cache.get('rootpath')}`)) {
+                  LOG && LOG(`  Model: "${meta.model}" Rule: ${context.id}`)
+                  Cache.set(`rule:${cdscontext.id}:${Cache.get('rootpath')}`, 'done')
+                  createReport(node, cdscontext, meta, create)
                 } else {
                   if (Cache.has(`report:${context.getFilename()}:${context.id}`)) {
-                    const reports = Cache.get(`report:${context.getFilename()}:${context.id}`);
+                    const reports = Cache.get(`report:${context.getFilename()}:${context.id}`)
                     for (const r of Array.from(reports)) {
-                      context.report(r);
+                      context.report(JSON.parse(r))
                     }
-                    Cache.remove(`report:${context.getFilename()}:${context.id}`);
+                    Cache.remove(`report:${context.getFilename()}:${context.id}`)
+                    Cache.set(`rule:${cdscontext.id}:${Cache.get('rootpath')}`, 'done')
                   }
                 }
               }
-              break;
+              break
 
             default:
               if (isValidFile) {
-                LOG && LOG(`  Model: "${meta.model}" Rule: ${context.id}`);
-                createReport(node, cdscontext, meta, create);
+                LOG && LOG(`  Model: "${meta.model}" Rule: ${context.id}`)
+                createReport(node, cdscontext, meta, create)
               }
-              break;
+              break
           }
-          filePrev = file;
+          filePrev = file
         } catch (err) {
-          LOG && LOG(err);
+          console.error(err)
         }
       }
     })
-  };
-};
+  }
+}
 
-function isRunningWithCDSLint() {
-  return process.argv[0].endsWith("node") && process.argv[1].endsWith("cds") && process.argv[2] === "lint";
+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")));
+function checkEntryCriteria (meta, cdscontext) {
+  const isTest = Cache.has('test')
+  const hasProjectRoots = Cache.has(`roots:${Cache.get('rootpath')}`)
+  const isValidFile = isConfiguredFileType(cdscontext.getFilename(), 'FILES')
+  const doRootModelChecks = isTest || (hasProjectRoots && (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 };
+    isTest || (hasProjectRoots && 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;
+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
 }
 
 /**
@@ -119,9 +120,8 @@ function setMetaDefaults(meta) {
  * @param {*} create
  * @returns
  */
-function createReport(node, cdscontext, meta, create) {
-  const handlers = create(cdscontext);
-
+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
@@ -130,129 +130,142 @@ function createReport(node, cdscontext, meta, create) {
    *  - Environment rules
    */
   switch (typeof handlers) {
-    case "function":
-      handlers();
-      break;
+    case 'function':
+      handlers()
+      break
+
+    case 'object': {
+      if (meta.model !== 'none') {
+        const model = cdscontext.getModel()
 
-    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);
+                  handler(d)
                 } catch (err) {
-                  console.log(`Error in rule "${cdscontext.id}" at ${d.name}`, err);
+                  console.log(`Error in rule "${cdscontext.id}" at ${d.name}`, err)
                 }
-              });
-          });
+              })
+          })
         }
       }
-      break;
+      break
     }
   }
 }
 
-function extendContext(node, context, meta) {
-  if (!Cache.has("test") && !Cache.has("rootpath")) {
-    Cache.set("rootpath", path.resolve("."));
+function extendContext (node, context, meta) {
+  if (!Cache.has('test')) {
+    const filePath = context.getFilename()
+    const rootPath = filePath && fs.existsSync(filePath) ? getProjectRootPath(filePath) : ''
+    if (rootPath) {
+      Cache.set('rootpath', rootPath)
+    }
   }
 
   const reportWrapper = (r) => {
-    const line = r.loc ? r.loc.start.line : r.node.loc.start.line;
+    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 (meta.model === 'inferred') {
+        if (!r.file) {
+          console.error(`Rule ${context.id} must return a "file" property in the rule report!`)
+          exit(1)
+        }
+        const file = Cache.get('rootpath') ? resolveFilePath(r.file) : 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);
-          }
+          delete r.file
+          context.report(r)
+        }
+        if (r.file) {
+          cacheReport(r, file, context, meta)
         }
-
       } else {
-        context.report(r);
+        context.report(r)
       }
     }
-  };
+  }
 
-  const descriptors = Object.getOwnPropertyDescriptors(context);
+  const descriptors = Object.getOwnPropertyDescriptors(context)
   descriptors.report = {
     value: reportWrapper,
     writable: false,
     enumerable: true,
     configurable: false
-  };
+  }
 
-  const cdscontext = Object.create(Object.getPrototypeOf(context), descriptors);
+  const cdscontext = Object.create(Object.getPrototypeOf(context), descriptors)
   cdscontext.getModel =
-    meta.model === "inferred" ? context.parserServices.getInferredCsn : context.parserServices.getParsedCsn;
+    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;
+    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;
+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";
+    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;
+  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 = [];
+function cacheReport (r, file, context, meta) {
+  delete r.file
+  r.node.range = []
+  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(JSON.stringify(r))
+    Cache.set(`report:${file}:${context.id}`, reports)
+  }
+}
+
+function getDisabled (code, sourcecode, line) {
+  const listDisabled = []
+  const rules = Cache.get('rules')
+  const rulesDisabled = Object.keys(rules).reduce((o, key) => ({ ...o, [key]: 'on' }), {})
+  let matches = []
   if (code) {
-    matches = [...code.matchAll(REGEX_COMMENTS)];
+    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];
+          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();
+            match = match.trim()
           }
-          ["disable", "enable"].forEach((keyword) => {
-            const loc = sourcecode.getLocFromIndex(index);
-            const disableType = match.split(" ")[0];
-            let disableRules = match.split(`${disableType} `)[1];
+          ['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 = {};
+              ? 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")
+              comment = disableType.includes('-next-line')
                 ? {
                     lineComment: loc.line,
                     lineDisabled: loc.line + 1,
@@ -264,41 +277,41 @@ function getDisabled(code, sourcecode, line) {
                     lineDisabled: loc.line,
                     rules: disableRules,
                     type: keyword
-                  };
-              if (!disableType.includes("-line")) {
-                comment.lineDisabled = "EOF";
+                  }
+              if (!disableType.includes('-line')) {
+                comment.lineDisabled = 'EOF'
               }
             }
-            listDisabled.push(comment);
-          });
+            listDisabled.push(comment)
+          })
         }
-      });
+      })
       for (const el of listDisabled.filter(
-        (d) => d.lineComment > line && (d.lineDisabled === "EOF" || d.lineDisabled === line)
+        (d) => d.lineComment > line && (d.lineDisabled === 'EOF' || d.lineDisabled === line)
       )) {
-        if (el.lineDisabled === "EOF") {
-          el.lineDisabled = getLastLine(code);
+        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";
+            if (el.type === 'disable') {
+              rulesDisabled[rule] = 'off'
+            } else if (el.type === 'enable') {
+              rulesDisabled[rule] = 'on'
             }
-          });
+          })
         }
       }
     }
   }
-  return rulesDisabled;
+  return rulesDisabled
 }
 
-function getLastLine(code) {
-  const lines = typeof code === "string" ? SourceCode.splitLines(code) : code;
-  return lines.length - 1;
+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);
+function resolveFilePath (file) {
+  return path.isAbsolute(file) ? file : path.join(Cache.get('rootpath'), file)
 }

package/lib/utils/findFuzzy.js

@@ -7,86 +7,81 @@
  * @returns array with best matches, is never null but might be empty in case no search was possible
  */
 
+const cache = {}
 
-const cache = {};
-
-
-module.exports = (input, list, log, keepCase=false) => {
-  let minDistWords = [];
+module.exports = (input, list, log, keepCase = false) => {
+  let minDistWords = []
 
   if (input.length > 50 || list.length > 50) {
-    return minDistWords;
+    return minDistWords
   }
 
-  let minDist = Number.MAX_SAFE_INTEGER;
+  let minDist = Number.MAX_SAFE_INTEGER
 
-  log && log('\nword\t\tlevDist\t\ttime(ms)');
+  log && log('\nword\t\tlevDist\t\ttime(ms)')
 
-  let runtime = 0;
+  let runtime = 0
 
   for (const word of list) {
-
-
-    const start = log && Date.now();
-    let levDist;
+    const start = log && Date.now()
+    let levDist
     if (word === word.toUpperCase() && !keepCase) {
-      levDist = levDistance(input.toUpperCase(), word);
+      levDist = levDistance(input.toUpperCase(), word)
     } else {
-      levDist = levDistance(input, word);
+      levDist = levDistance(input, word)
     }
 
     if (log) {
-      const duration = Date.now() - start;
-      runtime = runtime + duration;
-      log(`${word}\t\t${levDist}\t\t${duration}`);
+      const duration = Date.now() - start
+      runtime = runtime + duration
+      log(`${word}\t\t${levDist}\t\t${duration}`)
     }
 
     if (levDist === minDist) {
-      minDistWords.push(word);
+      minDistWords.push(word)
     }
 
     if (levDist < minDist) {
-      minDist = levDist;
-      minDistWords = [word];
+      minDist = levDist
+      minDistWords = [word]
     }
   }
 
-  log && log(`runtime: ${runtime}ms`);
+  log && log(`runtime: ${runtime}ms`)
 
-  return minDistWords.sort();
+  return minDistWords.sort()
 }
 
 const levDistance = (a, b) => {
-
   if (cache[a] && cache[a][b]) {
-    return cache[a][b];
+    return cache[a][b]
   }
 
   if (a.length === 0) {
-    return addToCache(a, b, b.length);
+    return addToCache(a, b, b.length)
   }
 
   if (b.length === 0) {
-    return addToCache(a, b, a.length);
+    return addToCache(a, b, a.length)
   }
 
-  const tail_a = a.substring(1);
-  const tail_b = b.substring(1);
+  const tailA = a.substring(1)
+  const tailB = b.substring(1)
 
   if (a[0] === b[0]) {
-    return levDistance(tail_a, tail_b);
+    return levDistance(tailA, tailB)
   }
 
-  const lev1 = levDistance(tail_a, b);
-  const lev2 = levDistance(a, tail_b);
-  const lev3 = levDistance(tail_a, tail_b);
+  const lev1 = levDistance(tailA, b)
+  const lev2 = levDistance(a, tailB)
+  const lev3 = levDistance(tailA, tailB)
 
-  const levDist = Math.min(lev1, lev2, lev3) + 1;
-  return addToCache(a, b, levDist);
+  const levDist = Math.min(lev1, lev2, lev3) + 1
+  return addToCache(a, b, levDist)
 }
 
 const addToCache = (a, b, value) => {
-  cache[a] = cache[a] || {};
-  cache[a][b] = value;
-  return value;
+  cache[a] = cache[a] || {}
+  cache[a][b] = value
+  return value
 }