ignore-lint-errors 0.3.0 → 0.4.1

package/README.md

@@ -2,14 +2,36 @@
 
 # ignore-lint-errors
 
-_Codemod to add ignore directives_
+_Codemod to ignore lint errors per line_
+
+
+## Why?
+
+In large production projects, ignoring lint errors for existing code is the most pragmatic, quickest approach to complete these tasks:
+
+- Introduce a new lint rule.
+- Update a linter to the next minor or major version.
+- Migrate code to a different format, e.g. convert `*.{gjs,js}` (JavaScript) to `*.{gts,ts}` (TypeScript).
+
+For the sake of reducing noise, some prefer disabling linting for the entire file. They do so by adding a global directive (e.g. `eslint-disable`) or creating a special file to "suppress" files with many errors.
+
+Instead, `ignore-lint-error` takes the honest approach: It adds a local directive (e.g. `eslint-disable-next-line`) for every line that has an error. This way, we can easily see and show others (including non-engineers),
+
+- How bad our code is in order to create the urgency to fix issues. The number of local ignores (1 per line) always estimates the actual number of errors better than the number of global ignores (1 per file).
+- Which parts of our code are good and should be replicated, and which parts are bad and to be avoided. When there is a global ignore, a linter doesn't check the file for the given rule(s).
 
 
 ## Usage
 
 ### Arguments
 
-[PROVIDE REQUIRED AND OPTIONAL ARGUMENTS.]
+You must pass `--linter` to indicate which linter to run.
+
+```sh
+pnpx ignore-lint-errors --linter eslint
+pnpx ignore-lint-errors --linter stylelint
+pnpx ignore-lint-errors --linter typescript
+```
 
 <details>
 
@@ -44,6 +66,7 @@ pnpm build
 ## Compatibility
 
 - Node.js v22 or above
+- Tested against `eslint@v9`, `stylelint@v17`, `typescript@v5`
 
 
 ## Contributing

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

@@ -8,7 +8,7 @@ process.title = 'ignore-lint-errors';
 // Set codemod options
 const argv = yargs(hideBin(process.argv))
     .option('linter', {
-    choices: ['eslint', 'typescript'],
+    choices: ['eslint', 'stylelint', 'typescript'],
     describe: 'Linter to run',
     type: 'string',
 })

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

@@ -9,6 +9,7 @@ function findDependencies(projectRoot) {
         eslint: projectDependencies.has('eslint'),
         glint: projectDependencies.has('@glint/core') ||
             projectDependencies.has('@glint/ember-tsc'),
+        stylelint: projectDependencies.has('stylelint'),
         typescript: projectDependencies.has('typescript'),
     };
 }

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

@@ -1,16 +1,8 @@
 import { readFileSync, writeFileSync } from 'node:fs';
-import { EOL } from 'node:os';
 import { join } from 'node:path';
 import { removeFiles } from '@codemod-utils/files';
+import { ignoreErrors } from '../../utils/ignore-errors/stylelint.js';
 import { outputFilePath, parseOutputFile } from '../../utils/linters/eslint.js';
-function ignoreErrors(file, lintErrors) {
-    const lines = file.split(EOL);
-    lintErrors.forEach(({ line, message }) => {
-        const ignoreDirective = `// eslint-disable-next-line ${message}`;
-        lines.splice(line - 1, 0, ignoreDirective);
-    });
-    return lines.join(EOL);
-}
 export function ignoreErrorsFromEslint(options) {
     const { projectRoot } = options;
     const outputFile = readFileSync(join(projectRoot, outputFilePath), 'utf8');

package/dist/src/steps/ignore-errors/index.js

@@ -1,2 +1,3 @@
 export * from './eslint.js';
+export * from './stylelint.js';
 export * from './typescript.js';

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

@@ -0,0 +1,16 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { removeFiles } from '@codemod-utils/files';
+import { ignoreErrors } from '../../utils/ignore-errors/stylelint.js';
+import { outputFilePath, parseOutputFile, } from '../../utils/linters/stylelint.js';
+export function ignoreErrorsFromStylelint(options) {
+    const { projectRoot } = options;
+    const outputFile = readFileSync(join(projectRoot, outputFilePath), 'utf8');
+    const filesWithErrors = parseOutputFile(outputFile, projectRoot);
+    filesWithErrors.forEach(({ filePath, lintErrors }) => {
+        const file = readFileSync(join(projectRoot, filePath), 'utf8');
+        const newFile = ignoreErrors(file, lintErrors);
+        writeFileSync(join(projectRoot, filePath), newFile, 'utf8');
+    });
+    removeFiles([outputFilePath], { projectRoot });
+}

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

@@ -1,49 +1,8 @@
 import { readFileSync, writeFileSync } from 'node:fs';
-import { EOL } from 'node:os';
 import { join } from 'node:path';
-import { updateTemplates } from '@codemod-utils/ast-template-tag';
 import { removeFiles } from '@codemod-utils/files';
-import { findLinesWithTemplate, isParseable, } from '../../utils/ignore-errors/typescript.js';
+import { ignoreErrors, ignoreErrorsFallback, isParseable, } from '../../utils/ignore-errors/typescript.js';
 import { outputFilePath, parseOutputFile, } from '../../utils/linters/typescript.js';
-function ignoreErrors(file, lintErrors) {
-    const linesWithTemplate = findLinesWithTemplate(file);
-    const lines = file.split(EOL);
-    lintErrors.forEach(({ line, message }) => {
-        const erroredInTemplate = linesWithTemplate.some(([lineStart, lineEnd]) => {
-            return lineStart <= line && line <= lineEnd;
-        });
-        const ignoreDirective = erroredInTemplate
-            ? `{{! @glint-expect-error: ${message} }}`
-            : `// @ts-expect-error: ${message}`;
-        lines.splice(line - 1, 0, ignoreDirective);
-    });
-    return lines.join(EOL);
-}
-// For fallback, ignore type checks in templates
-function ignoreErrorsFallback(file, lintErrors) {
-    const linesWithTemplate = findLinesWithTemplate(file);
-    const lines = file.split(EOL);
-    let hasErrorInTemplate = false;
-    lintErrors.forEach(({ line, message }) => {
-        const erroredInTemplate = linesWithTemplate.some(([lineStart, lineEnd]) => {
-            return lineStart <= line && line <= lineEnd;
-        });
-        if (erroredInTemplate) {
-            hasErrorInTemplate = true;
-            return;
-        }
-        const ignoreDirective = `// @ts-expect-error: ${message}`;
-        lines.splice(line - 1, 0, ignoreDirective);
-    });
-    let newFile = lines.join(EOL);
-    if (hasErrorInTemplate) {
-        newFile = updateTemplates(newFile, (code) => {
-            const ignoreDirective = '{{! @glint-nocheck }}';
-            return [ignoreDirective, code].join(EOL);
-        });
-    }
-    return newFile;
-}
 export function ignoreErrorsFromTypescript(options) {
     const { projectRoot } = options;
     const outputFile = readFileSync(join(projectRoot, outputFilePath), 'utf8');

package/dist/src/steps/ignore-errors.js

@@ -1,4 +1,4 @@
-import { ignoreErrorsFromEslint, ignoreErrorsFromTypescript, } from './ignore-errors/index.js';
+import { ignoreErrorsFromEslint, ignoreErrorsFromStylelint, ignoreErrorsFromTypescript, } from './ignore-errors/index.js';
 export function ignoreErrors(options) {
     const { dependencies, linter } = options;
     switch (linter) {
@@ -8,6 +8,12 @@ export function ignoreErrors(options) {
             }
             break;
         }
+        case 'stylelint': {
+            if (dependencies.stylelint) {
+                ignoreErrorsFromStylelint(options);
+            }
+            break;
+        }
         case 'typescript': {
             if (dependencies.typescript) {
                 ignoreErrorsFromTypescript(options);

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

@@ -1,2 +1,3 @@
 export * from './eslint.js';
+export * from './stylelint.js';
 export * from './typescript.js';

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

@@ -0,0 +1,19 @@
+import { execSync } from 'node:child_process';
+import { outputFilePath } from '../../utils/linters/stylelint.js';
+export function runStylelint(options) {
+    const { projectRoot } = options;
+    const command = [
+        './node_modules/.bin/stylelint "**/*.css"',
+        '--allow-empty-input',
+        '--formatter json',
+        `--output-file ${outputFilePath}`,
+        '--quiet',
+        '2>/dev/null', // Suppress output to process.stderr
+    ].join(' ');
+    try {
+        execSync(command, { cwd: projectRoot });
+    }
+    catch {
+        // Do nothing
+    }
+}

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

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
-import { runEslint, runTypescript } from './lint-files/index.js';
+import { runEslint, runStylelint, runTypescript } from './lint-files/index.js';
 export function lintFiles(options) {
     const { dependencies, linter, projectRoot } = options;
     if (!existsSync(join(projectRoot, '.ignore-lint-errors'))) {
@@ -13,6 +13,12 @@ export function lintFiles(options) {
             }
             break;
         }
+        case 'stylelint': {
+            if (dependencies.stylelint) {
+                runStylelint(options);
+            }
+            break;
+        }
         case 'typescript': {
             if (dependencies.typescript) {
                 runTypescript(options);

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

@@ -0,0 +1,9 @@
+import { EOL } from 'node:os';
+export function ignoreErrors(file, lintErrors) {
+    const lines = file.split(EOL);
+    lintErrors.forEach(({ line, message }) => {
+        const ignoreDirective = `// eslint-disable-next-line ${message}`;
+        lines.splice(line - 1, 0, ignoreDirective);
+    });
+    return lines.join(EOL);
+}

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

@@ -0,0 +1,9 @@
+import { EOL } from 'node:os';
+export function ignoreErrors(file, lintErrors) {
+    const lines = file.split(EOL);
+    lintErrors.forEach(({ line, message }) => {
+        const ignoreDirective = `/* stylelint-disable-next-line ${message} */`;
+        lines.splice(line - 1, 0, ignoreDirective);
+    });
+    return lines.join(EOL);
+}

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

@@ -1,5 +1,6 @@
+import { EOL } from 'node:os';
 import { AST } from '@codemod-utils/ast-template';
-import { findTemplateTags } from '@codemod-utils/ast-template-tag';
+import { findTemplateTags, updateTemplates, } from '@codemod-utils/ast-template-tag';
 export function findLinesWithTemplate(file) {
     function getLOC(file) {
         const matches = file.match(/\r?\n/g);
@@ -15,6 +16,45 @@ export function findLinesWithTemplate(file) {
     });
     return linesWithTemplate;
 }
+export function ignoreErrors(file, lintErrors) {
+    const linesWithTemplate = findLinesWithTemplate(file);
+    const lines = file.split(EOL);
+    lintErrors.forEach(({ line, message }) => {
+        const erroredInTemplate = linesWithTemplate.some(([lineStart, lineEnd]) => {
+            return lineStart <= line && line <= lineEnd;
+        });
+        const ignoreDirective = erroredInTemplate
+            ? `{{! @glint-expect-error: ${message} }}`
+            : `// @ts-expect-error: ${message}`;
+        lines.splice(line - 1, 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);
+    let hasErrorInTemplate = false;
+    lintErrors.forEach(({ line, message }) => {
+        const erroredInTemplate = linesWithTemplate.some(([lineStart, lineEnd]) => {
+            return lineStart <= line && line <= lineEnd;
+        });
+        if (erroredInTemplate) {
+            hasErrorInTemplate = true;
+            return;
+        }
+        const ignoreDirective = `// @ts-expect-error: ${message}`;
+        lines.splice(line - 1, 0, ignoreDirective);
+    });
+    let newFile = lines.join(EOL);
+    if (hasErrorInTemplate) {
+        newFile = updateTemplates(newFile, (code) => {
+            const ignoreDirective = '{{! @glint-nocheck }}';
+            return [ignoreDirective, code].join(EOL);
+        });
+    }
+    return newFile;
+}
 export function isParseable(file) {
     const traverse = AST.traverse();
     let isParseable = true;

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

@@ -27,6 +27,9 @@ export function parseOutputFile(file, projectRoot) {
                 message: ruleIds.join(', '),
             });
         });
+        if (lintErrors.length === 0) {
+            return;
+        }
         lintErrors.sort((a, b) => {
             if (a.line < b.line) {
                 return 1;

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

@@ -0,0 +1,51 @@
+import { relative, sep } from 'node:path';
+export const outputFilePath = '.ignore-lint-errors/stylelint.txt';
+export function parseOutputFile(file, projectRoot) {
+    const filePathToData = new Map();
+    const records = JSON.parse(file);
+    records.forEach((record) => {
+        const { errored, source: absoluteFilePath, warnings } = record;
+        if (!errored) {
+            return;
+        }
+        const data = new Map();
+        warnings.forEach(({ line, rule }) => {
+            if (data.has(line)) {
+                data.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;
+            }
+            return 0;
+        });
+        filesWithErrors.push({
+            filePath,
+            lintErrors,
+        });
+    });
+    return filesWithErrors;
+}

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

@@ -31,6 +31,9 @@ export function parseOutputFile(file) {
                 message: 'Incorrect type',
             });
         });
+        if (lintErrors.length === 0) {
+            return;
+        }
         lintErrors.sort((a, b) => {
             if (a.line < b.line) {
                 return 1;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ignore-lint-errors",
-  "version": "0.3.0",
-  "description": "Codemod to add ignore directives",
+  "version": "0.4.1",
+  "description": "Codemod to ignore lint errors per line",
   "keywords": [
     "codemod",
     "ember-codemod",