Support for ERROR & WARN per rule

docs/_data/formatters.json

@@ -35,7 +35,7 @@
   {
     "formatterName": "prose",
     "description": "The default formatter which outputs simple human-readable messages.",
-    "sample": "myFile.ts[1, 14]: Missing semicolon",
+    "sample": "ERROR: myFile.ts[1, 14]: Missing semicolon",
     "consumer": "human"
   },
   {
@@ -49,7 +49,7 @@
     "formatterName": "verbose",
     "description": "The human-readable formatter which includes the rule name in messages.",
     "descriptionDetails": "The output is the same as the prose formatter with the rule name included",
-    "sample": "(semicolon) myFile.ts[1, 14]: Missing semicolon",
+    "sample": "ERROR: (semicolon) myFile.ts[1, 14]: Missing semicolon",
     "consumer": "human"
   },
   {

docs/formatters/prose/index.html

@@ -1,7 +1,7 @@
 ---
 formatterName: prose
 description: The default formatter which outputs simple human-readable messages.
-sample: 'myFile.ts[1, 14]: Missing semicolon'
+sample: 'ERROR: myFile.ts[1, 14]: Missing semicolon'
 consumer: human
 layout: formatter
 title: 'Formatter: prose'

docs/formatters/verbose/index.html

@@ -2,7 +2,7 @@
 formatterName: verbose
 description: The human-readable formatter which includes the rule name in messages.
 descriptionDetails: The output is the same as the prose formatter with the rule name included
-sample: '(semicolon) myFile.ts[1, 14]: Missing semicolon'
+sample: 'ERROR: (semicolon) myFile.ts[1, 14]: Missing semicolon'
 consumer: human
 layout: formatter
 title: 'Formatter: verbose'

src/formatters/proseFormatter.ts

@@ -24,14 +24,14 @@ export class Formatter extends AbstractFormatter {
     public static metadata: IFormatterMetadata = {
         formatterName: "prose",
         description: "The default formatter which outputs simple human-readable messages.",
-        sample: "myFile.ts[1, 14]: Missing semicolon",
+        sample: "ERROR: myFile.ts[1, 14]: Missing semicolon",
         consumer: "human",
     };
     /* tslint:enable:object-literal-sort-keys */
 
-    public format(failures: RuleFailure[], fixes?: RuleFailure[]): string {
-        if (failures.length === 0 && (!fixes || fixes.length === 0)) {
-            return "";
+    public format(failures: RuleFailure[], warnings: RuleFailure[] = [], fixes?: RuleFailure[]): string {
+        if ((warnings && warnings.length === 0 && failures && failures.length === 0) && (!fixes || fixes.length === 0)) {
+            return "\n";
         }
 
         let fixLines: string[] = [];
@@ -52,16 +52,22 @@ export class Formatter extends AbstractFormatter {
             fixLines.push("");   // add a blank line between fixes and failures
         }
 
-        let errorLines = failures.map((failure: RuleFailure) => {
+        return fixLines.concat(this.mapToMessages("WARNING", warnings))
+          .concat(this.mapToMessages("ERROR", failures))
+          .join("\n") + "\n";
+
+    }
+
+    private mapToMessages(mode: string, failures: RuleFailure[]): string[] {
+        return failures.map((failure: RuleFailure) => {
             const fileName = failure.getFileName();
             const failureString = failure.getFailure();
 
             const lineAndCharacter = failure.getStartPosition().getLineAndCharacter();
             const positionTuple = `[${lineAndCharacter.line + 1}, ${lineAndCharacter.character + 1}]`;
 
-            return `${fileName}${positionTuple}: ${failureString}`;
+            return `${mode}: ${fileName}${positionTuple}: ${failureString}`;
         });
 
-        return fixLines.concat(errorLines).join("\n") + "\n";
     }
 }

src/formatters/stylishFormatter.ts

@@ -38,11 +38,22 @@ export class Formatter extends AbstractFormatter {
     };
     /* tslint:enable:object-literal-sort-keys */
 
-    public format(failures: RuleFailure[]): string {
-        if (typeof failures[0] === "undefined") {
-            return "\n";
+    public format(failures: RuleFailure[], warnings: RuleFailure[] = []): string {
+        let outputLines = this.mapToMessages("WARNING", warnings)
+          .concat(this.mapToMessages("ERROR", failures));
+
+        // Removes initial blank line
+        if (outputLines[0] === "") {
+            outputLines.shift();
         }
 
+        return outputLines.join("\n") + "\n";
+    }
+
+    private mapToMessages(mode: string, failures: RuleFailure[]): string[] {
+        if (!failures) {
+            return [];
+        }
         const outputLines: string[] = [];
         const positionMaxSize       = this.getPositionMaxSize(failures);
         const ruleMaxSize           = this.getRuleMaxSize(failures);
@@ -71,21 +82,20 @@ export class Formatter extends AbstractFormatter {
             const lineAndCharacter = failure.getStartPosition().getLineAndCharacter();
 
             let positionTuple = `${lineAndCharacter.line + 1}:${lineAndCharacter.character + 1}`;
-            positionTuple     = this.pad(positionTuple, positionMaxSize);
-            positionTuple     = colors.red(positionTuple);
+            positionTuple = this.pad(positionTuple, positionMaxSize);
 
-            // Ouput
+            if (mode === "WARNING") {
+                positionTuple = colors.blue("WARNING: " + positionTuple);
+            } else {
+                positionTuple = colors.red("ERROR: " + positionTuple);
+            }
+
+            // Output
             const output = `${positionTuple}  ${ruleName}  ${failureString}`;
 
             outputLines.push(output);
         }
-
-        // Removes initial blank line
-        if (outputLines[0] === "") {
-            outputLines.shift();
-        }
-
-        return outputLines.join("\n") + "\n\n";
+        return outputLines;
     }
 
     private pad(str: string, len: number): string {

src/formatters/verboseFormatter.ts

@@ -25,23 +25,29 @@ export class Formatter extends AbstractFormatter {
         formatterName: "verbose",
         description: "The human-readable formatter which includes the rule name in messages.",
         descriptionDetails: "The output is the same as the prose formatter with the rule name included",
-        sample: "(semicolon) myFile.ts[1, 14]: Missing semicolon",
+        sample: "ERROR: (semicolon) myFile.ts[1, 14]: Missing semicolon",
         consumer: "human",
     };
     /* tslint:enable:object-literal-sort-keys */
 
-    public format(failures: RuleFailure[]): string {
-        const outputLines = failures.map((failure: RuleFailure) => {
+    public format(failures: RuleFailure[], warnings: RuleFailure[] = []): string {
+
+        return this.mapToMessages("WARNING", warnings)
+            .concat(this.mapToMessages("ERROR", failures))
+            .join("\n") + "\n";
+    }
+
+    private mapToMessages(mode: string, failures: RuleFailure[]): string[] {
+        return failures.map((failure: RuleFailure) => {
             const fileName = failure.getFileName();
             const failureString = failure.getFailure();
             const ruleName = failure.getRuleName();
 
             const lineAndCharacter = failure.getStartPosition().getLineAndCharacter();
             const positionTuple = "[" + (lineAndCharacter.line + 1) + ", " + (lineAndCharacter.character + 1) + "]";
 
-            return `(${ruleName}) ${fileName}${positionTuple}: ${failureString}`;
+            return `${mode}: (${ruleName}) ${fileName}${positionTuple}: ${failureString}`;
         });
 
-        return outputLines.join("\n") + "\n";
     }
 }

src/formatters/vsoFormatter.ts

@@ -33,8 +33,10 @@ export class Formatter extends AbstractFormatter {
     };
     /* tslint:enable:object-literal-sort-keys */
 
-    public format(failures: RuleFailure[]): string {
-        const outputLines = failures.map((failure: RuleFailure) => {
+    public format(failures: RuleFailure[], warnings: RuleFailure[] = []): string {
+        const all = failures.concat(warnings);
+
+        const outputLines = all.map((failure: RuleFailure) => {
             const fileName = failure.getFileName();
             const failureString = failure.getFailure();
             const lineAndCharacter = failure.getStartPosition().getLineAndCharacter();

src/index.ts

@@ -35,6 +35,8 @@ export * from "./language/walker";
 export * from "./language/formatter/formatter";
 
 export interface LintResult {
+    warningCount: number;
+    warnings: RuleFailure[];
     failureCount: number;
     failures: RuleFailure[];
     fixes?: RuleFailure[];

src/language/formatter/formatter.ts

@@ -50,7 +50,8 @@ export interface IFormatter {
     /**
      * Formats linter results
      * @param {RuleFailure[]} failures Linter errors that were not fixed
+     * @param {RuleFailure[]} warnings Linter warnings that were not fixed
      * @param {RuleFailure[]} fixes Fixed linter errors. Available when the `--fix` argument is used on the command line
      */
-    format(failures: RuleFailure[], fixes?: RuleFailure[]): string;
+    format(failures: RuleFailure[], warnings?: RuleFailure[], fixes?: RuleFailure[]): string;
 }

src/language/rule/abstractRule.ts

@@ -17,6 +17,7 @@
 
 import * as ts from "typescript";
 
+import {arrayify} from "../../utils";
 import {RuleWalker} from "../walker/ruleWalker";
 import {IDisabledInterval, IOptions, IRule, IRuleMetadata, RuleFailure} from "./rule";
 
@@ -29,6 +30,8 @@ export abstract class AbstractRule implements IRule {
 
         if (Array.isArray(value) && value.length > 1) {
             ruleArguments = value.slice(1);
+        } else if (value.options) {
+            ruleArguments = arrayify(value.options);
         }
 
         this.options = {
@@ -49,6 +52,10 @@ export abstract class AbstractRule implements IRule {
         return walker.getFailures();
     }
 
+    public isWarning(): boolean {
+        return this.value.mode === "warn";
+    }
+
     public isEnabled(): boolean {
         const value = this.value;
 
@@ -60,6 +67,10 @@ export abstract class AbstractRule implements IRule {
             return value[0];
         }
 
+        if (value.mode !== "off") {
+            return true;
+        }
+
         return false;
     }
 }

src/language/rule/rule.ts

@@ -95,6 +95,7 @@ export interface IDisabledInterval {
 export interface IRule {
     getOptions(): IOptions;
     isEnabled(): boolean;
+    isWarning(): boolean;
     apply(sourceFile: ts.SourceFile): RuleFailure[];
     applyWithWalker(walker: RuleWalker): RuleFailure[];
 }

src/linter.ts

@@ -49,6 +49,7 @@ class Linter {
     public static loadConfigurationFromPath = loadConfigurationFromPath;
 
     private failures: RuleFailure[] = [];
+    private warnings: RuleFailure[] = [];
     private fixes: RuleFailure[] = [];
 
     /**
@@ -100,6 +101,7 @@ class Linter {
         let sourceFile = this.getSourceFile(fileName, source);
         let hasLinterRun = false;
         let fileFailures: RuleFailure[] = [];
+        let fileWarnings: RuleFailure[] = [];
 
         if (this.options.fix) {
             this.fixes = [];
@@ -115,22 +117,32 @@ class Linter {
                     // reload AST if file is modified
                     sourceFile = this.getSourceFile(fileName, source);
                 }
-                fileFailures = fileFailures.concat(ruleFailures);
+                if (rule.isWarning()) {
+                    fileWarnings = fileWarnings.concat(ruleFailures);
+                } else {
+                    fileFailures = fileFailures.concat(ruleFailures);
+                }
             }
             hasLinterRun = true;
         }
 
         // make a 1st pass or make a 2nd pass if there were any fixes because the positions may be off
         if (!hasLinterRun || this.fixes.length > 0) {
             fileFailures = [];
+            fileWarnings = [];
             for (let rule of enabledRules) {
                 const ruleFailures = this.applyRule(rule, sourceFile);
                 if (ruleFailures.length > 0) {
-                    fileFailures = fileFailures.concat(ruleFailures);
+                    if (rule.isWarning()) {
+                        fileWarnings = fileWarnings.concat(ruleFailures);
+                    } else {
+                        fileFailures = fileFailures.concat(ruleFailures);
+                    }
                 }
             }
         }
         this.failures = this.failures.concat(fileFailures);
+        this.warnings = this.warnings.concat(fileWarnings);
     }
 
     public getResult(): LintResult {
@@ -145,14 +157,16 @@ class Linter {
             throw new Error(`formatter '${formatterName}' not found`);
         }
 
-        const output = formatter.format(this.failures, this.fixes);
+        const output = formatter.format(this.failures, this.warnings, this.fixes);
 
         return {
             failureCount: this.failures.length,
             failures: this.failures,
             fixes: this.fixes,
             format: formatterName,
             output,
+            warningCount: this.warnings.length,
+            warnings: this.warnings,
         };
     }
 

test/external/tslint-test-custom-rules/rules/ruleOneRule.js

@@ -12,6 +12,7 @@ var Rule = (function (_super) {
     Rule.prototype.apply = function (sourceFile) {
         return this.applyWithWalker(new NoFailWalker(sourceFile, this.getOptions()));
     };
+    Rule.prototype.isWarning = function() { return false; };
     return Rule;
 })(Lint.Rules.AbstractRule);
 exports.Rule = Rule;

test/external/tslint-test-custom-rules/rules/ruleThreeRule.js

@@ -12,6 +12,7 @@ var Rule = (function (_super) {
     Rule.prototype.apply = function (sourceFile) {
         return this.applyWithWalker(new NoFailWalker(sourceFile, this.getOptions()));
     };
+    Rule.prototype.isWarning = function() { return false; };
     return Rule;
 })(Lint.Rules.AbstractRule);
 exports.Rule = Rule;

test/external/tslint-test-custom-rules/rules/ruleTwoRule.js

@@ -12,6 +12,7 @@ var Rule = (function (_super) {
     Rule.prototype.apply = function (sourceFile) {
         return this.applyWithWalker(new NoFailWalker(sourceFile, this.getOptions()));
     };
+    Rule.prototype.isWarning = function() { return false; };
     return Rule;
 })(Lint.Rules.AbstractRule);
 exports.Rule = Rule;

test/files/custom-rules-2/noFailRule.js

@@ -12,6 +12,7 @@ var Rule = (function (_super) {
     Rule.prototype.apply = function (sourceFile) {
         return this.applyWithWalker(new NoFailWalker(sourceFile, this.getOptions()));
     };
+    Rule.prototype.isWarning = function() { return false; };
     return Rule;
 })(Lint.Rules.AbstractRule);
 exports.Rule = Rule;

test/files/custom-rules/alwaysFailRule.js

@@ -12,6 +12,7 @@ var Rule = (function (_super) {
     Rule.prototype.apply = function (sourceFile) {
         return this.applyWithWalker(new AlwaysFailWalker(sourceFile, this.getOptions()));
     };
+    Rule.prototype.isWarning = function() { return false; };
     return Rule;
 })(Lint.Rules.AbstractRule);
 exports.Rule = Rule;

test/formatters/proseFormatterTests.ts

@@ -39,9 +39,9 @@ describe("Prose Formatter", () => {
         ];
 
         const expectedResult =
-            TEST_FILE + getPositionString(1, 1) + "first failure\n" +
-            TEST_FILE + getPositionString(2, 12) + "mid failure\n" +
-            TEST_FILE + getPositionString(9, 2) + "last failure\n";
+            "ERROR: " + TEST_FILE + getPositionString(1, 1) + "first failure\n" +
+            "ERROR: " + TEST_FILE + getPositionString(2, 12) + "mid failure\n" +
+            "ERROR: " + TEST_FILE + getPositionString(9, 2) + "last failure\n";
 
         const actualResult = formatter.format(failures);
         assert.equal(actualResult, expectedResult);
@@ -63,15 +63,15 @@ describe("Prose Formatter", () => {
         const expectedResult =
             `Fixed 2 error(s) in ${TEST_FILE}\n` +
             `Fixed 1 error(s) in file2\n\n` +
-            `${TEST_FILE}${getPositionString(1, 1)}first failure\n`;
+            `ERROR: ${TEST_FILE}${getPositionString(1, 1)}first failure\n`;
 
-        const actualResult = formatter.format(failures, fixes);
+        const actualResult = formatter.format(failures, [], fixes);
         assert.equal(actualResult, expectedResult);
     });
 
     it("handles no failures", () => {
         const result = formatter.format([]);
-        assert.equal(result, "");
+        assert.equal(result, "\n");
     });
 
     function getPositionString(line: number, character: number) {