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

@@ -17,21 +17,21 @@
 
 import {AbstractFormatter} from "../language/formatter/abstractFormatter";
 import {IFormatterMetadata} from "../language/formatter/formatter";
-import {RuleFailure} from "../language/rule/rule";
+import {RuleFailure, RuleLevel} from "../language/rule/rule";
 
 export class Formatter extends AbstractFormatter {
     /* tslint:disable:object-literal-sort-keys */
     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 "";
+            return "\n";
         }
 
         let fixLines: string[] = [];
@@ -52,16 +52,21 @@ 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(failures))
+          .join("\n") + "\n";
+
+    }
+
+    private mapToMessages(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 `${RuleLevel[failure.getRuleLevel()]}: ${fileName}${positionTuple}: ${failureString}`;
         });
 
-        return fixLines.concat(errorLines).join("\n") + "\n";
     }
 }

src/formatters/stylishFormatter.ts

@@ -17,7 +17,7 @@
 
 import {AbstractFormatter} from "../language/formatter/abstractFormatter";
 import {IFormatterMetadata} from "../language/formatter/formatter";
-import {RuleFailure} from "../language/rule/rule";
+import {RuleFailure, RuleLevel} from "../language/rule/rule";
 
 import * as colors from "colors";
 
@@ -39,10 +39,20 @@ export class Formatter extends AbstractFormatter {
     /* tslint:enable:object-literal-sort-keys */
 
     public format(failures: RuleFailure[]): string {
-        if (typeof failures[0] === "undefined") {
-            return "\n";
+        let outputLines = this.mapToMessages(failures);
+
+        // Removes initial blank line
+        if (outputLines[0] === "") {
+            outputLines.shift();
         }
 
+        return outputLines.join("\n") + "\n";
+    }
+
+    private mapToMessages(failures: RuleFailure[]): string[] {
+        if (!failures) {
+            return [];
+        }
         const outputLines: string[] = [];
         const positionMaxSize       = this.getPositionMaxSize(failures);
         const ruleMaxSize           = this.getRuleMaxSize(failures);
@@ -71,21 +81,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 (failure.getRuleLevel() === RuleLevel.WARNING) {
+                positionTuple = colors.blue(RuleLevel[failure.getRuleLevel()] + ": " + positionTuple);
+            } else {
+                positionTuple = colors.red(RuleLevel[failure.getRuleLevel()] + ": " + 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

@@ -17,31 +17,36 @@
 
 import {AbstractFormatter} from "../language/formatter/abstractFormatter";
 import {IFormatterMetadata} from "../language/formatter/formatter";
-import {RuleFailure} from "../language/rule/rule";
+import {RuleFailure, RuleLevel} from "../language/rule/rule";
 
 export class Formatter extends AbstractFormatter {
     /* tslint:disable:object-literal-sort-keys */
     public static metadata: IFormatterMetadata = {
         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) => {
+
+        return this.mapToMessages(failures)
+            .join("\n") + "\n";
+    }
+
+    private mapToMessages(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 `${RuleLevel[failure.getRuleLevel()]}: (${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/language/formatter/formatter.ts

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

src/language/rule/abstractRule.ts

@@ -17,22 +17,31 @@
 
 import * as ts from "typescript";
 
+import {arrayify} from "../../utils";
 import {RuleWalker} from "../walker/ruleWalker";
-import {IDisabledInterval, IOptions, IRule, IRuleMetadata, RuleFailure} from "./rule";
+import {IDisabledInterval, IOptions, IRule, IRuleMetadata, RuleFailure, RuleLevel} from "./rule";
 
 export abstract class AbstractRule implements IRule {
     public static metadata: IRuleMetadata;
     private options: IOptions;
 
     constructor(ruleName: string, private value: any, disabledIntervals: IDisabledInterval[]) {
         let ruleArguments: any[] = [];
+        let ruleLevel = RuleLevel.ERROR;
 
         if (Array.isArray(value) && value.length > 1) {
             ruleArguments = value.slice(1);
+        } else if (value.options) {
+            ruleArguments = arrayify(value.options);
+        }
+
+        if (value.level === "warn") {
+            ruleLevel = RuleLevel.WARNING;
         }
 
         this.options = {
             disabledIntervals,
+            ruleLevel,
             ruleArguments,
             ruleName,
         };
@@ -60,6 +69,10 @@ export abstract class AbstractRule implements IRule {
             return value[0];
         }
 
-        return false;
+        if (value.level === "off" || value.level === "none") {
+            return false;
+        }
+
+        return true;
     }
 }

src/language/rule/rule.ts

@@ -81,8 +81,14 @@ export interface IRuleMetadata {
 
 export type RuleType = "functionality" | "maintainability" | "style" | "typescript";
 
+export enum RuleLevel {
+    "WARNING" = 1,
+    "ERROR",
+}
+
 export interface IOptions {
     ruleArguments?: any[];
+    ruleLevel: RuleLevel;
     ruleName: string;
     disabledIntervals: IDisabledInterval[];
 }
@@ -195,6 +201,7 @@ export class RuleFailure {
                 start: number,
                 end: number,
                 private failure: string,
+                private ruleLevel: RuleLevel,
                 private ruleName: string,
                 private fix?: Fix) {
 
@@ -207,6 +214,10 @@ export class RuleFailure {
         return this.fileName;
     }
 
+    public getRuleLevel() {
+        return this.ruleLevel;
+    }
+
     public getRuleName() {
         return this.ruleName;
     }
@@ -237,6 +248,7 @@ export class RuleFailure {
             failure: this.failure,
             fix: this.fix,
             name: this.fileName,
+            ruleLevel: RuleLevel[this.ruleLevel],
             ruleName: this.ruleName,
             startPosition: this.startPosition.toJson(),
         };

src/language/walker/ruleWalker.ts

@@ -17,7 +17,7 @@
 
 import * as ts from "typescript";
 
-import {Fix, IDisabledInterval, IOptions, Replacement, RuleFailure} from "../rule/rule";
+import {Fix, IDisabledInterval, IOptions, Replacement, RuleFailure, RuleLevel} from "../rule/rule";
 import {doesIntersect} from "../utils";
 import {SyntaxWalker} from "./syntaxWalker";
 
@@ -27,6 +27,7 @@ export class RuleWalker extends SyntaxWalker {
     private options: any[];
     private failures: RuleFailure[];
     private disabledIntervals: IDisabledInterval[];
+    private ruleLevel: RuleLevel;
     private ruleName: string;
 
     constructor(private sourceFile: ts.SourceFile, options: IOptions) {
@@ -37,6 +38,7 @@ export class RuleWalker extends SyntaxWalker {
         this.options = options.ruleArguments;
         this.limit = this.sourceFile.getFullWidth();
         this.disabledIntervals = options.disabledIntervals;
+        this.ruleLevel = options.ruleLevel;
         this.ruleName = options.ruleName;
     }
 
@@ -71,7 +73,7 @@ export class RuleWalker extends SyntaxWalker {
     public createFailure(start: number, width: number, failure: string, fix?: Fix): RuleFailure {
         const from = (start > this.limit) ? this.limit : start;
         const to = ((start + width) > this.limit) ? this.limit : (start + width);
-        return new RuleFailure(this.sourceFile, from, to, failure, this.ruleName, fix);
+        return new RuleFailure(this.sourceFile, from, to, failure, this.ruleLevel, this.ruleName, fix);
     }
 
     public addFailure(failure: RuleFailure) {

src/linter.ts

@@ -31,7 +31,7 @@ import { EnableDisableRulesWalker } from "./enableDisableRules";
 import { findFormatter } from "./formatterLoader";
 import { ILinterOptions, LintResult } from "./index";
 import { IFormatter } from "./language/formatter/formatter";
-import { Fix, IRule, RuleFailure } from "./language/rule/rule";
+import {Fix, IRule, RuleFailure, RuleLevel} from "./language/rule/rule";
 import { TypedRule } from "./language/rule/typedRule";
 import * as utils from "./language/utils";
 import { loadRules } from "./ruleLoader";
@@ -177,6 +177,7 @@ class Linter {
         // walk the code first to find all the intervals where rules are disabled
         const rulesWalker = new EnableDisableRulesWalker(sourceFile, {
             disabledIntervals: [],
+            ruleLevel: RuleLevel.ERROR,
             ruleName: "",
         });
         rulesWalker.walk(sourceFile);

src/rules/eoflineRule.ts

@@ -45,7 +45,7 @@ export class Rule extends Lint.Rules.AbstractRule {
         if (eofTokenFullText.length === 0 || eofTokenFullText.charAt(eofTokenFullText.length - 1) !== "\n") {
             const start = eofToken.getStart();
             return [
-                new Lint.RuleFailure(sourceFile, start, start, Rule.FAILURE_STRING, this.getOptions().ruleName),
+                new Lint.RuleFailure(sourceFile, start, start, Rule.FAILURE_STRING, this.getOptions().ruleLevel, this.getOptions().ruleName),
             ];
         }
 

src/rules/linebreakStyleRule.ts

@@ -80,6 +80,6 @@ export class Rule extends Lint.Rules.AbstractRule {
         // the line ending, which happens to be the start of the token.
         const end = scanner.getStartPos();
 
-        return new Lint.RuleFailure(sourceFile, start, end, failure, this.getOptions().ruleName);
+        return new Lint.RuleFailure(sourceFile, start, end, failure, this.getOptions().ruleLevel, this.getOptions().ruleName);
     }
 }

src/rules/maxFileLineCountRule.ts

@@ -60,7 +60,7 @@ export class Rule extends Lint.Rules.AbstractRule {
 
         if (lineCount > lineLimit && disabledIntervals.length === 0) {
             const errorString = Rule.FAILURE_STRING_FACTORY(lineCount, lineLimit);
-            ruleFailures.push(new Lint.RuleFailure(sourceFile, 0, 1, errorString, this.getOptions().ruleName));
+            ruleFailures.push(new Lint.RuleFailure(sourceFile, 0, 1, errorString, this.getOptions().ruleLevel, this.getOptions().ruleName));
         }
 
         return ruleFailures;

src/rules/maxLineLengthRule.ts

@@ -70,7 +70,7 @@ export class Rule extends Lint.Rules.AbstractRule {
                 // that we are only over by the limit by exactly one and that the character we are over the
                 // limit by is a '\r' character which does not count against the limit
                 // (and thus we are not actually over the limit).
-                const ruleFailure = new Lint.RuleFailure(sourceFile, from, to - 1, errorString, this.getOptions().ruleName);
+                const ruleFailure = new Lint.RuleFailure(sourceFile, from, to - 1, errorString, this.getOptions().ruleLevel, this.getOptions().ruleName);
                 if (!Lint.doesIntersect(ruleFailure, disabledIntervals)) {
                     ruleFailures.push(ruleFailure);
                 }