eslint 0.22.0 → 0.24.1

package/lib/rules/linebreak-style.js

@@ -1,44 +1,44 @@
-/**
- * @fileoverview Rule to forbid mixing LF and LFCR line breaks.
- * @author Erik Mueller
- * @copyright 2015 Varun Verma. All rights reserverd.
- * @copyright 2015 James Whitney. All rights reserved.
- * @copyright 2015 Erik Mueller. All rights reserved.
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function (context) {
-    var EXPECTED_LF_MSG = "Expected linebreaks to be 'LF' but found 'CRLF'.",
-        EXPECTED_CRLF_MSG = "Expected linebreaks to be 'CRLF' but found 'LF'.";
-
-    return {
-        "Program": function checkForlinebreakStyle(node) {
-            var linebreakStyle = context.options[0] || "unix",
-                expectedLF = linebreakStyle === "unix",
-                linebreaks = context.getSource().match(/\r\n|\r|\n|\u2028|\u2029/g),
-                lineOfError = -1;
-
-            if (linebreaks !== null) {
-                lineOfError = linebreaks.indexOf(expectedLF ? "\r\n" : "\n");
-            }
-
-            if (lineOfError !== -1) {
-                context.report(node, {
-                    line: lineOfError + 1,
-                    column: context.getSourceLines()[lineOfError].length
-                }, expectedLF ? EXPECTED_LF_MSG : EXPECTED_CRLF_MSG);
-            }
-        }
-    };
-};
-
-module.exports.schema = [
-    {
-        "enum": ["unix", "windows"]
-    }
-];
+/**
+ * @fileoverview Rule to forbid mixing LF and LFCR line breaks.
+ * @author Erik Mueller
+ * @copyright 2015 Varun Verma. All rights reserverd.
+ * @copyright 2015 James Whitney. All rights reserved.
+ * @copyright 2015 Erik Mueller. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function (context) {
+    var EXPECTED_LF_MSG = "Expected linebreaks to be 'LF' but found 'CRLF'.",
+        EXPECTED_CRLF_MSG = "Expected linebreaks to be 'CRLF' but found 'LF'.";
+
+    return {
+        "Program": function checkForlinebreakStyle(node) {
+            var linebreakStyle = context.options[0] || "unix",
+                expectedLF = linebreakStyle === "unix",
+                linebreaks = context.getSource().match(/\r\n|\r|\n|\u2028|\u2029/g),
+                lineOfError = -1;
+
+            if (linebreaks !== null) {
+                lineOfError = linebreaks.indexOf(expectedLF ? "\r\n" : "\n");
+            }
+
+            if (lineOfError !== -1) {
+                context.report(node, {
+                    line: lineOfError + 1,
+                    column: context.getSourceLines()[lineOfError].length
+                }, expectedLF ? EXPECTED_LF_MSG : EXPECTED_CRLF_MSG);
+            }
+        }
+    };
+};
+
+module.exports.schema = [
+    {
+        "enum": ["unix", "windows"]
+    }
+];

package/lib/rules/lines-around-comment.js

@@ -1,160 +1,228 @@
-/**
- * @fileoverview Enforces empty lines around comments.
- * @author Jamund Ferguson
- * @copyright 2015 Jamund Ferguson. All rights reserved.
- */
-"use strict";
-
-/**
- * Return an array with with any line numbers that are empty.
- * @param {Array} lines An array of each line of the file.
- * @returns {Array} An array of line numbers.
- */
-function getEmptyLineNums(lines) {
-    var emptyLines = lines.map(function(line, i) {
-        return {
-            code: line.trim(),
-            num: i + 1
-        };
-    }).filter(function(line) {
-        return !line.code;
-    }).map(function(line) {
-        return line.num;
-    });
-    return emptyLines;
-}
-
-/**
- * Return an array with with any line numbers that contain comments.
- * @param {Array} comments An array of comment nodes.
- * @returns {Array} An array of line numbers.
- */
-function getCommentLineNums(comments) {
-    var lines = [];
-    comments.forEach(function (token) {
-        var start = token.loc.start.line;
-        var end = token.loc.end.line;
-        lines.push(start, end);
-    });
-    return lines;
-}
-
-/**
- * Determines if a value is an array.
- * @param {number} val The value we wish to check for in the array..
- * @param {Array} array An array.
- * @returns {boolean} True if the value is in the array..
- */
-function contains(val, array) {
-    return array.indexOf(val) > -1;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    var options = context.options[0] || {};
-    options.beforeLineComment = options.beforeLineComment || false;
-    options.afterLineComment = options.afterLineComment || false;
-    options.beforeBlockComment = options.beforeBlockComment || false;
-    options.afterBlockComment = typeof options.afterBlockComment !== "undefined" ? options.afterBlockComment : true;
-
-    /**
-     * Returns whether or not comments are not on lines starting with or ending with code
-     * @param {ASTNode} node The comment node to check.
-     * @returns {boolean} True if the comment is not alone.
-     */
-    function codeAroundComment(node) {
-
-        var lines = context.getSourceLines();
-
-        // Get the whole line and cut it off at the start of the comment
-        var startLine = lines[node.loc.start.line - 1];
-        var endLine = lines[node.loc.end.line - 1];
-
-        var preamble = startLine.slice(0, node.loc.start.column).trim();
-
-        // Also check after the comment
-        var postamble = endLine.slice(node.loc.end.column).trim();
-
-        // Should be false if there was only whitespace around the comment
-        return !!(preamble || postamble);
-    }
-
-    /**
-     * Checks if a comment node has lines around it (ignores inline comments)
-     * @param {ASTNode} node The Comment node.
-     * @param {Object} opts Options to determine the newline.
-     * @param {Boolean} opts.after Should have a newline after this line.
-     * @param {Boolean} opts.before Should have a newline before this line.
-     * @returns {void}
-     */
-    function checkForEmptyLine(node, opts) {
-
-        var lines = context.getSourceLines(),
-            numLines = lines.length + 1,
-            comments = context.getAllComments(),
-            commentLines = getCommentLineNums(comments),
-            emptyLines = getEmptyLineNums(lines),
-            commentAndEmptyLines = commentLines.concat(emptyLines);
-
-        var after = opts.after,
-            before = opts.before;
-
-        var prevLineNum = node.loc.start.line - 1,
-            nextLineNum = node.loc.end.line + 1,
-            commentIsNotAlone = codeAroundComment(node);
-
-        // ignore top of the file and bottom of the file
-        if (prevLineNum < 1) {
-            before = false;
-        }
-        if (nextLineNum >= numLines) {
-            after = false;
-        }
-
-        // we ignore all inline comments
-        if (commentIsNotAlone) {
-            return;
-        }
-
-        // check for newline before
-        if (before && !contains(prevLineNum, commentAndEmptyLines)) {
-            context.report(node, "Expected line before comment.");
-        }
-
-        // check for newline after
-        if (after && !contains(nextLineNum, commentAndEmptyLines)) {
-            context.report(node, "Expected line after comment.");
-        }
-
-    }
-
-    //--------------------------------------------------------------------------
-    // Public
-    //--------------------------------------------------------------------------
-
-    return {
-
-        "LineComment": function(node) {
-            if (options.beforeLineComment || options.afterLineComment) {
-                checkForEmptyLine(node, {
-                    after: options.afterLineComment,
-                    before: options.beforeLineComment
-                });
-            }
-        },
-
-        "BlockComment": function(node) {
-            if (options.beforeBlockComment || options.afterBlockComment) {
-                checkForEmptyLine(node, {
-                    after: options.afterBlockComment,
-                    before: options.beforeBlockComment
-                });
-            }
-        }
-
-    };
-};
+/**
+ * @fileoverview Enforces empty lines around comments.
+ * @author Jamund Ferguson
+ * @copyright 2015 Mathieu M-Gosselin. All rights reserved.
+ * @copyright 2015 Jamund Ferguson. All rights reserved.
+ * @copyright 2015 Gyandeep Singh. All rights reserved.
+ */
+"use strict";
+
+/**
+ * Return an array with with any line numbers that are empty.
+ * @param {Array} lines An array of each line of the file.
+ * @returns {Array} An array of line numbers.
+ */
+function getEmptyLineNums(lines) {
+    var emptyLines = lines.map(function(line, i) {
+        return {
+            code: line.trim(),
+            num: i + 1
+        };
+    }).filter(function(line) {
+        return !line.code;
+    }).map(function(line) {
+        return line.num;
+    });
+    return emptyLines;
+}
+
+/**
+ * Return an array with with any line numbers that contain comments.
+ * @param {Array} comments An array of comment nodes.
+ * @returns {Array} An array of line numbers.
+ */
+function getCommentLineNums(comments) {
+    var lines = [];
+    comments.forEach(function (token) {
+        var start = token.loc.start.line;
+        var end = token.loc.end.line;
+        lines.push(start, end);
+    });
+    return lines;
+}
+
+/**
+ * Determines if a value is an array.
+ * @param {number} val The value we wish to check for in the array..
+ * @param {Array} array An array.
+ * @returns {boolean} True if the value is in the array..
+ */
+function contains(val, array) {
+    return array.indexOf(val) > -1;
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    var options = context.options[0] || {};
+    options.beforeLineComment = options.beforeLineComment || false;
+    options.afterLineComment = options.afterLineComment || false;
+    options.beforeBlockComment = typeof options.beforeBlockComment !== "undefined" ? options.beforeBlockComment : true;
+    options.afterBlockComment = options.afterBlockComment || false;
+    options.allowBlockStart = options.allowBlockStart || false;
+    options.allowBlockEnd = options.allowBlockEnd || false;
+
+    /**
+     * Returns whether or not comments are not on lines starting with or ending with code
+     * @param {ASTNode} node The comment node to check.
+     * @returns {boolean} True if the comment is not alone.
+     */
+    function codeAroundComment(node) {
+
+        var lines = context.getSourceLines();
+
+        // Get the whole line and cut it off at the start of the comment
+        var startLine = lines[node.loc.start.line - 1];
+        var endLine = lines[node.loc.end.line - 1];
+
+        var preamble = startLine.slice(0, node.loc.start.column).trim();
+
+        // Also check after the comment
+        var postamble = endLine.slice(node.loc.end.column).trim();
+
+        // Should be false if there was only whitespace around the comment
+        return !!(preamble || postamble);
+    }
+
+    /**
+     * Returns whether or not comments are at the block start or not.
+     * @param {ASTNode} node The Comment node.
+     * @returns {boolean} True if the comment is at block start.
+     */
+    function isCommentAtBlockStart(node) {
+        var ancestors = context.getAncestors();
+        var parent;
+
+        if (ancestors.length) {
+            parent = ancestors.pop();
+        }
+
+        return parent && (parent.type === "ClassBody" || parent.type === "BlockStatement" || (parent.body && parent.body.type === "BlockStatement")) &&
+                node.loc.start.line - parent.loc.start.line === 1;
+    }
+
+    /**
+     * Returns whether or not comments are at the block end or not.
+     * @param {ASTNode} node The Comment node.
+     * @returns {boolean} True if the comment is at block end.
+     */
+    function isCommentAtBlockEnd(node) {
+        var ancestors = context.getAncestors();
+        var parent;
+
+        if (ancestors.length) {
+            parent = ancestors.pop();
+        }
+
+        return parent && (parent.type === "ClassBody" || parent.type === "BlockStatement" || (parent.body && parent.body.type === "BlockStatement")) &&
+                parent.loc.end.line - node.loc.end.line === 1;
+    }
+
+    /**
+     * Checks if a comment node has lines around it (ignores inline comments)
+     * @param {ASTNode} node The Comment node.
+     * @param {Object} opts Options to determine the newline.
+     * @param {Boolean} opts.after Should have a newline after this line.
+     * @param {Boolean} opts.before Should have a newline before this line.
+     * @returns {void}
+     */
+    function checkForEmptyLine(node, opts) {
+
+        var lines = context.getSourceLines(),
+            numLines = lines.length + 1,
+            comments = context.getAllComments(),
+            commentLines = getCommentLineNums(comments),
+            emptyLines = getEmptyLineNums(lines),
+            commentAndEmptyLines = commentLines.concat(emptyLines);
+
+        var after = opts.after,
+            before = opts.before;
+
+        var prevLineNum = node.loc.start.line - 1,
+            nextLineNum = node.loc.end.line + 1,
+            commentIsNotAlone = codeAroundComment(node);
+
+        var blockStartAllowed = options.allowBlockStart && isCommentAtBlockStart(node),
+            blockEndAllowed = options.allowBlockEnd && isCommentAtBlockEnd(node);
+
+        // ignore top of the file and bottom of the file
+        if (prevLineNum < 1) {
+            before = false;
+        }
+        if (nextLineNum >= numLines) {
+            after = false;
+        }
+
+        // we ignore all inline comments
+        if (commentIsNotAlone) {
+            return;
+        }
+
+        // check for newline before
+        if (!blockStartAllowed && before && !contains(prevLineNum, commentAndEmptyLines)) {
+            context.report(node, "Expected line before comment.");
+        }
+
+        // check for newline after
+        if (!blockEndAllowed && after && !contains(nextLineNum, commentAndEmptyLines)) {
+            context.report(node, "Expected line after comment.");
+        }
+
+    }
+
+    //--------------------------------------------------------------------------
+    // Public
+    //--------------------------------------------------------------------------
+
+    return {
+
+        "LineComment": function(node) {
+            if (options.beforeLineComment || options.afterLineComment) {
+                checkForEmptyLine(node, {
+                    after: options.afterLineComment,
+                    before: options.beforeLineComment
+                });
+            }
+        },
+
+        "BlockComment": function(node) {
+            if (options.beforeBlockComment || options.afterBlockComment) {
+                checkForEmptyLine(node, {
+                    after: options.afterBlockComment,
+                    before: options.beforeBlockComment
+                });
+            }
+        }
+
+    };
+};
+
+module.exports.schema = [
+    {
+        "type": "object",
+        "properties": {
+            "beforeBlockComment": {
+                "type": "boolean"
+            },
+            "afterBlockComment": {
+                "type": "boolean"
+            },
+            "beforeLineComment": {
+                "type": "boolean"
+            },
+            "afterLineComment": {
+                "type": "boolean"
+            },
+            "allowBlockStart": {
+                "type": "boolean"
+            },
+            "allowBlockEnd": {
+                "type": "boolean"
+            }
+        },
+        "additionalProperties": false
+    }
+];

package/lib/rules/max-depth.js

@@ -1,89 +1,89 @@
-/**
- * @fileoverview A rule to set the maximum depth block can be nested in a function.
- * @author Ian Christian Myers
- * @copyright 2013 Ian Christian Myers. All rights reserved.
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    //--------------------------------------------------------------------------
-    // Helpers
-    //--------------------------------------------------------------------------
-
-    var functionStack = [],
-        maxDepth = context.options[0] || 4;
-
-    function startFunction() {
-        functionStack.push(0);
-    }
-
-    function endFunction() {
-        functionStack.pop();
-    }
-
-    function pushBlock(node) {
-        var len = ++functionStack[functionStack.length - 1];
-
-        if (len > maxDepth) {
-            context.report(node, "Blocks are nested too deeply ({{depth}}).",
-                    { depth: len });
-        }
-    }
-
-    function popBlock() {
-        functionStack[functionStack.length - 1]--;
-    }
-
-    //--------------------------------------------------------------------------
-    // Public API
-    //--------------------------------------------------------------------------
-
-    return {
-        "Program": startFunction,
-        "FunctionDeclaration": startFunction,
-        "FunctionExpression": startFunction,
-        "ArrowFunctionExpression": startFunction,
-
-        "IfStatement": function(node) {
-            if (node.parent.type !== "IfStatement") {
-                pushBlock(node);
-            }
-        },
-        "SwitchStatement": pushBlock,
-        "TryStatement": pushBlock,
-        "DoWhileStatement": pushBlock,
-        "WhileStatement": pushBlock,
-        "WithStatement": pushBlock,
-        "ForStatement": pushBlock,
-        "ForInStatement": pushBlock,
-        "ForOfStatement": pushBlock,
-
-        "IfStatement:exit": popBlock,
-        "SwitchStatement:exit": popBlock,
-        "TryStatement:exit": popBlock,
-        "DoWhileStatement:exit": popBlock,
-        "WhileStatement:exit": popBlock,
-        "WithStatement:exit": popBlock,
-        "ForStatement:exit": popBlock,
-        "ForInStatement:exit": popBlock,
-        "ForOfStatement:exit": popBlock,
-
-        "FunctionDeclaration:exit": endFunction,
-        "FunctionExpression:exit": endFunction,
-        "ArrowFunctionExpression:exit": endFunction,
-        "Program:exit": endFunction
-    };
-
-};
-
-module.exports.schema = [
-    {
-        "type": "integer"
-    }
-];
+/**
+ * @fileoverview A rule to set the maximum depth block can be nested in a function.
+ * @author Ian Christian Myers
+ * @copyright 2013 Ian Christian Myers. All rights reserved.
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    var functionStack = [],
+        maxDepth = context.options[0] || 4;
+
+    function startFunction() {
+        functionStack.push(0);
+    }
+
+    function endFunction() {
+        functionStack.pop();
+    }
+
+    function pushBlock(node) {
+        var len = ++functionStack[functionStack.length - 1];
+
+        if (len > maxDepth) {
+            context.report(node, "Blocks are nested too deeply ({{depth}}).",
+                    { depth: len });
+        }
+    }
+
+    function popBlock() {
+        functionStack[functionStack.length - 1]--;
+    }
+
+    //--------------------------------------------------------------------------
+    // Public API
+    //--------------------------------------------------------------------------
+
+    return {
+        "Program": startFunction,
+        "FunctionDeclaration": startFunction,
+        "FunctionExpression": startFunction,
+        "ArrowFunctionExpression": startFunction,
+
+        "IfStatement": function(node) {
+            if (node.parent.type !== "IfStatement") {
+                pushBlock(node);
+            }
+        },
+        "SwitchStatement": pushBlock,
+        "TryStatement": pushBlock,
+        "DoWhileStatement": pushBlock,
+        "WhileStatement": pushBlock,
+        "WithStatement": pushBlock,
+        "ForStatement": pushBlock,
+        "ForInStatement": pushBlock,
+        "ForOfStatement": pushBlock,
+
+        "IfStatement:exit": popBlock,
+        "SwitchStatement:exit": popBlock,
+        "TryStatement:exit": popBlock,
+        "DoWhileStatement:exit": popBlock,
+        "WhileStatement:exit": popBlock,
+        "WithStatement:exit": popBlock,
+        "ForStatement:exit": popBlock,
+        "ForInStatement:exit": popBlock,
+        "ForOfStatement:exit": popBlock,
+
+        "FunctionDeclaration:exit": endFunction,
+        "FunctionExpression:exit": endFunction,
+        "ArrowFunctionExpression:exit": endFunction,
+        "Program:exit": endFunction
+    };
+
+};
+
+module.exports.schema = [
+    {
+        "type": "integer"
+    }
+];