eslint 1.4.1 → 1.5.1

package/lib/rules/comma-spacing.js

@@ -13,6 +13,8 @@ var astUtils = require("../ast-utils");
 
 module.exports = function(context) {
 
+    var sourceCode = context.getSourceCode();
+
     var options = {
         before: context.options[0] ? !!context.options[0].before : false,
         after: context.options[0] ? !!context.options[0].after : true
@@ -29,33 +31,6 @@ module.exports = function(context) {
     // list of comma tokens to ignore for the check of leading whitespace
     var commaTokensToIgnore = [];
 
-    /**
-     * Determines the length of comment between 2 tokens
-     * @param {Object} left - The left token object.
-     * @param {Object} right - The right token object.
-     * @returns {number} Length of comment in between tokens
-     */
-    function getCommentLengthBetweenTokens(left, right) {
-        return allComments.reduce(function(val, comment) {
-            if (left.range[1] <= comment.range[0] && comment.range[1] <= right.range[0]) {
-                val = val + comment.range[1] - comment.range[0];
-            }
-            return val;
-        }, 0);
-    }
-
-    /**
-     * Determines whether two adjacent tokens have whitespace between them.
-     * @param {Object} left - The left token object.
-     * @param {Object} right - The right token object.
-     * @returns {boolean} Whether or not there is space between the tokens.
-     */
-    function isSpaced(left, right) {
-        var punctuationLength = context.getTokensBetween(left, right).length; // the length of any parenthesis
-        var commentLenth = getCommentLengthBetweenTokens(left, right);
-        return (left.range[1] + punctuationLength + commentLenth) < right.range[0];
-    }
-
     /**
      * Determines if a given token is a comma operator.
      * @param {ASTNode} token The token to check.
@@ -91,12 +66,12 @@ module.exports = function(context) {
      */
     function validateCommaItemSpacing(tokens, reportItem) {
         if (tokens.left && astUtils.isTokenOnSameLine(tokens.left, tokens.comma) &&
-                (options.before !== isSpaced(tokens.left, tokens.comma))
+                (options.before !== sourceCode.isSpaceBetweenTokens(tokens.left, tokens.comma))
         ) {
             report(reportItem, "before");
         }
         if (tokens.right && astUtils.isTokenOnSameLine(tokens.comma, tokens.right) &&
-                (options.after !== isSpaced(tokens.comma, tokens.right))
+                (options.after !== sourceCode.isSpaceBetweenTokens(tokens.comma, tokens.right))
         ) {
             report(reportItem, "after");
         }

package/lib/rules/computed-property-spacing.js

@@ -12,6 +12,7 @@ var astUtils = require("../ast-utils");
 //------------------------------------------------------------------------------
 
 module.exports = function(context) {
+    var sourceCode = context.getSourceCode();
     var propertyNameMustBeSpaced = context.options[0] === "always"; // default is "never"
 
     //--------------------------------------------------------------------------
@@ -83,11 +84,11 @@ module.exports = function(context) {
 
             if (astUtils.isTokenOnSameLine(before, first)) {
                 if (propertyNameMustBeSpaced) {
-                    if (!astUtils.isTokenSpaced(before, first) && astUtils.isTokenOnSameLine(before, first)) {
+                    if (!sourceCode.isSpaceBetweenTokens(before, first) && astUtils.isTokenOnSameLine(before, first)) {
                         reportRequiredBeginningSpace(node, before);
                     }
                 } else {
-                    if (astUtils.isTokenSpaced(before, first)) {
+                    if (sourceCode.isSpaceBetweenTokens(before, first)) {
                         reportNoBeginningSpace(node, before);
                     }
                 }
@@ -95,11 +96,11 @@ module.exports = function(context) {
 
             if (astUtils.isTokenOnSameLine(last, after)) {
                 if (propertyNameMustBeSpaced) {
-                    if (!astUtils.isTokenSpaced(last, after) && astUtils.isTokenOnSameLine(last, after)) {
+                    if (!sourceCode.isSpaceBetweenTokens(last, after) && astUtils.isTokenOnSameLine(last, after)) {
                         reportRequiredEndingSpace(node, after);
                     }
                 } else {
-                    if (astUtils.isTokenSpaced(last, after)) {
+                    if (sourceCode.isSpaceBetweenTokens(last, after)) {
                         reportNoEndingSpace(node, after);
                     }
                 }

package/lib/rules/eol-last.js

@@ -27,7 +27,14 @@ module.exports = function(context) {
             if (src[src.length - 1] !== "\n") {
                 // file is not newline-terminated
                 location.line = src.split(/\n/g).length;
-                context.report(node, location, "Newline required at end of file but not found.");
+                context.report({
+                    node: node,
+                    loc: location,
+                    message: "Newline required at end of file but not found.",
+                    fix: function(fixer) {
+                        return fixer.insertTextAfterRange([0, src.length], "\n");
+                    }
+                });
             }
         }
 

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/id-length.js

@@ -19,10 +19,10 @@ module.exports = function(context) {
     var properties = options.properties !== "never";
     var exceptions = (options.exceptions ? options.exceptions : [])
         .reduce(function(obj, item) {
-        obj[item] = true;
+            obj[item] = true;
 
-        return obj;
-    }, {});
+            return obj;
+        }, {});
 
     var SUPPORTED_EXPRESSIONS = {
         "MemberExpression": function(parent) {

package/lib/rules/indent.js

@@ -83,20 +83,78 @@ module.exports = function(context) {
      * @param {int} needed Expected indentation character count
      * @param {int} gotten Indentation character count in the actual node/code
      * @param {Object=} loc Error line and column location
+     * @param {boolean} isLastNodeCheck Is the error for last node check
      * @returns {void}
      */
-    function report(node, needed, gotten, loc) {
+    function report(node, needed, gotten, loc, isLastNodeCheck) {
         var msgContext = {
             needed: needed,
             type: indentType,
             characters: needed === 1 ? "character" : "characters",
             gotten: gotten
         };
+        var indentChar = indentType === "space" ? " " : "\t";
+
+        /**
+         * Responsible for fixing the indentation issue fix
+         * @returns {Function} function to be executed by the fixer
+         * @private
+         */
+        function getFixerFunction() {
+            var rangeToFix = [];
+
+            if (needed > gotten) {
+                var spaces = "" + new Array(needed - gotten + 1).join(indentChar);  // replace with repeat in future
+
+                if (isLastNodeCheck === true) {
+                    rangeToFix = [
+                        node.range[1] - 1,
+                        node.range[1] - 1
+                    ];
+                } else {
+                    rangeToFix = [
+                        node.range[0],
+                        node.range[0]
+                    ];
+                }
+
+                return function(fixer) {
+                    return fixer.insertTextBeforeRange(rangeToFix, spaces);
+                };
+            } else {
+                if (isLastNodeCheck === true) {
+                    rangeToFix = [
+                        node.range[1] - (gotten - needed) - 1,
+                        node.range[1] - 1
+                    ];
+                } else {
+                    rangeToFix = [
+                        node.range[0] - (gotten - needed),
+                        node.range[0]
+                    ];
+                }
+
+                return function(fixer) {
+                    return fixer.removeRange(rangeToFix);
+                };
+            }
+        }
 
         if (loc) {
-            context.report(node, loc, MESSAGE, msgContext);
+            context.report({
+                node: node,
+                loc: loc,
+                message: MESSAGE,
+                data: msgContext,
+                fix: getFixerFunction()
+            });
         } else {
-            context.report(node, MESSAGE, msgContext);
+            context.report({
+                node: node,
+                message: MESSAGE,
+                data: msgContext,
+                fix: getFixerFunction()
+            });
         }
     }
 
@@ -172,7 +230,8 @@ module.exports = function(context) {
                 node,
                 lastLineIndent,
                 endIndent,
-                { line: lastToken.loc.start.line, column: lastToken.loc.start.column }
+                { line: lastToken.loc.start.line, column: lastToken.loc.start.column },
+                true
             );
         }
     }
@@ -195,6 +254,35 @@ module.exports = function(context) {
         }
     }
 
+    /**
+     * Returns the VariableDeclarator based on the current node
+     * if not present then return null
+     * @param {ASTNode} node node to examine
+     * @returns {ASTNode|void} if found then node otherwise null
+     */
+    function getVariableDeclaratorNode(node) {
+        var parent = node.parent;
+
+        while (parent.type !== "VariableDeclarator" && parent.type !== "Program") {
+            parent = parent.parent;
+        }
+
+        return parent.type === "VariableDeclarator" ? parent : null;
+    }
+
+    /**
+     * Check to see if the node is part of the multi-line variable declaration.
+     * Also if its on the same line as the varNode
+     * @param {ASTNode} node node to check
+     * @param {ASTNode} varNode variable declaration node to check against
+     * @returns {boolean} True if all the above condition satisfy
+     */
+    function isNodeInVarOnTop(node, varNode) {
+        return varNode &&
+            varNode.parent.loc.start.line === node.loc.start.line &&
+            varNode.parent.declarations.length > 1;
+    }
+
     /**
      * Check indent for function block content
      * @param {ASTNode} node node to examine
@@ -214,11 +302,6 @@ module.exports = function(context) {
         //
         // Looks for 'Models'
         var calleeNode = node.parent; // FunctionExpression
-        while (calleeNode.parent &&
-        calleeNode.parent.type === "CallExpression") {
-            calleeNode = calleeNode.parent;
-        }
-
         var indent;
 
         if (calleeNode.parent &&
@@ -244,17 +327,16 @@ module.exports = function(context) {
             indent += indentSize;
         }
 
+        // function body indent should be indent + indent size
         indent += indentSize;
-        // If function content is not empty
-        var bodyIndent;
-        if (node.body.length > 0) {
-            bodyIndent = getNodeIndent(node.body[0]);
-            // Calculate left shift position don't require strict indent
-            // allow function body align to (indentSize * X)
-            while (bodyIndent > indent) {
-                indent += indentSize;
-            }
 
+        // check if the node is inside a variable
+        var parentVarNode = getVariableDeclaratorNode(node);
+        if (parentVarNode && isNodeInVarOnTop(node, parentVarNode)) {
+            indent += indentSize * options.VariableDeclarator[parentVarNode.parent.kind];
+        }
+
+        if (node.body.length > 0) {
             checkNodesIndent(node.body, indent);
         }
 
@@ -275,35 +357,6 @@ module.exports = function(context) {
         return startLine === endLine;
     }
 
-    /**
-     * Returns the VariableDeclarator based on the current node
-     * if not present then return null
-     * @param {ASTNode} node node to examine
-     * @returns {ASTNode|void} if found then node otherwise null
-     */
-    function getVariableDeclaratorNode(node) {
-        var parent = node.parent;
-
-        while (parent.type !== "VariableDeclarator" && parent.type !== "Program") {
-            parent = parent.parent;
-        }
-
-        return parent.type === "VariableDeclarator" ? parent : null;
-    }
-
-    /**
-     * Check to see if the node is part of the multi-line variable declaration.
-     * Also if its on the same line as the varNode
-     * @param {ASTNode} node node to check
-     * @param {ASTNode} varNode variable declaration node to check against
-     * @returns {boolean} True if all the above condition satisfy
-     */
-    function isNodeInVarOnTop(node, varNode) {
-        return varNode &&
-            varNode.parent.loc.start.line === node.loc.start.line &&
-            varNode.parent.declarations.length > 1;
-    }
-
     /**
      * Check to see if the first element inside an array is an object and on the same line as the node
      * If the node is not an array then it will return false.

package/lib/rules/jsx-quotes.js

@@ -49,7 +49,7 @@ module.exports = function(context) {
         "JSXAttribute": function(node) {
             var attributeValue = node.value;
 
-            if (astUtils.isStringLiteral(attributeValue) && !usesExpectedQuotes(attributeValue)) {
+            if (attributeValue && astUtils.isStringLiteral(attributeValue) && !usesExpectedQuotes(attributeValue)) {
                 context.report(attributeValue, "Unexpected usage of {{description}}.", setting);
             }
         }

package/lib/rules/key-spacing.js

@@ -94,6 +94,7 @@ module.exports = function(context) {
 
     var options = context.options[0] || {},
         align = options.align,
+        mode = options.mode || "strict",
         beforeColon = +!!options.beforeColon, // Defaults to false
         afterColon = +!(options.afterColon === false); // Defaults to true
 
@@ -162,7 +163,9 @@ module.exports = function(context) {
             firstTokenAfterColon = context.getTokenAfter(key, 1),
             location = side === "key" ? key.loc.start : firstTokenAfterColon.loc.start;
 
-        if (diff && !(expected && containsLineTerminator(whitespace))) {
+        if ((diff && mode === "strict" || diff < 0 && mode === "minimum") &&
+            !(expected && containsLineTerminator(whitespace))
+        ) {
             context.report(property[side], location, messages[side], {
                 error: diff > 0 ? "Extra" : "Missing",
                 computed: property.computed ? "computed " : "",
@@ -333,6 +336,9 @@ module.exports.schema = [
             "align": {
                 "enum": ["colon", "value"]
             },
+            "mode": {
+                "enum": ["strict", "minimum"]
+            },
             "beforeColon": {
                 "type": "boolean"
             },

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/no-extra-semi.js

@@ -17,7 +17,13 @@ module.exports = function(context) {
      * @returns {void}
      */
     function report(nodeOrToken) {
-        context.report(nodeOrToken, "Unnecessary semicolon.");
+        context.report({
+            node: nodeOrToken,
+            message: "Unnecessary semicolon.",
+            fix: function(fixer) {
+                return fixer.remove(nodeOrToken);
+            }
+        });
     }
 
     /**

package/lib/rules/no-inline-comments.js

@@ -5,6 +5,8 @@
  */
 "use strict";
 
+var astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -29,7 +31,7 @@ module.exports = function(context) {
         var postamble = endLine.slice(node.loc.end.column).trim();
 
         // Check that this comment isn't an ESLint directive
-        var isDirective = node.value.trim().indexOf("eslint-") === 0;
+        var isDirective = astUtils.isDirectiveComment(node);
 
         // Should be empty if there was only whitespace around the comment
         if (!isDirective && (preamble || postamble)) {

package/lib/rules/no-spaced-func.js

@@ -11,6 +11,8 @@
 
 module.exports = function(context) {
 
+    var sourceCode = context.getSourceCode();
+
     /**
      * Check if open space is present in a function name
      * @param {ASTNode} node node to evaluate
@@ -18,18 +20,29 @@ module.exports = function(context) {
      * @private
      */
     function detectOpenSpaces(node) {
-        var lastCalleeToken = context.getLastToken(node.callee);
-        var tokens = context.getTokens(node);
-        var i = tokens.indexOf(lastCalleeToken), l = tokens.length;
+        var lastCalleeToken = sourceCode.getLastToken(node.callee),
+            tokens = sourceCode.getTokens(node),
+            i = tokens.indexOf(lastCalleeToken),
+            l = tokens.length;
+
         while (i < l && tokens[i].value !== "(") {
             ++i;
         }
+
         if (i >= l) {
             return;
         }
+
         // look for a space between the callee and the open paren
-        if (tokens[i - 1].range[1] !== tokens[i].range[0]) {
-            context.report(node, lastCalleeToken.loc.start, "Unexpected space between function name and paren.");
+        if (sourceCode.isSpaceBetweenTokens(tokens[i - 1], tokens[i])) {
+            context.report({
+                node: node,
+                loc: lastCalleeToken.loc.start,
+                message: "Unexpected space between function name and paren.",
+                fix: function(fixer) {
+                    return fixer.removeRange([tokens[i - 1].range[1], tokens[i].range[0]]);
+                }
+            });
         }
     }
 

package/lib/rules/no-trailing-spaces.js

@@ -18,6 +18,27 @@ module.exports = function(context) {
     var options = context.options[0] || {},
         skipBlankLines = options.skipBlankLines || false;
 
+    /**
+     * Report the error message
+     * @param {ASTNode} node node to report
+     * @param {int[]} location range information
+     * @param {int[]} fixRange Range based on the whole program
+     * @returns {void}
+     */
+    function report(node, location, fixRange) {
+        // Passing node is a bit dirty, because message data will contain
+        // big text in `source`. But... who cares :) ?
+        // One more kludge will not make worse the bloody wizardry of this plugin.
+        context.report({
+            node: node,
+            loc: location,
+            message: "Trailing spaces not allowed.",
+            fix: function(fixer) {
+                return fixer.removeRange(fixRange);
+            }
+        });
+    }
+
 
     //--------------------------------------------------------------------------
     // Public
@@ -33,10 +54,12 @@ module.exports = function(context) {
             var src = context.getSource(),
                 re = new RegExp(NONBLANK),
                 skipMatch = new RegExp(SKIP_BLANK),
-                matches, lines = src.split(/\r?\n/), location;
+                matches, lines = src.split(/\r?\n/),
+                location,
+                totalLength = 0,
+                fixRange = [];
 
             for (var i = 0, ii = lines.length; i < ii; i++) {
-
                 matches = re.exec(lines[i]);
                 if (matches) {
 
@@ -50,11 +73,16 @@ module.exports = function(context) {
                         column: matches.index
                     };
 
-                    // Passing node is a bit dirty, because message data will contain
-                    // big text in `source`. But... who cares :) ?
-                    // One more kludge will not make worse the bloody wizardry of this plugin.
-                    context.report(node, location, "Trailing spaces not allowed.");
+                    if (i === ii - 1) {
+                        fixRange = [totalLength + location.column + 1, totalLength + lines[i].length + 1];
+                    } else {
+                        fixRange = [totalLength + location.column, totalLength + lines[i].length];
+                    }
+
+                    report(node, location, fixRange);
                 }
+
+                totalLength += lines[i].length;
             }
         }