New rule: requireSpaceBeforeDestructuredValue

Require space after colon in object destructuring

Valid:
const { String: EmberString } = Ember;

Invalid:
const { String:EmberString } = Ember;

Fixes #2074
Closes gh-2142

Author: fxmaxvl

grouping.json

@@ -162,7 +162,8 @@
     "requireObjectDestructuring",
     "requireEnhancedObjectLiterals",
     "requireArrayDestructuring",
-    "disallowVar"
+    "disallowVar",
+    "requireSpaceBeforeDestructuredValues"
   ],
   "Everything else": [
     "requireParenthesesAroundIIFE",

lib/config/configuration.js

@@ -958,6 +958,7 @@ Configuration.prototype.registerDefaultRules = function() {
     this.registerRule(require('../rules/require-array-destructuring'));
     this.registerRule(require('../rules/disallow-var'));
     this.registerRule(require('../rules/require-imports-alphabetized'));
+    this.registerRule(require('../rules/require-space-before-destructured-values'));
     /* ES6 only (end) */
 
     this.registerRule(require('../rules/require-curly-braces'));

lib/rules/require-space-before-destructured-values.js

@@ -0,0 +1,112 @@
+/**
+ * Require space after colon in object destructuring.
+ *
+ * Type: `Boolean`
+ *
+ * Value: `true`
+ *
+ * Version: `ES6`
+ *
+ * #### Example
+ *
+ * ```js
+ * "requireSpaceBeforeDestructuredValues": true
+ * ```
+ *
+ * ##### Valid
+ * ```js
+ * const { foo: objectsFoo } = SomeObject;
+ * ```
+ * ##### Invalid
+ * ```js
+ * const { foo:objectsFoo } = SomeObject;
+ * ```
+ *
+ * ##### Valid
+ * ```js
+ * const { [ { foo: objectsFoo } ] } = SomeObject;
+ * ```
+ * ##### Invalid
+ * ```js
+ * const { [ { foo:objectsFoo } ] } = SomeObject;
+ * ```
+ */
+
+var assert = require('assert');
+
+module.exports = function() {};
+
+module.exports.prototype = {
+
+    configure: function(options) {
+        assert(
+            options === true,
+            this.getOptionName() + ' option requires a true value or should be removed'
+        );
+    },
+
+    getOptionName: function() {
+        return 'requireSpaceBeforeDestructuredValues';
+    },
+
+    check: function(file, errors) {
+        var checkSpaceMissing = function (propKey) {
+            var keyToken = file.getFirstNodeToken(propKey);
+            var colon    = file.findNextToken(keyToken, 'Punctuator', ':');
+
+            errors.assert.whitespaceBetween({
+                token: colon,
+                nextToken: file.getNextToken(colon),
+                message: 'Missing space after key colon'
+            });
+        };
+
+        var letsCheckThisOne = function(item) {
+
+            if (!item) {
+                return;
+            }
+
+            if (item.type === 'ObjectPattern') {
+                item.properties.forEach(function(property) {
+
+                    if (property.shorthand || property.method || property.kind !== 'init') {
+                        return;
+                    }
+
+                    checkSpaceMissing(property.key);
+
+                    //Strategy for nested structures
+                    var propValue = property.value;
+
+                    if (!propValue) {
+                        return;
+                    }
+
+                    letsCheckThisOne(propValue);
+                });
+            }
+
+            if (item.type === 'ArrayPattern') {
+                item.elements.forEach(letsCheckThisOne);
+            }
+        };
+
+        file.iterateNodesByType(['VariableDeclaration', 'AssignmentExpression'], function(node) {
+
+            if (node.type === 'VariableDeclaration') {
+                node.declarations.forEach(function(declaration) {
+                    letsCheckThisOne(declaration.id || {});
+                });
+            }
+
+            if (node.type === 'AssignmentExpression') {
+                var left = node.left;
+
+                if (left) {
+                    letsCheckThisOne(left);
+                }
+            }
+        });
+    }
+};

test/specs/rules/require-space-before-destructured-values.js

@@ -0,0 +1,107 @@
+var Checker = require('../../../lib/checker');
+var expect = require('chai').expect;
+
+describe('rules/require-space-before-destructured-values', function() {
+    var checker;
+    var rules = { requireSpaceBeforeDestructuredValues: true };
+
+    beforeEach(function() {
+        checker = new Checker();
+        checker.registerDefaultRules();
+        checker.configure(rules);
+    });
+
+    it('should report with no space after keys colons in plain objects', function() {
+        expect(checker.checkString('var { foo:objFoo, bar: objBar } = SomeThing;'))
+            .to.have.one.validation.error.from('requireSpaceBeforeDestructuredValues');
+
+        expect(checker.checkString('var { foo:objFoo, bar:objBar } = SomeThing;'))
+            .to.have.error.count.eq(2);
+    });
+
+    it('should report with no space after keys colons in nested arrays', function() {
+        expect(checker.checkString('var { a:[{b: objB}] } = obj;'))
+            .to.have.one.validation.error.from('requireSpaceBeforeDestructuredValues');
+
+        expect(checker.checkString('var { a: [{b:objB}] } = obj;'))
+            .to.have.one.validation.error.from('requireSpaceBeforeDestructuredValues');
+
+        expect(checker.checkString('var { a: [ {b: objB}, {c: [ {d:objD}] } ] } = obj;'))
+            .to.have.one.validation.error.from('requireSpaceBeforeDestructuredValues');
+    });
+
+    it('should report with no space after keys colons in nested objects', function() {
+        expect(checker.checkString('var { a: {b:objB} } = obj;'))
+            .to.have.one.validation.error.from('requireSpaceBeforeDestructuredValues');
+
+        expect(checker.checkString('var { a: {b: objB, c: {d:objD} } } = obj;'))
+            .to.have.one.validation.error.from('requireSpaceBeforeDestructuredValues');
+
+        expect(checker.checkString('var { a:{b: objB, c:{d:objD} } } = obj;'))
+            .to.have.error.count.eq(3);
+    });
+
+    it('should report with no space after keys colons in nested objects and arrays', function() {
+        expect(checker.checkString('var { a: {b:objB}, c: [ {d:objD} ] } = obj;'))
+            .to.have.error.count.eq(2);
+
+        expect(checker.checkString('var { a: { b: [ { c: { d: [ {e:objE} ] } } ] } } = obj;'))
+            .to.have.one.validation.error.from('requireSpaceBeforeDestructuredValues');
+    });
+
+    it('should report mixed shorthand and normal object destructured values', function() {
+        expect(checker.checkString('var { a, b:objB } = obj;'))
+            .to.have.one.validation.error.from('requireSpaceBeforeDestructuredValues');
+    });
+
+    it('should not report with end of line after keys colons', function() {
+        expect(checker.checkString(
+            'var {\n' +
+            '   a:\n' +
+            '   objA\n' +
+            '} = obj;'
+        )).to.have.no.errors();
+    });
+
+    it(
+        'should report in assignment expressions',
+        function() {
+            expect(checker.checkString(
+                '({a:asdf, b: asdf2} = {a:1, b:2});'
+            )).to.have.error.count.eq(1);
+
+            expect(checker.checkString(
+                'fn({a:asdf, b:asdf2} = obj);'
+            )).to.have.error.count.eq(2);
+
+            expect(checker.checkString(
+                '({a:a1, b:b1} = {a:a2, b:b2} = {a:1, b:1});'
+            )).to.have.error.count.eq(4);
+
+            expect(checker.checkString(
+                '([{a:asdf, b:asdf2}] = [{a:1, b:1}]);'
+            )).to.have.error.count.eq(2);
+
+            expect(checker.checkString(
+                '([{a:a1, b:b1}, {c:{d:[{e:e1}]}}] = obj);'
+            )).to.have.error.count.eq(5);
+        }
+    );
+
+    it(
+        'should report in multiline assignment expressions',
+        function() {
+            expect(checker.checkString(
+                '({\n' +
+                'a:asdf, b:asdf2\n' +
+                '} = {a:1, b:2});'
+            )).to.have.error.count.eq(2);
+        }
+    );
+
+    it('should not report with Identifiers', function() {
+        expect(checker.checkString(
+            '(a = {a:asdf, b:asdf2});'
+        )).to.have.no.errors();
+    });
+});