Implement --stdin and --stdin-filename CLI options

src/runner.ts

@@ -94,6 +94,16 @@ export interface Options {
      */
     rulesDirectory?: string | string[];
 
+    /**
+     * Check files via stdin.
+     */
+    stdin?: boolean;
+
+    /**
+     * Tell TSLint where the actual file being linted through stdin is, if any.
+     */
+    stdinFilename?: string;
+
     /**
      * Run the tests in the given directories to ensure a (custom) TSLint rule's output matches the expected output.
      * When this property is `true` the `files` property is used to specify the directories from which the tests should be executed.
@@ -157,7 +167,9 @@ async function runWorker(options: Options, logger: Logger): Promise<Status> {
 }
 
 async function runLinter(options: Options, logger: Logger): Promise<LintResult> {
-    const { files, program } = resolveFilesAndProgram(options, logger);
+    const program = resolveProgram(options);
+    const files = resolveFiles(options, program, logger);
+
     // if type checking, run the type checker
     if (program && options.typeCheck) {
         const diagnostics = ts.getPreEmitDiagnostics(program);
@@ -173,25 +185,80 @@ async function runLinter(options: Options, logger: Logger): Promise<LintResult>
     return doLinting(options, files, program, logger);
 }
 
-function resolveFilesAndProgram(
-    { files, project, exclude, outputAbsolutePaths }: Options,
+/** Read the stdin stream into a string with all of the contents. */
+async function readStdin(): Promise<string> {
+    return new Promise<string>((resolve, reject) => {
+        let fileData = "";
+
+        process.stdin.setEncoding("utf8");
+
+        process.stdin.on("readable", () => {
+            let chunk: string | Buffer | null = null;
+
+            // tslint:disable-next-line: no-conditional-assignment
+            while ((chunk = process.stdin.read()) !== null) {
+                fileData += chunk;
+            }
+        });
+
+        process.stdin.on("end", () => {
+            resolve(fileData);
+        });
+
+        process.stdin.on("error", (error: Error) => {
+            reject(error);
+        });
+    });
+}
+
+interface ResolvedFile {
+  filename: string;
+  isStdin: boolean;
+}
+
+function resolveProgram(
+    { project }: Options,
+): ts.Program | undefined {
+    if (project !== undefined) {
+        const projectPath = findTsconfig(project);
+
+        if (projectPath === undefined) {
+            throw new FatalError(`Invalid option for project: ${project}`);
+        }
+
+        return Linter.createProgram(projectPath);
+    }
+
+    return undefined;
+}
+
+function resolveFiles(
+    { files, stdin, stdinFilename, exclude, outputAbsolutePaths }: Options,
+    program: ts.Program | undefined,
     logger: Logger,
-): { files: string[]; program?: ts.Program } {
+): ResolvedFile[] {
+    // Return stdin files if we're reading from stdin.
+    if (stdin) {
+        if (stdinFilename) {
+            // Use a filename for shadowing stdin, if the option is set.
+            return [{filename: path.resolve(stdinFilename), isStdin: true}];
+        } else {
+            throw new Error("--stdin-filename must be provided with --stdin.");
+        }
+    }
+
     // remove single quotes which break matching on Windows when glob is passed in single quotes
     exclude = exclude.map(trimSingleQuotes);
 
-    if (project === undefined) {
-        return { files: resolveGlobs(files, exclude, outputAbsolutePaths, logger) };
-    }
-
-    const projectPath = findTsconfig(project);
-    if (projectPath === undefined) {
-        throw new FatalError(`Invalid option for project: ${project}`);
+    if (program === undefined) {
+        return resolveGlobs(files, exclude, outputAbsolutePaths, logger)
+            .map((filename) => ({filename, isStdin: false}));
     }
 
     exclude = exclude.map((pattern) => path.resolve(pattern));
-    const program = Linter.createProgram(projectPath);
+
     let filesFound: string[];
+
     if (files.length === 0) {
         filesFound = filterFiles(Linter.getFileNames(program), exclude, false);
     } else {
@@ -209,7 +276,8 @@ function resolveFilesAndProgram(
             }
         }
     }
-    return { files: filesFound, program };
+
+    return filesFound.map((filename) => ({filename, isStdin: false}));
 }
 
 function filterFiles(files: string[], patterns: string[], include: boolean): string[] {
@@ -235,7 +303,7 @@ function resolveGlobs(files: string[], ignore: string[], outputAbsolutePaths: bo
     return results.map((file) => outputAbsolutePaths ? path.resolve(cwd, file) : path.relative(cwd, file));
 }
 
-async function doLinting(options: Options, files: string[], program: ts.Program | undefined, logger: Logger): Promise<LintResult> {
+async function doLinting(options: Options, files: ResolvedFile[], program: ts.Program | undefined, logger: Logger): Promise<LintResult> {
     const linter = new Linter(
         {
             fix: !!options.fix,
@@ -248,7 +316,9 @@ async function doLinting(options: Options, files: string[], program: ts.Program
     let lastFolder: string | undefined;
     let configFile = options.config !== undefined ? findConfiguration(options.config).results : undefined;
 
-    for (const file of files) {
+    for (const resolvedFile of files) {
+        const file = resolvedFile.filename;
+
         if (options.config === undefined) {
             const folder = path.dirname(file);
             if (lastFolder !== folder) {
@@ -261,7 +331,10 @@ async function doLinting(options: Options, files: string[], program: ts.Program
         }
 
         let contents: string | undefined;
-        if (program !== undefined) {
+
+        if (resolvedFile.isStdin) {
+            contents = await readStdin();
+        } else if (program !== undefined) {
             const sourceFile = program.getSourceFile(file);
             if (sourceFile !== undefined) {
                 contents = sourceFile.text;

src/tslintCli.ts

@@ -35,6 +35,8 @@ interface Argv {
     outputAbsolutePaths: boolean;
     project?: string;
     rulesDir?: string;
+    stdin?: boolean;
+    stdinFilename?: string;
     formattersDir: string;
     format?: string;
     typeCheck?: boolean;
@@ -45,7 +47,11 @@ interface Argv {
 interface Option {
     short?: string;
     // Commander will camelCase option names.
-    name: keyof Argv | "rules-dir" | "formatters-dir" | "type-check";
+    name: keyof Argv
+      | "rules-dir"
+      | "stdin-filename"
+      | "formatters-dir"
+      | "type-check";
     type: "string" | "boolean" | "array";
     describe: string; // Short, used for usage message
     description: string; // Long, used for `--help`
@@ -130,6 +136,24 @@ const options: Option[] = [
             rules directory, so rules in the user-provided rules directory
             with the same name as the base rules will not be loaded.`,
     },
+    {
+        name: "stdin",
+        type: "string",
+        describe: "stdin input",
+        description: dedent`
+            Read and check a file via stdin. The --stdin-filename option must
+            also be given.`,
+    },
+    {
+        name: "stdin-filename",
+        type: "string",
+        describe: "stdin filename",
+        description: dedent`
+            When reading a file with --stdin, tell TSLint where the file
+            being checked resides on the filesystem. This option allows TSLint
+            to be used for checking for problems on the fly, and also support
+            loading project configuration files, etc.`,
+    },
     {
         short: "s",
         name: "formatters-dir",
@@ -232,8 +256,22 @@ if (parsed.unknown.length !== 0) {
 }
 const argv = commander.opts() as any as Argv;
 
-if (!(argv.init || argv.test !== undefined || argv.project !== undefined || commander.args.length > 0)) {
-    console.error("No files specified. Use --project to lint a project folder.");
+if (!(
+    argv.init
+    || argv.test !== undefined
+    || argv.project !== undefined
+    || commander.args.length > 0
+    || argv.stdin
+)) {
+    console.error(
+        "No files specified. Use --project to lint a project folder "
+        + "or use --stdin and --stdin-filename.",
+    );
+    process.exit(1);
+}
+
+if (argv.stdin && argv.stdinFilename === undefined) {
+    console.error("--stdin-filename must be used with --stdin.");
     process.exit(1);
 }
 
@@ -263,6 +301,8 @@ run(
         outputAbsolutePaths: argv.outputAbsolutePaths,
         project: argv.project,
         rulesDirectory: argv.rulesDir,
+        stdin: argv.stdin,
+        stdinFilename: argv.stdinFilename,
         test: argv.test,
         typeCheck: argv.typeCheck,
     },