--print-config flag

docs/usage/cli/index.md

@@ -41,6 +41,7 @@ Options:
 -i, --init                             generate a tslint.json config file in the current working directory
 -o, --out [out]                        output file
 --outputAbsolutePaths                  whether or not outputted file paths are absolute
+--print-config                         print resolved configuration for a file
 -r, --rules-dir [rules-dir]            rules directory
 -s, --formatters-dir [formatters-dir]  formatters directory
 -t, --format [format]                  output format (prose, json, stylish, verbose, pmd, msbuild, checkstyle, vso, fileslist, codeFrame)

src/configuration.ts

@@ -660,3 +660,24 @@ export function isFileExcluded(filepath: string, configFile?: IConfigurationFile
     const fullPath = path.resolve(filepath);
     return configFile.linterOptions.exclude.some(pattern => new Minimatch(pattern).match(fullPath));
 }
+
+export function stringifyConfiguration(configFile: IConfigurationFile) {
+    return JSON.stringify(
+        {
+            extends: configFile.extends,
+            jsRules: convertRulesMapToObject(configFile.jsRules),
+            linterOptions: configFile.linterOptions,
+            rules: convertRulesMapToObject(configFile.rules),
+            rulesDirectory: configFile.rulesDirectory,
+        },
+        undefined,
+        2,
+    );
+}
+
+function convertRulesMapToObject(rules: Map<string, Partial<IOptions>>) {
+    return Array.from(rules).reduce<{ [i: string]: Partial<IOptions> }>(
+        (result, [key, value]) => ({ ...result, [key]: value }),
+        {},
+    );
+}

src/files/reading.ts

@@ -0,0 +1,44 @@
+/**
+ * @license
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as fs from "fs";
+
+import { FatalError } from "../error";
+import { Logger } from "../runner";
+
+/** Read a file, but return undefined if it is an MPEG '.ts' file. */
+export async function tryReadFile(filename: string, logger: Logger): Promise<string | undefined> {
+    if (!fs.existsSync(filename)) {
+        throw new FatalError(`Unable to open file: ${filename}`);
+    }
+    const buffer = Buffer.allocUnsafe(256);
+    const fd = fs.openSync(filename, "r");
+    try {
+        fs.readSync(fd, buffer, 0, 256, 0);
+        if (buffer.readInt8(0) === 0x47 && buffer.readInt8(188) === 0x47) {
+            // MPEG transport streams use the '.ts' file extension. They use 0x47 as the frame
+            // separator, repeating every 188 bytes. It is unlikely to find that pattern in
+            // TypeScript source, so tslint ignores files with the specific pattern.
+            logger.error(`${filename}: ignoring MPEG transport stream\n`);
+            return undefined;
+        }
+    } finally {
+        fs.closeSync(fd);
+    }
+
+    return fs.readFileSync(filename, "utf8");
+}

src/files/resolution.ts

@@ -0,0 +1,109 @@
+/**
+ * @license
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as fs from "fs";
+import * as glob from "glob";
+import { filter as createMinimatchFilter, Minimatch } from "minimatch";
+import * as path from "path";
+import * as ts from "typescript";
+
+import { FatalError } from "../error";
+import { Linter } from "../linter";
+import { Logger, Options } from "../runner";
+import { flatMap, trimSingleQuotes } from "../utils";
+
+export function filterFiles(files: string[], patterns: string[], include: boolean): string[] {
+    if (patterns.length === 0) {
+        return include ? [] : files;
+    }
+    const matcher = patterns.map(pattern => new Minimatch(pattern, { dot: !include })); // `glob` always enables `dot` for ignore patterns
+    return files.filter(file => include === matcher.some(pattern => pattern.match(file)));
+}
+
+export function findTsconfig(project: string): string | undefined {
+    try {
+        const stats = fs.statSync(project); // throws if file does not exist
+        if (!stats.isDirectory()) {
+            return project;
+        }
+        const projectFile = path.join(project, "tsconfig.json");
+        fs.accessSync(projectFile); // throws if file does not exist
+        return projectFile;
+    } catch (e) {
+        return undefined;
+    }
+}
+
+export function resolveGlobs(
+    files: string[],
+    ignore: string[],
+    outputAbsolutePaths: boolean | undefined,
+    logger: Logger,
+): string[] {
+    const results = flatMap(files, file =>
+        glob.sync(trimSingleQuotes(file), { ignore, nodir: true }),
+    );
+    // warn if `files` contains non-existent files, that are not patters and not excluded by any of the exclude patterns
+    for (const file of filterFiles(files, ignore, false)) {
+        if (!glob.hasMagic(file) && !results.some(createMinimatchFilter(file))) {
+            logger.error(`'${file}' does not exist. This will be an error in TSLint 6.\n`); // TODO make this an error in v6.0.0
+        }
+    }
+    const cwd = process.cwd();
+    return results.map(file =>
+        outputAbsolutePaths ? path.resolve(cwd, file) : path.relative(cwd, file),
+    );
+}
+
+export function resolveFilesAndProgram(
+    { files, project, exclude, outputAbsolutePaths }: Options,
+    logger: Logger,
+): { files: string[]; program?: ts.Program } {
+    // 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}`);
+    }
+
+    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 {
+        files = files.map(f => path.resolve(f));
+        filesFound = filterFiles(program.getSourceFiles().map(f => f.fileName), files, true);
+        filesFound = filterFiles(filesFound, exclude, false);
+
+        // find non-glob files that have no matching file in the project and are not excluded by any exclude pattern
+        for (const file of filterFiles(files, exclude, false)) {
+            if (!glob.hasMagic(file) && !filesFound.some(createMinimatchFilter(file))) {
+                if (fs.existsSync(file)) {
+                    throw new FatalError(`'${file}' is not included in project.`);
+                }
+                logger.error(`'${file}' does not exist. This will be an error in TSLint 6.\n`); // TODO make this an error in v6.0.0
+            }
+        }
+    }
+    return { files: filesFound, program };
+}

src/runner.ts

@@ -18,21 +18,23 @@
 // tslint:disable strict-boolean-expressions (TODO: Fix up options)
 
 import * as fs from "fs";
-import * as glob from "glob";
-import { filter as createMinimatchFilter, Minimatch } from "minimatch";
 import * as path from "path";
 import * as ts from "typescript";
 
 import {
     DEFAULT_CONFIG,
     findConfiguration,
+    findConfigurationPath,
     isFileExcluded,
     JSON_CONFIG_FILENAME,
+    stringifyConfiguration,
 } from "./configuration";
 import { FatalError } from "./error";
+import { tryReadFile } from "./files/reading";
+import { resolveFilesAndProgram } from "./files/resolution";
 import { LintResult } from "./index";
 import { Linter } from "./linter";
-import { flatMap } from "./utils";
+import { trimSingleQuotes } from "./utils";
 
 export interface Options {
     /**
@@ -85,6 +87,11 @@ export interface Options {
      */
     outputAbsolutePaths?: boolean;
 
+    /**
+     * Outputs the configuration to be used instead of linting.
+     */
+    printConfig?: boolean;
+
     /**
      * tsconfig.json file.
      */
@@ -145,6 +152,10 @@ async function runWorker(options: Options, logger: Logger): Promise<Status> {
         return Status.Ok;
     }
 
+    if (options.printConfig) {
+        return printConfiguration(options, logger);
+    }
+
     if (options.test) {
         const test = await import("./test");
         const results = test.runTests(
@@ -165,6 +176,29 @@ async function runWorker(options: Options, logger: Logger): Promise<Status> {
     return options.force || errorCount === 0 ? Status.Ok : Status.LintError;
 }
 
+async function printConfiguration(options: Options, logger: Logger): Promise<Status> {
+    const { files } = options;
+    if (files.length !== 1) {
+        throw new FatalError(`--print-config must be run with exactly one file`);
+    }
+
+    const configurationPath =
+        options.config === undefined ? findConfigurationPath(null, files[0]) : options.config;
+    if (configurationPath === undefined) {
+        throw new FatalError(
+            `Could not find configuration path. Try passing a --config to your tslint.json.`,
+        );
+    }
+
+    const configuration = findConfiguration(configurationPath, files[0]).results;
+    if (configuration === undefined) {
+        throw new FatalError(`Could not find configuration for '${files[1]}`);
+    }
+
+    logger.log(`${stringifyConfiguration(configuration)}\n`);
+    return Status.Ok;
+}
+
 async function runLinter(options: Options, logger: Logger): Promise<LintResult> {
     const { files, program } = resolveFilesAndProgram(options, logger);
     // if type checking, run the type checker
@@ -184,74 +218,6 @@ async function runLinter(options: Options, logger: Logger): Promise<LintResult>
     return doLinting(options, files, program, logger);
 }
 
-function resolveFilesAndProgram(
-    { files, project, exclude, outputAbsolutePaths }: Options,
-    logger: Logger,
-): { files: string[]; program?: ts.Program } {
-    // 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}`);
-    }
-
-    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 {
-        files = files.map(f => path.resolve(f));
-        filesFound = filterFiles(program.getSourceFiles().map(f => f.fileName), files, true);
-        filesFound = filterFiles(filesFound, exclude, false);
-
-        // find non-glob files that have no matching file in the project and are not excluded by any exclude pattern
-        for (const file of filterFiles(files, exclude, false)) {
-            if (!glob.hasMagic(file) && !filesFound.some(createMinimatchFilter(file))) {
-                if (fs.existsSync(file)) {
-                    throw new FatalError(`'${file}' is not included in project.`);
-                }
-                logger.error(`'${file}' does not exist. This will be an error in TSLint 6.\n`); // TODO make this an error in v6.0.0
-            }
-        }
-    }
-    return { files: filesFound, program };
-}
-
-function filterFiles(files: string[], patterns: string[], include: boolean): string[] {
-    if (patterns.length === 0) {
-        return include ? [] : files;
-    }
-    const matcher = patterns.map(pattern => new Minimatch(pattern, { dot: !include })); // `glob` always enables `dot` for ignore patterns
-    return files.filter(file => include === matcher.some(pattern => pattern.match(file)));
-}
-
-function resolveGlobs(
-    files: string[],
-    ignore: string[],
-    outputAbsolutePaths: boolean | undefined,
-    logger: Logger,
-): string[] {
-    const results = flatMap(files, file =>
-        glob.sync(trimSingleQuotes(file), { ignore, nodir: true }),
-    );
-    // warn if `files` contains non-existent files, that are not patters and not excluded by any of the exclude patterns
-    for (const file of filterFiles(files, ignore, false)) {
-        if (!glob.hasMagic(file) && !results.some(createMinimatchFilter(file))) {
-            logger.error(`'${file}' does not exist. This will be an error in TSLint 6.\n`); // TODO make this an error in v6.0.0
-        }
-    }
-    const cwd = process.cwd();
-    return results.map(file =>
-        outputAbsolutePaths ? path.resolve(cwd, file) : path.relative(cwd, file),
-    );
-}
-
 async function doLinting(
     options: Options,
     files: string[],
@@ -312,29 +278,6 @@ async function doLinting(
     return linter.getResult();
 }
 
-/** Read a file, but return undefined if it is an MPEG '.ts' file. */
-async function tryReadFile(filename: string, logger: Logger): Promise<string | undefined> {
-    if (!fs.existsSync(filename)) {
-        throw new FatalError(`Unable to open file: ${filename}`);
-    }
-    const buffer = Buffer.allocUnsafe(256);
-    const fd = fs.openSync(filename, "r");
-    try {
-        fs.readSync(fd, buffer, 0, 256, 0);
-        if (buffer.readInt8(0) === 0x47 && buffer.readInt8(188) === 0x47) {
-            // MPEG transport streams use the '.ts' file extension. They use 0x47 as the frame
-            // separator, repeating every 188 bytes. It is unlikely to find that pattern in
-            // TypeScript source, so tslint ignores files with the specific pattern.
-            logger.error(`${filename}: ignoring MPEG transport stream\n`);
-            return undefined;
-        }
-    } finally {
-        fs.closeSync(fd);
-    }
-
-    return fs.readFileSync(filename, "utf8");
-}
-
 function showDiagnostic(
     { file, start, category, messageText }: ts.Diagnostic,
     program: ts.Program,
@@ -351,21 +294,3 @@ function showDiagnostic(
     }
     return `${message} ${ts.flattenDiagnosticMessageText(messageText, "\n")}`;
 }
-
-function trimSingleQuotes(str: string): string {
-    return str.replace(/^'|'$/g, "");
-}
-
-function findTsconfig(project: string): string | undefined {
-    try {
-        const stats = fs.statSync(project); // throws if file does not exist
-        if (!stats.isDirectory()) {
-            return project;
-        }
-        const projectFile = path.join(project, "tsconfig.json");
-        fs.accessSync(projectFile); // throws if file does not exist
-        return projectFile;
-    } catch (e) {
-        return undefined;
-    }
-}