Fix: requireSpacesInGenerator - account for named functions

Fixes #1955
Closes gh-1963

Author: hzoo

lib/config/configuration.js

@@ -947,7 +947,7 @@ 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'));
+    this.registerRule(require('../rules/require-spaces-in-generator'));
 
     /* ES6 only (end) */
 

…ules/require-spaces-around-generators.js lib/rules/require-spaces-in-generator.jslib/rules/require-spaces-around-generators.js renamed to lib/rules/require-spaces-in-generator.js lib/rules/require-spaces-around-generators.js renamed to lib/rules/require-spaces-in-generator.js

@@ -78,8 +78,6 @@ module.exports.prototype = {
                 return;
             }
 
-            // for a named function, use node.id
-            var functionNode = node.id || node;
             var parent = node.parentNode;
 
             // Ignore syntactic sugar for getters and setters.
@@ -89,10 +87,10 @@ module.exports.prototype = {
 
             // shorthand or constructor methods
             if (parent.method || parent.type === 'MethodDefinition') {
-                functionNode = parent.key;
+                node = parent.key;
             }
 
-            var currentToken = file.getFirstNodeToken(functionNode);
+            var currentToken = file.getFirstNodeToken(node);
 
             if (node.async && currentToken.value === 'async') {
                 currentToken = file.getNextToken(currentToken);

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

@@ -0,0 +1,126 @@
+var Checker = require('../../../lib/checker');
+var expect = require('chai').expect;
+var reportAndFix = require('../../lib/assertHelpers').reportAndFix;
+
+describe('rules/require-spaces-in-generator', 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 with function declaration',
+            rules: rules,
+            errors: 2,
+            input: 'function*asdf(){}',
+            output: 'function * asdf(){}'
+        });
+
+        reportAndFix({
+            name: 'should report missing space after the star with function declaration',
+            rules: rules,
+            errors: 1,
+            input: 'function *asdf(){}',
+            output: 'function * asdf(){}'
+        });
+
+        reportAndFix({
+            name: 'should report missing space before the star with function declaration',
+            rules: rules,
+            errors: 1,
+            input: 'function* asdf(){}',
+            output: 'function * asdf(){}'
+        });
+
+        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 * (){}'
+        });
+
+        reportAndFix({
+            name: 'should report missing space before and after the star with named function',
+            rules: rules,
+            errors: 2,
+            input: 'var x = function*asdf(){}',
+            output: 'var x = function * asdf(){}'
+        });
+
+        reportAndFix({
+            name: 'should report missing space after the star with named function',
+            rules: rules,
+            errors: 1,
+            input: 'var x = function *asdf(){}',
+            output: 'var x = function * asdf(){}'
+        });
+
+        reportAndFix({
+            name: 'should report missing space before the star with named function',
+            rules: rules,
+            errors: 1,
+            input: 'var x = function* asdf(){}',
+            output: 'var x = function * asdf(){}'
+        });
+
+        it('should not report missing spaces error', function() {
+            expect(checker.checkString('var x = function * (){}')).to.have.no.errors();
+        });
+
+        it('should not report missing spaces error with named function', function() {
+            expect(checker.checkString('var x = function * asdf(){}')).to.have.no.errors();
+        });
+
+        it('should not report missing spaces error with function delcaration', function() {
+            expect(checker.checkString('function * asdf(){}')).to.have.no.errors();
+        });
+
+        it('should not report missing spaces error with async function', function() {
+            expect(checker.checkString('var x = async function * (){}')).to.have.no.errors();
+        });
+
+        it('should skip async functions with named function', function() {
+            expect(checker.checkString('var x = async function * asdf(){}')).to.have.no.errors();
+        });
+
+        it('should report missing space after star for async function', function() {
+            var testExp = checker.checkString('var x = async function *(){}');
+            var reqTest = 'requireSpacesInGenerator';
+            expect(testExp).to.have.one.validation.error.from(reqTest);
+        });
+
+        it('should report missing space after star for named async function', function() {
+            var testExp = checker.checkString('var x = async function *asdf(){}');
+            var reqTest = 'requireSpacesInGenerator';
+            expect(testExp).to.have.one.validation.error.from(reqTest);
+        });
+    });
+});