eslint 4.7.1 → 4.10.0

package/lib/util/safe-emitter.js

@@ -0,0 +1,54 @@
+/**
+ * @fileoverview A variant of EventEmitter which does not give listeners information about each other
+ * @author Teddy Katz
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Typedefs
+//------------------------------------------------------------------------------
+
+/**
+ * An object describing an AST selector
+ * @typedef {Object} SafeEmitter
+ * @property {function(eventName: string, listenerFunc: Function): void} on Adds a listener for a given event name
+ * @property {function(eventName: string, arg1?: any, arg2?: any, arg3?: any)} emit Emits an event with a given name.
+ * This calls all the listeners that were listening for that name, with `arg1`, `arg2`, and `arg3` as arguments.
+ * @property {function(): string[]} eventNames Gets the list of event names that have registered listeners.
+ */
+
+/**
+ * Creates an object which can listen for and emit events.
+ * This is similar to the EventEmitter API in Node's standard library, but it has a few differences.
+ * The goal is to allow multiple modules to attach arbitrary listeners to the same emitter, without
+ * letting the modules know about each other at all.
+ * 1. It has no special keys like `error` and `newListener`, which would allow modules to detect when
+ * another module throws an error or registers a listener.
+ * 2. It calls listener functions without any `this` value. (`EventEmitter` calls listeners with a
+ * `this` value of the emitter instance, which would give listeners access to other listeners.)
+ * 3. Events can be emitted with at most 3 arguments. (For example: when using `emitter.emit('foo', a, b, c)`,
+ * the arguments `a`, `b`, and `c` will be passed to the listener functions.)
+ * @returns {SafeEmitter} An emitter
+ */
+module.exports = () => {
+    const listeners = Object.create(null);
+
+    return Object.freeze({
+        on(eventName, listener) {
+            if (eventName in listeners) {
+                listeners[eventName].push(listener);
+            } else {
+                listeners[eventName] = [listener];
+            }
+        },
+        emit(eventName, a, b, c) {
+            if (eventName in listeners) {
+                listeners[eventName].forEach(listener => listener(a, b, c));
+            }
+        },
+        eventNames() {
+            return Object.keys(listeners);
+        }
+    });
+};

package/lib/util/source-code.js

@@ -25,7 +25,6 @@ const TokenStore = require("../token-store"),
  * @private
  */
 function validate(ast) {
-
     if (!ast.tokens) {
         throw new Error("AST is missing the tokens array.");
     }
@@ -44,34 +43,9 @@ function validate(ast) {
 }
 
 /**
- * Finds a JSDoc comment node in an array of comment nodes.
- * @param {ASTNode[]} comments The array of comment nodes to search.
- * @param {int} line Line number to look around
- * @returns {ASTNode} The node if found, null if not.
- * @private
- */
-function findJSDocComment(comments, line) {
-
-    if (comments) {
-        for (let i = comments.length - 1; i >= 0; i--) {
-            if (comments[i].type === "Block" && comments[i].value.charAt(0) === "*") {
-
-                if (line - comments[i].loc.end.line <= 1) {
-                    return comments[i];
-                }
-                break;
-
-            }
-        }
-    }
-
-    return null;
-}
-
-/**
- * Check to see if its a ES6 export declaration
- * @param {ASTNode} astNode - any node
- * @returns {boolean} whether the given node represents a export declaration
+ * Check to see if its a ES6 export declaration.
+ * @param {ASTNode} astNode An AST node.
+ * @returns {boolean} whether the given node represents an export declaration.
  * @private
  */
 function looksLikeExport(astNode) {
@@ -80,10 +54,11 @@ function looksLikeExport(astNode) {
 }
 
 /**
- * Merges two sorted lists into a larger sorted list in O(n) time
- * @param {Token[]} tokens The list of tokens
- * @param {Token[]} comments The list of comments
- * @returns {Token[]} A sorted list of tokens and comments
+ * Merges two sorted lists into a larger sorted list in O(n) time.
+ * @param {Token[]} tokens The list of tokens.
+ * @param {Token[]} comments The list of comments.
+ * @returns {Token[]} A sorted list of tokens and comments.
+ * @private
  */
 function sortedMerge(tokens, comments) {
     const result = [];
@@ -182,9 +157,9 @@ class SourceCode extends TokenStore {
     }
 
     /**
-     * Split the source code into multiple lines based on the line delimiters
-     * @param {string} text Source code as a string
-     * @returns {string[]} Array of source code lines
+     * Split the source code into multiple lines based on the line delimiters.
+     * @param {string} text Source code as a string.
+     * @returns {string[]} Array of source code lines.
      * @public
      */
     static splitLines(text) {
@@ -197,6 +172,7 @@ class SourceCode extends TokenStore {
      * @param {int=} beforeCount The number of characters before the node to retrieve.
      * @param {int=} afterCount The number of characters after the node to retrieve.
      * @returns {string} The text representing the AST node.
+     * @public
      */
     getText(node, beforeCount, afterCount) {
         if (node) {
@@ -209,6 +185,7 @@ class SourceCode extends TokenStore {
     /**
      * Gets the entire source text split into an array of lines.
      * @returns {Array} The source text as an array of lines.
+     * @public
      */
     getLines() {
         return this.lines;
@@ -217,6 +194,7 @@ class SourceCode extends TokenStore {
     /**
      * Retrieves an array containing all comments in the source code.
      * @returns {ASTNode[]} An array of comment nodes.
+     * @public
      */
     getAllComments() {
         return this.ast.comments;
@@ -225,7 +203,8 @@ class SourceCode extends TokenStore {
     /**
      * Gets all comments for the given node.
      * @param {ASTNode} node The AST node to get the comments for.
-     * @returns {Object} The list of comments indexed by their position.
+     * @returns {Object} An object containing a leading and trailing array
+     *      of comments indexed by their position.
      * @public
      */
     getComments(node) {
@@ -297,47 +276,68 @@ class SourceCode extends TokenStore {
     /**
      * Retrieves the JSDoc comment for a given node.
      * @param {ASTNode} node The AST node to get the comment for.
-     * @returns {ASTNode} The Block comment node containing the JSDoc for the
-     *      given node or null if not found.
+     * @returns {Token|null} The Block comment token containing the JSDoc comment
+     *      for the given node or null if not found.
      * @public
      */
     getJSDocComment(node) {
+
+        /**
+         * Checks for the presence of a JSDoc comment for the given node and returns it.
+         * @param {ASTNode} astNode The AST node to get the comment for.
+         * @returns {Token|null} The Block comment token containing the JSDoc comment
+         *      for the given node or null if not found.
+         * @private
+         */
+        const findJSDocComment = astNode => {
+            const tokenBefore = this.getTokenBefore(astNode, { includeComments: true });
+
+            if (
+                tokenBefore &&
+                astUtils.isCommentToken(tokenBefore) &&
+                tokenBefore.type === "Block" &&
+                tokenBefore.value.charAt(0) === "*" &&
+                astNode.loc.start.line - tokenBefore.loc.end.line <= 1
+            ) {
+                return tokenBefore;
+            }
+
+            return null;
+        };
         let parent = node.parent;
-        const leadingComments = this.getCommentsBefore(node);
 
         switch (node.type) {
             case "ClassDeclaration":
             case "FunctionDeclaration":
-                if (looksLikeExport(parent)) {
-                    return findJSDocComment(this.getCommentsBefore(parent), parent.loc.start.line);
-                }
-                return findJSDocComment(leadingComments, node.loc.start.line);
+                return findJSDocComment(looksLikeExport(parent) ? parent : node);
 
             case "ClassExpression":
-                return findJSDocComment(this.getCommentsBefore(parent.parent), parent.parent.loc.start.line);
+                return findJSDocComment(parent.parent);
 
             case "ArrowFunctionExpression":
             case "FunctionExpression":
                 if (parent.type !== "CallExpression" && parent.type !== "NewExpression") {
-                    let parentLeadingComments = this.getCommentsBefore(parent);
-
-                    while (!parentLeadingComments.length && !/Function/.test(parent.type) && parent.type !== "MethodDefinition" && parent.type !== "Property") {
+                    while (
+                        !this.getCommentsBefore(parent).length &&
+                        !/Function/.test(parent.type) &&
+                        parent.type !== "MethodDefinition" &&
+                        parent.type !== "Property"
+                    ) {
                         parent = parent.parent;
 
                         if (!parent) {
                             break;
                         }
-
-                        parentLeadingComments = this.getCommentsBefore(parent);
                     }
 
-                    return parent && parent.type !== "FunctionDeclaration" && parent.type !== "Program" ? findJSDocComment(parentLeadingComments, parent.loc.start.line) : null;
-                } else if (leadingComments.length) {
-                    return findJSDocComment(leadingComments, node.loc.start.line);
+                    if (parent && parent.type !== "FunctionDeclaration" && parent.type !== "Program") {
+                        return findJSDocComment(parent);
+                    }
                 }
 
-            // falls through
+                return findJSDocComment(node);
 
+            // falls through
             default:
                 return null;
         }
@@ -347,15 +347,18 @@ class SourceCode extends TokenStore {
      * Gets the deepest node containing a range index.
      * @param {int} index Range index of the desired node.
      * @returns {ASTNode} The node if found or null if not found.
+     * @public
      */
     getNodeByRangeIndex(index) {
-        let result = null;
+        let result = null,
+            resultParent = null;
         const traverser = new Traverser();
 
         traverser.traverse(this.ast, {
-            enter(node) {
+            enter(node, parent) {
                 if (node.range[0] <= index && index < node.range[1]) {
                     result = node;
+                    resultParent = parent;
                 } else {
                     this.skip();
                 }
@@ -367,7 +370,7 @@ class SourceCode extends TokenStore {
             }
         });
 
-        return result;
+        return result ? Object.assign({ parent: resultParent }, result) : null;
     }
 
     /**
@@ -378,6 +381,7 @@ class SourceCode extends TokenStore {
      * @param {Token} second The token to check before.
      * @returns {boolean} True if there is only space between tokens, false
      *  if there is anything other than whitespace between tokens.
+     * @public
      */
     isSpaceBetweenTokens(first, second) {
         const text = this.text.slice(first.range[1], second.range[0]);
@@ -386,10 +390,11 @@ class SourceCode extends TokenStore {
     }
 
     /**
-    * Converts a source text index into a (line, column) pair.
-    * @param {number} index The index of a character in a file
-    * @returns {Object} A {line, column} location object with a 0-indexed column
-    */
+     * Converts a source text index into a (line, column) pair.
+     * @param {number} index The index of a character in a file
+     * @returns {Object} A {line, column} location object with a 0-indexed column
+     * @public
+     */
     getLocFromIndex(index) {
         if (typeof index !== "number") {
             throw new TypeError("Expected `index` to be a number.");
@@ -420,12 +425,13 @@ class SourceCode extends TokenStore {
     }
 
     /**
-    * Converts a (line, column) pair into a range index.
-    * @param {Object} loc A line/column location
-    * @param {number} loc.line The line number of the location (1-indexed)
-    * @param {number} loc.column The column number of the location (0-indexed)
-    * @returns {number} The range index of the location in the file.
-    */
+     * Converts a (line, column) pair into a range index.
+     * @param {Object} loc A line/column location
+     * @param {number} loc.line The line number of the location (1-indexed)
+     * @param {number} loc.column The column number of the location (0-indexed)
+     * @returns {number} The range index of the location in the file.
+     * @public
+     */
     getIndexFromLoc(loc) {
         if (typeof loc !== "object" || typeof loc.line !== "number" || typeof loc.column !== "number") {
             throw new TypeError("Expected `loc` to be an object with numeric `line` and `column` properties.");

package/messages/no-config-found.txt

@@ -2,6 +2,6 @@ ESLint couldn't find a configuration file. To set up a configuration file for th
 
     eslint --init
 
-ESLint looked for configuration files in <%= directory %> and its ancestors.
+ESLint looked for configuration files in <%= directory %> and its ancestors. If it found none, it then looked in your home directory.
 
 If you think you already have a configuration file or if you need more help, please stop by the ESLint chat room: https://gitter.im/eslint/eslint

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "4.7.1",
+  "version": "4.10.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -20,8 +20,7 @@
     "browserify": "node Makefile.js browserify",
     "perf": "node Makefile.js perf",
     "profile": "beefy tests/bench/bench.js --open -- -t brfs -t ./tests/bench/xform-rules.js -r espree",
-    "coveralls": "cat ./coverage/lcov.info | coveralls",
-    "check-commit": "node Makefile.js checkGitCommit"
+    "coveralls": "cat ./coverage/lcov.info | coveralls"
   },
   "files": [
     "LICENSE",
@@ -32,7 +31,7 @@
     "messages"
   ],
   "repository": "eslint/eslint",
-  "homepage": "http://eslint.org",
+  "homepage": "https://eslint.org",
   "bugs": "https://github.com/eslint/eslint/issues/",
   "dependencies": {
     "ajv": "^5.2.0",

package/lib/internal-rules/.eslintrc.yml

@@ -1,3 +0,0 @@
-rules:
-    internal-no-invalid-meta: "error"
-    internal-consistent-docs-description: "error"

package/lib/internal-rules/internal-consistent-docs-description.js

@@ -1,130 +0,0 @@
-/**
- * @fileoverview Internal rule to enforce meta.docs.description conventions.
- * @author Vitor Balocco
- */
-
-"use strict";
-
-const ALLOWED_FIRST_WORDS = [
-    "enforce",
-    "require",
-    "disallow"
-];
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Gets the property of the Object node passed in that has the name specified.
- *
- * @param {string} property Name of the property to return.
- * @param {ASTNode} node The ObjectExpression node.
- * @returns {ASTNode} The Property node or null if not found.
- */
-function getPropertyFromObject(property, node) {
-    const properties = node.properties;
-
-    for (let i = 0; i < properties.length; i++) {
-        if (properties[i].key.name === property) {
-            return properties[i];
-        }
-    }
-
-    return null;
-}
-
-/**
- * Verifies that the meta.docs.description property follows our internal conventions.
- *
- * @param {RuleContext} context The ESLint rule context.
- * @param {ASTNode} exportsNode ObjectExpression node that the rule exports.
- * @returns {void}
- */
-function checkMetaDocsDescription(context, exportsNode) {
-    if (exportsNode.type !== "ObjectExpression") {
-
-        // if the exported node is not the correct format, "internal-no-invalid-meta" will already report this.
-        return;
-    }
-
-    const metaProperty = getPropertyFromObject("meta", exportsNode);
-    const metaDocs = metaProperty && getPropertyFromObject("docs", metaProperty.value);
-    const metaDocsDescription = metaDocs && getPropertyFromObject("description", metaDocs.value);
-
-    if (!metaDocsDescription) {
-
-        // if there is no `meta.docs.description` property, "internal-no-invalid-meta" will already report this.
-        return;
-    }
-
-    const description = metaDocsDescription.value.value;
-
-    if (typeof description !== "string") {
-        context.report({
-            node: metaDocsDescription.value,
-            message: "`meta.docs.description` should be a string."
-        });
-        return;
-    }
-
-    if (description === "") {
-        context.report({
-            node: metaDocsDescription.value,
-            message: "`meta.docs.description` should not be empty."
-        });
-        return;
-    }
-
-    if (description.indexOf(" ") === 0) {
-        context.report({
-            node: metaDocsDescription.value,
-            message: "`meta.docs.description` should not start with whitespace."
-        });
-        return;
-    }
-
-    const firstWord = description.split(" ")[0];
-
-    if (ALLOWED_FIRST_WORDS.indexOf(firstWord) === -1) {
-        context.report({
-            node: metaDocsDescription.value,
-            message: "`meta.docs.description` should start with one of the following words: {{ allowedWords }}. Started with \"{{ firstWord }}\" instead.",
-            data: {
-                allowedWords: ALLOWED_FIRST_WORDS.join(", "),
-                firstWord
-            }
-        });
-    }
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = {
-    meta: {
-        docs: {
-            description: "enforce correct conventions of `meta.docs.description` property in core rules",
-            category: "Internal",
-            recommended: false
-        },
-
-        schema: []
-    },
-
-    create(context) {
-        return {
-            AssignmentExpression(node) {
-                if (node.left &&
-                    node.right &&
-                    node.left.type === "MemberExpression" &&
-                    node.left.object.name === "module" &&
-                    node.left.property.name === "exports") {
-
-                    checkMetaDocsDescription(context, node.right);
-                }
-            }
-        };
-    }
-};

package/lib/internal-rules/internal-no-invalid-meta.js

@@ -1,188 +0,0 @@
-/**
- * @fileoverview Internal rule to prevent missing or invalid meta property in core rules.
- * @author Vitor Balocco
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Gets the property of the Object node passed in that has the name specified.
- *
- * @param {string} property Name of the property to return.
- * @param {ASTNode} node The ObjectExpression node.
- * @returns {ASTNode} The Property node or null if not found.
- */
-function getPropertyFromObject(property, node) {
-    const properties = node.properties;
-
-    for (let i = 0; i < properties.length; i++) {
-        if (properties[i].key.name === property) {
-            return properties[i];
-        }
-    }
-
-    return null;
-}
-
-/**
- * Extracts the `meta` property from the ObjectExpression that all rules export.
- *
- * @param {ASTNode} exportsNode ObjectExpression node that the rule exports.
- * @returns {ASTNode} The `meta` Property node or null if not found.
- */
-function getMetaPropertyFromExportsNode(exportsNode) {
-    return getPropertyFromObject("meta", exportsNode);
-}
-
-/**
- * Whether this `meta` ObjectExpression has a `docs` property defined or not.
- *
- * @param {ASTNode} metaPropertyNode The `meta` ObjectExpression for this rule.
- * @returns {boolean} `true` if a `docs` property exists.
- */
-function hasMetaDocs(metaPropertyNode) {
-    return Boolean(getPropertyFromObject("docs", metaPropertyNode.value));
-}
-
-/**
- * Whether this `meta` ObjectExpression has a `docs.description` property defined or not.
- *
- * @param {ASTNode} metaPropertyNode The `meta` ObjectExpression for this rule.
- * @returns {boolean} `true` if a `docs.description` property exists.
- */
-function hasMetaDocsDescription(metaPropertyNode) {
-    const metaDocs = getPropertyFromObject("docs", metaPropertyNode.value);
-
-    return metaDocs && getPropertyFromObject("description", metaDocs.value);
-}
-
-/**
- * Whether this `meta` ObjectExpression has a `docs.category` property defined or not.
- *
- * @param {ASTNode} metaPropertyNode The `meta` ObjectExpression for this rule.
- * @returns {boolean} `true` if a `docs.category` property exists.
- */
-function hasMetaDocsCategory(metaPropertyNode) {
-    const metaDocs = getPropertyFromObject("docs", metaPropertyNode.value);
-
-    return metaDocs && getPropertyFromObject("category", metaDocs.value);
-}
-
-/**
- * Whether this `meta` ObjectExpression has a `docs.recommended` property defined or not.
- *
- * @param {ASTNode} metaPropertyNode The `meta` ObjectExpression for this rule.
- * @returns {boolean} `true` if a `docs.recommended` property exists.
- */
-function hasMetaDocsRecommended(metaPropertyNode) {
-    const metaDocs = getPropertyFromObject("docs", metaPropertyNode.value);
-
-    return metaDocs && getPropertyFromObject("recommended", metaDocs.value);
-}
-
-/**
- * Whether this `meta` ObjectExpression has a `schema` property defined or not.
- *
- * @param {ASTNode} metaPropertyNode The `meta` ObjectExpression for this rule.
- * @returns {boolean} `true` if a `schema` property exists.
- */
-function hasMetaSchema(metaPropertyNode) {
-    return getPropertyFromObject("schema", metaPropertyNode.value);
-}
-
-/**
- * Checks the validity of the meta definition of this rule and reports any errors found.
- *
- * @param {RuleContext} context The ESLint rule context.
- * @param {ASTNode} exportsNode ObjectExpression node that the rule exports.
- * @param {boolean} ruleIsFixable whether the rule is fixable or not.
- * @returns {void}
- */
-function checkMetaValidity(context, exportsNode) {
-    const metaProperty = getMetaPropertyFromExportsNode(exportsNode);
-
-    if (!metaProperty) {
-        context.report(exportsNode, "Rule is missing a meta property.");
-        return;
-    }
-
-    if (!hasMetaDocs(metaProperty)) {
-        context.report(metaProperty, "Rule is missing a meta.docs property.");
-        return;
-    }
-
-    if (!hasMetaDocsDescription(metaProperty)) {
-        context.report(metaProperty, "Rule is missing a meta.docs.description property.");
-        return;
-    }
-
-    if (!hasMetaDocsCategory(metaProperty)) {
-        context.report(metaProperty, "Rule is missing a meta.docs.category property.");
-        return;
-    }
-
-    if (!hasMetaDocsRecommended(metaProperty)) {
-        context.report(metaProperty, "Rule is missing a meta.docs.recommended property.");
-        return;
-    }
-
-    if (!hasMetaSchema(metaProperty)) {
-        context.report(metaProperty, "Rule is missing a meta.schema property.");
-    }
-}
-
-/**
- * Whether this node is the correct format for a rule definition or not.
- *
- * @param {ASTNode} node node that the rule exports.
- * @returns {boolean} `true` if the exported node is the correct format for a rule definition
- */
-function isCorrectExportsFormat(node) {
-    return node.type === "ObjectExpression";
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = {
-    meta: {
-        docs: {
-            description: "enforce correct use of `meta` property in core rules",
-            category: "Internal",
-            recommended: false
-        },
-
-        schema: []
-    },
-
-    create(context) {
-        let exportsNode;
-
-        return {
-            AssignmentExpression(node) {
-                if (node.left &&
-                    node.right &&
-                    node.left.type === "MemberExpression" &&
-                    node.left.object.name === "module" &&
-                    node.left.property.name === "exports") {
-
-                    exportsNode = node.right;
-                }
-            },
-
-            "Program:exit"() {
-                if (!isCorrectExportsFormat(exportsNode)) {
-                    context.report({ node: exportsNode, message: "Rule does not export an Object. Make sure the rule follows the new rule format." });
-                    return;
-                }
-
-                checkMetaValidity(context, exportsNode);
-            }
-        };
-    }
-};