eslint 0.22.0 → 0.24.1

package/lib/rules/camelcase.js

@@ -1,111 +1,111 @@
-/**
- * @fileoverview Rule to flag non-camelcased identifiers
- * @author Nicholas C. Zakas
- * @copyright 2015 Dieter Oberkofler. All rights reserved.
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    //--------------------------------------------------------------------------
-    // Helpers
-    //--------------------------------------------------------------------------
-
-    /**
-     * Checks if a string contains an underscore and isn't all upper-case
-     * @param {String} name The string to check.
-     * @returns {boolean} if the string is underscored
-     * @private
-     */
-    function isUnderscored(name) {
-
-        // if there's an underscore, it might be A_CONSTANT, which is okay
-        return name.indexOf("_") > -1 && name !== name.toUpperCase();
-    }
-
-    /**
-     * Reports an AST node as a rule violation.
-     * @param {ASTNode} node The node to report.
-     * @returns {void}
-     * @private
-     */
-    function report(node) {
-        context.report(node, "Identifier '{{name}}' is not in camel case.", { name: node.name });
-    }
-
-    var options = context.options[0] || {},
-        properties = options.properties || "";
-
-    if (properties !== "always" && properties !== "never") {
-        properties = "always";
-    }
-
-    return {
-
-        "Identifier": function(node) {
-
-            // Leading and trailing underscores are commonly used to flag private/protected identifiers, strip them
-            var name = node.name.replace(/^_+|_+$/g, ""),
-                effectiveParent = (node.parent.type === "MemberExpression") ? node.parent.parent : node.parent;
-
-            // MemberExpressions get special rules
-            if (node.parent.type === "MemberExpression") {
-
-                // "never" check properties
-                if (properties === "never") {
-                    return;
-                }
-
-                // Always report underscored object names
-                if (node.parent.object.type === "Identifier" &&
-                        node.parent.object.name === node.name &&
-                        isUnderscored(name)) {
-                    report(node);
-
-                // Report AssignmentExpressions only if they are the left side of the assignment
-                } else if (effectiveParent.type === "AssignmentExpression" &&
-                        isUnderscored(name) &&
-                        (effectiveParent.right.type !== "MemberExpression" ||
-                        effectiveParent.left.type === "MemberExpression" &&
-                        effectiveParent.left.property.name === node.name)) {
-                    report(node);
-                }
-
-            // Properties have their own rules
-            } else if (node.parent.type === "Property") {
-
-                // "never" check properties
-                if (properties === "never") {
-                    return;
-                }
-
-                if (isUnderscored(name) && effectiveParent.type !== "CallExpression") {
-                    report(node);
-                }
-
-            // Report anything that is underscored that isn't a CallExpression
-            } else if (isUnderscored(name) && effectiveParent.type !== "CallExpression") {
-                report(node);
-            }
-        }
-
-    };
-
-};
-
-module.exports.schema = [
-    {
-        "type": "object",
-        "properties": {
-            "properties": {
-                "enum": ["always", "never"]
-            }
-        },
-        "additionalProperties": false
-    }
-];
+/**
+ * @fileoverview Rule to flag non-camelcased identifiers
+ * @author Nicholas C. Zakas
+ * @copyright 2015 Dieter Oberkofler. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    /**
+     * Checks if a string contains an underscore and isn't all upper-case
+     * @param {String} name The string to check.
+     * @returns {boolean} if the string is underscored
+     * @private
+     */
+    function isUnderscored(name) {
+
+        // if there's an underscore, it might be A_CONSTANT, which is okay
+        return name.indexOf("_") > -1 && name !== name.toUpperCase();
+    }
+
+    /**
+     * Reports an AST node as a rule violation.
+     * @param {ASTNode} node The node to report.
+     * @returns {void}
+     * @private
+     */
+    function report(node) {
+        context.report(node, "Identifier '{{name}}' is not in camel case.", { name: node.name });
+    }
+
+    var options = context.options[0] || {},
+        properties = options.properties || "";
+
+    if (properties !== "always" && properties !== "never") {
+        properties = "always";
+    }
+
+    return {
+
+        "Identifier": function(node) {
+
+            // Leading and trailing underscores are commonly used to flag private/protected identifiers, strip them
+            var name = node.name.replace(/^_+|_+$/g, ""),
+                effectiveParent = (node.parent.type === "MemberExpression") ? node.parent.parent : node.parent;
+
+            // MemberExpressions get special rules
+            if (node.parent.type === "MemberExpression") {
+
+                // "never" check properties
+                if (properties === "never") {
+                    return;
+                }
+
+                // Always report underscored object names
+                if (node.parent.object.type === "Identifier" &&
+                        node.parent.object.name === node.name &&
+                        isUnderscored(name)) {
+                    report(node);
+
+                // Report AssignmentExpressions only if they are the left side of the assignment
+                } else if (effectiveParent.type === "AssignmentExpression" &&
+                        isUnderscored(name) &&
+                        (effectiveParent.right.type !== "MemberExpression" ||
+                        effectiveParent.left.type === "MemberExpression" &&
+                        effectiveParent.left.property.name === node.name)) {
+                    report(node);
+                }
+
+            // Properties have their own rules
+            } else if (node.parent.type === "Property") {
+
+                // "never" check properties
+                if (properties === "never") {
+                    return;
+                }
+
+                if (isUnderscored(name) && effectiveParent.type !== "CallExpression") {
+                    report(node);
+                }
+
+            // Report anything that is underscored that isn't a CallExpression
+            } else if (isUnderscored(name) && effectiveParent.type !== "CallExpression") {
+                report(node);
+            }
+        }
+
+    };
+
+};
+
+module.exports.schema = [
+    {
+        "type": "object",
+        "properties": {
+            "properties": {
+                "enum": ["always", "never"]
+            }
+        },
+        "additionalProperties": false
+    }
+];

package/lib/rules/comma-dangle.js

@@ -1,64 +1,67 @@
-/**
- * @fileoverview Rule to forbid or enforce dangling commas.
- * @author Ian Christian Myers
- * @copyright 2015 Mathias Schreck
- * @copyright 2013 Ian Christian Myers
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function (context) {
-    var allowDangle = context.options[0];
-    var forbidDangle = allowDangle !== "always-multiline" && allowDangle !== "always";
-    var UNEXPECTED_MESSAGE = "Unexpected trailing comma.";
-    var MISSING_MESSAGE = "Missing trailing comma.";
-
-    /**
-     * Checks the given node for trailing comma and reports violations.
-     * @param {ASTNode} node The node of an ObjectExpression or ArrayExpression
-     * @returns {void}
-     */
-    function checkForTrailingComma(node) {
-        var items = node.properties || node.elements,
-            length = items.length,
-            nodeIsMultiLine = node.loc.start.line !== node.loc.end.line,
-            lastItem,
-            penultimateToken,
-            hasDanglingComma;
-
-        if (length) {
-            lastItem = items[length - 1];
-            if (lastItem) {
-                penultimateToken = context.getLastToken(node, 1);
-                hasDanglingComma = penultimateToken.value === ",";
-
-                if (forbidDangle && hasDanglingComma) {
-                    context.report(lastItem, penultimateToken.loc.start, UNEXPECTED_MESSAGE);
-                } else if (allowDangle === "always-multiline") {
-                    if (hasDanglingComma && !nodeIsMultiLine) {
-                        context.report(lastItem, penultimateToken.loc.start, UNEXPECTED_MESSAGE);
-                    } else if (!hasDanglingComma && nodeIsMultiLine) {
-                        context.report(lastItem, penultimateToken.loc.end, MISSING_MESSAGE);
-                    }
-                } else if (allowDangle === "always" && !hasDanglingComma) {
-                    context.report(lastItem, lastItem.loc.end, MISSING_MESSAGE);
-                }
-            }
-        }
-    }
-
-    return {
-        "ObjectExpression": checkForTrailingComma,
-        "ArrayExpression": checkForTrailingComma
-    };
-};
-
-module.exports.schema = [
-    {
-        "enum": ["always", "always-multiline", "never"]
-    }
-];
+/**
+ * @fileoverview Rule to forbid or enforce dangling commas.
+ * @author Ian Christian Myers
+ * @copyright 2015 Mathias Schreck
+ * @copyright 2013 Ian Christian Myers
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function (context) {
+    var allowDangle = context.options[0];
+    var forbidDangle = allowDangle !== "always-multiline" && allowDangle !== "always";
+    var UNEXPECTED_MESSAGE = "Unexpected trailing comma.";
+    var MISSING_MESSAGE = "Missing trailing comma.";
+
+    /**
+     * Checks the given node for trailing comma and reports violations.
+     * @param {ASTNode} node The node of an ObjectExpression or ArrayExpression
+     * @returns {void}
+     */
+    function checkForTrailingComma(node) {
+        var items = node.properties || node.elements,
+            length = items.length,
+            lastTokenOnNewLine,
+            lastItem,
+            penultimateToken,
+            hasDanglingComma;
+
+        if (length) {
+            lastItem = items[length - 1];
+            if (lastItem) {
+                penultimateToken = context.getLastToken(node, 1);
+                hasDanglingComma = penultimateToken.value === ",";
+
+                if (forbidDangle && hasDanglingComma) {
+                    context.report(lastItem, penultimateToken.loc.start, UNEXPECTED_MESSAGE);
+                } else if (allowDangle === "always-multiline") {
+                    lastTokenOnNewLine = node.loc.end.line !== penultimateToken.loc.end.line;
+                    if (hasDanglingComma && !lastTokenOnNewLine) {
+                        context.report(lastItem, penultimateToken.loc.start, UNEXPECTED_MESSAGE);
+                    } else if (!hasDanglingComma && lastTokenOnNewLine) {
+                        context.report(lastItem, penultimateToken.loc.end, MISSING_MESSAGE);
+                    }
+                } else if (allowDangle === "always" && !hasDanglingComma) {
+                    context.report(lastItem, lastItem.loc.end, MISSING_MESSAGE);
+                }
+            }
+        }
+    }
+
+    return {
+        "ObjectExpression": checkForTrailingComma,
+        "ObjectPattern": checkForTrailingComma,
+        "ArrayExpression": checkForTrailingComma,
+        "ArrayPattern": checkForTrailingComma
+    };
+};
+
+module.exports.schema = [
+    {
+        "enum": ["always", "always-multiline", "never"]
+    }
+];