eslint 1.7.1 → 1.9.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,8 +4,10 @@
     "rules": {
         "no-alert": 0,
         "no-array-constructor": 0,
+        "no-arrow-condition": 0,
         "no-bitwise": 0,
         "no-caller": 0,
+        "no-case-declarations": 0,
         "no-catch-shadow": 0,
         "no-class-assign": 0,
         "no-cond-assign": 2,
@@ -110,6 +112,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

@@ -22,7 +22,6 @@ var fs = require("fs"),
 
     assign = require("object-assign"),
     debug = require("debug"),
-    glob = require("glob"),
     shell = require("shelljs"),
 
     rules = require("./rules"),
@@ -31,6 +30,7 @@ var fs = require("fs"),
     Config = require("./config"),
     util = require("./util"),
     fileEntryCache = require("file-entry-cache"),
+    globUtil = require("./util/glob-util"),
     SourceCodeFixer = require("./util/source-code-fixer"),
     validator = require("./config-validator"),
     stringify = require("json-stable-stringify"),
@@ -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
     },
@@ -293,51 +297,78 @@ function isErrorMessage(message) {
     return message.severity === 2;
 }
 
+/**
+ * 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");
+}
 
 /**
- * Checks if a provided path is a directory and returns a glob string matching
- * all files under that directory if so, the path itself otherwise.
+ * 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`
  *
- * Reason for this is that `glob` needs `/**` to collect all the files under a
- * directory where as our previous implementation without `glob` simply walked
- * a directory that is passed. So this is to maintain backwards compatibility.
+ * if cacheFile points to a file or looks like a file then in will just use that file
  *
- * Also makes sure all path separators are POSIX style for `glob` compatibility.
- *
- * @param {string[]} [extensions] An array of accepted extensions
- * @returns {Function} A function that takes a pathname and returns a glob that
- *                     matches all files with the provided extensions if
- *                     pathname is a directory.
+ * @param {string} cacheFile The name of file to be used to store the cache
+ * @returns {string} the resolved path to the cache file
  */
-function processPath(extensions) {
-    var suffix = "/**";
+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);
 
-    if (extensions) {
-        if (extensions.length === 1) {
-            suffix += "/*." + extensions[0];
-        } else {
-            suffix += "/*.{" + extensions.join(",") + "}";
-        }
-    }
+    var resolvedCacheFile = path.resolve(cacheFile);
+    var looksLikeADirectory = cacheFile[cacheFile.length - 1 ] === path.sep;
 
     /**
-     * A function that converts a directory name to a glob pattern
-     *
-     * @param {string} pathname The directory path to be modified
-     * @returns {string} The glob path or the file path itself
-     * @private
+     * return the name for the cache file in case the provided parameter is a directory
+     * @returns {string} the resolved path to the cacheFile
      */
-    return function(pathname) {
-        var newPath = pathname;
+    function getCacheFileForDirectory() {
+        return path.join(resolvedCacheFile, ".cache_" + md5Hash(process.cwd()));
+    }
 
-        if (shell.test("-d", pathname)) {
-            newPath = pathname.replace(/[\/\\]$/, "") + suffix;
+    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;
+    }
 
-        return newPath.replace(/\\/g, "/").replace(/^\.\//, "");
-    };
-}
+    // 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 +387,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
@@ -478,11 +512,7 @@ CLIEngine.prototype = {
      * @returns {string[]} The equivalent glob patterns.
      */
     resolveFileGlobPatterns: function(patterns) {
-        var extensions = this.options.extensions.map(function(ext) {
-            return ext.charAt(0) === "." ? ext.substr(1) : ext;
-        });
-
-        return patterns.map(processPath(extensions));
+        return globUtil.resolveFileGlobPatterns(patterns, this.options.extensions);
     },
 
     /**
@@ -496,32 +526,13 @@ CLIEngine.prototype = {
             options = this.options,
             fileCache = this._fileCache, // eslint-disable-line no-underscore-dangle
             configHelper = new Config(options),
-            ignoredPaths = IgnoredPaths.load(options),
-            ignoredPathsList = ignoredPaths.patterns || [],
-            globOptions,
             stats,
             startTime,
             prevConfig; // the previous configuration used
 
         startTime = Date.now();
-        patterns = this.resolveFileGlobPatterns(patterns);
 
-        globOptions = {
-            nodir: true,
-            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");
-        }
+        patterns = this.resolveFileGlobPatterns(patterns);
 
         /**
          * Calculates the hash of the config file used to validate a given file
@@ -552,22 +563,16 @@ CLIEngine.prototype = {
         /**
          * Executes the linter on a file defined by the `filename`. Skips
          * unsupported file extensions and any files that are already linted.
-         * @param {string} filename The file to be linted
+         * @param {string} filename The resolved filename of the file to be linted
          * @returns {void}
          */
         function executeOnFile(filename) {
-            var shouldIgnore = ignoredPaths.contains(filename);
-            if (shouldIgnore) {
-                return;
-            }
+            var hashOfConfig;
 
-            filename = fs.realpathSync(filename);
             if (processed[filename]) {
                 return;
             }
 
-            var hashOfConfig;
-
             if (options.cache) {
                 // get the descriptor for this file
                 // with the metadata and the flag that determines if
@@ -623,13 +628,8 @@ CLIEngine.prototype = {
             results.push(res);
         }
 
-        patterns.forEach(function(pattern) {
-            if (shell.test("-f", pattern) && !ignoredPaths.contains(pattern)) {
-                executeOnFile(pattern);
-            } else {
-                glob.sync(pattern, globOptions).forEach(executeOnFile);
-            }
-        });
+        // Lint each desired file
+        globUtil.listFilesToProcess(patterns, options).forEach(executeOnFile);
 
         // only warn for files explicitly passed on the command line
         if (options.ignore) {

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

@@ -10,7 +10,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-var estraverse = require("estraverse-fb"),
+var estraverse = require("./util/estraverse"),
     escope = require("escope"),
     environments = require("../conf/environments"),
     blankScriptAST = require("../conf/blank-script.json"),
@@ -32,17 +32,6 @@ var DEFAULT_PARSER = require("../conf/eslint.json").parser;
 // Helpers
 //------------------------------------------------------------------------------
 
-// additional changes to make estraverse happy
-estraverse.Syntax.ExperimentalSpreadProperty = "ExperimentalSpreadProperty";
-estraverse.Syntax.ExperimentalRestProperty = "ExperimentalRestProperty";
-
-estraverse.VisitorKeys.ExperimentalSpreadProperty = ["argument"];
-estraverse.VisitorKeys.ExperimentalRestProperty = ["argument"];
-
-// All nodes in ObjectExpression.properties and ObjectPattern.properties are visited as `Property`.
-// See Also: https://github.com/estools/estraverse/blob/master/estraverse.js#L687-L688
-estraverse.VisitorKeys.Property.push("argument");
-
 /**
  * Parses a list of "name:boolean_value" or/and "name" options divided by comma or
  * whitespace.
@@ -637,6 +626,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 +649,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-dangle.js

@@ -16,12 +16,12 @@
 /**
  * Gets the last element of a given array.
  *
- * @param {any[]} xs - An array to get.
- * @returns {any} The last element, or undefined.
+ * @param {*[]} xs - An array to get.
+ * @returns {*} The last element, or undefined.
  */
 function getLast(xs) {
     if (xs.length === 0) {
-        return void 0;
+        return null;
     }
     return xs[xs.length - 1];
 }
@@ -79,9 +79,9 @@ module.exports = function(context) {
             return false;
         }
 
-        var sourceCode = context.getSourceCode();
-        var penultimateToken = sourceCode.getLastToken(lastItem);
-        var lastToken = sourceCode.getTokenAfter(penultimateToken);
+        var sourceCode = context.getSourceCode(),
+            penultimateToken = sourceCode.getLastToken(lastItem),
+            lastToken = sourceCode.getLastToken(node);
 
         if (lastToken.value === ",") {
             penultimateToken = lastToken;
@@ -105,8 +105,16 @@ module.exports = function(context) {
             return;
         }
 
-        var sourceCode = context.getSourceCode();
-        var trailingToken = sourceCode.getTokenAfter(lastItem);
+        var sourceCode = context.getSourceCode(),
+            trailingToken;
+
+        // last item can be surrounded by parentheses for object and array literals
+        if (node.type === "ObjectExpression" || node.type === "ArrayExpression") {
+            trailingToken = sourceCode.getTokenBefore(sourceCode.getLastToken(node));
+        } else {
+            trailingToken = sourceCode.getTokenAfter(lastItem);
+        }
+
         if (trailingToken.value === ",") {
             context.report(
                 lastItem,
@@ -137,8 +145,16 @@ module.exports = function(context) {
             return;
         }
 
-        var sourceCode = context.getSourceCode();
-        var trailingToken = sourceCode.getTokenAfter(lastItem);
+        var sourceCode = context.getSourceCode(),
+            trailingToken;
+
+        // last item can be surrounded by parentheses for object and array literals
+        if (node.type === "ObjectExpression" || node.type === "ArrayExpression") {
+            trailingToken = sourceCode.getTokenBefore(sourceCode.getLastToken(node));
+        } else {
+            trailingToken = sourceCode.getTokenAfter(lastItem);
+        }
+
         if (trailingToken.value !== ",") {
             context.report(
                 lastItem,