eslint 3.18.0 → 3.19.0

package/lib/rules/space-before-function-paren.js

@@ -51,31 +51,9 @@ module.exports = {
     },
 
     create(context) {
-
-        const configuration = context.options[0],
-            sourceCode = context.getSourceCode();
-        let requireAnonymousFunctionSpacing = true,
-            forbidAnonymousFunctionSpacing = false,
-            requireNamedFunctionSpacing = true,
-            forbidNamedFunctionSpacing = false,
-            requireArrowFunctionSpacing = false,
-            forbidArrowFunctionSpacing = false;
-
-        if (typeof configuration === "object") {
-            requireAnonymousFunctionSpacing = (
-                !configuration.anonymous || configuration.anonymous === "always");
-            forbidAnonymousFunctionSpacing = configuration.anonymous === "never";
-            requireNamedFunctionSpacing = (
-                !configuration.named || configuration.named === "always");
-            forbidNamedFunctionSpacing = configuration.named === "never";
-            requireArrowFunctionSpacing = configuration.asyncArrow === "always";
-            forbidArrowFunctionSpacing = configuration.asyncArrow === "never";
-        } else if (configuration === "never") {
-            requireAnonymousFunctionSpacing = false;
-            forbidAnonymousFunctionSpacing = true;
-            requireNamedFunctionSpacing = false;
-            forbidNamedFunctionSpacing = true;
-        }
+        const sourceCode = context.getSourceCode();
+        const baseConfig = typeof context.options[0] === "string" ? context.options[0] : "always";
+        const overrideConfig = typeof context.options[0] === "object" ? context.options[0] : {};
 
         /**
          * Determines whether a function has a name.
@@ -100,69 +78,67 @@ module.exports = {
         }
 
         /**
-         * Validates the spacing before function parentheses.
-         * @param {ASTNode} node The node to be validated.
-         * @returns {void}
+         * Gets the config for a given function
+         * @param {ASTNode} node The function node
+         * @returns {string} "always", "never", or "ignore"
          */
-        function validateSpacingBeforeParentheses(node) {
-            const isArrow = node.type === "ArrowFunctionExpression";
-            const isNamed = !isArrow && isNamedFunction(node);
-            const isAnonymousGenerator = node.generator && !isNamed;
-            const isNormalArrow = isArrow && !node.async;
-            const isArrowWithoutParens = isArrow && sourceCode.getFirstToken(node, 1).value !== "(";
-            let forbidSpacing, requireSpacing;
-
-            // isAnonymousGenerator → `generator-star-spacing` should warn it. E.g. `function* () {}`
-            // isNormalArrow → ignore always.
-            // isArrowWithoutParens → ignore always. E.g. `async a => a`
-            if (isAnonymousGenerator || isNormalArrow || isArrowWithoutParens) {
-                return;
+        function getConfigForFunction(node) {
+            if (node.type === "ArrowFunctionExpression") {
+
+                // Always ignore non-async functions and arrow functions without parens, e.g. async foo => bar
+                if (node.async && astUtils.isOpeningParenToken(sourceCode.getFirstToken(node, { skip: 1 }))) {
+
+                    // For backwards compatibility, the base config does not apply to async arrow functions.
+                    return overrideConfig.asyncArrow || "ignore";
+                }
+            } else if (isNamedFunction(node)) {
+                return overrideConfig.named || baseConfig;
+
+            // `generator-star-spacing` should warn anonymous generators. E.g. `function* () {}`
+            } else if (!node.generator) {
+                return overrideConfig.anonymous || baseConfig;
             }
 
-            if (isArrow) {
-                forbidSpacing = forbidArrowFunctionSpacing;
-                requireSpacing = requireArrowFunctionSpacing;
-            } else if (isNamed) {
-                forbidSpacing = forbidNamedFunctionSpacing;
-                requireSpacing = requireNamedFunctionSpacing;
-            } else {
-                forbidSpacing = forbidAnonymousFunctionSpacing;
-                requireSpacing = requireAnonymousFunctionSpacing;
+            return "ignore";
+        }
+
+        /**
+         * Checks the parens of a function node
+         * @param {ASTNode} node A function node
+         * @returns {void}
+         */
+        function checkFunction(node) {
+            const functionConfig = getConfigForFunction(node);
+
+            if (functionConfig === "ignore") {
+                return;
             }
 
             const rightToken = sourceCode.getFirstToken(node, astUtils.isOpeningParenToken);
             const leftToken = sourceCode.getTokenBefore(rightToken);
-            const location = leftToken.loc.end;
-
-            if (sourceCode.isSpaceBetweenTokens(leftToken, rightToken)) {
-                if (forbidSpacing) {
-                    context.report({
-                        node,
-                        loc: location,
-                        message: "Unexpected space before function parentheses.",
-                        fix(fixer) {
-                            return fixer.removeRange([leftToken.range[1], rightToken.range[0]]);
-                        }
-                    });
-                }
-            } else {
-                if (requireSpacing) {
-                    context.report({
-                        node,
-                        loc: location,
-                        message: "Missing space before function parentheses.",
-                        fix(fixer) {
-                            return fixer.insertTextAfter(leftToken, " ");
-                        }
-                    });
-                }
+            const hasSpacing = sourceCode.isSpaceBetweenTokens(leftToken, rightToken);
+
+            if (hasSpacing && functionConfig === "never") {
+                context.report({
+                    node,
+                    loc: leftToken.loc.end,
+                    message: "Unexpected space before function parentheses.",
+                    fix: fixer => fixer.removeRange([leftToken.range[1], rightToken.range[0]])
+                });
+            } else if (!hasSpacing && functionConfig === "always") {
+                context.report({
+                    node,
+                    loc: leftToken.loc.end,
+                    message: "Missing space before function parentheses.",
+                    fix: fixer => fixer.insertTextAfter(leftToken, " ")
+                });
             }
         }
 
         return {
-            FunctionDeclaration: validateSpacingBeforeParentheses,
-            FunctionExpression: validateSpacingBeforeParentheses,
-            ArrowFunctionExpression: validateSpacingBeforeParentheses
+            ArrowFunctionExpression: checkFunction,
+            FunctionDeclaration: checkFunction,
+            FunctionExpression: checkFunction
         };
     }
 };

package/lib/rules/space-in-parens.js

@@ -128,7 +128,7 @@ module.exports = {
             }
 
             if (ALWAYS) {
-                if (right.type === "Punctuator" && right.value === ")") {
+                if (astUtils.isClosingParenToken(right)) {
                     return false;
                 }
                 return !isOpenerException(right);
@@ -144,7 +144,7 @@ module.exports = {
          * @returns {boolean} True if the paren should have a space
          */
         function shouldCloserHaveSpace(left, right) {
-            if (left.type === "Punctuator" && left.value === "(") {
+            if (astUtils.isOpeningParenToken(left)) {
                 return false;
             }
 
@@ -192,7 +192,7 @@ module.exports = {
          * @returns {boolean} True if the paren should reject the space
          */
         function shouldCloserRejectSpace(left, right) {
-            if (left.type === "Punctuator" && left.value === "(") {
+            if (astUtils.isOpeningParenToken(left)) {
                 return false;
             }
 
@@ -224,11 +224,7 @@ module.exports = {
                     const prevToken = tokens[i - 1];
                     const nextToken = tokens[i + 1];
 
-                    if (token.type !== "Punctuator") {
-                        return;
-                    }
-
-                    if (token.value !== "(" && token.value !== ")") {
+                    if (!astUtils.isOpeningParenToken(token) && !astUtils.isClosingParenToken(token)) {
                         return;
                     }
 

package/lib/util/glob-util.js

@@ -86,7 +86,7 @@ function resolveFileGlobPatterns(patterns, options) {
 
     const processPathExtensions = processPath(options);
 
-    return patterns.map(processPathExtensions);
+    return patterns.filter(p => p.length).map(processPathExtensions);
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "3.18.0",
+  "version": "3.19.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -71,42 +71,42 @@
     "user-home": "^2.0.0"
   },
   "devDependencies": {
-    "babel-polyfill": "^6.9.1",
-    "babel-preset-es2015": "^6.9.0",
+    "babel-polyfill": "^6.23.0",
+    "babel-preset-es2015": "^6.24.0",
     "babelify": "^7.3.0",
-    "beefy": "^2.0.0",
-    "brfs": "0.0.9",
-    "browserify": "^12.0.1",
+    "beefy": "^2.1.8",
+    "brfs": "1.4.3",
+    "browserify": "^14.1.0",
     "chai": "^3.5.0",
-    "cheerio": "^0.19.0",
-    "coveralls": "^2.11.16",
-    "dateformat": "^1.0.8",
-    "ejs": "^2.3.3",
+    "cheerio": "^0.22.0",
+    "coveralls": "^2.12.0",
+    "dateformat": "^2.0.0",
+    "ejs": "^2.5.6",
     "eslint-plugin-eslint-plugin": "^0.7.1",
-    "eslint-plugin-node": "^4.1.0",
-    "eslint-release": "^0.10.0",
-    "esprima": "^2.4.1",
+    "eslint-plugin-node": "^4.2.1",
+    "eslint-release": "^0.10.1",
+    "esprima": "^3.1.3",
     "esprima-fb": "^15001.1001.0-dev-harmony-fb",
-    "istanbul": "^0.4.0",
-    "jsdoc": "^3.3.0-beta1",
-    "karma": "^0.13.22",
+    "istanbul": "^0.4.5",
+    "jsdoc": "^3.4.3",
+    "karma": "^1.5.0",
     "karma-babel-preprocessor": "^6.0.1",
-    "karma-mocha": "^1.0.1",
-    "karma-mocha-reporter": "^2.0.3",
-    "karma-phantomjs-launcher": "^1.0.0",
-    "leche": "^2.1.1",
+    "karma-mocha": "^1.3.0",
+    "karma-mocha-reporter": "^2.2.2",
+    "karma-phantomjs-launcher": "^1.0.4",
+    "leche": "^2.1.2",
     "load-perf": "^0.2.0",
-    "markdownlint": "^0.3.1",
-    "mocha": "^2.4.5",
+    "markdownlint": "^0.4.0",
+    "mocha": "^3.2.0",
     "mock-fs": "^4.2.0",
-    "npm-license": "^0.3.2",
-    "phantomjs-prebuilt": "^2.1.7",
-    "proxyquire": "^1.7.10",
-    "semver": "^5.0.3",
-    "shelljs-nodecli": "~0.1.0",
-    "sinon": "^1.17.2",
+    "npm-license": "^0.3.3",
+    "phantomjs-prebuilt": "^2.1.14",
+    "proxyquire": "^1.7.11",
+    "semver": "^5.3.0",
+    "shelljs-nodecli": "~0.1.1",
+    "sinon": "^2.0.0",
     "temp": "^0.8.3",
-    "through": "^2.3.6"
+    "through": "^2.3.8"
   },
   "keywords": [
     "ast",