4am and it works

Author: JoshuaKGoldberg

.prettierrc

@@ -1,5 +1,6 @@
 {
+    "arrowParens": "avoid",
     "printWidth": 100,
     "tabWidth": 4,
     "trailingComma": "all"
-}
+}

docs/Architecture.md

@@ -15,7 +15,8 @@ Within `src/conversion/convertConfig.ts`, the following steps occur:
 2. TSLint rules are converted into their ESLint configurations
 3. ESLint configurations are simplified based on extended ESLint and TSLint presets
 4. The simplified configuration is written to the output config file
-5. A summary of the results is printed to the user's console
+5. Files to transform comments in have source text rewritten using the same rule conversion logic
+6. A summary of the results is printed to the user's console
 
 ### Conversion Results
 

package-lock.json

@@ -12,6 +12,7 @@
     "dependencies": {
         "chalk": "4.0.0",
         "commander": "5.0.0",
+        "glob": "^7.1.6",
         "strip-json-comments": "3.1.0",
         "tslint": "6.1.1",
         "typescript": "3.8.3"
@@ -22,6 +23,7 @@
         "@babel/plugin-proposal-optional-chaining": "7.9.0",
         "@babel/preset-env": "7.9.5",
         "@babel/preset-typescript": "7.9.0",
+        "@types/glob": "^7.1.1",
         "@types/jest": "25.2.1",
         "@types/node": "12.12.21",
         "@typescript-eslint/eslint-plugin": "2.28.0",

package.json

@@ -1,11 +1,5 @@
-import * as fs from "fs";
-
-export type ReadDirOptions = { encoding?: string | null; withFileTypes: true };
-
 export type FileSystem = {
     fileExists: (filePath: string) => Promise<boolean>;
     readFile: (filePath: string) => Promise<Error | string>;
     writeFile: (filePath: string, contents: string) => Promise<Error | undefined>;
-    writeFileSync: (filePath: string, contents: string) => undefined;
-    readDir: (dirPath: string, options: ReadDirOptions) => Promise<Error | fs.Dirent[]>;
 };

src/adapters/fileSystem.ts

@@ -1,12 +1,10 @@
 import * as fs from "fs";
 import { promisify } from "util";
 
-import { FileSystem, ReadDirOptions } from "./fileSystem";
+import { FileSystem } from "./fileSystem";
 
 const readFile = promisify(fs.readFile);
-const readDir = promisify(fs.readdir);
 const writeFile = promisify(fs.writeFile);
-const writeFileSync = fs.writeFileSync;
 
 export const fsFileSystem: FileSystem = {
     fileExists: async (filePath: string) => {
@@ -30,18 +28,4 @@ export const fsFileSystem: FileSystem = {
             return error;
         }
     },
-    writeFileSync: (filePath: string, contents: string) => {
-        try {
-            return writeFileSync(filePath, contents);
-        } catch (error) {
-            return error;
-        }
-    },
-    readDir: async (dirPath: string, options: ReadDirOptions) => {
-        try {
-            return readDir(dirPath, options);
-        } catch (error) {
-            return error;
-        }
-    },
 };

src/adapters/fsFileSystem.ts

@@ -0,0 +1,11 @@
+import glob from "glob";
+
+export const globAsync = async (pattern: string) => {
+    return new Promise<string[] | Error>(resolve => {
+        glob(pattern, (error, matches) => {
+            resolve(error || matches);
+        });
+    });
+};
+
+export type GlobAsync = typeof globAsync;

src/adapters/globAsync.ts

@@ -2,10 +2,20 @@ import { EOL } from "os";
 
 import { childProcessExec } from "../adapters/childProcessExec";
 import { fsFileSystem } from "../adapters/fsFileSystem";
+import { globAsync } from "../adapters/globAsync";
 import { nativeImporter } from "../adapters/nativeImporter";
 import { processLogger } from "../adapters/processLogger";
 import { bind } from "../binding";
+import { convertComments, ConvertCommentsDependencies } from "../comments/convertComments";
+import {
+    ConvertFileCommentsDependencies,
+    convertFileComments,
+} from "../comments/convertFileComments";
 import { convertConfig, ConvertConfigDependencies } from "../conversion/convertConfig";
+import {
+    replaceFileComments,
+    ReplaceFileCommentsDependencies,
+} from "../comments/replaceFileComments";
 import {
     convertEditorConfig,
     ConvertEditorConfigDependencies,
@@ -50,7 +60,20 @@ import { convertRules, ConvertRulesDependencies } from "../rules/convertRules";
 import { mergers } from "../rules/mergers";
 import { rulesConverters } from "../rules/rulesConverters";
 import { runCli, RunCliDependencies } from "./runCli";
-import { convertComments, ConvertCommentsResultsDependencies } from "../rules/convertComments";
+
+const replaceFileCommentsDependencies: ReplaceFileCommentsDependencies = {
+    converters: rulesConverters,
+};
+
+const convertFileCommentsDependencies: ConvertFileCommentsDependencies = {
+    fileSystem: fsFileSystem,
+    replaceFileComments: bind(replaceFileComments, replaceFileCommentsDependencies),
+};
+
+const convertCommentsDependencies: ConvertCommentsDependencies = {
+    convertFileComments: bind(convertFileComments, convertFileCommentsDependencies),
+    globAsync,
+};
 
 const convertRulesDependencies: ConvertRulesDependencies = {
     converters: rulesConverters,
@@ -100,10 +123,6 @@ const simplifyPackageRulesDependencies: SimplifyPackageRulesDependencies = {
     retrieveExtendsValues: bind(retrieveExtendsValues, retrieveExtendsValuesDependencies),
 };
 
-const convertCommentsResultsDependencies: ConvertCommentsResultsDependencies = {
-    fileSystem: fsFileSystem,
-};
-
 const writeConversionResultsDependencies: WriteConversionResultsDependencies = {
     fileSystem: fsFileSystem,
 };
@@ -122,14 +141,14 @@ const convertEditorConfigDependencies: ConvertEditorConfigDependencies = {
 };
 
 const convertConfigDependencies: ConvertConfigDependencies = {
+    convertComments: bind(convertComments, convertCommentsDependencies),
     convertRules: bind(convertRules, convertRulesDependencies),
     findOriginalConfigurations: bind(
         findOriginalConfigurations,
         findOriginalConfigurationsDependencies,
     ),
     reportConversionResults: bind(reportConversionResults, reportConversionResultsDependencies),
     simplifyPackageRules: bind(simplifyPackageRules, simplifyPackageRulesDependencies),
-    convertComments: bind(convertComments, convertCommentsResultsDependencies),
     writeConversionResults: bind(writeConversionResults, writeConversionResultsDependencies),
 };
 

src/cli/main.ts

@@ -19,13 +19,13 @@ export const runCli = async (
 ): Promise<ResultStatus> => {
     const command = new Command()
         .usage("[options] <file ...> --language [language]")
+        .option("--comments [files]", "convert tslint:disable comments in matching files")
         .option("--config [config]", "eslint configuration file to output to")
+        .option("--editor [editor]", "editor configuration file to convert")
         .option("--eslint [eslint]", "eslint configuration file to convert using")
         .option("--package [package]", "package configuration file to convert using")
         .option("--tslint [tslint]", "tslint configuration file to convert using")
         .option("--typescript [typescript]", "typescript configuration file to convert using")
-        .option("--editor [editor]", "editor configuration file to convert")
-        .option("-C --convertComments", "convert all tslint:disable comments into eslint-disable")
         .option("-V --version", "output the package version");
 
     const parsedArgv = {

src/cli/runCli.ts

@@ -0,0 +1,50 @@
+import { GlobAsync } from "../adapters/globAsync";
+import { SansDependencies } from "../binding";
+import { ResultStatus, ResultWithStatus } from "../types";
+import { separateErrors, uniqueFromSources, isError } from "../utils";
+import { convertFileComments } from "./convertFileComments";
+
+export type ConvertCommentsDependencies = {
+    convertFileComments: SansDependencies<typeof convertFileComments>;
+    globAsync: GlobAsync;
+};
+
+export const convertComments = async (
+    dependencies: ConvertCommentsDependencies,
+    filePathGlobs: string | string[] | undefined,
+): Promise<ResultWithStatus> => {
+    if (filePathGlobs === undefined) {
+        return {
+            status: ResultStatus.Succeeded,
+        };
+    }
+
+    const [fileGlobErrors, globbedFilePaths] = separateErrors(
+        await Promise.all(uniqueFromSources(filePathGlobs).map(dependencies.globAsync)),
+    );
+    if (fileGlobErrors.length !== 0) {
+        return {
+            errors: fileGlobErrors,
+            status: ResultStatus.Failed,
+        };
+    }
+
+    const ruleConversionCache = new Map<string, string | undefined>();
+    const fileFailures = (
+        await Promise.all(
+            uniqueFromSources(...globbedFilePaths).map(async filePath =>
+                dependencies.convertFileComments(filePath, ruleConversionCache),
+            ),
+        )
+    ).filter(isError);
+    if (fileFailures.length !== 0) {
+        return {
+            errors: fileFailures,
+            status: ResultStatus.Failed,
+        };
+    }
+
+    return {
+        status: ResultStatus.Succeeded,
+    };
+};

src/comments/convertComments.ts

@@ -0,0 +1,25 @@
+import { FileSystem } from "../adapters/fileSystem";
+import { SansDependencies } from "../binding";
+import { parseFileComments } from "./parseFileComments";
+import { replaceFileComments } from "./replaceFileComments";
+
+export type ConvertFileCommentsDependencies = {
+    fileSystem: Pick<FileSystem, "readFile" | "writeFile">;
+    replaceFileComments: SansDependencies<typeof replaceFileComments>;
+};
+
+export const convertFileComments = async (
+    dependencies: ConvertFileCommentsDependencies,
+    filePath: string,
+    ruleConversionCache: Map<string, string | undefined>,
+) => {
+    const content = await dependencies.fileSystem.readFile(filePath);
+    if (content instanceof Error) {
+        return content;
+    }
+
+    const comments = parseFileComments(filePath, content);
+    const newFileContent = dependencies.replaceFileComments(content, comments, ruleConversionCache);
+
+    return await dependencies.fileSystem.writeFile(filePath, newFileContent);
+};

src/comments/convertFileComments.ts

@@ -0,0 +1,66 @@
+import * as utils from "tsutils";
+import * as ts from "typescript";
+
+export type FileComment = {
+    commentKind: ts.CommentKind;
+    directive: TSLintDirective;
+    end: number;
+    pos: number;
+    ruleNames: string[];
+};
+
+export type TSLintDirective =
+    | "tslint:disable"
+    | "tslint:disable-next-line"
+    | "tslint:enable"
+    | "tslint:enable-next-line";
+
+export const parseFileComments = (filePath: string, content: string) => {
+    // See https://github.com/Microsoft/TypeScript/issues/21049
+    const sourceFile = ts.createSourceFile(
+        filePath,
+        content,
+        ts.ScriptTarget.Latest,
+        /*setParentNodes */ true,
+    );
+    const directives: FileComment[] = [];
+
+    utils.forEachComment(sourceFile, (fullText, comment) => {
+        const parsedComment = parseFileComment(fullText, comment);
+        if (parsedComment !== undefined) {
+            directives.push(parsedComment);
+        }
+    });
+
+    return directives;
+};
+
+/**
+ * @see https://github.com/palantir/tslint/blob/master/src/enableDisableRules.ts
+ */
+const tslintRegex = new RegExp(/tslint:(enable|disable)(?:-(line|next-line))?(:|\s|$)/g);
+
+const parseFileComment = (fullText: string, comment: ts.CommentRange): FileComment | undefined => {
+    const commentText = (comment.kind === ts.SyntaxKind.SingleLineCommentTrivia
+        ? fullText.substring(comment.pos + 2, comment.end)
+        : fullText.substring(comment.pos + 2, comment.end - 2)
+    ).trim();
+    const match = tslintRegex.exec(commentText);
+    if (match === null) {
+        return undefined;
+    }
+
+    return {
+        commentKind: comment.kind,
+        directive: match[0].replace("e:", "e") as TSLintDirective,
+        end: comment.end,
+        pos: comment.pos,
+        ruleNames: commentText.slice(match[0].length).split(/\s+/).map(trimColons).filter(Boolean),
+    };
+};
+
+const trimColons = (text: string) =>
+    text
+        .replace(/^(:|\s)*/, "")
+        .replace(/(:|\s)*$/, "")
+        .trim();