New rule: requireObjectShorthand

Requires shorthand properties when possible

Fixes #2038

Author: markelog

grouping.json

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

lib/config/configuration.js

@@ -953,6 +953,7 @@ Configuration.prototype.registerDefaultRules = function() {
     this.registerRule(require('../rules/require-enhanced-object-literals'));
     this.registerRule(require('../rules/require-array-destructuring'));
     this.registerRule(require('../rules/disallow-var'));
+    this.registerRule(require('../rules/require-object-shorthand'));
     /* ES6 only (end) */
 
     this.registerRule(require('../rules/require-curly-braces'));

lib/rules/require-object-shorthand.js

@@ -0,0 +1,62 @@
+/**
+ * Group your shorthand properties at the beginning of your object declaration.
+ * Why? Because it's fancy! Oh, yeah.
+ *
+ * Types: `Boolean`
+ *
+ * Values: `true`
+ *
+ * Version: `ES6`
+ *
+ * #### Example
+ *
+ * ```js
+ * "requireObjectShorthand": true
+ * ```
+ *
+ * ##### Valid
+ *
+ * ```js
+ * var x = {
+ *     a,
+ *     handler,
+ *     abc: xyz,
+ *     test: test2
+ * }
+ * ```
+ *
+ * ##### Invalid
+ *
+ * ```js
+  * var x = {
+ *     a: a
+ * }
+ * ```
+ *
+ */
+
+var assert = require('assert');
+
+module.exports = function() {};
+
+module.exports.prototype = {
+
+    configure: function(options) {
+        assert(
+            options === true,
+            this.getOptionName() + ' option requires true value'
+        );
+    },
+
+    getOptionName: function() {
+        return 'requireObjectShorthand';
+    },
+
+    check: function(file, errors) {
+        file.iterateNodesByType('Property', function(node) {
+            if (node.key.name === node.value.name && !node.shorthand) {
+                errors.add('You should use shorthand version', node.loc.start);
+            }
+        });
+    }
+};

test/specs/rules/require-object-shorthand.js

@@ -0,0 +1,35 @@
+var Checker = require('../../../lib/checker');
+var expect = require('chai').expect;
+
+describe('rules/require-object-shorthand.js', function() {
+    var checker;
+
+    beforeEach(function() {
+        checker = new Checker();
+        checker.registerDefaultRules();
+
+        checker.configure({
+            requireObjectShorthand: true
+        });
+    });
+
+    it('should warn on incorrect configuration', function() {
+        expect(function() {
+            checker.configure({
+                requireObjectShorthand: 1
+            });
+        }).to.throw();
+    });
+
+    it('should warn on possible shorthand', function() {
+        expect(checker.checkString('({a: a})')).to.have.one.validation.error.from('requireObjectShorthand');
+    });
+
+    it('should warn on one possible shorthand for two props', function() {
+        expect(checker.checkString('({a: a, b: c})')).to.have.one.validation.error.from('requireObjectShorthand');
+    });
+
+    it('should not warn', function() {
+        expect(checker.checkString('({b: c})')).to.have.no.errors();
+    });
+});