Add new values and deprecate some for (require | disallow)SpacesInsideObjectBrackets

lib/rules/disallow-spaces-inside-object-brackets.js

@@ -1,14 +1,20 @@
 /**
  * Disallows space after opening object curly brace and before closing.
  *
- * Type: `Boolean` or `String`
+ * Type: `Object`, `Boolean` or `String`
  *
- * Values: `"all"` or `true` for strict mode, `"nested"` ignores closing brackets in a row.
+ * Values: `"all"` or `true` for strict mode, `"nested"` (*deprecated* use `"allExcept": ['}']`)
+ * ignores closing brackets in a row.
  *
  * #### Example
  *
  * ```js
- * "disallowSpacesInsideObjectBrackets": "all"
+ * "disallowSpacesInsideObjectBrackets": {
+ *     "allExcept": [ "}", ")" ]
+ * }
+ *
+ * // or
+ * * "disallowSpacesInsideObjectBrackets": true | "all" | "nested"
  * ```
  *
  * ##### Valid for mode `"all"`
@@ -20,7 +26,13 @@
  * ##### Valid for mode `"nested"`
  *
  * ```js
- * var x = { a: {b: 1} };
+ * var x = {a: {b: 1} };
+ * ```
+ *
+ * ##### Valid for mode `"allExcept": ["}"]`
+ *
+ * ```js
+ * var x = {a: {b: 1} };
  * ```
  *
  * ##### Invalid
@@ -36,59 +48,73 @@ module.exports = function() {};
 
 module.exports.prototype = {
 
-    configure: function(disallowSpacesInsideObjectBrackets) {
-        assert(
-            disallowSpacesInsideObjectBrackets === true || disallowSpacesInsideObjectBrackets === 'all' ||
-            disallowSpacesInsideObjectBrackets === 'nested',
-            'disallowSpacesInsideObjectBrackets option requires "all"(true value) or "nested" string'
-        );
+    configure: function(value) {
+        var mode;
+        var modes = {
+            'all': true,
+            'nested': true
+        };
+        var isObject = typeof value === 'object';
+
+        var error = 'disallowSpacesInsideObjectBrackets rule' +
+        ' requires string "all" or "nested", true value or object';
+
+        if (typeof value === 'string' || value === true) {
+            assert(modes[ value === true ? 'all' : value], error);
+
+        } else if (isObject) {
+            assert('allExcept' in value, error);
+        } else {
+            assert(false, error);
+        }
+
+        this._exceptions = {};
 
-        this._mode = disallowSpacesInsideObjectBrackets === true ? 'all' : disallowSpacesInsideObjectBrackets;
+        if (isObject) {
+            (value.allExcept || []).forEach(function(value) {
+                this._exceptions[value] = true;
+            }, this);
+
+        } else {
+            mode = value;
+        }
+
+        if (mode === 'nested') {
+            this._exceptions['}'] = true;
+        }
     },
 
     getOptionName: function() {
         return 'disallowSpacesInsideObjectBrackets';
     },
 
     check: function(file, errors) {
-        var mode = this._mode;
+        var exceptions = this._exceptions;
 
         file.iterateNodesByType('ObjectExpression', function(node) {
-            var tokens = file.getTokens();
-
-            var openingBracketPos = file.getTokenPosByRangeStart(node.range[0]);
-            var closingBracketPos = file.getTokenPosByRangeStart(node.range[1] - 1);
+            var openingBracket = file.getFirstNodeToken(node);
+            var nextToken = file.getNextToken(openingBracket);
 
-            var brackets = {
-                opening: tokens[openingBracketPos],
-                closing: tokens[closingBracketPos]
-            };
+            errors.assert.noWhitespaceBetween({
+                token: openingBracket,
+                nextToken: nextToken,
+                spaces: 1,
+                message: 'Illegal space after opening curly brace'
+            });
 
-            var insideTokens = {
-                prev: tokens[closingBracketPos - 1],
-                next: tokens[openingBracketPos + 1]
-            };
+            var closingBracket = file.getLastNodeToken(node);
+            var prevToken = file.getPrevToken(closingBracket);
 
-            if (mode === 'all') {
-                check(brackets, errors, insideTokens);
-
-            } else if (node.parentNode.type === 'Property') {
-                check(brackets, errors, insideTokens);
+            if (prevToken.value in exceptions) {
+                return;
             }
+
+            errors.assert.noWhitespaceBetween({
+                token: prevToken,
+                nextToken: closingBracket,
+                spaces: 1,
+                message: 'Illegal space before closing curly brace'
+            });
         });
     }
 };
-
-function check(brackets, errors, insideTokens) {
-    if (brackets.opening.loc.start.line === insideTokens.next.loc.start.line &&
-        brackets.opening.range[1] !== insideTokens.next.range[0]
-    ) {
-        errors.add('Illegal space after opening curly brace', brackets.opening.loc.end);
-    }
-
-    if (brackets.closing.loc.start.line === insideTokens.prev.loc.start.line &&
-        brackets.closing.range[0] !== insideTokens.prev.range[1]
-    ) {
-        errors.add('Illegal space before closing curly brace', insideTokens.prev.loc.end);
-    }
-}

lib/rules/require-spaces-inside-object-brackets.js

@@ -1,14 +1,20 @@
 /**
  * Requires space after opening object curly brace and before closing.
  *
- * Type: `String`
+ * Type: `Object` or `String`
  *
- * Values: `"all"` for strict mode, `"allButNested"` ignores closing brackets in a row.
+ * Values: `"all"` for strict mode, `"allButNested"` (*deprecated* use `"allExcept": ['}']`)
+ * ignores closing brackets in a row.
  *
  * #### Example
  *
  * ```js
- * "requireSpacesInsideObjectBrackets": "all"
+ * "requireSpacesInsideObjectBrackets": {
+ *     "allExcept": [ "}", ")" ]
+ * }
+ *
+ * // or
+ * "requireSpacesInsideObjectBrackets": true | "all" | "allButNested"
  * ```
  *
  * ##### Valid for mode `"all"`
@@ -23,6 +29,13 @@
  * var x = { a: { b: 1 }};
  * ```
  *
+ * ##### Valid for mode `"allExcept": [ "}", ")" ]`
+ *
+ * ```js
+ * var x = { a: (b ? 1 : 2)};
+ * var x = { a: { b: 1 }};
+ * ```
+ *
  * ##### Invalid
  *
  * ```js
@@ -36,51 +49,78 @@ module.exports = function() {};
 
 module.exports.prototype = {
 
-    configure: function(mode) {
+    configure: function(value) {
+        var mode;
         var modes = {
             'all': true,
             'allButNested': true
         };
-        assert(
-            typeof mode === 'string' &&
-            modes[mode],
-            'requireSpacesInsideObjectBrackets option requires string value \'all\' or \'allButNested\''
-        );
-        this._mode = mode;
+        var isObject = typeof value === 'object';
+
+        var error = 'requireSpacesInsideObjectBrackets rule' +
+        ' requires string value \'all\' or \'allButNested\' or object';
+
+        if (typeof value === 'string') {
+            assert(modes[value], error);
+
+        } else if (isObject) {
+            assert('allExcept' in value, error);
+        } else {
+            assert(false, error);
+        }
+
+        this._exceptions = {};
+
+        if (isObject) {
+            (value.allExcept || []).forEach(function(value) {
+                this._exceptions[value] = true;
+            }, this);
+
+        } else {
+            mode = value;
+        }
+
+        if (mode === 'allButNested') {
+            this._exceptions['}'] = true;
+        }
     },
 
     getOptionName: function() {
         return 'requireSpacesInsideObjectBrackets';
     },
 
     check: function(file, errors) {
-        var mode = this._mode;
-        file.iterateNodesByType('ObjectExpression', function(node) {
-            var tokens = file.getTokens();
-            var openingBracketPos = file.getTokenPosByRangeStart(node.range[0]);
+        var exceptions = this._exceptions;
 
-            var openingBracket = tokens[openingBracketPos];
-            var nextToken = tokens[openingBracketPos + 1];
+        file.iterateNodesByType('ObjectExpression', function(node) {
+            var openingBracket = file.getFirstNodeToken(node);
+            var nextToken = file.getNextToken(openingBracket);
 
-            if (nextToken.type === 'Punctuator' && nextToken.value === '}') {
+            // Don't check empty object
+            if (nextToken.value === '}') {
                 return;
             }
 
-            if (openingBracket.range[1] === nextToken.range[0]) {
-                errors.add('Missing space after opening curly brace', nextToken.loc.start);
-            }
+            errors.assert.whitespaceBetween({
+                token: openingBracket,
+                nextToken: nextToken,
+                spaces: 1,
+                message: 'Missing space after opening curly brace'
+            });
 
-            var closingBracketPos = file.getTokenPosByRangeStart(node.range[1] - 1);
-            var closingBracket = tokens[closingBracketPos];
-            var prevToken = tokens[closingBracketPos - 1];
-            var isNested = mode === 'allButNested' &&
-                           prevToken.type === 'Punctuator' &&
-                           prevToken.value === '}';
+            var closingBracket = file.getLastNodeToken(node);
+            var prevToken = file.getPrevToken(closingBracket);
 
-            if (closingBracket.range[0] === prevToken.range[1] && !isNested) {
-                errors.add('Missing space before closing curly brace', closingBracket.loc.start);
+            if (prevToken.value in exceptions) {
+                return;
             }
+
+            errors.assert.whitespaceBetween({
+                token: prevToken,
+                nextToken: closingBracket,
+                spaces: 1,
+                message: 'Missing space before closing curly brace'
+            });
         });
     }
-
 };