eslint 1.8.0 → 1.9.0

package/conf/eslint.json

@@ -7,6 +7,7 @@
         "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,

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"),
@@ -297,51 +297,6 @@ function isErrorMessage(message) {
     return message.severity === 2;
 }
 
-
-/**
- * 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.
- *
- * 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.
- *
- * 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.
- */
-function processPath(extensions) {
-    var suffix = "/**";
-
-    if (extensions) {
-        if (extensions.length === 1) {
-            suffix += "/*." + extensions[0];
-        } else {
-            suffix += "/*.{" + extensions.join(",") + "}";
-        }
-    }
-
-    /**
-     * 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 function(pathname) {
-        var newPath = pathname;
-
-        if (shell.test("-d", pathname)) {
-            newPath = pathname.replace(/[\/\\]$/, "") + suffix;
-        }
-
-        return newPath.replace(/\\/g, "/").replace(/^\.\//, "");
-    };
-}
-
 /**
  * create a md5Hash of a given string
  * @param  {string} str the string to calculate the hash for
@@ -557,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);
     },
 
     /**
@@ -575,20 +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
-        };
+        patterns = this.resolveFileGlobPatterns(patterns);
 
         /**
          * Calculates the hash of the config file used to validate a given file
@@ -619,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
@@ -690,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/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.

package/lib/rules/linebreak-style.js

@@ -13,25 +13,60 @@
 //------------------------------------------------------------------------------
 
 module.exports = function(context) {
+
     var EXPECTED_LF_MSG = "Expected linebreaks to be 'LF' but found 'CRLF'.",
         EXPECTED_CRLF_MSG = "Expected linebreaks to be 'CRLF' but found 'LF'.";
 
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    /**
+     * Builds a fix function that replaces text at the specified range in the source text.
+     * @param {int[]} range The range to replace
+     * @param {string} text The text to insert.
+     * @returns {function} Fixer function
+     * @private
+     */
+    function createFix(range, text) {
+        return function(fixer) {
+            return fixer.replaceTextRange(range, text);
+        };
+    }
+
+    //--------------------------------------------------------------------------
+    // Public
+    //--------------------------------------------------------------------------
+
     return {
         "Program": function checkForlinebreakStyle(node) {
             var linebreakStyle = context.options[0] || "unix",
                 expectedLF = linebreakStyle === "unix",
-                linebreaks = context.getSource().match(/\r\n|\r|\n|\u2028|\u2029/g),
-                lineOfError = -1;
+                expectedLFChars = expectedLF ? "\n" : "\r\n",
+                source = context.getSource(),
+                pattern = /\r\n|\r|\n|\u2028|\u2029/g,
+                match,
+                index,
+                range;
 
-            if (linebreaks !== null) {
-                lineOfError = linebreaks.indexOf(expectedLF ? "\r\n" : "\n");
-            }
+            var i = 0;
+            while ((match = pattern.exec(source)) !== null) {
+                i++;
+                if (match[0] === expectedLFChars) {
+                    continue;
+                }
 
-            if (lineOfError !== -1) {
-                context.report(node, {
-                    line: lineOfError + 1,
-                    column: context.getSourceLines()[lineOfError].length
-                }, expectedLF ? EXPECTED_LF_MSG : EXPECTED_CRLF_MSG);
+                index = match.index;
+                range = [index, index + match[0].length];
+                context.report({
+                    node: node,
+                    loc: {
+                        line: i,
+                        column: context.getSourceLines()[i - 1].length
+                    },
+                    message: expectedLF ? EXPECTED_LF_MSG : EXPECTED_CRLF_MSG,
+                    fix: createFix(range, expectedLFChars)
+                });
             }
         }
     };

package/lib/rules/max-nested-callbacks.js

@@ -16,7 +16,7 @@ module.exports = function(context) {
     // Constants
     //--------------------------------------------------------------------------
 
-    var THRESHOLD = context.options[0];
+    var THRESHOLD = context.options[0] || 10;
 
     //--------------------------------------------------------------------------
     // Helpers

package/lib/rules/no-case-declarations.js

@@ -0,0 +1,47 @@
+/**
+ * @fileoverview Rule to flag use of an lexical declarations inside a case clause
+ * @author Erik Arvidsson
+ * @copyright 2015 Erik Arvidsson. All rights reserved.
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    /**
+     * Checks whether or not a node is a lexical declaration.
+     * @param {ASTNode} node A direct child statement of a switch case.
+     * @returns {boolean} Whether or not the node is a lexical declaration.
+     */
+    function isLexicalDeclaration(node) {
+        switch (node.type) {
+            case "FunctionDeclaration":
+            case "ClassDeclaration":
+                return true;
+            case "VariableDeclaration":
+                return node.kind !== "var";
+            default:
+                return false;
+        }
+    }
+
+    return {
+        "SwitchCase": function(node) {
+            for (var i = 0; i < node.consequent.length; i++) {
+                var statement = node.consequent[i];
+                if (isLexicalDeclaration(statement)) {
+                    context.report({
+                        node: node,
+                        message: "Unexpected lexical declaration in case block."
+                    });
+                }
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-multiple-empty-lines.js

@@ -88,13 +88,13 @@ module.exports = function(context) {
                         // within the file, not at the end
                         if (blankCounter >= max) {
                             context.report(node, location,
-                                    "Multiple blank lines not allowed.");
+                                    "More than " + max + " blank lines not allowed.");
                         }
                     } else {
                         // inside the last blank lines
                         if (blankCounter >= maxEOF) {
                             context.report(node, location,
-                                    "Too many blank lines at the end of file.");
+                                    "Too many blank lines at the end of file. Max of " + maxEOF + " allowed.");
                         }
                     }
 

package/lib/rules/no-shadow.js

@@ -132,7 +132,7 @@ module.exports = function(context) {
             if (variable.identifiers.length > 0 && isContainedInScopeVars(variable, scope.variables)) {
                 context.report(
                     variable.identifiers[0],
-                    "{{name}} is already declared in the upper scope.",
+                    "\"{{name}}\" is already declared in the upper scope.",
                     {name: variable.name});
             } else {
                 passedVars.push(variable);

package/lib/rules/no-use-before-define.js

@@ -57,7 +57,7 @@ module.exports = function(context) {
         function checkLocationAndReport(reference, declaration) {
             if (typeOption !== NO_FUNC || declaration.defs[0].type !== "FunctionName") {
                 if (declaration.identifiers[0].range[1] > reference.identifier.range[1]) {
-                    context.report(reference.identifier, "{{a}} was used before it was defined", {a: reference.identifier.name});
+                    context.report(reference.identifier, "\"{{a}}\" was used before it was defined", {a: reference.identifier.name});
                 }
             }
         }

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

@@ -79,7 +79,7 @@ module.exports = function(context) {
         var matches = commentContainsWarningTerm(node.value);
 
         matches.forEach(function(matchedTerm) {
-            context.report(node, "Unexpected " + matchedTerm + " comment.");
+            context.report(node, "Unexpected \"" + matchedTerm + "\" comment.");
         });
     }
 

package/lib/rules/radix.js

@@ -11,6 +11,11 @@
 
 module.exports = function(context) {
 
+    var MODE_ALWAYS = "always",
+        MODE_AS_NEEDED = "as-needed";
+
+    var mode = context.options[0] || MODE_ALWAYS;
+
     return {
         "CallExpression": function(node) {
 
@@ -25,17 +30,37 @@ module.exports = function(context) {
                 return;
             }
 
-            if (node.arguments.length < 2) {
-                context.report(node, "Missing radix parameter.");
+            if (node.arguments.length === 0) {
+                context.report({
+                    node: node,
+                    message: "Missing parameters."
+                });
+            } else if (node.arguments.length < 2 && mode === MODE_ALWAYS) {
+                context.report({
+                    node: node,
+                    message: "Missing radix parameter."
+                });
+            } else if (node.arguments.length > 1 && mode === MODE_AS_NEEDED &&
+                (node.arguments[1] && node.arguments[1].type === "Literal" &&
+                    node.arguments[1].value === 10)
+            ) {
+                context.report({
+                    node: node,
+                    message: "Redundant radix parameter."
+                });
             } else {
 
                 radix = node.arguments[1];
 
                 // don't allow non-numeric literals or undefined
-                if ((radix.type === "Literal" && typeof radix.value !== "number") ||
-                    (radix.type === "Identifier" && radix.name === "undefined")
+                if (radix &&
+                    ((radix.type === "Literal" && typeof radix.value !== "number") ||
+                    (radix.type === "Identifier" && radix.name === "undefined"))
                 ) {
-                    context.report(node, "Invalid radix parameter.");
+                    context.report({
+                        node: node,
+                        message: "Invalid radix parameter."
+                    });
                 }
             }
 
@@ -44,4 +69,9 @@ module.exports = function(context) {
 
 };
 
-module.exports.schema = [];
+module.exports.schema = [
+    {
+        "enum": ["always", "as-needed"]
+    }
+];
+

package/lib/rules/space-in-parens.js

@@ -137,6 +137,10 @@ module.exports = function(context) {
      * @returns {boolean} True if the paren should reject the space
      */
     function shouldOpenerRejectSpace(left, right) {
+        if (right.type === "Line") {
+            return false;
+        }
+
         if (!astUtils.isTokenOnSameLine(left, right)) {
             return false;
         }
@@ -184,9 +188,9 @@ module.exports = function(context) {
 
     return {
         "Program": function checkParenSpaces(node) {
-            var tokens = node.tokens;
-            var prevToken, nextToken;
+            var tokens, prevToken, nextToken;
             exceptions = getExceptions();
+            tokens = sourceCode.tokensAndComments;
 
             tokens.forEach(function(token, i) {
                 prevToken = tokens[i - 1];

package/lib/rules/spaced-comment.js

@@ -165,16 +165,16 @@ module.exports = function(context) {
         if (requireSpace) {
             if (!rule.regex.test(node.value)) {
                 if (rule.hasExceptions) {
-                    context.report(node, "Expected exception block, space or tab after " + commentIdentifier + " in comment.");
+                    context.report(node, "Expected exception block, space or tab after \"" + commentIdentifier + "\" in comment.");
                 } else {
-                    context.report(node, "Expected space or tab after " + commentIdentifier + " in comment.");
+                    context.report(node, "Expected space or tab after \"" + commentIdentifier + "\" in comment.");
                 }
             }
         } else {
             var matched = rule.regex.exec(node.value);
             if (matched) {
                 if (!matched[1]) {
-                    context.report(node, "Unexpected space or tab after " + commentIdentifier + " in comment.");
+                    context.report(node, "Unexpected space or tab after \"" + commentIdentifier + "\" in comment.");
                 } else {
                     context.report(node, "Unexpected space or tab after marker (" + matched[1] + ") in comment.");
                 }

package/lib/rules.js

@@ -31,8 +31,6 @@ function define(ruleId, ruleModule) {
     rules[ruleId] = ruleModule;
 }
 
-exports.define = define;
-
 /**
  * Loads and registers all rules from passed rules directory.
  * @param {String} [rulesDir] Path to rules directory, may be relative. Defaults to `lib/rules`.
@@ -45,43 +43,49 @@ function load(rulesDir) {
     });
 }
 
-exports.load = load;
-
 /**
  * Registers all given rules of a plugin.
  * @param {Object} pluginRules A key/value map of rule definitions.
  * @param {String} pluginName The name of the plugin without prefix (`eslint-plugin-`).
  * @returns {void}
  */
-exports.import = function(pluginRules, pluginName) {
+function importPlugin(pluginRules, pluginName) {
     Object.keys(pluginRules).forEach(function(ruleId) {
         var qualifiedRuleId = pluginName + "/" + ruleId,
             rule = pluginRules[ruleId];
 
         define(qualifiedRuleId, rule);
     });
-};
+}
 
 /**
  * Access rule handler by id (file name).
  * @param {String} ruleId Rule id (file name).
  * @returns {Function} Rule handler.
  */
-exports.get = function(ruleId) {
+function get(ruleId) {
     if (typeof rules[ruleId] === "string") {
         return require(rules[ruleId]);
     } else {
         return rules[ruleId];
     }
-};
+}
 
 /**
  * Reset rules storage.
  * Should be used only in tests.
  * @returns {void}
  */
-exports.testClear = function() {
+function testClear() {
     rules = Object.create(null);
+}
+
+module.exports = {
+    define: define,
+    load: load,
+    import: importPlugin,
+    get: get,
+    testClear: testClear
 };
 
 //------------------------------------------------------------------------------

package/lib/util/estraverse.js

@@ -0,0 +1,54 @@
+/**
+ * @fileoverview Patch for estraverse
+ * @author Toru Nagashima
+ * @copyright 2015 Toru Nagashima. All rights reserved.
+ * See LICENSE file in root directory for full license.
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+var estraverse = require("estraverse"),
+    jsxKeys = require("estraverse-fb/keys");
+
+//------------------------------------------------------------------------------
+// Helers
+//------------------------------------------------------------------------------
+
+var experimentalKeys = {
+    ExperimentalRestProperty: ["argument"],
+    ExperimentalSpreadProperty: ["argument"]
+};
+
+/**
+ * Adds a given keys to Syntax and VisitorKeys of estraverse.
+ *
+ * @param {object} keys - Key definitions to add.
+ *   This is an object as map.
+ *   Keys are the node type.
+ *   Values are an array of property names to visit.
+ * @returns {void}
+ */
+function installKeys(keys) {
+    for (var key in keys) {
+        if (keys.hasOwnProperty(key)) {
+            estraverse.Syntax[key] = key;
+            if (keys[key]) {
+                estraverse.VisitorKeys[key] = keys[key];
+            }
+        }
+    }
+}
+
+// Add JSX node types.
+installKeys(jsxKeys);
+// Add Experimental node types.
+installKeys(experimentalKeys);
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = estraverse;

package/lib/util/glob-util.js

@@ -0,0 +1,149 @@
+/**
+ * @fileoverview Utilities for working with globs and the filesystem.
+ * @author Ian VanSchooten
+ * @copyright 2015 Ian VanSchooten. All rights reserved.
+ * See LICENSE in root directory for full license.
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+var debug = require("debug"),
+    fs = require("fs"),
+    glob = require("glob"),
+    shell = require("shelljs"),
+
+    IgnoredPaths = require("../ignored-paths");
+
+debug = debug("eslint:glob-util");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * 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.
+ *
+ * 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.
+ *
+ * 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.
+ */
+function processPath(extensions) {
+    var suffix = "/**";
+
+    if (extensions) {
+        if (extensions.length === 1) {
+            suffix += "/*." + extensions[0];
+        } else {
+            suffix += "/*.{" + extensions.join(",") + "}";
+        }
+    }
+
+    /**
+     * 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 function(pathname) {
+        var newPath = pathname;
+
+        if (shell.test("-d", pathname)) {
+            newPath = pathname.replace(/[\/\\]$/, "") + suffix;
+        }
+
+        return newPath.replace(/\\/g, "/").replace(/^\.\//, "");
+    };
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+/**
+ * Resolves the patterns into glob-based patterns for easier handling.
+ * @param   {string[]} patterns    File patterns (such as passed on the command line).
+ * @param   {string[]} extensions  List of valid file extensions.
+ * @returns {string[]} The equivalent glob patterns.
+ */
+function resolveFileGlobPatterns(patterns, extensions) {
+    extensions = extensions || [".js"];
+
+    extensions = extensions.map(function(ext) {
+        return ext.charAt(0) === "." ? ext.substr(1) : ext;
+    });
+
+    return patterns.map(processPath(extensions));
+}
+
+/**
+ * Build a list of absolute filesnames on which ESLint will act.
+ * Ignored files are excluded from the results, as are duplicates.
+ *
+ * @param   {string[]} globPatterns            Glob patterns.
+ * @param   {Object}   [options]               An options object.
+ * @param   {boolean}  [options.ignore]        False disables use of .eslintignore.
+ * @param   {string}   [options.ignorePath]    The ignore file to use instead of .eslintignore.
+ * @param   {string}   [options.ignorePattern] A pattern of files to ignore.
+ * @returns {string[]} Resolved absolute filenames.
+ */
+function listFilesToProcess(globPatterns, options) {
+    var ignoredPaths,
+        ignoredPathsList,
+        files = [],
+        added = {},
+        globOptions;
+
+    /**
+     * 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 processed
+     * @returns {void}
+     */
+    function addFile(filename) {
+        if (ignoredPaths.contains(filename)) {
+            return;
+        }
+        filename = fs.realpathSync(filename);
+        if (added[filename]) {
+            return;
+        }
+        files.push(filename);
+        added[filename] = true;
+    }
+
+    options = options || { ignore: true };
+    ignoredPaths = IgnoredPaths.load(options);
+    ignoredPathsList = ignoredPaths.patterns || [];
+    globOptions = {
+        nodir: true,
+        ignore: ignoredPathsList
+    };
+
+    debug("Creating list of files to process.");
+    globPatterns.forEach(function(pattern) {
+        if (shell.test("-f", pattern)) {
+            addFile(pattern);
+        } else {
+            glob.sync(pattern, globOptions).forEach(addFile);
+        }
+    });
+
+    return files;
+}
+
+module.exports = {
+    resolveFileGlobPatterns: resolveFileGlobPatterns,
+    listFilesToProcess: listFilesToProcess
+};

package/lib/util/source-code-fixer.js

@@ -97,7 +97,7 @@ SourceCodeFixer.applyFixes = function(sourceCode, messages) {
         fixes.forEach(function(problem) {
             var fix = problem.fix;
 
-            if (fix.range[1] <= lastFixPos) {
+            if (fix.range[1] < lastFixPos) {
                 chars.splice(fix.range[0], fix.range[1] - fix.range[0], fix.text);
                 lastFixPos = fix.range[0];
             } else {

package/lib/util/source-code.js

@@ -12,7 +12,7 @@
 //------------------------------------------------------------------------------
 
 var createTokenStore = require("../token-store.js"),
-    estraverse = require("estraverse"),
+    estraverse = require("./estraverse"),
     assign = require("object-assign");
 
 //------------------------------------------------------------------------------
@@ -115,6 +115,10 @@ function SourceCode(text, ast) {
      */
     this.lines = text.split(/\r\n|\r|\n|\u2028|\u2029/g);
 
+    this.tokensAndComments = ast.tokens.concat(ast.comments).sort(function(left, right) {
+        return left.range[0] - right.range[0];
+    });
+
     // create token store methods
     var tokenStore = createTokenStore(ast.tokens);
     Object.keys(tokenStore).forEach(function(methodName) {

package/lib/util.js

@@ -22,7 +22,7 @@ var PLUGIN_NAME_PREFIX = "eslint-plugin-",
  * @param {boolean} [isRule] Whether its a rule
  * @returns {Object} merged config object.
  */
-exports.mergeConfigs = function deepmerge(target, src, combine, isRule) {
+function deepmerge(target, src, combine, isRule) {
     /*
      The MIT License (MIT)
 
@@ -104,32 +104,38 @@ exports.mergeConfigs = function deepmerge(target, src, combine, isRule) {
     }
 
     return dst;
-};
+}
 
 /**
  * Removes the prefix `eslint-plugin-` from a plugin name.
  * @param {string} pluginName The name of the plugin which may have the prefix.
  * @returns {string} The name of the plugin without prefix.
  */
-exports.removePluginPrefix = function removePluginPrefix(pluginName) {
+function removePluginPrefix(pluginName) {
     return pluginName.indexOf(PLUGIN_NAME_PREFIX) === 0 ? pluginName.substring(PLUGIN_NAME_PREFIX.length) : pluginName;
-};
+}
 
 /**
  * @param {string} pluginName The name of the plugin which may have the prefix.
  * @returns {string} The name of the plugins namepace if it has one.
  */
-exports.getNamespace = function getNamespace(pluginName) {
+function getNamespace(pluginName) {
     return pluginName.match(NAMESPACE_REGEX) ? pluginName.match(NAMESPACE_REGEX)[0] : "";
-};
+}
 
 /**
  * Removes the namespace from a plugin name.
  * @param {string} pluginName The name of the plugin which may have the prefix.
  * @returns {string} The name of the plugin without the namespace.
  */
-exports.removeNameSpace = function removeNameSpace(pluginName) {
+function removeNameSpace(pluginName) {
     return pluginName.replace(NAMESPACE_REGEX, "");
-};
+}
 
-exports.PLUGIN_NAME_PREFIX = PLUGIN_NAME_PREFIX;
+module.exports = {
+    mergeConfigs: deepmerge,
+    removePluginPrefix: removePluginPrefix,
+    getNamespace: getNamespace,
+    removeNameSpace: removeNameSpace,
+    "PLUGIN_NAME_PREFIX": PLUGIN_NAME_PREFIX
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -42,14 +42,14 @@
     "escape-string-regexp": "^1.0.2",
     "escope": "^3.2.0",
     "espree": "^2.2.4",
-    "estraverse": "^4.1.0",
+    "estraverse": "^4.1.1",
     "estraverse-fb": "^1.3.1",
     "esutils": "^2.0.2",
     "file-entry-cache": "^1.1.1",
     "glob": "^5.0.14",
     "globals": "^8.11.0",
     "handlebars": "^4.0.0",
-    "inquirer": "^0.9.0",
+    "inquirer": "^0.11.0",
     "is-my-json-valid": "^2.10.0",
     "is-resolvable": "^1.0.0",
     "js-yaml": "^3.2.5",
@@ -57,33 +57,33 @@
     "lodash.clonedeep": "^3.0.1",
     "lodash.merge": "^3.3.2",
     "lodash.omit": "^3.1.0",
-    "minimatch": "^2.0.1",
+    "minimatch": "^3.0.0",
     "mkdirp": "^0.5.0",
-    "object-assign": "^2.0.0",
-    "optionator": "^0.5.0",
+    "object-assign": "^4.0.1",
+    "optionator": "^0.6.0",
     "path-is-absolute": "^1.0.0",
     "path-is-inside": "^1.0.1",
-    "shelljs": "^0.3.0",
+    "shelljs": "^0.5.3",
     "strip-json-comments": "~1.0.1",
     "text-table": "~0.2.0",
-    "to-double-quotes": "^1.0.1",
-    "to-single-quotes": "^1.0.3",
-    "user-home": "^1.0.0",
+    "to-double-quotes": "^2.0.0",
+    "to-single-quotes": "^2.0.0",
+    "user-home": "^2.0.0",
     "xml-escape": "~1.0.0"
   },
   "devDependencies": {
     "beefy": "^1.0.0",
     "brfs": "0.0.9",
-    "browserify": "^8.1.3",
-    "chai": "^1.9.1",
+    "browserify": "^12.0.1",
+    "chai": "^3.4.0",
     "cheerio": "^0.19.0",
-    "coveralls": "2.11.2",
+    "coveralls": "2.11.4",
     "dateformat": "^1.0.8",
     "ejs": "^2.3.3",
     "esprima": "^2.4.1",
-    "esprima-fb": "^10001.1.0-dev-harmony-fb",
-    "gh-got": "^1.0.3",
-    "istanbul": "^0.3.5",
+    "esprima-fb": "^15001.1001.0-dev-harmony-fb",
+    "gh-got": "^2.2.0",
+    "istanbul": "^0.4.0",
     "jsdoc": "^3.3.0-beta1",
     "jsonlint": "^1.6.2",
     "leche": "^2.1.1",
@@ -91,14 +91,14 @@
     "load-perf": "^0.2.0",
     "markdownlint": "^0.0.8",
     "mocha": "^2.1.0",
-    "mocha-phantomjs": "3.6.0",
-    "npm-license": "^0.2.3",
-    "phantomjs": "1.9.7-15",
+    "mocha-phantomjs": "4.0.1",
+    "npm-license": "^0.3.1",
+    "phantomjs": "1.9.18",
     "proxyquire": "^1.0.0",
     "rewire": "^2.3.4",
-    "semver": "^4.1.0",
+    "semver": "^5.0.3",
     "shelljs-nodecli": "~0.1.0",
-    "sinon": "1.14.1",
+    "sinon": "1.17.2",
     "through": "^2.3.6"
   },
   "keywords": [