eslint 0.22.0 → 0.24.1

package/lib/rules/no-invalid-regexp.js

@@ -1,53 +1,53 @@
-/**
- * @fileoverview Validate strings passed to the RegExp constructor
- * @author Michael Ficarra
- * @copyright 2014 Michael Ficarra. All rights reserved.
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-var espree = require("espree");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    function isString(node) {
-        return node && node.type === "Literal" && typeof node.value === "string";
-    }
-
-    function check(node) {
-        if (node.callee.type === "Identifier" && node.callee.name === "RegExp" && isString(node.arguments[0])) {
-            var flags = isString(node.arguments[1]) ? node.arguments[1].value : "";
-
-            try {
-                void new RegExp(node.arguments[0].value);
-            } catch(e) {
-                context.report(node, e.message);
-            }
-
-            if (flags) {
-
-                try {
-                    espree.parse("/./" + flags, { ecmaFeatures: context.ecmaFeatures });
-                } catch (ex) {
-                    context.report(node, "Invalid flags supplied to RegExp constructor '" + flags + "'");
-                }
-            }
-
-        }
-    }
-
-    return {
-        "CallExpression": check,
-        "NewExpression": check
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Validate strings passed to the RegExp constructor
+ * @author Michael Ficarra
+ * @copyright 2014 Michael Ficarra. All rights reserved.
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+var espree = require("espree");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    function isString(node) {
+        return node && node.type === "Literal" && typeof node.value === "string";
+    }
+
+    function check(node) {
+        if (node.callee.type === "Identifier" && node.callee.name === "RegExp" && isString(node.arguments[0])) {
+            var flags = isString(node.arguments[1]) ? node.arguments[1].value : "";
+
+            try {
+                void new RegExp(node.arguments[0].value);
+            } catch(e) {
+                context.report(node, e.message);
+            }
+
+            if (flags) {
+
+                try {
+                    espree.parse("/./" + flags, { ecmaFeatures: context.ecmaFeatures });
+                } catch (ex) {
+                    context.report(node, "Invalid flags supplied to RegExp constructor '" + flags + "'");
+                }
+            }
+
+        }
+    }
+
+    return {
+        "CallExpression": check,
+        "NewExpression": check
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-irregular-whitespace.js

@@ -1,135 +1,135 @@
-/**
- * @fileoverview Rule to disalow whitespace that is not a tab or space, whitespace inside strings and comments are allowed
- * @author Jonathan Kingston
- * @copyright 2014 Jonathan Kingston. All rights reserved.
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    var irregularWhitespace = /[\u0085\u00A0\ufeff\f\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000]+/mg,
-        irregularLineTerminators = /[\u2028\u2029]/mg;
-
-    // Module store of errors that we have found
-    var errors = [];
-
-    /**
-     * Removes errors that occur inside a string node
-     * @param {ASTNode} node to check for matching errors.
-     * @returns {void}
-     * @private
-     */
-    function removeStringError(node) {
-        var locStart = node.loc.start;
-        var locEnd = node.loc.end;
-
-        errors = errors.filter(function (error) {
-            var errorLoc = error[1];
-            if (errorLoc.line >= locStart.line && errorLoc.line <= locEnd.line) {
-                if (errorLoc.column >= locStart.column && (errorLoc.column <= locEnd.column || errorLoc.line < locEnd.line)) {
-                    return false;
-                }
-            }
-            return true;
-        });
-    }
-
-    /**
-     * Checks nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
-     * @param {ASTNode} node to check for matching errors.
-     * @returns {void}
-     * @private
-     */
-    function removeInvalidNodeErrors(node) {
-        if (typeof node.value === "string") {
-            // If we have irregular characters remove them from the errors list
-            if (node.raw.match(irregularWhitespace) || node.raw.match(irregularLineTerminators)) {
-                removeStringError(node);
-            }
-        }
-    }
-
-    /**
-     * Checks the program source for irregular whitespace
-     * @param {ASTNode} node The program node
-     * @returns {void}
-     * @private
-     */
-    function checkForIrregularWhitespace(node) {
-        var sourceLines = context.getSourceLines();
-
-        sourceLines.forEach(function (sourceLine, lineIndex) {
-            var lineNumber = lineIndex + 1,
-                location,
-                match;
-
-            while ((match = irregularWhitespace.exec(sourceLine)) !== null) {
-                location = {
-                    line: lineNumber,
-                    column: match.index
-                };
-
-                errors.push([node, location, "Irregular whitespace not allowed"]);
-            }
-        });
-    }
-
-    /**
-     * Checks the program source for irregular line terminators
-     * @param {ASTNode} node The program node
-     * @returns {void}
-     * @private
-     */
-    function checkForIrregularLineTerminators(node) {
-        var source = context.getSource(),
-            sourceLines = context.getSourceLines(),
-            linebreaks = source.match(/\r\n|\r|\n|\u2028|\u2029/g),
-            lastLineIndex = -1,
-            lineIndex,
-            location,
-            match;
-
-        while ((match = irregularLineTerminators.exec(source)) !== null) {
-            lineIndex = linebreaks.indexOf(match[0], lastLineIndex + 1) || 0;
-
-            location = {
-                line: lineIndex + 1,
-                column: sourceLines[lineIndex].length
-            };
-
-            errors.push([node, location, "Irregular whitespace not allowed"]);
-            lastLineIndex = lineIndex;
-        }
-    }
-
-    return {
-        "Program": function (node) {
-            /**
-             * As we can easily fire warnings for all white space issues with all the source its simpler to fire them here
-             * This means we can check all the application code without having to worry about issues caused in the parser tokens
-             * When writing this code also evaluating per node was missing out connecting tokens in some cases
-             * We can later filter the errors when they are found to be not an issue in nodes we don't care about
-             */
-
-            checkForIrregularWhitespace(node);
-            checkForIrregularLineTerminators(node);
-        },
-
-        "Identifier": removeInvalidNodeErrors,
-        "Literal": removeInvalidNodeErrors,
-        "Program:exit": function () {
-
-            // If we have any errors remaining report on them
-            errors.forEach(function (error) {
-                context.report.apply(this, error);
-            });
-        }
-    };
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to disalow whitespace that is not a tab or space, whitespace inside strings and comments are allowed
+ * @author Jonathan Kingston
+ * @copyright 2014 Jonathan Kingston. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    var irregularWhitespace = /[\u0085\u00A0\ufeff\f\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000]+/mg,
+        irregularLineTerminators = /[\u2028\u2029]/mg;
+
+    // Module store of errors that we have found
+    var errors = [];
+
+    /**
+     * Removes errors that occur inside a string node
+     * @param {ASTNode} node to check for matching errors.
+     * @returns {void}
+     * @private
+     */
+    function removeStringError(node) {
+        var locStart = node.loc.start;
+        var locEnd = node.loc.end;
+
+        errors = errors.filter(function (error) {
+            var errorLoc = error[1];
+            if (errorLoc.line >= locStart.line && errorLoc.line <= locEnd.line) {
+                if (errorLoc.column >= locStart.column && (errorLoc.column <= locEnd.column || errorLoc.line < locEnd.line)) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
+
+    /**
+     * Checks nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
+     * @param {ASTNode} node to check for matching errors.
+     * @returns {void}
+     * @private
+     */
+    function removeInvalidNodeErrors(node) {
+        if (typeof node.value === "string") {
+            // If we have irregular characters remove them from the errors list
+            if (node.raw.match(irregularWhitespace) || node.raw.match(irregularLineTerminators)) {
+                removeStringError(node);
+            }
+        }
+    }
+
+    /**
+     * Checks the program source for irregular whitespace
+     * @param {ASTNode} node The program node
+     * @returns {void}
+     * @private
+     */
+    function checkForIrregularWhitespace(node) {
+        var sourceLines = context.getSourceLines();
+
+        sourceLines.forEach(function (sourceLine, lineIndex) {
+            var lineNumber = lineIndex + 1,
+                location,
+                match;
+
+            while ((match = irregularWhitespace.exec(sourceLine)) !== null) {
+                location = {
+                    line: lineNumber,
+                    column: match.index
+                };
+
+                errors.push([node, location, "Irregular whitespace not allowed"]);
+            }
+        });
+    }
+
+    /**
+     * Checks the program source for irregular line terminators
+     * @param {ASTNode} node The program node
+     * @returns {void}
+     * @private
+     */
+    function checkForIrregularLineTerminators(node) {
+        var source = context.getSource(),
+            sourceLines = context.getSourceLines(),
+            linebreaks = source.match(/\r\n|\r|\n|\u2028|\u2029/g),
+            lastLineIndex = -1,
+            lineIndex,
+            location,
+            match;
+
+        while ((match = irregularLineTerminators.exec(source)) !== null) {
+            lineIndex = linebreaks.indexOf(match[0], lastLineIndex + 1) || 0;
+
+            location = {
+                line: lineIndex + 1,
+                column: sourceLines[lineIndex].length
+            };
+
+            errors.push([node, location, "Irregular whitespace not allowed"]);
+            lastLineIndex = lineIndex;
+        }
+    }
+
+    return {
+        "Program": function (node) {
+            /**
+             * As we can easily fire warnings for all white space issues with all the source its simpler to fire them here
+             * This means we can check all the application code without having to worry about issues caused in the parser tokens
+             * When writing this code also evaluating per node was missing out connecting tokens in some cases
+             * We can later filter the errors when they are found to be not an issue in nodes we don't care about
+             */
+
+            checkForIrregularWhitespace(node);
+            checkForIrregularLineTerminators(node);
+        },
+
+        "Identifier": removeInvalidNodeErrors,
+        "Literal": removeInvalidNodeErrors,
+        "Program:exit": function () {
+
+            // If we have any errors remaining report on them
+            errors.forEach(function (error) {
+                context.report.apply(this, error);
+            });
+        }
+    };
+};
+
+module.exports.schema = [];

package/lib/rules/no-iterator.js

@@ -1,28 +1,28 @@
-/**
- * @fileoverview Rule to flag usage of __iterator__ property
- * @author Ian Christian Myers
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-
-        "MemberExpression": function(node) {
-
-            if (node.property &&
-                    (node.property.type === "Identifier" && node.property.name === "__iterator__" && !node.computed) ||
-                    (node.property.type === "Literal" && node.property.value === "__iterator__")) {
-                context.report(node, "Reserved name '__iterator__'.");
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag usage of __iterator__ property
+ * @author Ian Christian Myers
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+
+        "MemberExpression": function(node) {
+
+            if (node.property &&
+                    (node.property.type === "Identifier" && node.property.name === "__iterator__" && !node.computed) ||
+                    (node.property.type === "Literal" && node.property.value === "__iterator__")) {
+                context.report(node, "Reserved name '__iterator__'.");
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-label-var.js

@@ -1,64 +1,64 @@
-/**
- * @fileoverview Rule to flag labels that are the same as an identifier
- * @author Ian Christian Myers
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    //--------------------------------------------------------------------------
-    // Helpers
-    //--------------------------------------------------------------------------
-
-    function findIdentifier(scope, identifier) {
-        var found = false;
-
-        scope.variables.forEach(function(variable) {
-            if (variable.name === identifier) {
-                found = true;
-            }
-        });
-
-        scope.references.forEach(function(reference) {
-            if (reference.identifier.name === identifier) {
-                found = true;
-            }
-        });
-
-        // If we have not found the identifier in this scope, check the parent
-        // scope.
-        if (scope.upper && !found) {
-            return findIdentifier(scope.upper, identifier);
-        }
-
-        return found;
-    }
-
-    //--------------------------------------------------------------------------
-    // Public API
-    //--------------------------------------------------------------------------
-
-    return {
-
-        "LabeledStatement": function(node) {
-
-            // Fetch the innermost scope.
-            var scope = context.getScope();
-
-            // Recursively find the identifier walking up the scope, starting
-            // with the innermost scope.
-            if (findIdentifier(scope, node.label.name)) {
-                context.report(node, "Found identifier with same name as label.");
-            }
-        }
-
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag labels that are the same as an identifier
+ * @author Ian Christian Myers
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    function findIdentifier(scope, identifier) {
+        var found = false;
+
+        scope.variables.forEach(function(variable) {
+            if (variable.name === identifier) {
+                found = true;
+            }
+        });
+
+        scope.references.forEach(function(reference) {
+            if (reference.identifier.name === identifier) {
+                found = true;
+            }
+        });
+
+        // If we have not found the identifier in this scope, check the parent
+        // scope.
+        if (scope.upper && !found) {
+            return findIdentifier(scope.upper, identifier);
+        }
+
+        return found;
+    }
+
+    //--------------------------------------------------------------------------
+    // Public API
+    //--------------------------------------------------------------------------
+
+    return {
+
+        "LabeledStatement": function(node) {
+
+            // Fetch the innermost scope.
+            var scope = context.getScope();
+
+            // Recursively find the identifier walking up the scope, starting
+            // with the innermost scope.
+            if (findIdentifier(scope, node.label.name)) {
+                context.report(node, "Found identifier with same name as label.");
+            }
+        }
+
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-labels.js

@@ -1,44 +1,44 @@
-/**
- * @fileoverview Disallow Labeled Statements
- * @author Nicholas C. Zakas
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    //--------------------------------------------------------------------------
-    // Public
-    //--------------------------------------------------------------------------
-
-    return {
-
-        "LabeledStatement": function(node) {
-            context.report(node, "Unexpected labeled statement.");
-        },
-
-        "BreakStatement": function(node) {
-
-            if (node.label) {
-                context.report(node, "Unexpected label in break statement.");
-            }
-
-        },
-
-        "ContinueStatement": function(node) {
-
-            if (node.label) {
-                context.report(node, "Unexpected label in continue statement.");
-            }
-
-        }
-
-
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Disallow Labeled Statements
+ * @author Nicholas C. Zakas
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    //--------------------------------------------------------------------------
+    // Public
+    //--------------------------------------------------------------------------
+
+    return {
+
+        "LabeledStatement": function(node) {
+            context.report(node, "Unexpected labeled statement.");
+        },
+
+        "BreakStatement": function(node) {
+
+            if (node.label) {
+                context.report(node, "Unexpected label in break statement.");
+            }
+
+        },
+
+        "ContinueStatement": function(node) {
+
+            if (node.label) {
+                context.report(node, "Unexpected label in continue statement.");
+            }
+
+        }
+
+
+    };
+
+};
+
+module.exports.schema = [];