eslint 1.5.0 → 1.5.1

package/README.md

@@ -104,7 +104,7 @@ The following projects are using ESLint to validate their JavaScript:
 
 * [Drupal](https://www.drupal.org/node/2274223)
 * [Esprima](https://github.com/ariya/esprima)
-* [io.js](https://github.com/iojs/io.js/commit/f9dd34d301ab385ae316769b85ef916f9b70b6f6)
+* [Node.js](https://github.com/nodejs/node/commit/f9dd34d301ab385ae316769b85ef916f9b70b6f6)
 * [WebKit](https://bugs.webkit.org/show_bug.cgi?id=125048)
 
 In addition, the following companies are using ESLint internally to validate their JavaScript:

package/lib/config.js

@@ -295,14 +295,16 @@ function getLocalConfig(thisConfig, directory) {
         config = {},
         localConfigFiles = thisConfig.findLocalConfigFiles(directory),
         numFiles = localConfigFiles.length,
-        rootPath;
+        rootPath,
+        projectConfigPath = path.join(process.cwd(), LOCAL_CONFIG_FILENAME);
 
     for (i = 0; i < numFiles; i++) {
 
         localConfigFile = localConfigFiles[i];
 
-        // Don't consider the personal config file in the home directory.
-        if (localConfigFile === PERSONAL_CONFIG_PATH) {
+        // Don't consider the personal config file in the home directory,
+        // except if the home directory is the same as the current working directory
+        if (localConfigFile === PERSONAL_CONFIG_PATH && localConfigFile !== projectConfigPath) {
             continue;
         }
 

package/lib/rules/func-style.js

@@ -12,32 +12,52 @@
 module.exports = function(context) {
 
     var style = context.options[0],
-        enforceDeclarations = (style === "declaration");
+        enforceDeclarations = (style === "declaration"),
+        stack = [];
 
     return {
+        "Program": function() {
+            stack = [];
+        },
 
         "FunctionDeclaration": function(node) {
+            stack.push(false);
+
             if (!enforceDeclarations) {
                 context.report(node, "Expected a function expression.");
             }
         },
+        "FunctionDeclaration:exit": function() {
+            stack.pop();
+        },
 
-        "FunctionExpression": function() {
-            var parent = context.getAncestors().pop();
+        "FunctionExpression": function(node) {
+            stack.push(false);
 
-            if (enforceDeclarations && parent.type === "VariableDeclarator") {
-                context.report(parent, "Expected a function declaration.");
+            if (enforceDeclarations && node.parent.type === "VariableDeclarator") {
+                context.report(node.parent, "Expected a function declaration.");
             }
         },
+        "FunctionExpression:exit": function() {
+            stack.pop();
+        },
 
         "ArrowFunctionExpression": function() {
-            var parent = context.getAncestors().pop();
+            stack.push(false);
+        },
+        "ArrowFunctionExpression:exit": function(node) {
+            var hasThisExpr = stack.pop();
 
-            if (enforceDeclarations && parent.type === "VariableDeclarator") {
-                context.report(parent, "Expected a function declaration.");
+            if (enforceDeclarations && !hasThisExpr && node.parent.type === "VariableDeclarator") {
+                context.report(node.parent, "Expected a function declaration.");
             }
-        }
+        },
 
+        "ThisExpression": function() {
+            if (stack.length > 0) {
+                stack[stack.length - 1] = true;
+            }
+        }
     };
 
 };

package/lib/rules/no-dupe-args.js

@@ -2,6 +2,8 @@
  * @fileoverview Rule to flag duplicate arguments
  * @author Jamund Ferguson
  * @copyright 2015 Jamund Ferguson. All rights reserved.
+ * @copyright 2015 Toru Nagashima. All rights reserved.
+ * See LICENSE file in root directory for full license.
  */
 
 "use strict";
@@ -16,6 +18,15 @@ module.exports = function(context) {
     // Helpers
     //--------------------------------------------------------------------------
 
+    /**
+     * Checks whether or not a given definition is a parameter's.
+     * @param {escope.DefEntry} def - A definition to check.
+     * @returns {boolean} `true` if the definition is a parameter's.
+     */
+    function isParameter(def) {
+        return def.type === "Parameter";
+    }
+
     /**
      * Determines if a given node has duplicate parameters.
      * @param {ASTNode} node The node to check.
@@ -23,56 +34,29 @@ module.exports = function(context) {
      * @private
      */
     function checkParams(node) {
-        var params = {},
-            dups = {};
+        var variables = context.getDeclaredVariables(node);
+        var keyMap = Object.create(null);
 
+        for (var i = 0; i < variables.length; ++i) {
+            var variable = variables[i];
 
-        /**
-         * Marks a given param as either seen or duplicated.
-         * @param {string} name The name of the param to mark.
-         * @returns {void}
-         * @private
-         */
-        function markParam(name) {
-            if (params.hasOwnProperty(name)) {
-                dups[name] = 1;
-            } else {
-                params[name] = 1;
+            // TODO(nagashima): Remove this duplication check after https://github.com/estools/escope/pull/79
+            var key = "$" + variable.name; // to avoid __proto__.
+            if (!isParameter(variable.defs[0]) || keyMap[key]) {
+                continue;
             }
-        }
-
-        // loop through and find each duplicate param
-        node.params.forEach(function(param) {
-
-            switch (param.type) {
-                case "Identifier":
-                    markParam(param.name);
-                    break;
-
-                case "ObjectPattern":
-                    param.properties.forEach(function(property) {
-                        markParam(property.key.name);
-                    });
-                    break;
-
-                case "ArrayPattern":
-                    param.elements.forEach(function(element) {
-
-                        // Arrays can be sparse (unwanted arguments)
-                        if (element !== null) {
-                            markParam(element.name);
-                        }
-                    });
-                    break;
-
-                // no default
+            keyMap[key] = true;
+
+            // Checks and reports duplications.
+            var defs = variable.defs.filter(isParameter);
+            if (defs.length >= 2) {
+                context.report({
+                    node: node,
+                    message: "Duplicate param '{{name}}'.",
+                    data: {name: variable.name}
+                });
             }
-        });
-
-        // log an error for each duplicate (not 2 for each)
-        Object.keys(dups).forEach(function(currentParam) {
-            context.report(node, "Duplicate param '{{key}}'.", { key: currentParam });
-        });
+        }
     }
 
     //--------------------------------------------------------------------------

package/lib/rules/space-before-keywords.js

@@ -72,7 +72,7 @@ module.exports = function(context) {
         }
 
         options = options || {};
-        options.allowedPrecedingChars = options.allowedPrecedingChars || [];
+        options.allowedPrecedingChars = options.allowedPrecedingChars || [ "{" ];
         options.requireSpace = typeof options.requireSpace === "undefined" ? SPACE_REQUIRED : options.requireSpace;
 
         var hasSpace = sourceCode.isSpaceBetweenTokens(left, right);
@@ -155,7 +155,7 @@ module.exports = function(context) {
                 check(caseNode);
             });
         },
-        ThrowStatement: check,
+        "ThrowStatement": check,
         "TryStatement": function(node) {
             // try
             check(node);
@@ -169,7 +169,7 @@ module.exports = function(context) {
         },
         "WithStatement": check,
         "VariableDeclaration": function(node) {
-            check(node, { allowedPrecedingChars: [ "(" ] });
+            check(node, { allowedPrecedingChars: [ "(", "{" ] });
         },
         "ReturnStatement": check,
         "BreakStatement": check,
@@ -177,25 +177,18 @@ module.exports = function(context) {
         "ContinueStatement": check,
         "FunctionDeclaration": check,
         "FunctionExpression": function(node) {
-
             var left = context.getTokenBefore(node);
+            var right = context.getFirstToken(node);
 
-            // Check to see if the function expression is a class method
-            if (node.parent && node.parent.type === "MethodDefinition") {
-                return;
-            }
-
-            // Check to see if the function expression is an object literal shorthand method
-            if (node.parent && node.parent.method && node.parent.type === "Property") {
+            // If it's a method, a getter, or a setter, the first token is not the `function` keyword.
+            if (right.type !== "Keyword") {
                 return;
             }
 
-            var right = context.getFirstToken(node);
-
-            checkTokens(node, left, right, { allowedPrecedingChars: [ "(" ] });
+            checkTokens(node, left, right, { allowedPrecedingChars: [ "(", "{" ] });
         },
         "YieldExpression": function(node) {
-            check(node, { allowedPrecedingChars: [ "(" ] });
+            check(node, { allowedPrecedingChars: [ "(", "{" ] });
         },
         "ForOfStatement": check,
         "ClassBody": function(node) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -38,7 +38,7 @@
     "chalk": "^1.0.0",
     "concat-stream": "^1.4.6",
     "debug": "^2.1.1",
-    "doctrine": "^0.6.2",
+    "doctrine": "^0.7.0",
     "escape-string-regexp": "^1.0.2",
     "escope": "^3.2.0",
     "espree": "^2.2.4",