eslint 0.22.0 → 0.24.1

package/lib/rules/no-native-reassign.js

@@ -1,62 +1,62 @@
-/**
- * @fileoverview Rule to flag when re-assigning native objects
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    var NATIVE_OBJECTS = ["Array", "Boolean", "Date", "decodeURI",
-                        "decodeURIComponent", "encodeURI", "encodeURIComponent",
-                        "Error", "eval", "EvalError", "Function", "isFinite",
-                        "isNaN", "JSON", "Math", "Number", "Object", "parseInt",
-                        "parseFloat", "RangeError", "ReferenceError", "RegExp",
-                        "String", "SyntaxError", "TypeError", "URIError",
-                        "Map", "NaN", "Set", "WeakMap", "Infinity", "undefined"];
-    var config = context.options[0] || {};
-    var exceptions = config.exceptions || [];
-    var modifiedNativeObjects = NATIVE_OBJECTS;
-
-    if (exceptions.length) {
-        modifiedNativeObjects = NATIVE_OBJECTS.filter(function(builtIn) {
-            return exceptions.indexOf(builtIn) === -1;
-        });
-    }
-
-    return {
-
-        "AssignmentExpression": function(node) {
-            if (modifiedNativeObjects.indexOf(node.left.name) >= 0) {
-                context.report(node, node.left.name + " is a read-only native object.");
-            }
-        },
-
-        "VariableDeclarator": function(node) {
-            if (modifiedNativeObjects.indexOf(node.id.name) >= 0) {
-                context.report(node, "Redefinition of '{{nativeObject}}'.", { nativeObject: node.id.name });
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [
-    {
-        "type": "object",
-        "properties": {
-            "exceptions": {
-                "type": "array",
-                "items": {
-                    "type": "string"
-                },
-                "uniqueItems": true
-            }
-        },
-        "additionalProperties": false
-    }
-];
+/**
+ * @fileoverview Rule to flag when re-assigning native objects
+ * @author Ilya Volodin
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    var NATIVE_OBJECTS = ["Array", "Boolean", "Date", "decodeURI",
+                        "decodeURIComponent", "encodeURI", "encodeURIComponent",
+                        "Error", "eval", "EvalError", "Function", "isFinite",
+                        "isNaN", "JSON", "Math", "Number", "Object", "parseInt",
+                        "parseFloat", "RangeError", "ReferenceError", "RegExp",
+                        "String", "SyntaxError", "TypeError", "URIError",
+                        "Map", "NaN", "Set", "WeakMap", "Infinity", "undefined"];
+    var config = context.options[0] || {};
+    var exceptions = config.exceptions || [];
+    var modifiedNativeObjects = NATIVE_OBJECTS;
+
+    if (exceptions.length) {
+        modifiedNativeObjects = NATIVE_OBJECTS.filter(function(builtIn) {
+            return exceptions.indexOf(builtIn) === -1;
+        });
+    }
+
+    return {
+
+        "AssignmentExpression": function(node) {
+            if (modifiedNativeObjects.indexOf(node.left.name) >= 0) {
+                context.report(node, node.left.name + " is a read-only native object.");
+            }
+        },
+
+        "VariableDeclarator": function(node) {
+            if (modifiedNativeObjects.indexOf(node.id.name) >= 0) {
+                context.report(node, "Redefinition of '{{nativeObject}}'.", { nativeObject: node.id.name });
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [
+    {
+        "type": "object",
+        "properties": {
+            "exceptions": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "uniqueItems": true
+            }
+        },
+        "additionalProperties": false
+    }
+];

package/lib/rules/no-negated-in-lhs.js

@@ -1,25 +1,25 @@
-/**
- * @fileoverview A rule to disallow negated left operands of the `in` operator
- * @author Michael Ficarra
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-
-        "BinaryExpression": function(node) {
-            if (node.operator === "in" && node.left.type === "UnaryExpression" && node.left.operator === "!") {
-                context.report(node, "The `in` expression's left operand is negated");
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview A rule to disallow negated left operands of the `in` operator
+ * @author Michael Ficarra
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+
+        "BinaryExpression": function(node) {
+            if (node.operator === "in" && node.left.type === "UnaryExpression" && node.left.operator === "!") {
+                context.report(node, "The `in` expression's left operand is negated");
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-nested-ternary.js

@@ -1,24 +1,24 @@
-/**
- * @fileoverview Rule to flag nested ternary expressions
- * @author Ian Christian Myers
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-        "ConditionalExpression": function(node) {
-            if (node.alternate.type === "ConditionalExpression" ||
-                    node.consequent.type === "ConditionalExpression") {
-                context.report(node, "Do not nest ternary expressions");
-            }
-        }
-    };
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag nested ternary expressions
+ * @author Ian Christian Myers
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+        "ConditionalExpression": function(node) {
+            if (node.alternate.type === "ConditionalExpression" ||
+                    node.consequent.type === "ConditionalExpression") {
+                context.report(node, "Do not nest ternary expressions");
+            }
+        }
+    };
+};
+
+module.exports.schema = [];

package/lib/rules/no-new-func.js

@@ -1,25 +1,25 @@
-/**
- * @fileoverview Rule to flag when using new Function
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-
-        "NewExpression": function(node) {
-            if (node.callee.name === "Function") {
-                context.report(node, "The Function constructor is eval.");
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag when using new Function
+ * @author Ilya Volodin
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+
+        "NewExpression": function(node) {
+            if (node.callee.name === "Function") {
+                context.report(node, "The Function constructor is eval.");
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-new-object.js

@@ -1,25 +1,25 @@
-/**
- * @fileoverview A rule to disallow calls to the Object constructor
- * @author Matt DuVall <http://www.mattduvall.com/>
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-
-        "NewExpression": function(node) {
-            if (node.callee.name === "Object") {
-                context.report(node, "The object literal notation {} is preferrable.");
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview A rule to disallow calls to the Object constructor
+ * @author Matt DuVall <http://www.mattduvall.com/>
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+
+        "NewExpression": function(node) {
+            if (node.callee.name === "Object") {
+                context.report(node, "The object literal notation {} is preferrable.");
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-new-require.js

@@ -1,25 +1,25 @@
-/**
- * @fileoverview Rule to disallow use of new operator with the `require` function
- * @author Wil Moore III
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-
-        "NewExpression": function(node) {
-            if (node.callee.type === "Identifier" && node.callee.name === "require") {
-                context.report(node, "Unexpected use of new with require.");
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to disallow use of new operator with the `require` function
+ * @author Wil Moore III
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+
+        "NewExpression": function(node) {
+            if (node.callee.type === "Identifier" && node.callee.name === "require") {
+                context.report(node, "Unexpected use of new with require.");
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-new-wrappers.js

@@ -1,26 +1,26 @@
-/**
- * @fileoverview Rule to flag when using constructor for wrapper objects
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-
-        "NewExpression": function(node) {
-            var wrapperObjects = ["String", "Number", "Boolean", "Math", "JSON"];
-            if (wrapperObjects.indexOf(node.callee.name) > -1) {
-                context.report(node, "Do not use {{fn}} as a constructor.", { fn: node.callee.name });
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag when using constructor for wrapper objects
+ * @author Ilya Volodin
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+
+        "NewExpression": function(node) {
+            var wrapperObjects = ["String", "Number", "Boolean", "Math", "JSON"];
+            if (wrapperObjects.indexOf(node.callee.name) > -1) {
+                context.report(node, "Do not use {{fn}} as a constructor.", { fn: node.callee.name });
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-new.js

@@ -1,27 +1,27 @@
-/**
- * @fileoverview Rule to flag statements with function invocation preceded by
- * "new" and not part of assignment
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-
-        "ExpressionStatement": function(node) {
-
-            if (node.expression.type === "NewExpression") {
-                context.report(node, "Do not use 'new' for side effects.");
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag statements with function invocation preceded by
+ * "new" and not part of assignment
+ * @author Ilya Volodin
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+
+        "ExpressionStatement": function(node) {
+
+            if (node.expression.type === "NewExpression") {
+                context.report(node, "Do not use 'new' for side effects.");
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-obj-calls.js

@@ -1,28 +1,28 @@
-/**
- * @fileoverview Rule to flag use of an object property of the global object (Math and JSON) as a function
- * @author James Allardice
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-        "CallExpression": function(node) {
-
-            if (node.callee.type === "Identifier") {
-                var name = node.callee.name;
-                if (name === "Math" || name === "JSON") {
-                    context.report(node, "'{{name}}' is not a function.", { name: name });
-                }
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag use of an object property of the global object (Math and JSON) as a function
+ * @author James Allardice
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+        "CallExpression": function(node) {
+
+            if (node.callee.type === "Identifier") {
+                var name = node.callee.name;
+                if (name === "Math" || name === "JSON") {
+                    context.report(node, "'{{name}}' is not a function.", { name: name });
+                }
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-octal-escape.js

@@ -1,39 +1,39 @@
-/**
- * @fileoverview Rule to flag octal escape sequences in string literals.
- * @author Ian Christian Myers
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    return {
-
-        "Literal": function(node) {
-            if (typeof node.value !== "string") {
-                return;
-            }
-
-            var match = node.raw.match(/^([^\\]|\\[^0-7])*\\([0-3][0-7]{1,2}|[4-7][0-7]|[0-7])/),
-                octalDigit;
-
-            if (match) {
-                octalDigit = match[2];
-
-                // \0 is actually not considered an octal
-                if (match[2] !== "0" || typeof match[3] !== "undefined") {
-                    context.report(node, "Don't use octal: '\\{{octalDigit}}'. Use '\\u....' instead.",
-                            { octalDigit: octalDigit });
-                }
-            }
-        }
-
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Rule to flag octal escape sequences in string literals.
+ * @author Ian Christian Myers
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    return {
+
+        "Literal": function(node) {
+            if (typeof node.value !== "string") {
+                return;
+            }
+
+            var match = node.raw.match(/^([^\\]|\\[^0-7])*\\([0-3][0-7]{1,2}|[4-7][0-7]|[0-7])/),
+                octalDigit;
+
+            if (match) {
+                octalDigit = match[2];
+
+                // \0 is actually not considered an octal
+                if (match[2] !== "0" || typeof match[3] !== "undefined") {
+                    context.report(node, "Don't use octal: '\\{{octalDigit}}'. Use '\\u....' instead.",
+                            { octalDigit: octalDigit });
+                }
+            }
+        }
+
+    };
+
+};
+
+module.exports.schema = [];