Breaking: log number of fixable problems (fixes #7364) (#8324)

* Breaking: log number of fixable problems (fixes #7364)

* Shorten message

* Add fixable counts to codeframe

* Update documentaiton and rebase

* Fixing minor issues

* Fixing indentation issues

Author: alberto

index.js

@@ -74,11 +74,14 @@ function formatMessage(message, parentResult) {
  * Gets the formatted output summary for a given number of errors and warnings.
  * @param   {number} errors   The number of errors.
  * @param   {number} warnings The number of warnings.
+ * @param   {number} fixableErrors The number of fixable errors.
+ * @param   {number} fixableWarnings The number of fixable warnings.
  * @returns {string}          The formatted output summary.
  */
-function formatSummary(errors, warnings) {
+function formatSummary(errors, warnings, fixableErrors, fixableWarnings) {
     const summaryColor = errors > 0 ? "red" : "yellow";
     const summary = [];
+    const fixablesSummary = [];
 
     if (errors > 0) {
         summary.push(`${errors} ${pluralize("error", errors)}`);
@@ -88,7 +91,21 @@ function formatSummary(errors, warnings) {
         summary.push(`${warnings} ${pluralize("warning", warnings)}`);
     }
 
-    return chalk[summaryColor].bold(`${summary.join(" and ")} found.`);
+    if (fixableErrors > 0) {
+        fixablesSummary.push(`${fixableErrors} ${pluralize("error", fixableErrors)}`);
+    }
+
+    if (fixableWarnings > 0) {
+        fixablesSummary.push(`${fixableWarnings} ${pluralize("warning", fixableWarnings)}`);
+    }
+
+    let output = chalk[summaryColor].bold(`${summary.join(" and ")} found.`);
+
+    if (fixableErrors || fixableWarnings) {
+        output += chalk[summaryColor].bold(`\n${fixablesSummary.join(" and ")} potentially fixable with the \`--fix\` option.`);
+    }
+
+    return output;
 }
 
 //------------------------------------------------------------------------------
@@ -98,19 +115,24 @@ function formatSummary(errors, warnings) {
 module.exports = function(results) {
     let errors = 0;
     let warnings = 0;
+    let fixableErrors = 0;
+    let fixableWarnings = 0;
+
     const resultsWithMessages = results.filter(result => result.messages.length > 0);
 
     let output = resultsWithMessages.reduce((resultsOutput, result) => {
         const messages = result.messages.map(message => `${formatMessage(message, result)}\n\n`);
 
         errors += result.errorCount;
         warnings += result.warningCount;
+        fixableErrors += result.fixableErrorCount;
+        fixableWarnings += result.fixableWarningCount;
 
         return resultsOutput.concat(messages);
     }, []).join("\n");
 
     output += "\n";
-    output += formatSummary(errors, warnings);
+    output += formatSummary(errors, warnings, fixableErrors, fixableWarnings);
 
     return (errors + warnings) > 0 ? output : "";
 };

test.js

@@ -78,7 +78,9 @@ describe("formatter:codeframe", () => {
                 ruleId: "foo"
             }],
             errorCount: 0,
-            warningCount: 1
+            warningCount: 1,
+            fixableErrorCount: 0,
+            fixableWarningCount: 0
         }];
 
         it("should return a string in the correct format for warnings", () => {
@@ -104,6 +106,27 @@ describe("formatter:codeframe", () => {
             assert.equal(chalkStub.yellow.bold.callCount, 1);
             assert.equal(chalkStub.red.bold.callCount, 0);
         });
+
+        describe("when the warning is fixable", () => {
+            beforeEach(() => {
+                code[0].fixableWarningCount = 1;
+            });
+
+            it("should return a string in the correct format", () => {
+                const result = formatter(code);
+
+                assert.equal(chalk.stripColor(result), [
+                    `warning: Unexpected foo (foo) at ${path.join("lib", "foo.js")}:1:5:`,
+                    "> 1 | var foo = 1;",
+                    "    |     ^",
+                    "  2 |  var bar = 2;",
+                    "  3 | ",
+                    "\n",
+                    "1 warning found.",
+                    "1 warning potentially fixable with the `--fix` option."
+                ].join("\n"));
+            });
+        });
     });
 
     describe("when passed a single error message", () => {
@@ -353,4 +376,93 @@ describe("formatter:codeframe", () => {
             assert.equal(chalk.stripColor(result), "error: Unexpected foo (foo) at foo.js\n\n\n1 error found.");
         });
     });
+
+
+    describe("fixable problems", () => {
+        it("should not output fixable problems message when no errors or warnings are fixable", () => {
+            const code = [{
+                filePath: "foo.js",
+                errorCount: 1,
+                warningCount: 0,
+                fixableErrorCount: 0,
+                fixableWarningCount: 0,
+                messages: [{
+                    message: "Unexpected foo.",
+                    severity: 2,
+                    line: 5,
+                    column: 10,
+                    ruleId: "foo"
+                }]
+            }];
+
+            const result = formatter(code);
+
+            assert.notInclude(result, "potentially fixable");
+        });
+
+        it("should output the fixable problems message when errors are fixable", () => {
+            const code = [{
+                filePath: "foo.js",
+                errorCount: 1,
+                warningCount: 0,
+                fixableErrorCount: 1,
+                fixableWarningCount: 0,
+                messages: [{
+                    message: "Unexpected foo.",
+                    severity: 2,
+                    line: 5,
+                    column: 10,
+                    ruleId: "foo"
+                }]
+            }];
+
+            const result = formatter(code);
+
+            assert.include(result, "1 error potentially fixable with the `--fix` option.");
+        });
+
+        it("should output fixable problems message when warnings are fixable", () => {
+            const code = [{
+                filePath: "foo.js",
+                errorCount: 0,
+                warningCount: 3,
+                fixableErrorCount: 0,
+                fixableWarningCount: 2,
+                messages: [{
+                    message: "Unexpected foo."
+                }]
+            }];
+
+            const result = formatter(code);
+
+            assert.include(result, "2 warnings potentially fixable with the `--fix` option.");
+        });
+
+        it("should output the total number of fixable errors and warnings", () => {
+            const code = [{
+                filePath: "foo.js",
+                errorCount: 5,
+                warningCount: 3,
+                fixableErrorCount: 5,
+                fixableWarningCount: 2,
+                messages: [{
+                    message: "Unexpected foo."
+                }]
+            }, {
+                filePath: "bar.js",
+                errorCount: 4,
+                warningCount: 2,
+                fixableErrorCount: 4,
+                fixableWarningCount: 1,
+                messages: [{
+                    message: "Unexpected bar."
+                }]
+            }];
+
+            const result = formatter(code);
+
+            assert.include(result, "9 errors and 3 warnings potentially fixable with the `--fix` option.");
+        });
+    });
+
 });