eslint-plugin-ember-template-lint 0.18.0 → 0.21.0

package/lib/config/base.js

@@ -0,0 +1,9 @@
+module.exports = {
+  root: true,
+
+  plugins: {
+    'ember-template-lint': require('../index'),
+  },
+
+  rules: {}
+};

package/lib/config/index.js

@@ -0,0 +1,21 @@
+const info = require('../ember-template-lint/info');
+const base = require('./base');
+
+const configs = {};
+
+Object.entries(info.configs).forEach(([name, config]) => {
+  Object.entries(config.rules).forEach(([name, conf]) => {
+    if (typeof conf == 'boolean') {
+      config.rules[name] = [conf ? 'error' : 'off'];
+    }
+  });
+  configs[name] = {...base, rules: config.rules};
+});
+configs['config'] = {
+  ...base,
+  rules: info.configuredRules,
+  overrides: info.configuredOverrides,
+};
+
+module.exports = configs;
+

package/lib/config-legacy/base.js

@@ -0,0 +1,7 @@
+module.exports = {
+  root: true,
+
+  plugins: ['ember-template-lint'],
+
+  rules: {}
+};

package/lib/config-legacy/index.js

@@ -0,0 +1,21 @@
+const info = require('../ember-template-lint/info');
+const base = require('./base');
+
+const configs = {};
+
+Object.entries(info.configs).forEach(([name, config]) => {
+  Object.entries(config.rules).forEach(([name, conf]) => {
+    if (typeof conf == 'boolean') {
+      config.rules[name] = [conf ? 'error' : 'off'];
+    }
+  });
+  configs[name] = {...base, rules: config.rules};
+});
+configs['config'] = {
+  ...base,
+  rules: info.configuredRules,
+  overrides: info.configuredOverrides,
+};
+
+module.exports = configs;
+

package/lib/ember-template-lint/config.js

@@ -0,0 +1,35 @@
+const templateLintConfig = {
+  rules: {},
+  plugins: [],
+  overrides: [],
+};
+
+let current = templateLintConfig;
+
+function registerRule(name, config) {
+  current.rules[name] = Array.isArray(config) ? config[0] : config;
+}
+
+function registerPlugin(name) {
+  current.plugins.push(name);
+}
+
+function startOverride(files) {
+  current = {
+    files,
+    rules: {}
+  };
+  templateLintConfig.overrides.push(current);
+}
+
+function finishOverride() {
+  current = templateLintConfig;
+}
+
+module.exports = {
+  registerRule,
+  registerPlugin,
+  startOverride,
+  finishOverride,
+  templateLintConfig
+};

package/lib/ember-template-lint/info.js

@@ -0,0 +1,133 @@
+const synckit = require('synckit');
+const syncFn = synckit.createSyncFn(require.resolve('./worker'));
+const { runTemplateLint } = require('../rules/lint');
+const { registerRule, templateLintConfig } = require('../ember-template-lint/config');
+
+const lintWithEslintConfigs = syncFn({ config: templateLintConfig });
+const lintConfigs = syncFn();
+
+const activeRules = new Map();
+const allMessages = {};
+
+const reporter = {
+  setup(context) {
+    this.getSourceCode = context.getSourceCode;
+    this.getPhysicalFilename = context.getPhysicalFilename;
+  },
+  report(message) {
+    message.meta = {
+      fixable: 'code'
+    };
+    allMessages[message.rule] = allMessages[message.rule] || [];
+    allMessages[message.rule].push(message);
+  }
+};
+
+class Rule {
+
+  constructor(name) {
+    this.create = this.create.bind(this);
+    this.name = name;
+    this.meta = {
+      fixable: 'code'
+    };
+  }
+  create(context) {
+    const rule = this;
+    let options = context.options;
+    if (options.length === 0) {
+      options = true;
+    }
+    registerRule(this.name, options);
+    const visitor = {
+      enter(node) {
+        if (!activeRules.get(node)) {
+          activeRules.set(node, 0);
+          reporter.setup(context);
+          runTemplateLint(node, reporter);
+        }
+        activeRules.set(node, activeRules.get(node) + 1);
+      },
+      exit(node) {
+        const messages = allMessages[rule.name] || [];
+        messages.forEach(m => context.report(m));
+        activeRules.set(node, activeRules.get(node) - 1);
+        allMessages[rule.name] = [];
+      },
+    };
+    return {
+      'Program': (node) => node.isHbs && visitor.enter(node),
+      'Program:exit': (node) => node.isHbs && visitor.exit(node),
+      'GlimmerTemplate': visitor.enter,
+      'GlimmerTemplate:exit': visitor.exit,
+    };
+  }
+}
+
+function createRules(rules) {
+  const created = rules.map(r => new Rule(r));
+  const map = {};
+  created.forEach(r => {
+    map[r.name] = r;
+  });
+  return map;
+}
+
+const configs = {
+  ...lintWithEslintConfigs.configs,
+  ...lintConfigs.configs
+};
+
+const rules = [...new Set([...lintConfigs.rules, ...lintWithEslintConfigs.rules])];
+
+delete configs.recommended.overrides;
+
+Object.values(configs).forEach((config) => {
+  const rules = {};
+  Object.entries(config.rules).forEach(([rule, conf]) => {
+    rules['ember-template-lint/' + rule] = conf;
+  });
+  config.rules = rules;
+});
+
+// enable all rules
+const configuredRules = {};
+
+for (const rule of rules) {
+  configuredRules['ember-template-lint/' + rule] = [];
+  configuredRules['ember-template-lint/' + rule].push(2);
+  configuredRules['ember-template-lint/' + rule].push({ __placeholder__: true });
+}
+
+Object.entries(lintConfigs.configuredRules).forEach(([name, conf]) => {
+  configuredRules['ember-template-lint/' + name] = [];
+  configuredRules['ember-template-lint/' + name].push(conf.severity);
+  if (typeof conf.config !== 'boolean') {
+    configuredRules['ember-template-lint/' + name].push(conf.config);
+  }
+});
+
+const configuredOverrides = [];
+
+for (const configuredOverride of lintConfigs.configuredOverrides) {
+  const configuredRules = {};
+  Object.entries(configuredOverride.rules).forEach(([name, conf]) => {
+    configuredRules['ember-template-lint/' + name] = [];
+    configuredRules['ember-template-lint/' + name].push(conf.severity);
+    if (typeof conf.config !== 'boolean') {
+      configuredRules['ember-template-lint/' + name].push(conf.config);
+    }
+  });
+  configuredOverrides.push({
+    files: configuredOverride.files,
+    rules: configuredRules
+  });
+}
+
+
+module.exports = {
+  configs: configs,
+  rules: createRules(rules),
+  configuredRules,
+  configuredOverrides
+};

package/lib/ember-template-lint/worker.js

@@ -0,0 +1,13 @@
+const { runAsWorker } = require('synckit');
+
+runAsWorker(async (options) => {
+  const Lint = await import('ember-template-lint');
+  const lint = new Lint.default(options);
+  await lint.loadConfig();
+  return {
+    configs: lint.config.loadedConfigurations,
+    rules: Object.keys(lint.config.loadedRules),
+    configuredRules: lint.config.rules,
+    configuredOverrides: lint.config.overrides,
+  };
+});

package/lib/index.js

@@ -8,10 +8,9 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const configs = require('./config');
-const base = require('./config/base');
+const configs = require('./config-legacy');
+const base = require('./config-legacy/base');
 const templateRules = require('./ember-template-lint/info');
-const processor = require('./processor');
 
 //------------------------------------------------------------------------------
 // Plugin Definition
@@ -25,8 +24,5 @@ module.exports = {
   configs: {
     base,
     ...configs
-  },
-  processors: {
-    'noop': processor,
   }
 };

package/lib/parser/hbs-parser.js

@@ -0,0 +1,57 @@
+
+class Scope {
+  type = 'global';
+  variables = [];
+  through= [];
+  set = new Map();
+  upper = null;
+  childScopes = [];
+  references = [];
+  block = null;
+}
+
+class ScopeManager {
+  globalScope = new Scope();
+  scopes = [this.globalScope];
+
+  acquire() {
+    return;
+  }
+
+  getDeclaredVariables() {
+    return [];
+  }
+}
+
+module.exports = {
+  parseForESLint(code) {
+    const comments = [];
+    const types = new Set(['Program']);
+    const ast = {};
+    ast.body = [];
+    ast.tokens = [ast];
+    ast.range = [0, code.length];
+    const lines = code.split('\n');
+    ast.loc = {
+      start: {
+        line: 1,
+        column: 1
+      },
+      end: {
+        line: lines.length,
+        column: lines[lines.length - 1].length
+      }
+    };
+    ast.comments = comments;
+    const visitorKeys = {};
+    types.forEach((t) => {
+      visitorKeys[t] = [];
+    });
+    ast.type = 'Program';
+    ast.isHbs = true;
+    ast.contents = code;
+    const scope = new ScopeManager();
+    scope.globalScope.block = ast;
+    return { ast, scopeManager: scope, visitorKeys };
+  }
+};

package/lib/rules/hbs-worker.js

@@ -113,12 +113,23 @@ async function _applyFixes(options, results, columnOffset) {
   return currentSource;
 }
 
-runAsWorker(async (filename, text, options, columnOffset=0) => {
+async function runTemplateLint(filename, text, options, columnOffset=0) {
   const Lint = await import('ember-template-lint');
   const lint = new Lint.default(options);
   process.env.emberTemplateLintFileName = filename;
   process.env.emberTemplateLintFixMode = false;
   await lint.loadConfig();
+  const processedConf = lint.config;
+  delete options.config;
+  await lint.loadConfig();
+  lint.config.rules = {
+    ...lint.config.rules,
+    ...processedConf.rules
+  };
+  lint.config.overrides = [
+    ...lint.config.overrides,
+    ...processedConf.overrides
+  ];
   let fileConfig = lint._moduleStatusCache.getConfigForFile(options);
   if (fileConfig.loadedRules['prettier']) {
     const rule = fileConfig.loadedRules['prettier'].prototype;
@@ -131,14 +142,16 @@ runAsWorker(async (filename, text, options, columnOffset=0) => {
 
   const messages = await lint.verify({
     source: text,
-    filePath: filename.replace('.gts', '.hbs')
+    filePath: filename,
   });
   process.env.emberTemplateLintFixMode = true;
   await _applyFixes.call(lint,{
     source: text,
-    filePath: filename.replace('.gts', '.hbs'),
+    filePath: filename,
   }, messages, columnOffset);
   return {
     messages,
   };
-});
+}
+
+runAsWorker(runTemplateLint);

package/lib/rules/lint.js

@@ -1,5 +1,6 @@
 'use strict';
 const synckit = require('synckit');
+const path = require('path');
 const DocumentLines = require('../utils/document');
 const { templateLintConfig } = require('../ember-template-lint/config');
 
@@ -22,7 +23,13 @@ function runTemplateLint(node, context) {
 
   try {
     const syncFn = synckit.createSyncFn(require.resolve('./hbs-worker'));
-    const response = syncFn(filename, text, { config: templateLintConfig }, columnOffset);
+    const config = JSON.parse(JSON.stringify(templateLintConfig));
+    for (const key of Object.keys(config.rules)) {
+      if (config.rules[key].__placeholder__) {
+        delete config.rules[key];
+      }
+    }
+    const response = syncFn(filename, text, { config, workingDir: path.dirname(filename) }, columnOffset);
     const lintMessages = response.messages;
     lintMessages.forEach((m) => {
       if (m.fix) {

package/lib/utils/document.js

@@ -0,0 +1,100 @@
+/**
+ * @typedef {{ line: number; character: number }} Position
+ */
+
+// Helper class to convert line/column from and to offset
+// taken and adapt from https://github.com/typed-ember/glint/blob/main/packages/core/src/language-server/util/position.ts
+class DocumentLines {
+  /**
+   * @param {string} contents
+   */
+  constructor(contents) {
+    this.lineStarts = computeLineStarts(contents);
+  }
+
+  /**
+   * @param {Position} position
+   * @return {number}
+   */
+  positionToOffset(position) {
+    const { line, character } = position;
+    return this.lineStarts[line] + character;
+  }
+
+  /**
+   *
+   * @param {number} position
+   * @return {Position}
+   */
+  offsetToPosition(position) {
+    const lineStarts = this.lineStarts;
+    let line = 0;
+    while (line + 1 < lineStarts.length && lineStarts[line + 1] <= position) {
+      line++;
+    }
+    const character = position - lineStarts[line];
+    return { line, character };
+  }
+}
+
+/**
+ * @returns {number[]}
+ * @param {string} text
+ */
+function computeLineStarts(text) {
+  const result = [];
+  let pos = 0;
+  let lineStart = 0;
+  while (pos < text.length) {
+    const ch = text.codePointAt(pos);
+    pos++;
+    switch (ch) {
+    case 13 /* carriageReturn */: {
+      if (text.codePointAt(pos) === 10 /* lineFeed */) {
+        pos++;
+      }
+    }
+    // falls through
+    case 10 /* lineFeed */: {
+      result.push(lineStart);
+      lineStart = pos;
+      break;
+    }
+    default: {
+      if (ch > 127 /* maxAsciiCharacter */ && isLineBreak(ch)) {
+        result.push(lineStart);
+        lineStart = pos;
+      }
+      break;
+    }
+    }
+  }
+  result.push(lineStart);
+  return result;
+}
+
+/* istanbul ignore next */
+/**
+ * @param {number} ch
+ * @return {boolean}
+ */
+function isLineBreak(ch) {
+  // ES5 7.3:
+  // The ECMAScript line terminator characters are listed in Table 3.
+  //     Table 3: Line Terminator Characters
+  //     Code Unit Value     Name                    Formal Name
+  //     \u000A              Line Feed               <LF>
+  //     \u000D              Carriage Return         <CR>
+  //     \u2028              Line separator          <LS>
+  //     \u2029              Paragraph separator     <PS>
+  // Only the characters in Table 3 are treated as line terminators. Other new line or line
+  // breaking characters are treated as white space but not as line terminators.
+  return (
+    ch === 10 /* lineFeed */ ||
+    ch === 13 /* carriageReturn */ ||
+    ch === 8232 /* lineSeparator */ ||
+    ch === 8233 /* paragraphSeparator */
+  );
+}
+
+module.exports = DocumentLines;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-ember-template-lint",
-  "version": "0.18.0",
+  "version": "0.21.0",
   "description": "Provide linting for ember template",
   "keywords": [
     "eslint",
@@ -10,20 +10,15 @@
   "author": "Patrick Pircher",
   "main": "lib/index.js",
   "repository": "patricklx/eslint-plugin-ember-template-lint",
-  "scripts": {
-    "test": "jest",
-    "lint:js": "eslint --cache .",
-    "test:watch": "jest --watchAll"
-  },
   "dependencies": {
-    "@glimmer/syntax": "^0.84.3",
-    "@typescript-eslint/parser": "^5.59.7",
-    "@typescript-eslint/typescript-estree": "^5.59.7",
+    "@glimmer/syntax": "^0.93.0",
+    "@typescript-eslint/parser": "^8.16.0",
+    "@typescript-eslint/typescript-estree": "^8.16.0",
     "ember-eslint-parser": "^0.5.6",
     "ember-template-recast": "^6.1.5",
     "ember-template-lint": "^6.0.0",
     "prettier-linter-helpers": "^1.0.0",
-    "synckit": "^0.8.5",
+    "synckit": "^0.9.2",
     "typescript": "^5.0.4"
   },
   "peerDependencies": {
@@ -33,7 +28,7 @@
     "ember-template-lint-plugin-prettier": "^5.0.0",
     "eslint": "^8.41.0",
     "eslint-plugin-jest": "^27.2.1",
-    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-n": "^17.14.0",
     "jest": "^29.5.0"
   },
   "jest": {
@@ -46,6 +41,13 @@
   },
   "license": "ISC",
   "files": [
-    "lib/rules/*.js"
-  ]
-}
+    "lib/**/*.js"
+  ],
+  "scripts": {
+    "test": "pnpm run /test:.*/",
+    "test:jest": "jest",
+    "lint:js": "eslint --cache lib tests",
+    "lint:js:fix": "eslint --cache lib tests --fix",
+    "test-watch": "jest --watchAll"
+  }
+}