CLI: Support a maxErrors option to limit the number of reported errors

Closes jscs-devgh-664
Fixes jscs-dev#238

README.md

@@ -85,6 +85,9 @@ jscs path[ path[...]] --reporter=./some-dir/my-reporter.js
 ### `--no-colors`
 Clean output without colors.
 
+### '--max-errors'
+Set the maximum number of errors to report
+
 ### `--help`
 Outputs usage information.
 
@@ -166,6 +169,20 @@ Values: A single file extension or an Array of file extensions, beginning with a
 "fileExtensions": [".js"]
 ```
 
+### maxErrors
+
+Set the maximum number of errors to report
+
+Type: `Number`
+
+Default: 50
+
+#### Example
+
+```js
+"maxErrors": 10
+```
+
 ## Error Suppression
 
 ### Inline Comments

bin/jscs

@@ -18,6 +18,7 @@ program
     .option('-p, --preset <preset>', 'preset config')
     .option('-r, --reporter <reporter>', 'error reporter, console - default, text, checkstyle, junit, inline')
     .option('-v, --verbose', 'adds rule names to the error output')
+    .option('-m, --max-errors <number>', 'maximum number of errors to report')
     .option('', 'Also accepts relative or absolute path to custom reporter')
     .option('', 'For instance:')
     .option('', '\t  ../some-dir/my-reporter.js\t(relative path with extension)')

lib/checker.js

@@ -7,6 +7,7 @@ var path = require('path');
 var additionalRules = require('./options/additional-rules');
 var excludeFiles = require('./options/exclude-files');
 var fileExtensions = require('./options/file-extensions');
+var maxErrors = require('./options/max-errors');
 
 /**
  * Starts Code Style checking process.
@@ -30,6 +31,7 @@ Checker.prototype.configure = function(config) {
     fileExtensions(config, this);
     excludeFiles(config, this, cwd);
     additionalRules(config, this, cwd);
+    maxErrors(config, this);
 
     StringChecker.prototype.configure.apply(this, arguments);
 };

lib/cli.js

@@ -82,6 +82,10 @@ module.exports = function(program) {
         config.preset = program.preset;
     }
 
+    if (program.maxErrors) {
+        config.maxErrors = Number(program.maxErrors);
+    }
+
     if (program.reporter) {
         reporterPath = path.resolve(process.cwd(), program.reporter);
         returnArgs.reporter = reporterPath;

lib/errors.js

@@ -14,13 +14,46 @@ var Errors = function(file, verbose) {
     this._verbose = verbose || false;
 };
 
+/**
+ * Default maximum number of errors
+ *
+ * Dangling for tests to reset
+ *
+ * @type {Number}
+ */
+Errors._defaultMaxErrors = 50;
+
+/**
+ * Tracks the number of errors found across all instances
+ *
+ * @type {Number}
+ */
+Errors._errorCount = 0;
+
+/**
+ * Maximum number of errors possible across all instances
+ *
+ * @type {Number}
+ */
+Errors.maxErrors = Errors._defaultMaxErrors;
+
+/**
+ * Whether or not the maximum error limit was reached
+ *
+ * @type {Boolean}
+ */
+Errors.wasMaxErrorsHit = false;
+
 Errors.prototype = {
     /**
      * Adds style error to the list
      *
      * @param {String} message
      * @param {Number|Object} line
      * @param {Number} [column]
+     * @returns {Boolean|undefined} true if the addition was successful,
+     *                              false if the add limit was hit
+     *                              undefined if the rule is not enabled
      */
     add: function(message, line, column) {
         if (typeof line === 'object') {
@@ -32,12 +65,22 @@ Errors.prototype = {
             return;
         }
 
+        // We're trying to add more than the max number of errors
+        if (Errors._errorCount === Errors.maxErrors) {
+            Errors.wasMaxErrorsHit = true;
+            return false;
+        }
+
         this._errorList.push({
             rule: this._currentRule,
             message: this._verbose ? this._currentRule + ': ' + message : message,
             line: line,
             column: column || 0
         });
+
+        Errors._errorCount++;
+
+        return true;
     },
 
     /**

lib/options/max-errors.js

@@ -0,0 +1,18 @@
+var Errors = require('../errors');
+
+/**
+ * Limits the total number of errors reported
+ *
+ * @param  {Object} config
+ * @param  {lib/checker} instance
+ */
+module.exports = function(config, instance) {
+    if (config.maxErrors) {
+        Errors.maxErrors = Number(config.maxErrors);
+    }
+
+    Object.defineProperty(config, 'maxErrors', {
+        value: config.maxErrors,
+        enumerable: false
+    });
+};

lib/reporters/console.js

@@ -1,8 +1,13 @@
+var Errors = require('../errors');
+
 /**
  * @param {Errors[]} errorsCollection
  */
 module.exports = function(errorsCollection) {
     var errorCount = 0;
+    var hadMoreErrors = Errors.wasMaxErrorsHit ? '+' : '';
+    var message;
+
     /**
      * Formatting every error set.
      */
@@ -17,11 +22,13 @@ module.exports = function(errorsCollection) {
             });
         }
     });
+
     if (errorCount) {
         /**
          * Printing summary.
          */
-        console.log('\n' + errorCount + ' code style ' + (errorCount === 1 ? 'error' : 'errors') + ' found.');
+        message = errorCount + hadMoreErrors + ' code style ' + (errorCount === 1 ? 'error' : 'errors') + ' found.';
+        console.log('\n' + message);
     } else {
         console.log('No code style errors found.');
     }

lib/string-checker.js

@@ -245,6 +245,7 @@ StringChecker.prototype = {
         } catch (e) {
             parseError = e;
         }
+
         var file = new JsFile(filename, str, tree);
         var errors = new Errors(file, this._verbose);
 
@@ -255,14 +256,14 @@ StringChecker.prototype = {
             return errors;
         }
 
-        this._activeRules.forEach(function(rule) {
-
+        this._activeRules.some(function(rule) {
             // Do not process the rule if it's equals to null (#203)
             if (this._config[rule.getOptionName()] !== null) {
                 errors.setCurrentRule(rule.getOptionName());
-                rule.check(file, errors);
-            }
 
+                // If the rule was disabled, add would return undefined
+                return rule.check(file, errors) === false;
+            }
         }, this);
 
         // sort errors list to show errors as they appear in source

test/cli.js

@@ -11,6 +11,7 @@ var exec = require('child_process').exec;
 
 var cli = rewire('../lib/cli');
 var startingDir = process.cwd();
+var Errors = require('../lib/errors');
 
 describe('modules/cli', function() {
     before(function() {
@@ -524,4 +525,29 @@ describe('modules/cli', function() {
             });
         });
     });
+
+    describe('maxErrors option', function() {
+        beforeEach(function() {
+            sinon.spy(console, 'log');
+            Errors._resetMaxErrors();
+        });
+
+        afterEach(function() {
+            console.log.restore();
+            Errors._resetMaxErrorsForTests();
+        });
+
+        it('should limit the number of errors reported to the provided amount', function(done) {
+            return cli({
+                maxErrors: 1,
+                args: ['test/data/cli/error.js'],
+                config: 'test/data/cli/maxErrors.json'
+            })
+            .promise.always(function() {
+                assert(console.log.getCall(1).args[0].indexOf('1 code style error found.') !== -1);
+                rAfter();
+                done();
+            });
+        });
+    });
 });

test/data/cli/maxErrors.json

@@ -0,0 +1,4 @@
+{
+  "disallowKeywords": ["with"],
+  "requireSpaceBeforePostfixUnaryOperators": ["++"]
+}

test/errors.js

@@ -1,5 +1,7 @@
 var Checker = require('../lib/checker');
+var Errors = require('../lib/errors');
 var assert = require('assert');
+var fs = require('fs');
 
 describe('modules/errors', function() {
     var checker = new Checker();
@@ -88,4 +90,12 @@ describe('modules/errors', function() {
 
         assert.ok(errors.isEmpty());
     });
+
+    it('should report a maximum of 50 errors, by default', function() {
+        Errors._resetMaxErrors();
+        var fixture = fs.readFileSync(__dirname + '/data/validate-indentation.js', 'utf8');
+        checker.configure({ validateIndentation: 2 });
+        assert(checker.checkString(fixture).getErrorList().length === 50);
+        Errors._resetMaxErrorsForTests();
+    });
 });

test/mocha.opts

@@ -1,3 +1,3 @@
-test/*.js test/rules/*.js test/options/*.js test/reporters/*.js
+test/test-config.js test/*.js test/rules/*.js test/options/*.js test/reporters/*.js
 -R dot
 -u bdd

test/rules/validate-indentation.js

@@ -36,7 +36,8 @@ describe('rules/validate-indentation', function() {
     });
 
     it('should validate 2 spaces indentation properly', function() {
-        checker.configure({ validateIndentation: 2 });
+        // maxErrors set to avoid this test failing with the default value
+        checker.configure({ validateIndentation: 2, maxErrors: 500 });
         checkErrors(fixture, [
             5,
             10,

test/string-checker.js

@@ -1,4 +1,5 @@
 var Checker = require('../lib/checker');
+var Errors = require('../lib/errors');
 var assert = require('assert');
 
 describe('modules/string-checker', function() {
@@ -70,6 +71,32 @@ describe('modules/string-checker', function() {
         }
     });
 
+    describe('maxErrors', function() {
+        beforeEach(function() {
+            Errors._resetMaxErrors();
+            checker.configure({
+                requireSpaceBeforeBinaryOperators: ['='],
+                maxErrors: 1
+            });
+        });
+
+        afterEach(function() {
+            Errors._resetMaxErrorsForTests();
+        });
+
+        it('should allow a maximum number of reported errors to be set', function() {
+            var errors = checker.checkString('var foo=1;\n var bar=2;').getErrorList();
+            assert(errors.length === 1);
+        });
+
+        it('should not report more than the maximum errors across multiple checks', function() {
+            var errors = checker.checkString('var foo=1;\n var bar=2;').getErrorList();
+            var errors2 = checker.checkString('var baz=1;\n var qux=2;').getErrorList();
+            assert(errors.length === 1);
+            assert(errors2.length === 0);
+        });
+    });
+
     describe('rules registration', function() {
         it('should report rules in config which don\'t match any registered rules', function() {
             var error;

test/test-config.js

@@ -0,0 +1,24 @@
+var Errors = require('../lib/errors');
+
+var largeDefault = 1000000;
+
+// Set an arbitrarily large number of errors for the tests to bypass
+// the maxErrors default of 50 errors. Otherwise, the specs would
+// hit the limit and fail the suite.
+Errors.maxErrors = largeDefault;
+
+/**
+ * Reset maxErrors to the large default value.
+ *
+ * Tests for maxError will need to manipulate the constructor's value
+ * at runtime and need a way to set the testing default
+ */
+Errors._resetMaxErrorsForTests = function() {
+    Errors._resetMaxErrors();
+    Errors.maxErrors = largeDefault;
+};
+
+Errors._resetMaxErrors = function() {
+    this._errorCount = 0;
+    this.maxErrors = this._defaultMaxErrors;
+};