New Rule: requireSpacesInGenerator

Fixes #1879
Closes gh-1922

Author: stefania11

grouping.json

@@ -156,7 +156,8 @@
     "requireShorthandArrowFunctions",
     "requireNumericLiterals",
     "requireSpread",
-    "requireTemplateStrings"
+    "requireTemplateStrings",
+    "requireSpacesInGenerator"
   ],
   "Everything else": [
     "requireParenthesesAroundIIFE",

lib/config/configuration.js

@@ -939,6 +939,8 @@ Configuration.prototype.registerDefaultRules = function() {
     this.registerRule(require('../rules/require-shorthand-arrow-functions'));
     this.registerRule(require('../rules/disallow-shorthand-arrow-functions'));
     this.registerRule(require('../rules/disallow-identical-destructuring-names'));
+    this.registerRule(require('../rules/require-spaces-around-generators'));
+
     /* ES6 only (end) */
 
     this.registerRule(require('../rules/require-curly-braces'));

lib/rules/require-spaces-around-generators.js

@@ -0,0 +1,121 @@
+/**
+ * Requires space before and after `*` in generator functions
+ *
+ * Types: `Object`
+ *
+ *  - `Object` (at least one of properties must be present and it must be set to true):
+ *      - `'beforeStar'`
+ *          - `true` validates that there is a space before `*`
+ *      - `'afterStar'`
+ *          - `true` validates that there is a space after `*`
+ *
+ * #### Example
+ *
+ * ```js
+ * "requireSpacesInGenerator": {
+ *     "beforeStar": true,
+ *     "afterStar": true
+ * }
+ * ```
+ * ##### Valid for mode `{ "beforeStar": true, "afterStar": true }`
+ *
+ * ```js
+ * var x = function * () {};
+ * function * a() {};
+ * var x = async function * () {};
+ * var x = async function * a () {};
+ * async function * a() {}
+ * var x = async function * (){};
+ * ```
+ *
+*/
+
+var assert = require('assert');
+
+module.exports = function() {};
+
+module.exports.prototype = {
+    configure: function(options) {
+        assert(
+            typeof options === 'object',
+            this.getOptionName() + ' option must be an object'
+        );
+
+        if ('beforeStar' in options) {
+            assert(
+                options.beforeStar === true,
+                this.getOptionName() + '.beforeStar ' +
+                'property requires true value or should be removed'
+            );
+        }
+        if ('afterStar' in options) {
+            assert(
+                options.afterStar === true,
+                this.getOptionName() + '.afterStar ' +
+                'property requires true value or should be removed'
+            );
+        }
+
+        assert(
+            options.beforeStar || options.afterStar,
+            this.getOptionName() + ' must have beforeStar or afterStar property'
+        );
+
+        this._beforeStar = options.beforeStar;
+        this._afterStar = options.afterStar;
+    },
+
+    getOptionName: function() {
+        return 'requireSpacesInGenerator';
+    },
+
+    check: function(file, errors) {
+        var beforeStar = this._beforeStar;
+        var afterStar = this._afterStar;
+
+        file.iterateNodesByType(['FunctionDeclaration', 'FunctionExpression'], function(node) {
+            // for a named function, use node.id
+            var functionNode = node.id || node;
+            var parent = node.parentNode;
+
+            // Ignore syntactic sugar for getters and setters.
+            if (parent.type === 'Property' && (parent.kind === 'get' || parent.kind === 'set')) {
+                return;
+            }
+
+            // shorthand or constructor methods
+            if (parent.method || parent.type === 'MethodDefinition') {
+                functionNode = parent.key;
+            }
+
+            var currentToken = file.getFirstNodeToken(functionNode);
+
+            if (!node.generator) {
+                return;
+            }
+
+            if (node.async && currentToken.value === 'async') {
+                currentToken = file.getNextToken(currentToken);
+            }
+
+            if (beforeStar) {
+                // currentToken assigned outside of function
+                errors.assert.whitespaceBetween({
+                    token: currentToken,
+                    nextToken: file.getNextToken(currentToken),
+                    message: 'Missing space before star'
+                });
+            }
+
+            if (afterStar) {
+                // currentToken reassigned for star token
+                currentToken = file.getNextToken(currentToken);
+                errors.assert.whitespaceBetween({
+                    token: currentToken,
+                    nextToken: file.getNextToken(currentToken),
+                    message: 'Missing space after star'
+                });
+            }
+        });
+    }
+};

test/specs/rules/require-space-around-generators.js

@@ -0,0 +1,60 @@
+var Checker = require('../../../lib/checker');
+var expect = require('chai').expect;
+var reportAndFix = require('../../lib/assertHelpers').reportAndFix;
+
+describe('rules/require-spaces-around-generators', function() {
+    var checker;
+    beforeEach(function() {
+        checker = new Checker();
+        checker.registerDefaultRules();
+    });
+
+    describe('both true', function() {
+        var rules = {
+            requireSpacesInGenerator: { beforeStar: true, afterStar: true },
+            esnext: true
+        };
+
+        beforeEach(function() {
+            checker.configure(rules);
+        });
+
+        reportAndFix({
+            name: 'should report missing space before and after the star',
+            rules: rules,
+            errors: 2,
+            input: 'var x = function*(){}',
+            output: 'var x = function * (){}'
+        });
+
+        reportAndFix({
+            name: 'should report missing space after the star',
+            rules: rules,
+            errors: 1,
+            input: 'var x = function *(){}',
+            output: 'var x = function * (){}'
+        });
+
+        reportAndFix({
+            name: 'should report missing space before the star',
+            rules: rules,
+            errors: 1,
+            input: 'var x = function* (){}',
+            output: 'var x = function * (){}'
+        });
+
+        it('should not report missing spaces error', function() {
+            expect(checker.checkString('var x = function * (){}')).to.have.no.errors();
+        });
+
+        it('should skip async functions', function() {
+            expect(checker.checkString('var x = async function * (){}')).to.have.no.errors();
+        });
+
+        it('should skip async functions', function() {
+            var testExp = checker.checkString('var x = async function *(){}');
+            var reqTest = 'requireSpacesInGenerator';
+            expect(testExp).to.have.one.validation.error.from(reqTest);
+        });
+    });
+});