@sap/eslint-plugin-cds 2.2.2 → 2.3.3

package/lib/rules/valid-csv-header.js

@@ -0,0 +1,100 @@
+const {basename, extname} = require('path')
+const findFuzzy = require('../utils/fuzzySearch')
+const SEP = '[,;\t]'
+const EOL = '\\r?\\n'
+
+module.exports = {
+  meta: {
+    docs: {
+      description: `CSV files for entities must refer to valid element names.`,
+      category: "Model Validation",
+      recommended: true,
+      version: "2.3.0",
+    },
+    severity: "warn",
+    type: "problem",
+    hasSuggestions: true,
+    messages: {
+      InvalidColumn: `Invalid column '{{column}}'. Did you mean '{{candidates}}'?`,
+      ReplaceColumnWith: `Replace '{{column}}' with '{{candidates}}'`
+    }
+  },
+  create: function (context) {
+
+    return { all: check_valid_headers }
+
+    function check_valid_headers() {
+    const reports = [];
+    const {cds, code, filePath, sourcecode} = context;
+
+    if (!filePath.endsWith('.csv')) return
+    if (!cds.model)  return
+    let { env, model } = cds;
+    model = cds.compile.for.sql(model, { names:env.sql.names, messages: [] } )
+
+    const filename = basename(filePath)
+    const entityName = filename.replace(/-/g,'.').slice(0, -extname(filename).length)
+    const entity = _entity4(entityName, model);
+    if (!entity)  return
+
+    const elements = Object.values(entity.elements)
+      .filter (e => !!e['@cds.persistence.name'])
+      .map (e => e['@cds.persistence.name'].toUpperCase())
+
+    const [ cols ] = cds.parse.csv(code);
+    const missing = cols.filter (col => !elements.includes(col.toUpperCase()))
+    missing.forEach(miss => {
+      const index = _findInCode (miss, code)
+      const loc = sourcecode.getLocFromIndex(index)
+      const candidates = findFuzzy(miss, Object.keys(entity.elements).sort())
+      const suggest = candidates.map(cand => { return {
+        messageId: 'ReplaceColumnWith',
+        data: {column: miss, candidates:cand},
+        fix: (fixer) => fixer.replaceTextRange([index, index+miss.length], cand)
+      }})
+      reports.push({
+        messageId: 'InvalidColumn',
+        data: {column: miss, candidates},
+        loc: {start: loc, end: {line: loc.line, column: loc.column+miss.length}},
+        file: filePath,
+        suggest
+      })
+    })
+    return reports
+    }
+
+  }
+
+}
+
+function _findInCode (miss, code) {
+  // middle
+  let match = new RegExp(SEP+miss+SEP).exec(code)
+  if (match)  return match.index+1
+  // end of line
+  match = new RegExp(SEP+miss+EOL).exec(code)
+  if (match)  return match.index+1
+  // start of doc
+  match = new RegExp('^'+miss+SEP).exec(code)
+  if (match)  return match.index
+  // somewhere (fallback)
+  return code.indexOf(miss)
+}
+
+function _entity4 (name, csn) {
+  let entity = csn.definitions [name]
+  if (!entity) {
+    if (/(.+)[._]texts_?/.test (name)) { // 'Books.texts', 'Books.texts_de'
+      const base = csn.definitions [RegExp.$1]
+      return base && _entity4 (base.elements.texts.target, csn)
+    }
+    else return
+  }
+  // we also support simple views if they have no projection
+  const p = entity.query && entity.query.SELECT || entity.projection
+  if (p && !p.columns && p.from.ref && p.from.ref.length === 1) {
+    if (csn.definitions [p.from.ref[0]])  return entity
+  }
+  return entity.name ? entity : { name, __proto__:entity }
+}
+

package/lib/utils/fuzzySearch.js

@@ -0,0 +1,87 @@
+/**
+ * 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
+ */
+
+
+const cache = {};
+
+
+module.exports = (input, list, log) => {
+  let minDistWords = [];
+
+  if (input.length > 50 || list.length > 50) {
+    return minDistWords;
+  }
+
+  let minDist = Number.MAX_SAFE_INTEGER;
+
+  log && log('\nword\t\tlevDist\t\ttime(ms)');
+
+  let runtime = 0;
+
+  for (const word of list) {
+    const start = log && Date.now();
+    const levDist = levDistance(input, word);
+
+    if (log) {
+      const duration = Date.now() - start;
+      runtime = runtime + duration;
+      log(`${word}\t\t${levDist}\t\t${duration}`);
+    }
+
+    if (levDist === minDist) {
+      minDistWords.push(word);
+    }
+
+    if (levDist < minDist) {
+      minDist = levDist;
+      minDistWords = [word];
+    }
+  }
+
+  log && log(`runtime: ${runtime}ms`);
+
+  return minDistWords.sort();
+}
+
+
+const levDistance = (a, b) => {
+
+  if (cache[a] && cache[a][b]) {
+    return cache[a][b];
+  }
+
+  if (a.length === 0) {
+    return addToCache(a, b, b.length);
+  }
+
+  if (b.length === 0) {
+    return addToCache(a, b, a.length);
+  }
+
+  const tail_a = a.substring(1);
+  const tail_b = b.substring(1);
+
+  if (a[0] === b[0]) {
+    return levDistance(tail_a, tail_b);
+  }
+
+  const lev1 = levDistance(tail_a, b);
+  const lev2 = levDistance(a, tail_b);
+  const lev3 = levDistance(tail_a, tail_b);
+
+  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;
+}

package/lib/utils/helpers.js

@@ -0,0 +1,55 @@
+const { FILES, MODEL_FILES } = require("../constants");
+
+module.exports = {
+  /**
+   * Checks whether the given filePath matches a regex `files`
+   * @param {string} filePath
+   * @returns boolean
+   */
+  isValidFile: function (filePath, fileType) {
+    function genRegex(key) {
+      return new RegExp(
+        `${key
+          .map((file) => {
+            return file.replace("*", "");
+          })
+          .join("$|")}$`
+      );
+    }
+    let isValid = false;
+    switch(fileType) {
+      case 'MODEL_FILES':
+        isValid = genRegex(MODEL_FILES).test(filePath);
+        break;
+      case 'FILES': 
+        isValid = genRegex(FILES).test(filePath);
+        break;
+    }
+    return isValid;
+  },
+  /**
+   * Checks whether the plugin is run via VS Code ESLint extension
+   * @returns boolean
+   */
+  isVSCodeEditor() {
+    return process.argv.join(" ").includes("dbaeumer.vscode-eslint");
+  },
+
+  /**
+   * Checks whether ESLint is running in debug mode
+   * @returns boolean
+   */
+  hasDebugFlag() {
+    return process.argv.includes("--debug");
+  },
+
+  /**
+   * Returns an array of allowed file extensions
+   * the plugin can parse of the form "*.ext"
+   * @returns {ConfigOverrideFiles} Array of file extensions
+   */
+  getFileExtensions: function() {
+    return FILES;
+  },
+
+};