eslint 1.7.3 → 1.8.0

package/README.md

@@ -69,6 +69,7 @@ These folks keep the project moving and are resources for help:
 * Ian VanSchooten ([@ianvs](https://github.com/ianvs)) - committer
 * Toru Nagashima ([@mysticatea](https://github.com/mysticatea)) - committer
 * Burak Yiğit Kaya ([@byk](https://github.com/byk)) - committer
+* Alberto Rodríguez ([@alberto](https://github.com/alberto)) - committer
 
 ## Releases
 

package/conf/eslint.json

@@ -4,6 +4,7 @@
     "rules": {
         "no-alert": 0,
         "no-array-constructor": 0,
+        "no-arrow-condition": 0,
         "no-bitwise": 0,
         "no-caller": 0,
         "no-catch-shadow": 0,
@@ -110,6 +111,7 @@
         "no-magic-numbers": 0,
 
         "array-bracket-spacing": [0, "never"],
+        "arrow-body-style": [0, "as-needed"],
         "arrow-parens": 0,
         "arrow-spacing": 0,
         "accessor-pairs": 0,

package/lib/cli-engine.js

@@ -90,6 +90,10 @@ var defaultOptions = {
         ignorePath: null,
         parser: DEFAULT_PARSER,
         cache: false,
+        // in order to honor the cacheFile option if specified
+        // this option should not have a default value otherwise
+        // it will always be used
+        cacheLocation: "",
         cacheFile: ".eslintcache",
         fix: false
     },
@@ -338,6 +342,78 @@ function processPath(extensions) {
     };
 }
 
+/**
+ * create a md5Hash of a given string
+ * @param  {string} str the string to calculate the hash for
+ * @returns {string}    the calculated hash
+ */
+function md5Hash(str) {
+    return crypto
+        .createHash("md5")
+        .update(str, "utf8")
+        .digest("hex");
+}
+
+/**
+ * return the cacheFile to be used by eslint, based on whether the provided parameter is
+ * a directory or looks like a directory (ends in `path.sep`), in which case the file
+ * name will be the `cacheFile/.cache_hashOfCWD`
+ *
+ * if cacheFile points to a file or looks like a file then in will just use that file
+ *
+ * @param {string} cacheFile The name of file to be used to store the cache
+ * @returns {string} the resolved path to the cache file
+ */
+function getCacheFile(cacheFile) {
+    // make sure the path separators are normalized for the environment/os
+    // keeping the trailing path separator if present
+    cacheFile = path.normalize(cacheFile);
+
+    var resolvedCacheFile = path.resolve(cacheFile);
+    var looksLikeADirectory = cacheFile[cacheFile.length - 1 ] === path.sep;
+
+    /**
+     * return the name for the cache file in case the provided parameter is a directory
+     * @returns {string} the resolved path to the cacheFile
+     */
+    function getCacheFileForDirectory() {
+        return path.join(resolvedCacheFile, ".cache_" + md5Hash(process.cwd()));
+    }
+
+    var fileStats;
+
+    try {
+        fileStats = fs.lstatSync(resolvedCacheFile);
+    } catch (ex) {
+        fileStats = null;
+    }
+
+
+    // in case the file exists we need to verify if the provided path
+    // is a directory or a file. If it is a directory we want to create a file
+    // inside that directory
+    if (fileStats) {
+        // is a directory or is a file, but the original file the user provided
+        // looks like a directory but `path.resolve` removed the `last path.sep`
+        // so we need to still treat this like a directory
+        if (fileStats.isDirectory() || looksLikeADirectory) {
+            return getCacheFileForDirectory();
+        }
+        // is file so just use that file
+        return resolvedCacheFile;
+    }
+
+    // here we known the file or directory doesn't exist,
+    // so we will try to infer if its a directory if it looks like a directory
+    // for the current operating system.
+
+    // if the last character passed is a path separator we assume is a directory
+    if (looksLikeADirectory) {
+        return getCacheFileForDirectory();
+    }
+
+    return resolvedCacheFile;
+}
 
 //------------------------------------------------------------------------------
 // Public Interface
@@ -356,12 +432,15 @@ function CLIEngine(options) {
      */
     this.options = assign(Object.create(defaultOptions), options || {});
 
+
+    var cacheFile = getCacheFile(this.options.cacheLocation || this.options.cacheFile);
+
     /**
      * cache used to not operate on files that haven't changed since last successful
      * execution (e.g. file passed with no errors and no warnings
      * @type {Object}
      */
-    this._fileCache = fileEntryCache.create(path.resolve(this.options.cacheFile)); // eslint-disable-line no-underscore-dangle
+    this._fileCache = fileEntryCache.create(cacheFile); // eslint-disable-line no-underscore-dangle
 
     if (!this.options.cache) {
         this._fileCache.destroy(); // eslint-disable-line no-underscore-dangle
@@ -511,18 +590,6 @@ CLIEngine.prototype = {
             ignore: ignoredPathsList
         };
 
-        /**
-         * create a md5Hash of a given string
-         * @param  {string} str the string to calculate the hash for
-         * @returns {string}    the calculated hash
-         */
-        function md5Hash(str) {
-            return crypto
-                .createHash("md5")
-                .update(str)
-                .digest("hex");
-        }
-
         /**
          * Calculates the hash of the config file used to validate a given file
          * @param  {string} filename The path of the file to retrieve a config object for to calculate the hash

package/lib/cli.js

@@ -22,7 +22,8 @@ var fs = require("fs"),
 
     options = require("./options"),
     CLIEngine = require("./cli-engine"),
-    mkdirp = require("mkdirp");
+    mkdirp = require("mkdirp"),
+    log = require("./logging");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -52,6 +53,7 @@ function translateOptions(cliOptions) {
         parser: cliOptions.parser,
         cache: cliOptions.cache,
         cacheFile: cliOptions.cacheFile,
+        cacheLocation: cliOptions.cacheLocation,
         fix: cliOptions.fix
     };
 }
@@ -72,7 +74,7 @@ function printResults(engine, results, format, outputFile) {
 
     formatter = engine.getFormatter(format);
     if (!formatter) {
-        console.error("Could not find formatter '%s'.", format);
+        log.error("Could not find formatter '%s'.", format);
         return false;
     }
 
@@ -83,7 +85,7 @@ function printResults(engine, results, format, outputFile) {
             filePath = path.resolve(process.cwd(), outputFile);
 
             if (fs.existsSync(filePath) && fs.statSync(filePath).isDirectory()) {
-                console.error("Cannot write to output file path, it is a directory: %s", outputFile);
+                log.error("Cannot write to output file path, it is a directory: %s", outputFile);
                 return false;
             }
 
@@ -91,11 +93,11 @@ function printResults(engine, results, format, outputFile) {
                 mkdirp.sync(path.dirname(filePath));
                 fs.writeFileSync(filePath, output);
             } catch (ex) {
-                console.error("There was a problem writing the output file:\n%s", ex);
+                log.error("There was a problem writing the output file:\n%s", ex);
                 return false;
             }
         } else {
-            console.log(output);
+            log.info(output);
         }
     }
 
@@ -130,7 +132,7 @@ var cli = {
         try {
             currentOptions = options.parse(args);
         } catch (error) {
-            console.error(error.message);
+            log.error(error.message);
             return 1;
         }
 
@@ -138,11 +140,11 @@ var cli = {
 
         if (currentOptions.version) { // version from package.json
 
-            console.log("v" + require("../package.json").version);
+            log.info("v" + require("../package.json").version);
 
         } else if (currentOptions.help || (!files.length && !text)) {
 
-            console.log(options.generateHelp());
+            log.info(options.generateHelp());
 
         } else {
 
@@ -150,7 +152,7 @@ var cli = {
 
             // disable --fix for piped-in code until we know how to do it correctly
             if (text && currentOptions.fix) {
-                console.error("The --fix option is not available for piped-in code.");
+                log.error("The --fix option is not available for piped-in code.");
                 return 1;
             }
 
@@ -171,7 +173,7 @@ var cli = {
                 tooManyWarnings = currentOptions.maxWarnings >= 0 && report.warningCount > currentOptions.maxWarnings;
 
                 if (!report.errorCount && tooManyWarnings) {
-                    console.error("ESLint found too many warnings (maximum: %s).", currentOptions.maxWarnings);
+                    log.error("ESLint found too many warnings (maximum: %s).", currentOptions.maxWarnings);
                 }
 
                 return (report.errorCount || tooManyWarnings) ? 1 : 0;

package/lib/eslint.js

@@ -637,6 +637,20 @@ module.exports = (function() {
             this.reset();
         }
 
+        // search and apply "eslint-env *".
+        var envInFile = findEslintEnv(text || textOrSourceCode.text);
+        if (envInFile) {
+            if (!config || !config.env) {
+                config = assign({}, config || {}, {env: envInFile});
+            } else {
+                config = assign({}, config);
+                config.env = assign({}, config.env, envInFile);
+            }
+        }
+
+        // process initial config to make it safe to extend
+        config = prepareConfig(config || {});
+
         // only do this for text
         if (text !== null) {
 
@@ -646,20 +660,6 @@ module.exports = (function() {
                 return messages;
             }
 
-            // search and apply "eslint-env *".
-            var envInFile = findEslintEnv(text);
-            if (envInFile) {
-                if (!config || !config.env) {
-                    config = assign({}, config || {}, {env: envInFile});
-                } else {
-                    config = assign({}, config);
-                    config.env = assign({}, config.env, envInFile);
-                }
-            }
-
-            // process initial config to make it safe to extend
-            config = prepareConfig(config || {});
-
             ast = parse(text.replace(/^#!([^\r\n]+)/, function(match, captured) {
                 shebang = captured;
                 return "//" + captured;

package/lib/logging.js

@@ -0,0 +1,25 @@
+/**
+ * @fileoverview Handle logging for Eslint
+ * @author Gyandeep Singh
+ * @copyright 2015 Gyandeep Singh. All rights reserved.
+ */
+"use strict";
+
+/* istanbul ignore next */
+module.exports = {
+    /**
+     * Cover for console.log
+     * @returns {void}
+     */
+    info: function() {
+        console.log.apply(console, Array.prototype.slice.call(arguments));
+    },
+
+    /**
+     * Cover for console.error
+     * @returns {void}
+     */
+    error: function() {
+        console.error.apply(console, Array.prototype.slice.call(arguments));
+    }
+};

package/lib/options.js

@@ -69,9 +69,14 @@ module.exports = optionator({
         },
         {
             option: "cache-file",
-            type: "String",
+            type: "path::String",
             default: ".eslintcache",
-            description: "Path to the cache file"
+            description: "Path to the cache file. Deprecated: use --cache-location"
+        },
+        {
+            option: "cache-location",
+            type: "path::String",
+            description: "Path to the cache file or directory"
         },
         {
             heading: "Specifying rules and plugins"

package/lib/rules/array-bracket-spacing.js

@@ -116,7 +116,7 @@ module.exports = function(context) {
     * @returns {boolean} Whether or not the node is an object type.
     */
     function isObjectType(node) {
-        return node.type === "ObjectExpression" || node.type === "ObjectPattern";
+        return node && (node.type === "ObjectExpression" || node.type === "ObjectPattern");
     }
 
     /**
@@ -125,7 +125,7 @@ module.exports = function(context) {
     * @returns {boolean} Whether or not the node is an array type.
     */
     function isArrayType(node) {
-        return node.type === "ArrayExpression" || node.type === "ArrayPattern";
+        return node && (node.type === "ArrayExpression" || node.type === "ArrayPattern");
     }
 
     /**

package/lib/rules/arrow-body-style.js

@@ -0,0 +1,71 @@
+/**
+ * @fileoverview Rule to require braces in arrow function body.
+ * @author Alberto Rodríguez
+ * @copyright 2015 Alberto Rodríguez. All rights reserved.
+ * See LICENSE file in root directory for full license.
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+    var always = context.options[0] === "always";
+    var asNeeded = !context.options[0] || context.options[0] === "as-needed";
+
+    /**
+     * Determines whether a arrow function body needs braces
+     * @param {ASTNode} node The arrow function node.
+     * @returns {void}
+     */
+    function validate(node) {
+        var arrowBody = node.body;
+        if (arrowBody.type === "BlockStatement") {
+            var blockBody = arrowBody.body;
+
+            if (blockBody.length > 1) {
+                return;
+            }
+
+            if (blockBody.length === 0) {
+                var hasComments = context.getComments(arrowBody).trailing.length > 0;
+                if (hasComments) {
+                    return;
+                }
+
+                context.report({
+                    node: node,
+                    loc: arrowBody.loc.start,
+                    message: "Unexpected empty block in arrow body."
+                });
+            } else {
+                if (asNeeded && blockBody[0].type === "ReturnStatement") {
+                    context.report({
+                        node: node,
+                        loc: arrowBody.loc.start,
+                        message: "Unexpected block statement surrounding arrow body."
+                    });
+                }
+            }
+        } else {
+            if (always) {
+                context.report({
+                    node: node,
+                    loc: arrowBody.loc.start,
+                    message: "Expected block statement surrounding arrow body."
+                });
+            }
+        }
+    }
+
+    return {
+        "ArrowFunctionExpression": validate
+    };
+};
+
+module.exports.schema = [
+    {
+        "enum": ["always", "as-needed"]
+    }
+];

package/lib/rules/comma-spacing.js

@@ -41,42 +41,6 @@ module.exports = function(context) {
         return !!token && (token.type === "Punctuator") && (token.value === ",");
     }
 
-    /**
-     * Reports a spacing error with an appropriate message.
-     * @param {ASTNode} node The binary expression node to report.
-     * @param {string} dir Is the error "before" or "after" the comma?
-     * @returns {void}
-     * @private
-     */
-    function report(node, dir) {
-        context.report(node, options[dir] ?
-            "A space is required " + dir + " ','." :
-            "There should be no space " + dir + " ','.");
-    }
-
-    /**
-     * Validates the spacing around a comma token.
-     * @param {Object} tokens - The tokens to be validated.
-     * @param {Token} tokens.comma The token representing the comma.
-     * @param {Token} [tokens.left] The last token before the comma.
-     * @param {Token} [tokens.right] The first token after the comma.
-     * @param {Token|ASTNode} reportItem The item to use when reporting an error.
-     * @returns {void}
-     * @private
-     */
-    function validateCommaItemSpacing(tokens, reportItem) {
-        if (tokens.left && astUtils.isTokenOnSameLine(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 !== sourceCode.isSpaceBetweenTokens(tokens.comma, tokens.right))
-        ) {
-            report(reportItem, "after");
-        }
-    }
-
     /**
      * Determines if a given source index is in a comment or not by checking
      * the index against the comment range. Since the check goes straight
@@ -90,6 +54,7 @@ module.exports = function(context) {
     function isIndexInComment(index, comments) {
 
         var comment;
+        lastCommentIndex = 0;
 
         while (lastCommentIndex < comments.length) {
 
@@ -108,6 +73,77 @@ module.exports = function(context) {
         return false;
     }
 
+
+    /**
+     * Reports a spacing error with an appropriate message.
+     * @param {ASTNode} node The binary expression node to report.
+     * @param {string} dir Is the error "before" or "after" the comma?
+     * @param {ASTNode} otherNode The node at the left or right of `node`
+     * @returns {void}
+     * @private
+     */
+    function report(node, dir, otherNode) {
+        context.report({
+            node: node,
+            fix: function(fixer) {
+                if (options[dir]) {
+                    if (dir === "before") {
+                        return fixer.insertTextBefore(node, " ");
+                    } else {
+                        return fixer.insertTextAfter(node, " ");
+                    }
+                } else {
+                    /*
+                     * Comments handling
+                     */
+                    var start, end;
+                    var newText = "";
+
+                    if (dir === "before") {
+                        start = otherNode.range[1];
+                        end = node.range[0];
+                    } else {
+                        start = node.range[1];
+                        end = otherNode.range[0];
+                    }
+
+                    for (var i = start; i < end; i++) {
+                        if (isIndexInComment(i, allComments)) {
+                            newText += context.getSource()[i];
+                        }
+                    }
+                    return fixer.replaceTextRange([start, end], newText);
+                }
+            },
+            message: options[dir] ?
+              "A space is required " + dir + " ','." :
+              "There should be no space " + dir + " ','."
+        });
+    }
+
+    /**
+     * Validates the spacing around a comma token.
+     * @param {Object} tokens - The tokens to be validated.
+     * @param {Token} tokens.comma The token representing the comma.
+     * @param {Token} [tokens.left] The last token before the comma.
+     * @param {Token} [tokens.right] The first token after the comma.
+     * @param {Token|ASTNode} reportItem The item to use when reporting an error.
+     * @returns {void}
+     * @private
+     */
+    function validateCommaItemSpacing(tokens, reportItem) {
+        if (tokens.left && astUtils.isTokenOnSameLine(tokens.left, tokens.comma) &&
+                (options.before !== sourceCode.isSpaceBetweenTokens(tokens.left, tokens.comma))
+        ) {
+            report(reportItem, "before", tokens.left);
+        }
+        if (tokens.right && astUtils.isTokenOnSameLine(tokens.comma, tokens.right) &&
+                (options.after !== sourceCode.isSpaceBetweenTokens(tokens.comma, tokens.right))
+        ) {
+            report(reportItem, "after", tokens.right);
+        }
+    }
+
     /**
      * Adds null elements of the given ArrayExpression or ArrayPattern node to the ignore list.
      * @param {ASTNode} node An ArrayExpression or ArrayPattern node.

package/lib/rules/eol-last.js

@@ -18,8 +18,10 @@ module.exports = function(context) {
 
         "Program": function checkBadEOF(node) {
             // Get the whole source code, not for node only.
-            var src = context.getSource(), location = {column: 1};
-
+            var src = context.getSource(),
+                location = {column: 1},
+                linebreakStyle = context.options[0] || "unix",
+                linebreak = linebreakStyle === "unix" ? "\n" : "\r\n";
             if (src.length === 0) {
                 return;
             }
@@ -32,7 +34,7 @@ module.exports = function(context) {
                     loc: location,
                     message: "Newline required at end of file but not found.",
                     fix: function(fixer) {
-                        return fixer.insertTextAfterRange([0, src.length], "\n");
+                        return fixer.insertTextAfterRange([0, src.length], linebreak);
                     }
                 });
             }
@@ -42,4 +44,8 @@ module.exports = function(context) {
 
 };
 
-module.exports.schema = [];
+module.exports.schema = [
+    {
+        "enum": ["unix", "windows"]
+    }
+];

package/lib/rules/no-arrow-condition.js

@@ -0,0 +1,88 @@
+/**
+ * @fileoverview A rule to warn against using arrow functions in conditions.
+ * @author Jxck <https://github.com/Jxck>
+ * @copyright 2015 Luke Karrys. All rights reserved.
+ * The MIT License (MIT)
+
+ * Copyright (c) 2015 Jxck
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Checks whether or not a node is an arrow function expression.
+ * @param {ASTNode} node - node to test
+ * @returns {boolean} `true` if the node is an arrow function expression.
+ */
+function isArrowFunction(node) {
+    return node.test && node.test.type === "ArrowFunctionExpression";
+}
+
+/**
+ * Checks whether or not a node is a conditional expression.
+ * @param {ASTNode} node - node to test
+ * @returns {boolean} `true` if the node is a conditional expression.
+ */
+function isConditional(node) {
+    return node.body && node.body.type === "ConditionalExpression";
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+    /**
+     * Reports if a conditional statement is an arrow function.
+     * @param {ASTNode} node - A node to check and report.
+     * @returns {void}
+     */
+    function checkCondition(node) {
+        if (isArrowFunction(node)) {
+            context.report(node, "Arrow function `=>` used inside {{statementType}} instead of comparison operator.", {statementType: node.type});
+        }
+    }
+
+    /**
+     * Reports if an arrow function contains an ambiguous conditional.
+     * @param {ASTNode} node - A node to check and report.
+     * @returns {void}
+     */
+    function checkArrowFunc(node) {
+        if (isConditional(node)) {
+            context.report(node, "Arrow function used ambiguously with a conditional expression.");
+        }
+    }
+
+    return {
+        "IfStatement": checkCondition,
+        "WhileStatement": checkCondition,
+        "ForStatement": checkCondition,
+        "ConditionalExpression": checkCondition,
+        "ArrowFunctionExpression": checkArrowFunc
+    };
+};
+
+module.exports.schema = [];