eslint 1.4.1 → 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/bin/eslint.js

@@ -1,11 +1,40 @@
 #!/usr/bin/env node
+
+/**
+ * @fileoverview Main CLI that is run via the eslint command.
+ * @author Nicholas C. Zakas
+ * @copyright 2013 Nicholas C. Zakas. All rights reserved.
+ * See LICENSE file in root directory for full license.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+var exitCode = 0,
+    useStdIn = (process.argv.indexOf("--stdin") > -1),
+    init = (process.argv.indexOf("--init") > -1),
+    debug = (process.argv.indexOf("--debug") > -1);
+
+// must do this initialization *before* other requires in order to work
+if (debug) {
+    require("debug").enable("eslint:*");
+}
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+// now we can safely include the other modules that use debug
 var concat = require("concat-stream"),
     configInit = require("../lib/config-initializer"),
     cli = require("../lib/cli");
 
-var exitCode = 0,
-    useStdIn = (process.argv.indexOf("--stdin") > -1),
-    init = (process.argv.indexOf("--init") > -1);
+//------------------------------------------------------------------------------
+// Execution
+//------------------------------------------------------------------------------
 
 if (useStdIn) {
     process.stdin.pipe(concat({ encoding: "string" }, function(text) {

package/lib/ast-utils.js

@@ -37,17 +37,6 @@ function isModifyingReference(reference, index, references) {
 
 module.exports = {
 
-    /**
-     * Determines whether two adjacent tokens are 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.
-     * @public
-     */
-    isTokenSpaced: function(left, right) {
-        return left.range[1] < right.range[0];
-    },
-
     /**
      * Determines whether two adjacent tokens are on the same line.
      * @param {Object} left - The left token object.
@@ -104,5 +93,22 @@ module.exports = {
      */
     isSurroundedBy: function(val, character) {
         return val[0] === character && val[val.length - 1] === character;
+    },
+
+    /**
+     * Returns whether the provided node is an ESLint directive comment or not
+     * @param {LineComment|BlockComment} node The node to be checked
+     * @returns {boolean} `true` if the node is an ESLint directive comment
+     */
+    isDirectiveComment: function(node) {
+        var comment = node.value.trim();
+        return (
+            node.type === "Line" && comment.indexOf("eslint-") === 0 ||
+            node.type === "Block" && (
+                comment.indexOf("global ") === 0 ||
+                comment.indexOf("eslint ") === 0 ||
+                comment.indexOf("eslint-") === 0
+            )
+        );
     }
 };

package/lib/cli-engine.js

@@ -32,7 +32,10 @@ var fs = require("fs"),
     util = require("./util"),
     fileEntryCache = require("file-entry-cache"),
     SourceCodeFixer = require("./util/source-code-fixer"),
-    validator = require("./config-validator");
+    validator = require("./config-validator"),
+
+    crypto = require( "crypto" ),
+    pkg = require("../package.json");
 
 var DEFAULT_PARSER = require("../conf/eslint.json").parser;
 
@@ -321,12 +324,13 @@ function processPath(extensions) {
      *
      * @param {string} pathname The directory path to be modified
      * @returns {string} The glob path or the file path itself
+     * @private
      */
     return function(pathname) {
         var newPath = pathname;
 
         if (shell.test("-d", pathname)) {
-            newPath = pathname + suffix;
+            newPath = pathname.replace(/[\/\\]$/, "") + suffix;
         }
 
         return newPath.replace(/\\/g, "/").replace(/^\.\//, "");
@@ -466,6 +470,20 @@ CLIEngine.prototype = {
         loadedPlugins[pluginNameWithoutPrefix] = pluginobject;
     },
 
+    /**
+     * Resolves the patterns passed into executeOnFiles() into glob-based patterns
+     * for easier handling.
+     * @param {string[]} patterns The file patterns passed on the command line.
+     * @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));
+    },
+
     /**
      * Executes the current configuration on an array of file and directory names.
      * @param {string[]} patterns An array of file and directory names.
@@ -479,23 +497,57 @@ CLIEngine.prototype = {
             configHelper = new Config(options),
             ignoredPaths = IgnoredPaths.load(options),
             ignoredPathsList = ignoredPaths.patterns || [],
-            extensions = options.extensions.map(function(ext) {
-                return ext.charAt(0) === "." ? ext.substr(1) : ext;
-            }),
             globOptions,
             stats,
-            startTime;
+            startTime,
+            prevConfig; // the previous configuration used
 
         startTime = Date.now();
-
-        patterns = patterns.map(processPath(extensions));
-        ignoredPathsList = ignoredPathsList.map(processPath());
+        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");
+        }
+
+        /**
+         * 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
+         * @returns {string}         the hash of the config
+         */
+        function hashOfConfigFor(filename) {
+            var config = configHelper.getConfig(filename);
+
+            if (!prevConfig) {
+                prevConfig = {};
+            }
+
+            // reuse the previously hashed config if the config hasn't changed
+            if (prevConfig.config !== config) {
+                // config changed so we need to calculate the hash of the config
+                // and the hash of the plugins being used
+                prevConfig.config = config;
+
+                var eslintVersion = pkg.version;
+
+                prevConfig.hash = md5Hash(eslintVersion + "_" + JSON.stringify(config));
+            }
+
+            return prevConfig.hash;
+        }
+
         /**
          * Executes the linter on a file defined by the `filename`. Skips
          * unsupported file extensions and any files that are already linted.
@@ -503,18 +555,26 @@ CLIEngine.prototype = {
          * @returns {void}
          */
         function executeOnFile(filename) {
+            var shouldIgnore = ignoredPaths.contains(filename);
             filename = fs.realpathSync(filename);
 
-            if (processed[filename]) {
+            if (processed[filename] || shouldIgnore) {
                 return;
             }
 
+            var hashOfConfig;
+
             if (options.cache) {
                 // get the descriptor for this file
                 // with the metadata and the flag that determines if
                 // the file has changed
                 var descriptor = fileCache.getFileDescriptor(filename);
-                if (!descriptor.changed) {
+                var meta = descriptor.meta || {};
+
+                hashOfConfig = hashOfConfigFor(filename);
+
+                var changed = descriptor.changed || meta.hashOfConfig !== hashOfConfig;
+                if (!changed) {
                     debug("Skipping file since hasn't changed: " + filename);
 
                     // Adding the filename to the processed hashmap
@@ -551,6 +611,7 @@ CLIEngine.prototype = {
                     // since the file passed we store the result here
                     // TODO: check this as we might not need to store the
                     // successful runs as it will always should be 0 error 0 warnings
+                    descriptor.meta.hashOfConfig = hashOfConfig;
                     descriptor.meta.results = res;
                 }
             }

package/lib/config.js

@@ -69,6 +69,44 @@ function isObject(item) {
     return typeof item === "object" && !Array.isArray(item) && item !== null;
 }
 
+/**
+ * Creates an environment config based on the specified environments.
+ * @param {Object<string,boolean>} envs The environment settings.
+ * @returns {Object} A configuration object with the appropriate rules and globals
+ *      set.
+ * @private
+ */
+function createEnvironmentConfig(envs) {
+
+    var envConfig = {
+        globals: {},
+        env: envs || {},
+        rules: {},
+        ecmaFeatures: {}
+    };
+
+    if (envs) {
+        Object.keys(envs).filter(function(name) {
+            return envs[name];
+        }).forEach(function(name) {
+            var environment = environments[name];
+
+            if (environment) {
+
+                if (environment.globals) {
+                    assign(envConfig.globals, environment.globals);
+                }
+
+                if (environment.ecmaFeatures) {
+                    assign(envConfig.ecmaFeatures, environment.ecmaFeatures);
+                }
+            }
+        });
+    }
+
+    return envConfig;
+}
+
 /**
  * Read the config from the config JSON file
  * @param {string} filePath the path to the JSON config file
@@ -175,6 +213,10 @@ function loadConfig(configToLoad) {
 
         }
 
+        if (config.env) {
+            // Merge in environment-specific globals and ecmaFeatures.
+            config = util.mergeConfigs(createEnvironmentConfig(config.env), config);
+        }
 
     }
 
@@ -253,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;
         }
 
@@ -291,44 +335,6 @@ function getLocalConfig(thisConfig, directory) {
     return found ? config : util.mergeConfigs(config, getPersonalConfig());
 }
 
-/**
- * Creates an environment config based on the specified environments.
- * @param {Object<string,boolean>} envs The environment settings.
- * @returns {Object} A configuration object with the appropriate rules and globals
- *      set.
- * @private
- */
-function createEnvironmentConfig(envs) {
-
-    var envConfig = {
-        globals: {},
-        env: envs || {},
-        rules: {},
-        ecmaFeatures: {}
-    };
-
-    if (envs) {
-        Object.keys(envs).filter(function(name) {
-            return envs[name];
-        }).forEach(function(name) {
-            var environment = environments[name];
-
-            if (environment) {
-
-                if (environment.globals) {
-                    assign(envConfig.globals, environment.globals);
-                }
-
-                if (environment.ecmaFeatures) {
-                    assign(envConfig.ecmaFeatures, environment.ecmaFeatures);
-                }
-            }
-        });
-    }
-
-    return envConfig;
-}
-
 //------------------------------------------------------------------------------
 // API
 //------------------------------------------------------------------------------
@@ -412,44 +418,37 @@ Config.prototype.getConfig = function(filePath) {
     // Step 2: Create a copy of the baseConfig
     config = util.mergeConfigs({parser: this.parser}, this.baseConfig);
 
-    // Step 3: Merge in environment-specific globals and rules from .eslintrc files
-    config = util.mergeConfigs(config, createEnvironmentConfig(userConfig.env));
-
-    // Step 4: Merge in the user-specified configuration from .eslintrc and package.json
+    // Step 3: Merge in the user-specified configuration from .eslintrc and package.json
     config = util.mergeConfigs(config, userConfig);
 
-    // Step 5: Merge in command line config file
+    // Step 4: Merge in command line config file
     if (this.useSpecificConfig) {
         debug("Merging command line config file");
 
-        if (this.useSpecificConfig.env) {
-            config = util.mergeConfigs(config, createEnvironmentConfig(this.useSpecificConfig.env));
-        }
-
         config = util.mergeConfigs(config, this.useSpecificConfig);
     }
 
-    // Step 6: Merge in command line environments
+    // Step 5: Merge in command line environments
     debug("Merging command line environment settings");
     config = util.mergeConfigs(config, createEnvironmentConfig(this.env));
 
-    // Step 7: Merge in command line rules
+    // Step 6: Merge in command line rules
     if (this.options.rules) {
         debug("Merging command line rules");
         config = util.mergeConfigs(config, { rules: this.options.rules });
     }
 
-    // Step 8: Merge in command line globals
+    // Step 7: Merge in command line globals
     config = util.mergeConfigs(config, { globals: this.globals });
 
-    // Step 9: Merge in command line plugins
+    // Step 8: Merge in command line plugins
     if (this.options.plugins) {
         debug("Merging command line plugins");
         pluginConfig = getPluginsConfig(this.options.plugins);
         config = util.mergeConfigs(config, { plugins: this.options.plugins });
     }
 
-    // Step 10: Merge in plugin specific rules in reverse
+    // Step 9: Merge in plugin specific rules in reverse
     if (config.plugins) {
         pluginConfig = getPluginsConfig(config.plugins);
         config = util.mergeConfigs(pluginConfig, config);

package/lib/eslint.js

@@ -20,6 +20,8 @@ var estraverse = require("estraverse-fb"),
     RuleContext = require("./rule-context"),
     timing = require("./timing"),
     SourceCode = require("./util/source-code"),
+    NodeEventGenerator = require("./util/node-event-generator"),
+    CommentEventGenerator = require("./util/comment-event-generator"),
     EventEmitter = require("events").EventEmitter,
     validator = require("./config-validator"),
     replacements = require("../conf/replacements.json");
@@ -498,8 +500,6 @@ module.exports = (function() {
         currentFilename = null,
         controller = null,
         reportingConfig = [],
-        commentLocsEnter = [],
-        commentLocsExit = [],
         sourceCode = null;
 
     /**
@@ -564,46 +564,6 @@ module.exports = (function() {
         }
     }
 
-    /**
-     * Check collection of comments to prevent double event for comment as
-     * leading and trailing, then emit event if passing
-     * @param {ASTNode[]} comments Collection of comment nodes
-     * @param {Object[]} locs List of locations of previous comment nodes
-     * @param {string} eventName Event name postfix
-     * @returns {void}
-     */
-    function emitComments(comments, locs, eventName) {
-
-        if (comments.length) {
-            comments.forEach(function(node) {
-                if (locs.indexOf(node.loc) >= 0) {
-                    locs.splice(locs.indexOf(node.loc), 1);
-                } else {
-                    locs.push(node.loc);
-                    api.emit(node.type + eventName, node);
-                }
-            });
-        }
-    }
-
-    /**
-     * Shortcut to check and emit enter of comment nodes
-     * @param {ASTNode[]} comments Collection of comment nodes
-     * @returns {void}
-     */
-    function emitCommentsEnter(comments) {
-        emitComments(comments, commentLocsEnter, "Comment");
-    }
-
-    /**
-     * Shortcut to check and emit exit of comment nodes
-     * @param {ASTNode[]} comments Collection of comment nodes
-     * @returns {void}
-     */
-    function emitCommentsExit(comments) {
-        emitComments(comments, commentLocsExit, "Comment:exit");
-    }
-
     /**
      * Get the severity level of a rule (0 - none, 1 - warning, 2 - error)
      * Returns 0 if the rule config is not valid (an Array or a number)
@@ -649,8 +609,6 @@ module.exports = (function() {
         scopeManager = null;
         controller = null;
         reportingConfig = [];
-        commentLocsEnter = [];
-        commentLocsExit = [];
         sourceCode = null;
     };
 
@@ -811,6 +769,9 @@ module.exports = (function() {
                 }
             }
 
+            var eventGenerator = new NodeEventGenerator(api);
+            eventGenerator = new CommentEventGenerator(eventGenerator, sourceCode);
+
             /*
              * Each node has a type property. Whenever a particular type of node is found,
              * an event is fired. This allows any listeners to automatically be informed
@@ -818,21 +779,11 @@ module.exports = (function() {
              */
             controller.traverse(ast, {
                 enter: function(node, parent) {
-
-                    var comments = api.getComments(node);
-
-                    emitCommentsEnter(comments.leading);
                     node.parent = parent;
-                    api.emit(node.type, node);
-                    emitCommentsEnter(comments.trailing);
+                    eventGenerator.enterNode(node);
                 },
                 leave: function(node) {
-
-                    var comments = api.getComments(node);
-
-                    emitCommentsExit(comments.trailing);
-                    api.emit(node.type + ":exit", node);
-                    emitCommentsExit(comments.leading);
+                    eventGenerator.leaveNode(node);
                 }
             });
 

package/lib/options.js

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Options configuration for optionator.
  * @author George Zahariev
+ * See LICENSE in root directory for full license.
  */
 "use strict";
 
@@ -175,6 +176,12 @@ module.exports = optionator({
             default: false,
             description: "Automatically fix problems"
         },
+        {
+            option: "debug",
+            type: "Boolean",
+            default: false,
+            description: "Output debugging information"
+        },
         {
             option: "help",
             alias: "h",

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

@@ -15,7 +15,8 @@ var astUtils = require("../ast-utils");
 //------------------------------------------------------------------------------
 
 module.exports = function(context) {
-    var spaced = context.options[0] === "always";
+    var spaced = context.options[0] === "always",
+        sourceCode = context.getSourceCode();
 
     /**
      * Determines whether an option is set, relative to the spacing option.
@@ -111,19 +112,19 @@ module.exports = function(context) {
                 ? !options.spaced : options.spaced;
 
         if (astUtils.isTokenOnSameLine(first, second)) {
-            if (openingBracketMustBeSpaced && !astUtils.isTokenSpaced(first, second)) {
+            if (openingBracketMustBeSpaced && !sourceCode.isSpaceBetweenTokens(first, second)) {
                 reportRequiredBeginningSpace(node, first);
             }
-            if (!openingBracketMustBeSpaced && astUtils.isTokenSpaced(first, second)) {
+            if (!openingBracketMustBeSpaced && sourceCode.isSpaceBetweenTokens(first, second)) {
                 reportNoBeginningSpace(node, first);
             }
         }
 
         if (astUtils.isTokenOnSameLine(penultimate, last)) {
-            if (closingBracketMustBeSpaced && !astUtils.isTokenSpaced(penultimate, last)) {
+            if (closingBracketMustBeSpaced && !sourceCode.isSpaceBetweenTokens(penultimate, last)) {
                 reportRequiredEndingSpace(node, last);
             }
-            if (!closingBracketMustBeSpaced && astUtils.isTokenSpaced(penultimate, last)) {
+            if (!closingBracketMustBeSpaced && sourceCode.isSpaceBetweenTokens(penultimate, last)) {
                 reportNoEndingSpace(node, last);
             }
         }

package/lib/rules/block-spacing.js

@@ -13,8 +13,9 @@ var util = require("../ast-utils");
 //------------------------------------------------------------------------------
 
 module.exports = function(context) {
-    var always = (context.options[0] !== "never");
-    var message = always ? "Requires a space" : "Unexpected space(s)";
+    var always = (context.options[0] !== "never"),
+        message = always ? "Requires a space" : "Unexpected space(s)",
+        sourceCode = context.getSourceCode();
 
     /**
      * Gets the open brace token from a given node.
@@ -45,7 +46,7 @@ module.exports = function(context) {
     function isValid(left, right) {
         return (
             !util.isTokenOnSameLine(left, right) ||
-            util.isTokenSpaced(left, right) === always
+            sourceCode.isSpaceBetweenTokens(left, right) === always
         );
     }
 

package/lib/rules/comma-dangle.js

@@ -74,9 +74,19 @@ module.exports = function(context) {
      * @returns {boolean} `true` if the node is multiline.
      */
     function isMultiline(node) {
+        var lastItem = getLast(node.properties || node.elements || node.specifiers);
+        if (!lastItem) {
+            return false;
+        }
+
         var sourceCode = context.getSourceCode();
-        var lastToken = sourceCode.getLastToken(node);
-        var penultimateToken = sourceCode.getLastToken(node, 1);
+        var penultimateToken = sourceCode.getLastToken(lastItem);
+        var lastToken = sourceCode.getTokenAfter(penultimateToken);
+
+        if (lastToken.value === ",") {
+            penultimateToken = lastToken;
+            lastToken = sourceCode.getTokenAfter(lastToken);
+        }
 
         return lastToken.loc.end.line !== penultimateToken.loc.end.line;
     }
@@ -85,12 +95,13 @@ module.exports = function(context) {
      * Reports a trailing comma if it exists.
      *
      * @param {ASTNode} node - A node to check. Its type is one of
-     *   ObjectExpression, ObjectPattern, ArrayExpression, and ArrayPattern.
+     *   ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern,
+     *   ImportDeclaration, and ExportNamedDeclaration.
      * @returns {void}
      */
     function forbidTrailingComma(node) {
-        var lastItem = getLast(node.properties || node.elements);
-        if (!lastItem) {
+        var lastItem = getLast(node.properties || node.elements || node.specifiers);
+        if (!lastItem || (node.type === "ImportDeclaration" && lastItem.type !== "ImportSpecifier")) {
             return;
         }
 
@@ -112,12 +123,13 @@ module.exports = function(context) {
      * comma is disallowed, so report if it exists.
      *
      * @param {ASTNode} node - A node to check. Its type is one of
-     *   ObjectExpression, ObjectPattern, ArrayExpression, and ArrayPattern.
+     *   ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern,
+     *   ImportDeclaration, and ExportNamedDeclaration.
      * @returns {void}
      */
     function forceTrailingComma(node) {
-        var lastItem = getLast(node.properties || node.elements);
-        if (!lastItem) {
+        var lastItem = getLast(node.properties || node.elements || node.specifiers);
+        if (!lastItem || (node.type === "ImportDeclaration" && lastItem.type !== "ImportSpecifier")) {
             return;
         }
         if (!isTrailingCommaAllowed(node, lastItem)) {
@@ -141,7 +153,8 @@ module.exports = function(context) {
      * Otherwise, reports a trailing comma if it exists.
      *
      * @param {ASTNode} node - A node to check. Its type is one of
-     *   ObjectExpression, ObjectPattern, ArrayExpression, and ArrayPattern.
+     *   ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern,
+     *   ImportDeclaration, and ExportNamedDeclaration.
      * @returns {void}
      */
     function forceTrailingCommaIfMultiline(node) {
@@ -166,7 +179,9 @@ module.exports = function(context) {
         "ObjectExpression": checkForTrailingComma,
         "ObjectPattern": checkForTrailingComma,
         "ArrayExpression": checkForTrailingComma,
-        "ArrayPattern": checkForTrailingComma
+        "ArrayPattern": checkForTrailingComma,
+        "ImportDeclaration": checkForTrailingComma,
+        "ExportNamedDeclaration": checkForTrailingComma
     };
 };