disallowCommaBeforeLineBreak: added allExcept function

Added supoort to ignore object expressions with function properties
and to place a comma on the new line when fixing.

"lineBreak" option changed into default behavior for multiline expressions

Closes gh-1410

Author: dreef3

lib/rules/disallow-comma-before-line-break.js

@@ -1,9 +1,13 @@
 /**
  * Disallows commas as last token on a line in lists.
  *
- * Type: `Boolean`
+ * Type: `Boolean`|`Object`
  *
- * Value: `true`
+ * Values:
+ *  - `true` for default behavior (strict mode, comma on the same line)
+ *  - `Object`:
+ *    - `'allExcept'` array of exceptions:
+ *       - `'function'` ignores objects if one of their values is a function expression
  *
  * JSHint: [`laxcomma`](http://www.jshint.com/docs/options/#laxcomma)
  *
@@ -13,7 +17,7 @@
  * "disallowCommaBeforeLineBreak": true
  * ```
  *
- * ##### Valid
+ * ##### Valid for `true`
  *
  * ```js
  * var x = {
@@ -31,6 +35,16 @@
  *     two: 2
  * };
  * ```
+ *
+ * ##### Valid for `{"allExcept": ["function"]}`
+ *
+ * ```js
+ * var x = {
+ *     one: 1,
+ *     two: function() {}
+ * };
+ * ```
+ *
  */
 
 var assert = require('assert');
@@ -40,21 +54,53 @@ module.exports = function() {};
 module.exports.prototype = {
 
     configure: function(options) {
-        assert(
-            options === true,
-            this.getOptionName() + ' option requires a true value or should be removed'
-        );
+        if (typeof options !== 'object') {
+            assert(
+                options === true,
+                this.getOptionName() + ' option requires either a true value or an object'
+            );
+
+            var _options = {allExcept: []};
+            return this.configure(_options);
+        }
+
+        if (Array.isArray(options.allExcept)) {
+            this._exceptFunction = options.allExcept.indexOf('function') > -1;
+        }
     },
 
     getOptionName: function() {
         return 'disallowCommaBeforeLineBreak';
     },
 
     check: function(file, errors) {
+        var exceptFunction = this._exceptFunction;
+
+        function canSkip(token) {
+            var node = file.getNodeByRange(token.range[0]);
+            if (node.loc.start.line === node.loc.end.line) {
+                return true;
+            }
+
+            return exceptFunction && node.properties.some(function(property) {
+                return exceptFunction && property.value.type === 'FunctionExpression';
+            });
+        }
+
         file.iterateTokensByTypeAndValue('Punctuator', ',', function(token) {
+            if (canSkip(token)) {
+                return;
+            }
+
             errors.assert.sameLine({
                 token: token,
                 nextToken: file.getNextToken(token),
+                message: 'Commas should be placed on the same line as value'
+            });
+
+            errors.assert.differentLine({
+                token: file.getPrevToken(token),
+                nextToken: token,
                 message: 'Commas should be placed on new line'
             });
         });

test/specs/rules/disallow-comma-before-line-break.js

@@ -15,22 +15,25 @@ describe('rules/disallow-comma-before-line-break', function() {
     reportAndFix({
         name: 'illegal comma placement in multiline var declaration',
         rules: rules,
+        errors: 2,
         input: 'var a,\nb;',
-        output: 'var a, b;'
+        output: 'var a\n, b;'
     });
 
     reportAndFix({
         name: 'illegal comma placement in multiline array declaration',
         rules: rules,
+        errors: 2,
         input: 'var a = [1,\n2];',
-        output: 'var a = [1, 2];'
+        output: 'var a = [1\n, 2];'
     });
 
     reportAndFix({
         name: 'illegal comma placement in multiline object declaration',
         rules: rules,
+        errors: 2,
         input: 'var a = {a:1,\nc:3};',
-        output: 'var a = {a:1, c:3};'
+        output: 'var a = {a:1\n, c:3};'
     });
 
     it('should not report legal comma placement in multiline var declaration', function() {
@@ -60,4 +63,32 @@ describe('rules/disallow-comma-before-line-break', function() {
     it('should not report comma placement in single line object declaration', function() {
         assert(checker.checkString('var a = {a:1, c:3};').isEmpty());
     });
+
+    describe('options as object', function() {
+        describe('allExcept as option', function() {
+            describe('with value `function`', function() {
+                beforeEach(function() {
+                    checker = new Checker();
+                    checker.registerDefaultRules();
+                    checker.configure({disallowCommaBeforeLineBreak: {allExcept: ['function']}});
+                });
+                it('should not report objects with function values', function() {
+                    assert(
+                        checker.checkString(
+                            'var x = {\n' +
+                                'a : 1,\n' +
+                                'foo : function() {},\n' +
+                                'bcd : 2\n' +
+                            '};'
+                        ).isEmpty()
+                    );
+                });
+                it('should report objects without function values', function() {
+                    assert(
+                        checker.checkString('var a = {a:1,\nc:3};').getErrorCount() === 2
+                    );
+                });
+            });
+        });
+    });
 });