ignore-lint-errors 0.6.0 → 0.8.0

package/README.md

@@ -65,6 +65,33 @@ pnpx ignore-lint-errors --root <path/to/your/project>
 
 </details>
 
+<details>
+
+<summary>Optional: Specify files to lint</summary>
+
+Pass `--src` to lint specific files.
+
+```sh
+# eslint supports files
+pnpx ignore-lint-errors --linter eslint --src app/components/example-1.gts app/templates/example-2.gts
+
+# eslint supports directories
+pnpx ignore-lint-errors --linter eslint --src app tests
+
+# eslint supports globs
+pnpx ignore-lint-errors --linter eslint --src app/{components,templates}/**/*.gts
+```
+
+```sh
+# stylelint supports files
+pnpx ignore-lint-errors --linter stylelint --src app/components/example-1.module.css app/templates/example-2.module.css
+
+# stylelint supports globs
+pnpx ignore-lint-errors --linter stylelint --src **/*.scss
+```
+
+</details>
+
 
 ### Limitations
 

package/dist/bin/ignore-lint-errors.js

@@ -15,11 +15,17 @@ const argv = yargs(hideBin(process.argv))
     .option('root', {
     describe: 'Where to run the codemod',
     type: 'string',
+})
+    .option('src', {
+    describe: 'Locations of files to lint',
+    string: true,
+    type: 'array',
 })
     .demandOption(['linter'])
     .parseSync();
 const codemodOptions = {
     linter: argv['linter'],
     projectRoot: argv['root'] ?? process.cwd(),
+    src: argv['src'],
 };
 runCodemod(codemodOptions);

package/dist/src/steps/create-options.js

@@ -7,17 +7,17 @@ function findDependencies(projectRoot) {
     ]);
     return {
         eslint: projectDependencies.has('eslint'),
-        glint: projectDependencies.has('@glint/core') ||
-            projectDependencies.has('@glint/ember-tsc'),
+        glint: projectDependencies.has('@glint/ember-tsc'),
         stylelint: projectDependencies.has('stylelint'),
         typescript: projectDependencies.has('typescript'),
     };
 }
 export function createOptions(codemodOptions) {
-    const { linter, projectRoot } = codemodOptions;
+    const { linter, projectRoot, src } = codemodOptions;
     return {
         dependencies: findDependencies(projectRoot),
         linter,
         projectRoot,
+        src,
     };
 }

package/dist/src/steps/lint-files/eslint.js

@@ -1,9 +1,44 @@
 import { execSync } from 'node:child_process';
+import { findFiles } from '@codemod-utils/files';
 import { outputFilePath } from '../../utils/linters/eslint.js';
+function getConcurrencyOption(options) {
+    const { projectRoot } = options;
+    let isConcurrencySupported = true;
+    try {
+        const command = [
+            './node_modules/.bin/eslint does-not-exist.js',
+            '--concurrency off',
+            '--no-error-on-unmatched-pattern',
+            '2>/dev/null', // Suppress output to process.stderr
+        ].join(' ');
+        execSync(command, { cwd: projectRoot });
+    }
+    catch {
+        isConcurrencySupported = false;
+    }
+    if (!isConcurrencySupported) {
+        return '';
+    }
+    const filePaths = findFiles('**/*.{gjs,gts,js,ts}', {
+        ignoreList: ['{dist,node_modules}/**/*', '**/*.d.ts'],
+        projectRoot,
+    });
+    const concurrency = Math.max(Math.ceil(Math.log10(filePaths.length)), 1);
+    return `--concurrency ${concurrency}`;
+}
+function getSrc(options) {
+    const { src } = options;
+    if (src === undefined) {
+        return '.';
+    }
+    return src.map((token) => `"${token}"`).join(' ');
+}
 export function runEslint(options) {
     const { projectRoot } = options;
     const command = [
         './node_modules/.bin/eslint',
+        getSrc(options),
+        getConcurrencyOption(options),
         '--format json',
         `--output-file ${outputFilePath}`,
         '--quiet',

package/dist/src/steps/lint-files/stylelint.js

@@ -1,10 +1,17 @@
 import { execSync } from 'node:child_process';
 import { outputFilePath } from '../../utils/linters/stylelint.js';
+function getSrc(options) {
+    const { src } = options;
+    if (src === undefined) {
+        return '**/*.css';
+    }
+    return src.map((token) => `"${token}"`).join(' ');
+}
 export function runStylelint(options) {
     const { projectRoot } = options;
     const command = [
-        './node_modules/.bin/stylelint "**/*.css"',
-        '--allow-empty-input',
+        './node_modules/.bin/stylelint',
+        getSrc(options),
         '--formatter json',
         `--output-file ${outputFilePath}`,
         '--quiet',

package/dist/src/utils/ignore-errors/eslint.js

@@ -1,44 +1,22 @@
 import { EOL } from 'node:os';
-import { AST } from '@codemod-utils/ast-javascript';
-function getIgnoredRules(lineOfCode) {
-    const traverse = AST.traverse(true);
-    let ignoredRules = [];
-    try {
-        traverse(lineOfCode, {
-            visitComment(node) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                const comment = node.value.value.trim();
-                if (comment.startsWith('eslint-disable-next-line')) {
-                    ignoredRules = comment
-                        .replace(/^eslint-disable-next-line\s+/, '')
-                        .split(',')
-                        .map((token) => token.trim());
-                }
-                return false;
-            },
-        });
-    }
-    catch {
-        // Do nothing
-    }
-    return ignoredRules;
-}
+import { getIgnoredRules } from './shared/index.js';
 export function ignoreErrors(file, lintErrors) {
     const lines = file.split(EOL);
+    const ignoreDirective = 'eslint-disable-next-line';
     lintErrors.forEach(({ line, message }) => {
         const currentIndex = line - 1;
         const previousIndex = Math.max(currentIndex - 1, 0);
-        const ignoredRules = getIgnoredRules(lines[previousIndex]);
+        const ignoredRules = getIgnoredRules(lines[previousIndex], {
+            ignoreDirective,
+        });
         if (ignoredRules.length === 0) {
-            const ignoreDirective = `// eslint-disable-next-line ${message}`;
-            lines.splice(currentIndex, 0, ignoreDirective);
+            lines.splice(currentIndex, 0, `// ${ignoreDirective} ${message}`);
         }
         else {
             const newMessage = [...ignoredRules, ...message.split(', ')]
                 .sort()
                 .join(', ');
-            const ignoreDirective = `// eslint-disable-next-line ${newMessage}`;
-            lines.splice(previousIndex, 1, ignoreDirective);
+            lines.splice(previousIndex, 1, `// ${ignoreDirective} ${newMessage}`);
         }
     });
     return lines.join(EOL);

package/dist/src/utils/ignore-errors/shared/index.js

@@ -0,0 +1,24 @@
+import { AST } from '@codemod-utils/ast-javascript';
+export function getIgnoredRules(lineOfCode, options) {
+    const traverse = AST.traverse(true);
+    let ignoredRules = [];
+    try {
+        traverse(lineOfCode, {
+            visitComment(node) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                const comment = node.value.value.trim();
+                if (comment.startsWith(options.ignoreDirective)) {
+                    ignoredRules = comment
+                        .replace(new RegExp(`^${options.ignoreDirective}\\s+`, 'g'), '')
+                        .split(',')
+                        .map((token) => token.trim());
+                }
+                return false;
+            },
+        });
+    }
+    catch {
+        // Do nothing
+    }
+    return ignoredRules;
+}

package/dist/src/utils/ignore-errors/stylelint.js

@@ -1,44 +1,22 @@
 import { EOL } from 'node:os';
-import { AST } from '@codemod-utils/ast-javascript';
-function getIgnoredRules(lineOfCode) {
-    const traverse = AST.traverse(true);
-    let ignoredRules = [];
-    try {
-        traverse(lineOfCode, {
-            visitComment(node) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                const comment = node.value.value.trim();
-                if (comment.startsWith('stylelint-disable-next-line')) {
-                    ignoredRules = comment
-                        .replace(/^stylelint-disable-next-line\s+/, '')
-                        .split(',')
-                        .map((token) => token.trim());
-                }
-                return false;
-            },
-        });
-    }
-    catch {
-        // Do nothing
-    }
-    return ignoredRules;
-}
+import { getIgnoredRules } from './shared/index.js';
 export function ignoreErrors(file, lintErrors) {
     const lines = file.split(EOL);
+    const ignoreDirective = 'stylelint-disable-next-line';
     lintErrors.forEach(({ line, message }) => {
         const currentIndex = line - 1;
         const previousIndex = Math.max(currentIndex - 1, 0);
-        const ignoredRules = getIgnoredRules(lines[previousIndex]);
+        const ignoredRules = getIgnoredRules(lines[previousIndex], {
+            ignoreDirective,
+        });
         if (ignoredRules.length === 0) {
-            const ignoreDirective = `/* stylelint-disable-next-line ${message} */`;
-            lines.splice(currentIndex, 0, ignoreDirective);
+            lines.splice(currentIndex, 0, `/* ${ignoreDirective} ${message} */`);
         }
         else {
             const newMessage = [...ignoredRules, ...message.split(', ')]
                 .sort()
                 .join(', ');
-            const ignoreDirective = `/* stylelint-disable-next-line ${newMessage} */`;
-            lines.splice(previousIndex, 1, ignoreDirective);
+            lines.splice(previousIndex, 1, `/* ${ignoreDirective} ${newMessage} */`);
         }
     });
     return lines.join(EOL);

package/dist/src/utils/ignore-errors/typescript.js

@@ -1,56 +1,92 @@
 import { EOL } from 'node:os';
 import { AST } from '@codemod-utils/ast-template';
-import { findTemplateTags, updateTemplates, } from '@codemod-utils/ast-template-tag';
-export function findLinesWithTemplate(file) {
+import { findTemplateTags as upstreamFindTemplateTags, updateTemplates, } from '@codemod-utils/ast-template-tag';
+import { getIgnoredRules } from './shared/index.js';
+function findTemplateTags(file) {
     function getLOC(file) {
         const matches = file.match(/\r?\n/g);
         return (matches ?? []).length;
     }
-    const templateTags = findTemplateTags(file);
-    const linesWithTemplate = [];
-    templateTags.forEach((templateTag) => {
-        const { range } = templateTag;
+    const templateTags = upstreamFindTemplateTags(file);
+    return templateTags.map((templateTag) => {
+        const { contents, range } = templateTag;
         const lineStart = getLOC(file.substring(0, range.startChar)) + 1;
         const lineEnd = getLOC(file.substring(0, range.endChar)) + 1;
-        linesWithTemplate.push([lineStart, lineEnd]);
+        const lineRange = {
+            end: lineEnd,
+            start: lineStart,
+        };
+        return {
+            contents,
+            lineRange,
+        };
     });
-    return linesWithTemplate;
 }
 export function ignoreErrors(file, lintErrors) {
-    const linesWithTemplate = findLinesWithTemplate(file);
     const lines = file.split(EOL);
+    const templateTags = findTemplateTags(file);
     lintErrors.forEach(({ line, message }) => {
-        const erroredInTemplate = linesWithTemplate.some(([lineStart, lineEnd]) => {
-            return lineStart <= line && line <= lineEnd;
+        const currentIndex = line - 1;
+        const previousIndex = Math.max(currentIndex - 1, 0);
+        const templateTagIndex = templateTags.findIndex(({ lineRange }) => {
+            return lineRange.start <= line && line <= lineRange.end;
+        });
+        const erroredInTemplate = templateTagIndex >= 0;
+        if (erroredInTemplate) {
+            const ignoreDirective = `{{! @glint-expect-error: ${message} }}`;
+            const { contents, lineRange } = templateTags[templateTagIndex];
+            if (lineRange.start !== lineRange.end) {
+                lines.splice(currentIndex, 0, ignoreDirective);
+                return;
+            }
+            const newTemplate = lines[currentIndex].replace(/<template>(.+)<\/template>/, `<template>${ignoreDirective}${contents}</template>`);
+            lines.splice(currentIndex, 1, newTemplate);
+            return;
+        }
+        const ignoreDirective = `// @ts-expect-error: ${message}`;
+        const ignoredRules = getIgnoredRules(lines[previousIndex], {
+            ignoreDirective: 'eslint-disable-next-line',
         });
-        const ignoreDirective = erroredInTemplate
-            ? `{{! @glint-expect-error: ${message} }}`
-            : `// @ts-expect-error: ${message}`;
-        lines.splice(line - 1, 0, ignoreDirective);
+        if (ignoredRules.length === 0) {
+            lines.splice(currentIndex, 0, ignoreDirective);
+        }
+        else {
+            lines.splice(previousIndex, 0, ignoreDirective);
+        }
     });
     return lines.join(EOL);
 }
 // For fallback, ignore type checks in templates
 export function ignoreErrorsFallback(file, lintErrors) {
-    const linesWithTemplate = findLinesWithTemplate(file);
     const lines = file.split(EOL);
+    const templateTags = findTemplateTags(file);
     let hasErrorInTemplate = false;
     lintErrors.forEach(({ line, message }) => {
-        const erroredInTemplate = linesWithTemplate.some(([lineStart, lineEnd]) => {
-            return lineStart <= line && line <= lineEnd;
+        const currentIndex = line - 1;
+        const previousIndex = Math.max(currentIndex - 1, 0);
+        const erroredInTemplate = templateTags.some(({ lineRange }) => {
+            return lineRange.start <= line && line <= lineRange.end;
         });
         if (erroredInTemplate) {
             hasErrorInTemplate = true;
             return;
         }
         const ignoreDirective = `// @ts-expect-error: ${message}`;
-        lines.splice(line - 1, 0, ignoreDirective);
+        const ignoredRules = getIgnoredRules(lines[previousIndex], {
+            ignoreDirective: 'eslint-disable-next-line',
+        });
+        if (ignoredRules.length === 0) {
+            lines.splice(currentIndex, 0, ignoreDirective);
+        }
+        else {
+            lines.splice(previousIndex, 0, ignoreDirective);
+        }
     });
     let newFile = lines.join(EOL);
     if (hasErrorInTemplate) {
         newFile = updateTemplates(newFile, (code) => {
             const ignoreDirective = '{{! @glint-nocheck }}';
-            return [ignoreDirective, code].join(EOL);
+            return [ignoreDirective, code].join('');
         });
     }
     return newFile;
@@ -60,8 +96,8 @@ export function isParseable(file) {
     let isParseable = true;
     try {
         const templateTags = findTemplateTags(file);
-        templateTags.forEach((templateTag) => {
-            traverse(templateTag.contents);
+        templateTags.forEach(({ contents }) => {
+            traverse(contents);
         });
     }
     catch {

package/dist/src/utils/linters/eslint.js

@@ -1,48 +1,31 @@
 import { relative, sep } from 'node:path';
+import { getFilesWithErrors } from './shared/index.js';
 export const outputFilePath = '.ignore-lint-errors/eslint.txt';
-export function parseOutputFile(file, projectRoot) {
+function normalize(file, projectRoot) {
     const filePathToData = new Map();
     const records = JSON.parse(file);
     records.forEach((record) => {
         const { filePath: absoluteFilePath, messages } = record;
+        const filePath = relative(projectRoot, absoluteFilePath).replaceAll(sep, '/');
+        const lineToRules = new Map();
         const data = new Map();
         messages.forEach(({ line, ruleId }) => {
-            if (data.has(line)) {
-                data.get(line).push(ruleId);
+            if (lineToRules.has(line)) {
+                lineToRules.get(line).push(ruleId);
             }
             else {
-                data.set(line, [ruleId]);
-            }
-        });
-        const filePath = relative(projectRoot, absoluteFilePath).replaceAll(sep, '/');
-        filePathToData.set(filePath, data);
-    });
-    const filesWithErrors = [];
-    filePathToData.forEach((data, filePath) => {
-        const lintErrors = [];
-        data.forEach((allMessages, line) => {
-            const ruleIds = Array.from(new Set(allMessages.sort()));
-            lintErrors.push({
-                line,
-                message: ruleIds.join(', '),
-            });
-        });
-        if (lintErrors.length === 0) {
-            return;
-        }
-        lintErrors.sort((a, b) => {
-            if (a.line < b.line) {
-                return 1;
-            }
-            if (b.line < a.line) {
-                return -1;
+                lineToRules.set(line, [ruleId]);
             }
-            return 0;
         });
-        filesWithErrors.push({
-            filePath,
-            lintErrors,
+        lineToRules.forEach((rules, line) => {
+            const message = Array.from(new Set(rules.sort())).join(', ');
+            data.set(line, message);
         });
+        filePathToData.set(filePath, data);
     });
-    return filesWithErrors;
+    return filePathToData;
+}
+export function parseOutputFile(file, projectRoot) {
+    const filePathToData = normalize(file, projectRoot);
+    return getFilesWithErrors(filePathToData);
 }

package/dist/src/utils/linters/shared/index.js

@@ -0,0 +1,29 @@
+export function getFilesWithErrors(filePathToData) {
+    const filesWithErrors = [];
+    filePathToData.forEach((data, filePath) => {
+        const lintErrors = [];
+        data.forEach((message, line) => {
+            lintErrors.push({
+                line,
+                message,
+            });
+        });
+        if (lintErrors.length === 0) {
+            return;
+        }
+        lintErrors.sort((a, b) => {
+            if (a.line < b.line) {
+                return 1;
+            }
+            if (b.line < a.line) {
+                return -1;
+            }
+            return 0;
+        });
+        filesWithErrors.push({
+            filePath,
+            lintErrors,
+        });
+    });
+    return filesWithErrors;
+}

package/dist/src/utils/linters/stylelint.js

@@ -1,6 +1,7 @@
 import { relative, sep } from 'node:path';
+import { getFilesWithErrors } from './shared/index.js';
 export const outputFilePath = '.ignore-lint-errors/stylelint.txt';
-export function parseOutputFile(file, projectRoot) {
+function normalize(file, projectRoot) {
     const filePathToData = new Map();
     const records = JSON.parse(file);
     records.forEach((record) => {
@@ -8,44 +9,26 @@ export function parseOutputFile(file, projectRoot) {
         if (!errored) {
             return;
         }
+        const filePath = relative(projectRoot, absoluteFilePath).replaceAll(sep, '/');
+        const lineToRules = new Map();
         const data = new Map();
         warnings.forEach(({ line, rule }) => {
-            if (data.has(line)) {
-                data.get(line).push(rule);
+            if (lineToRules.has(line)) {
+                lineToRules.get(line).push(rule);
             }
             else {
-                data.set(line, [rule]);
-            }
-        });
-        const filePath = relative(projectRoot, absoluteFilePath).replaceAll(sep, '/');
-        filePathToData.set(filePath, data);
-    });
-    const filesWithErrors = [];
-    filePathToData.forEach((data, filePath) => {
-        const lintErrors = [];
-        data.forEach((allMessages, line) => {
-            const ruleIds = Array.from(new Set(allMessages.sort()));
-            lintErrors.push({
-                line,
-                message: ruleIds.join(', '),
-            });
-        });
-        if (lintErrors.length === 0) {
-            return;
-        }
-        lintErrors.sort((a, b) => {
-            if (a.line < b.line) {
-                return 1;
-            }
-            if (b.line < a.line) {
-                return -1;
+                lineToRules.set(line, [rule]);
             }
-            return 0;
         });
-        filesWithErrors.push({
-            filePath,
-            lintErrors,
+        lineToRules.forEach((rules, line) => {
+            const message = Array.from(new Set(rules.sort())).join(', ');
+            data.set(line, message);
         });
+        filePathToData.set(filePath, data);
     });
-    return filesWithErrors;
+    return filePathToData;
+}
+export function parseOutputFile(file, projectRoot) {
+    const filePathToData = normalize(file, projectRoot);
+    return getFilesWithErrors(filePathToData);
 }

package/dist/src/utils/linters/typescript.js

@@ -1,6 +1,7 @@
 import { EOL } from 'node:os';
+import { getFilesWithErrors } from './shared/index.js';
 export const outputFilePath = '.ignore-lint-errors/typescript.txt';
-export function parseOutputFile(file) {
+function normalize(file) {
     const filePathToData = new Map();
     file.split(EOL).forEach((str) => {
         const matches = str.match(/^(.+)\((\d+),\d+\): error TS\d+: (.+)\.$/);
@@ -9,44 +10,17 @@ export function parseOutputFile(file) {
         }
         const filePath = matches[1];
         const line = Number.parseInt(matches[2]);
-        const message = matches[3];
+        const message = 'Incorrect type';
         if (filePathToData.has(filePath)) {
-            if (filePathToData.get(filePath).has(line)) {
-                filePathToData.get(filePath).get(line).push(message);
-            }
-            else {
-                filePathToData.get(filePath).set(line, [message]);
-            }
+            filePathToData.get(filePath).set(line, message);
         }
         else {
-            filePathToData.set(filePath, new Map([[line, [message]]]));
-        }
-    });
-    const filesWithErrors = [];
-    filePathToData.forEach((data, filePath) => {
-        const lintErrors = [];
-        data.forEach((_allMessages, line) => {
-            lintErrors.push({
-                line,
-                message: 'Incorrect type',
-            });
-        });
-        if (lintErrors.length === 0) {
-            return;
+            filePathToData.set(filePath, new Map([[line, message]]));
         }
-        lintErrors.sort((a, b) => {
-            if (a.line < b.line) {
-                return 1;
-            }
-            if (b.line < a.line) {
-                return -1;
-            }
-            return 0;
-        });
-        filesWithErrors.push({
-            filePath,
-            lintErrors,
-        });
     });
-    return filesWithErrors;
+    return filePathToData;
+}
+export function parseOutputFile(file) {
+    const filePathToData = normalize(file);
+    return getFilesWithErrors(filePathToData);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ignore-lint-errors",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Codemod to ignore lint errors per line",
   "keywords": [
     "codemod",