eslint 0.22.0 → 0.24.1

package/lib/rules/operator-assignment.js

@@ -1,118 +1,118 @@
-/**
- * @fileoverview Rule to replace assignment expressions with operator assignment
- * @author Brandon Mills
- * @copyright 2014 Brandon Mills. All rights reserved.
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Checks whether an operator is commutative and has an operator assignment
- * shorthand form.
- * @param   {string}  operator Operator to check.
- * @returns {boolean}          True if the operator is commutative and has a
- *     shorthand form.
- */
-function isCommutativeOperatorWithShorthand(operator) {
-    return ["*", "&", "^", "|"].indexOf(operator) >= 0;
-}
-
-/**
- * Checks whether an operator is not commuatative and has an operator assignment
- * shorthand form.
- * @param   {string}  operator Operator to check.
- * @returns {boolean}          True if the operator is not commuatative and has
- *     a shorthand form.
- */
-function isNonCommutativeOperatorWithShorthand(operator) {
-    return ["+", "-", "/", "%", "<<", ">>", ">>>"].indexOf(operator) >= 0;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/**
- * Checks whether two expressions reference the same value. For example:
- *     a = a
- *     a.b = a.b
- *     a[0] = a[0]
- *     a['b'] = a['b']
- * @param   {ASTNode} a Left side of the comparison.
- * @param   {ASTNode} b Right side of the comparison.
- * @returns {boolean}   True if both sides match and reference the same value.
- */
-function same(a, b) {
-    if (a.type !== b.type) {
-        return false;
-    }
-
-    switch (a.type) {
-        case "Identifier":
-            return a.name === b.name;
-        case "Literal":
-            return a.value === b.value;
-        case "MemberExpression":
-            // x[0] = x[0]
-            // x[y] = x[y]
-            // x.y = x.y
-            return same(a.object, b.object) && same(a.property, b.property);
-        default:
-            return false;
-    }
-}
-
-module.exports = function(context) {
-
-    /**
-     * Ensures that an assignment uses the shorthand form where possible.
-     * @param   {ASTNode} node An AssignmentExpression node.
-     * @returns {void}
-     */
-    function verify(node) {
-        var expr, left, operator;
-
-        if (node.operator !== "=" || node.right.type !== "BinaryExpression") {
-            return;
-        }
-
-        left = node.left;
-        expr = node.right;
-        operator = expr.operator;
-
-        if (isCommutativeOperatorWithShorthand(operator)) {
-            if (same(left, expr.left) || same(left, expr.right)) {
-                context.report(node, "Assignment can be replaced with operator assignment.");
-            }
-        } else if (isNonCommutativeOperatorWithShorthand(operator)) {
-            if (same(left, expr.left)) {
-                context.report(node, "Assignment can be replaced with operator assignment.");
-            }
-        }
-    }
-
-    /**
-     * Warns if an assignment expression uses operator assignment shorthand.
-     * @param   {ASTNode} node An AssignmentExpression node.
-     * @returns {void}
-     */
-    function prohibit(node) {
-        if (node.operator !== "=") {
-            context.report(node, "Unexpected operator assignment shorthand.");
-        }
-    }
-
-    return {
-        "AssignmentExpression": context.options[0] !== "never" ? verify : prohibit
-    };
-
-};
-
-module.exports.schema = [
-    {
-        "enum": ["always", "never"]
-    }
-];
+/**
+ * @fileoverview Rule to replace assignment expressions with operator assignment
+ * @author Brandon Mills
+ * @copyright 2014 Brandon Mills. All rights reserved.
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Checks whether an operator is commutative and has an operator assignment
+ * shorthand form.
+ * @param   {string}  operator Operator to check.
+ * @returns {boolean}          True if the operator is commutative and has a
+ *     shorthand form.
+ */
+function isCommutativeOperatorWithShorthand(operator) {
+    return ["*", "&", "^", "|"].indexOf(operator) >= 0;
+}
+
+/**
+ * Checks whether an operator is not commuatative and has an operator assignment
+ * shorthand form.
+ * @param   {string}  operator Operator to check.
+ * @returns {boolean}          True if the operator is not commuatative and has
+ *     a shorthand form.
+ */
+function isNonCommutativeOperatorWithShorthand(operator) {
+    return ["+", "-", "/", "%", "<<", ">>", ">>>"].indexOf(operator) >= 0;
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/**
+ * Checks whether two expressions reference the same value. For example:
+ *     a = a
+ *     a.b = a.b
+ *     a[0] = a[0]
+ *     a['b'] = a['b']
+ * @param   {ASTNode} a Left side of the comparison.
+ * @param   {ASTNode} b Right side of the comparison.
+ * @returns {boolean}   True if both sides match and reference the same value.
+ */
+function same(a, b) {
+    if (a.type !== b.type) {
+        return false;
+    }
+
+    switch (a.type) {
+        case "Identifier":
+            return a.name === b.name;
+        case "Literal":
+            return a.value === b.value;
+        case "MemberExpression":
+            // x[0] = x[0]
+            // x[y] = x[y]
+            // x.y = x.y
+            return same(a.object, b.object) && same(a.property, b.property);
+        default:
+            return false;
+    }
+}
+
+module.exports = function(context) {
+
+    /**
+     * Ensures that an assignment uses the shorthand form where possible.
+     * @param   {ASTNode} node An AssignmentExpression node.
+     * @returns {void}
+     */
+    function verify(node) {
+        var expr, left, operator;
+
+        if (node.operator !== "=" || node.right.type !== "BinaryExpression") {
+            return;
+        }
+
+        left = node.left;
+        expr = node.right;
+        operator = expr.operator;
+
+        if (isCommutativeOperatorWithShorthand(operator)) {
+            if (same(left, expr.left) || same(left, expr.right)) {
+                context.report(node, "Assignment can be replaced with operator assignment.");
+            }
+        } else if (isNonCommutativeOperatorWithShorthand(operator)) {
+            if (same(left, expr.left)) {
+                context.report(node, "Assignment can be replaced with operator assignment.");
+            }
+        }
+    }
+
+    /**
+     * Warns if an assignment expression uses operator assignment shorthand.
+     * @param   {ASTNode} node An AssignmentExpression node.
+     * @returns {void}
+     */
+    function prohibit(node) {
+        if (node.operator !== "=") {
+            context.report(node, "Unexpected operator assignment shorthand.");
+        }
+    }
+
+    return {
+        "AssignmentExpression": context.options[0] !== "never" ? verify : prohibit
+    };
+
+};
+
+module.exports.schema = [
+    {
+        "enum": ["always", "never"]
+    }
+];

package/lib/rules/operator-linebreak.js

@@ -1,114 +1,114 @@
-/**
- * @fileoverview Operator linebreak - enforces operator linebreak style of two types: after and before
- * @author Benoît Zugmeyer
- * @copyright 2015 Benoît Zugmeyer. All rights reserved.
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    var style = context.options[0] || "after";
-
-    //--------------------------------------------------------------------------
-    // Helpers
-    //--------------------------------------------------------------------------
-
-    /**
-     * Checks whether two tokens are on the same line.
-     * @param {ASTNode} left The leftmost token.
-     * @param {ASTNode} right The rightmost token.
-     * @returns {boolean} True if the tokens are on the same line, false if not.
-     * @private
-     */
-    function isSameLine(left, right) {
-        return left.loc.end.line === right.loc.start.line;
-    }
-
-    /**
-     * Checks the operator placement
-     * @param {ASTNode} node The binary operator node to check
-     * @private
-     * @returns {void}
-     */
-    function validateBinaryExpression(node) {
-        var leftToken = context.getLastToken(node.left || node.id);
-        var operatorToken = context.getTokenAfter(leftToken);
-
-        // When the left part of a binary expression is a single expression wrapped in
-        // parentheses (ex: `(a) + b`), leftToken will be the last token of the expression
-        // and operatorToken will be the closing parenthesis.
-        // The leftToken should be the last closing parenthesis, and the operatorToken
-        // should be the token right after that.
-        while (operatorToken.value === ")") {
-            leftToken = operatorToken;
-            operatorToken = context.getTokenAfter(operatorToken);
-        }
-
-        var rightToken = context.getTokenAfter(operatorToken);
-        var operator = operatorToken.value;
-
-        // if single line
-        if (isSameLine(leftToken, operatorToken) &&
-                isSameLine(operatorToken, rightToken)) {
-
-            return;
-
-        } else if (!isSameLine(leftToken, operatorToken) &&
-                !isSameLine(operatorToken, rightToken)) {
-
-            // lone operator
-            context.report(node, {
-                line: operatorToken.loc.end.line,
-                column: operatorToken.loc.end.column
-            }, "Bad line breaking before and after '" + operator + "'.");
-
-        } else if (style === "before" && isSameLine(leftToken, operatorToken)) {
-
-            context.report(node, {
-                line: operatorToken.loc.end.line,
-                column: operatorToken.loc.end.column
-            }, "'" + operator + "' should be placed at the beginning of the line.");
-
-        } else if (style === "after" && isSameLine(operatorToken, rightToken)) {
-
-            context.report(node, {
-                line: operatorToken.loc.end.line,
-                column: operatorToken.loc.end.column
-            }, "'" + operator + "' should be placed at the end of the line.");
-
-        } else if (style === "none") {
-
-            context.report(node, {
-                line: operatorToken.loc.end.line,
-                column: operatorToken.loc.end.column
-            }, "There should be no line break before or after '" + operator + "'");
-
-        }
-    }
-
-    //--------------------------------------------------------------------------
-    // Public
-    //--------------------------------------------------------------------------
-
-    return {
-        "BinaryExpression": validateBinaryExpression,
-        "LogicalExpression": validateBinaryExpression,
-        "AssignmentExpression": validateBinaryExpression,
-        "VariableDeclarator": function (node) {
-            if (node.init) {
-                validateBinaryExpression(node);
-            }
-        }
-    };
-};
-
-module.exports.schema = [
-    {
-        "enum": ["after", "before", "none"]
-    }
-];
+/**
+ * @fileoverview Operator linebreak - enforces operator linebreak style of two types: after and before
+ * @author Benoît Zugmeyer
+ * @copyright 2015 Benoît Zugmeyer. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    var style = context.options[0] || "after";
+
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    /**
+     * Checks whether two tokens are on the same line.
+     * @param {ASTNode} left The leftmost token.
+     * @param {ASTNode} right The rightmost token.
+     * @returns {boolean} True if the tokens are on the same line, false if not.
+     * @private
+     */
+    function isSameLine(left, right) {
+        return left.loc.end.line === right.loc.start.line;
+    }
+
+    /**
+     * Checks the operator placement
+     * @param {ASTNode} node The binary operator node to check
+     * @private
+     * @returns {void}
+     */
+    function validateBinaryExpression(node) {
+        var leftToken = context.getLastToken(node.left || node.id);
+        var operatorToken = context.getTokenAfter(leftToken);
+
+        // When the left part of a binary expression is a single expression wrapped in
+        // parentheses (ex: `(a) + b`), leftToken will be the last token of the expression
+        // and operatorToken will be the closing parenthesis.
+        // The leftToken should be the last closing parenthesis, and the operatorToken
+        // should be the token right after that.
+        while (operatorToken.value === ")") {
+            leftToken = operatorToken;
+            operatorToken = context.getTokenAfter(operatorToken);
+        }
+
+        var rightToken = context.getTokenAfter(operatorToken);
+        var operator = operatorToken.value;
+
+        // if single line
+        if (isSameLine(leftToken, operatorToken) &&
+                isSameLine(operatorToken, rightToken)) {
+
+            return;
+
+        } else if (!isSameLine(leftToken, operatorToken) &&
+                !isSameLine(operatorToken, rightToken)) {
+
+            // lone operator
+            context.report(node, {
+                line: operatorToken.loc.end.line,
+                column: operatorToken.loc.end.column
+            }, "Bad line breaking before and after '" + operator + "'.");
+
+        } else if (style === "before" && isSameLine(leftToken, operatorToken)) {
+
+            context.report(node, {
+                line: operatorToken.loc.end.line,
+                column: operatorToken.loc.end.column
+            }, "'" + operator + "' should be placed at the beginning of the line.");
+
+        } else if (style === "after" && isSameLine(operatorToken, rightToken)) {
+
+            context.report(node, {
+                line: operatorToken.loc.end.line,
+                column: operatorToken.loc.end.column
+            }, "'" + operator + "' should be placed at the end of the line.");
+
+        } else if (style === "none") {
+
+            context.report(node, {
+                line: operatorToken.loc.end.line,
+                column: operatorToken.loc.end.column
+            }, "There should be no line break before or after '" + operator + "'");
+
+        }
+    }
+
+    //--------------------------------------------------------------------------
+    // Public
+    //--------------------------------------------------------------------------
+
+    return {
+        "BinaryExpression": validateBinaryExpression,
+        "LogicalExpression": validateBinaryExpression,
+        "AssignmentExpression": validateBinaryExpression,
+        "VariableDeclarator": function (node) {
+            if (node.init) {
+                validateBinaryExpression(node);
+            }
+        }
+    };
+};
+
+module.exports.schema = [
+    {
+        "enum": ["after", "before", "none"]
+    }
+];

package/lib/rules/padded-blocks.js

@@ -1,98 +1,98 @@
-/**
- * @fileoverview A rule to ensure blank lines within blocks.
- * @author Mathias Schreck <https://github.com/lo1tuma>
- * @copyright 2014 Mathias Schreck. All rights reserved.
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function (context) {
-    var requirePadding = context.options[0] !== "never";
-
-    var ALWAYS_MESSAGE = "Block must be padded by blank lines.",
-        NEVER_MESSAGE = "Block must not be padded by blank lines.";
-
-    /**
-     * Checks if the given non empty block node has a blank line before its first child node.
-     * @param {ASTNode} node The AST node of a BlockStatement.
-     * @returns {boolean} Whether or not the block starts with a blank line.
-     */
-    function isBlockTopPadded(node) {
-        var blockStart = node.loc.start.line,
-            first = node.body[0],
-            firstLine = first.loc.start.line,
-            expectedFirstLine = blockStart + 2,
-            leadingComments = context.getComments(first).leading;
-
-        if (leadingComments.length > 0) {
-            firstLine = leadingComments[0].loc.start.line;
-        }
-
-        return expectedFirstLine <= firstLine;
-    }
-
-    /**
-     * Checks if the given non empty block node has a blank line after its last child node.
-     * @param {ASTNode} node The AST node of a BlockStatement.
-     * @returns {boolean} Whether or not the block ends with a blank line.
-     */
-    function isBlockBottomPadded(node) {
-        var blockEnd = node.loc.end.line,
-            last = node.body[node.body.length - 1],
-            lastLine = context.getLastToken(last).loc.end.line,
-            expectedLastLine = blockEnd - 2,
-            trailingComments = context.getComments(last).trailing;
-
-        if (trailingComments.length > 0) {
-            lastLine = trailingComments[trailingComments.length - 1].loc.end.line;
-        }
-
-        return lastLine <= expectedLastLine;
-    }
-
-    /**
-     * Checks the given BlockStatement node to be padded if the block is not empty.
-     * @param {ASTNode} node The AST node of a BlockStatement.
-     * @returns {void} undefined.
-     */
-    function checkPadding(node) {
-        if (node.body.length > 0) {
-
-            var blockHasTopPadding = isBlockTopPadded(node),
-                blockHasBottomPadding = isBlockBottomPadded(node);
-
-            if (requirePadding) {
-                if (!blockHasTopPadding) {
-                    context.report(node, ALWAYS_MESSAGE);
-                }
-
-                if (!blockHasBottomPadding) {
-                    context.report(node, node.loc.end, ALWAYS_MESSAGE);
-                }
-            } else {
-                if (blockHasTopPadding) {
-                    context.report(node, NEVER_MESSAGE);
-                }
-
-                if (blockHasBottomPadding) {
-                    context.report(node, node.loc.end, NEVER_MESSAGE);
-                }
-            }
-        }
-    }
-
-    return {
-        "BlockStatement": checkPadding
-    };
-
-};
-
-module.exports.schema = [
-    {
-        "enum": ["always", "never"]
-    }
-];
+/**
+ * @fileoverview A rule to ensure blank lines within blocks.
+ * @author Mathias Schreck <https://github.com/lo1tuma>
+ * @copyright 2014 Mathias Schreck. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function (context) {
+    var requirePadding = context.options[0] !== "never";
+
+    var ALWAYS_MESSAGE = "Block must be padded by blank lines.",
+        NEVER_MESSAGE = "Block must not be padded by blank lines.";
+
+    /**
+     * Checks if the given non empty block node has a blank line before its first child node.
+     * @param {ASTNode} node The AST node of a BlockStatement.
+     * @returns {boolean} Whether or not the block starts with a blank line.
+     */
+    function isBlockTopPadded(node) {
+        var blockStart = node.loc.start.line,
+            first = node.body[0],
+            firstLine = first.loc.start.line,
+            expectedFirstLine = blockStart + 2,
+            leadingComments = context.getComments(first).leading;
+
+        if (leadingComments.length > 0) {
+            firstLine = leadingComments[0].loc.start.line;
+        }
+
+        return expectedFirstLine <= firstLine;
+    }
+
+    /**
+     * Checks if the given non empty block node has a blank line after its last child node.
+     * @param {ASTNode} node The AST node of a BlockStatement.
+     * @returns {boolean} Whether or not the block ends with a blank line.
+     */
+    function isBlockBottomPadded(node) {
+        var blockEnd = node.loc.end.line,
+            last = node.body[node.body.length - 1],
+            lastLine = context.getLastToken(last).loc.end.line,
+            expectedLastLine = blockEnd - 2,
+            trailingComments = context.getComments(last).trailing;
+
+        if (trailingComments.length > 0) {
+            lastLine = trailingComments[trailingComments.length - 1].loc.end.line;
+        }
+
+        return lastLine <= expectedLastLine;
+    }
+
+    /**
+     * Checks the given BlockStatement node to be padded if the block is not empty.
+     * @param {ASTNode} node The AST node of a BlockStatement.
+     * @returns {void} undefined.
+     */
+    function checkPadding(node) {
+        if (node.body.length > 0) {
+
+            var blockHasTopPadding = isBlockTopPadded(node),
+                blockHasBottomPadding = isBlockBottomPadded(node);
+
+            if (requirePadding) {
+                if (!blockHasTopPadding) {
+                    context.report(node, ALWAYS_MESSAGE);
+                }
+
+                if (!blockHasBottomPadding) {
+                    context.report(node, node.loc.end, ALWAYS_MESSAGE);
+                }
+            } else {
+                if (blockHasTopPadding) {
+                    context.report(node, NEVER_MESSAGE);
+                }
+
+                if (blockHasBottomPadding) {
+                    context.report(node, node.loc.end, NEVER_MESSAGE);
+                }
+            }
+        }
+    }
+
+    return {
+        "BlockStatement": checkPadding
+    };
+
+};
+
+module.exports.schema = [
+    {
+        "enum": ["always", "never"]
+    }
+];