eslint 0.22.0 → 0.24.1

package/lib/rules/indent.js

@@ -1,486 +1,486 @@
-/**
- * @fileoverview This option sets a specific tab width for your code
- * This rule has been ported and modified from JSCS.
- * @author Dmitriy Shekhovtsov
- * @copyright 2015 Dmitriy Shekhovtsov. All rights reserved.
- * @copyright 2013 Dulin Marat and other contributors.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-/*eslint no-use-before-define:[2, "nofunc"]*/
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function (context) {
-    // indentation defaults: 4 spaces
-    var indentChar = " ";
-    var indentSize = 4;
-    var options = {indentSwitchCase: false};
-
-    var lines = null;
-    var indentStack = [0];
-    var linesToCheck = null;
-    var breakIndents = null;
-
-    if (context.options.length) {
-        if (context.options[0] === "tab") {
-            indentChar = "\t";
-            indentSize = 1;
-        } else /* istanbul ignore else : this will be caught by options validation */ if (typeof context.options[0] === "number") {
-            indentSize = context.options[0];
-        }
-
-        if (context.options[1]) {
-            var opts = context.options[1];
-            options.indentSwitchCase = opts.indentSwitchCase === true;
-        }
-    }
-
-    var blockParents = [
-        "IfStatement",
-        "WhileStatement",
-        "DoWhileStatement",
-        "ForStatement",
-        "ForInStatement",
-        "ForOfStatement",
-        "FunctionDeclaration",
-        "FunctionExpression",
-        "ArrowExpression",
-        "CatchClause",
-        "WithStatement"
-    ];
-
-    var indentableNodes = {
-        BlockStatement: "body",
-        Program: "body",
-        ObjectExpression: "properties",
-        ArrayExpression: "elements",
-        SwitchStatement: "cases"
-    };
-
-    if (options.indentSwitchCase) {
-        indentableNodes.SwitchCase = "consequent";
-    }
-
-    //--------------------------------------------------------------------------
-    // Helpers
-    //--------------------------------------------------------------------------
-
-    /**
-     * Mark line to be checked
-     * @param {Number} line - line number
-     * @returns {void}
-     */
-    function markCheckLine(line) {
-        linesToCheck[line].check = true;
-    }
-
-    /**
-     * Mark line with targeted node to be checked
-     * @param {ASTNode} checkNode - targeted node
-     * @returns {void}
-     */
-    function markCheck(checkNode) {
-        markCheckLine(checkNode.loc.start.line - 1);
-    }
-
-    /**
-     * Sets pushing indent of current node
-     * @param {ASTNode} node - targeted node
-     * @param {Number} indents - indents count to push
-     * @returns {void}
-     */
-    function markPush(node, indents) {
-        linesToCheck[node.loc.start.line - 1].push.push(indents);
-    }
-
-    /**
-     * Marks line as outdent, end of block statement for example
-     * @param {ASTNode} node - targeted node
-     * @param {Number} outdents - count of outedents in targeted line
-     * @returns {void}
-     */
-    function markPop(node, outdents) {
-        linesToCheck[node.loc.end.line - 1].pop.push(outdents);
-    }
-
-    /**
-     * Set alt push for current node
-     * @param {ASTNode} node - targeted node
-     * @returns {void}
-     */
-    function markPushAlt(node) {
-        linesToCheck[node.loc.start.line - 1].pushAltLine.push(node.loc.end.line - 1);
-    }
-
-    /**
-     * Marks end of node block to be checked
-     * and marks targeted node as indent pushing
-     * @param {ASTNode} pushNode - targeted node
-     * @param {Number} indents - indent count to push
-     * @returns {void}
-     */
-    function markPushAndEndCheck(pushNode, indents) {
-        markPush(pushNode, indents);
-        markCheckLine(pushNode.loc.end.line - 1);
-    }
-
-    /**
-     * Mark node as switch case statement
-     * and set push\pop indentation changes
-     * @param {ASTNode} caseNode - targeted node
-     * @param {ASTNode[]} children - consequent child nodes of case node
-     * @returns {void}
-     */
-    function markCase(caseNode, children) {
-        var outdentNode = getCaseOutdent(children);
-
-        if (outdentNode) {
-            // If a case statement has a `break` as a direct child and it is the
-            // first one encountered, use it as the example for all future case indentation
-            if (breakIndents === null) {
-                breakIndents = (caseNode.loc.start.column === outdentNode.loc.start.column) ? 1 : 0;
-            }
-            markPop(outdentNode, breakIndents);
-        } else {
-            markPop(caseNode, 0);
-        }
-    }
-
-    /**
-     * Mark child nodes to be checked later of targeted node,
-     * only if child node not in same line as targeted one
-     * (if child and parent nodes wrote in single line)
-     * @param {ASTNode} node - targeted node
-     * @returns {void}
-     */
-    function markChildren(node) {
-        getChildren(node).forEach(function(childNode) {
-            if (childNode.loc.start.line !== node.loc.start.line || node.type === "Program") {
-                markCheck(childNode);
-            }
-        });
-    }
-
-    /**
-     * Mark child block as scope pushing and mark to check
-     * @param {ASTNode} node - target node
-     * @param {String} property - target node property containing child
-     * @returns {void}
-     */
-    function markAlternateBlockStatement(node, property) {
-        var child = node[property];
-        if (child && child.type === "BlockStatement") {
-            markCheck(child);
-        }
-    }
-
-    /**
-     * Checks whether node is multiline or single line
-     * @param {ASTNode} node - target node
-     * @returns {boolean} - is multiline node
-     */
-    function isMultiline(node) {
-        return node.loc.start.line !== node.loc.end.line;
-    }
-
-    /**
-     * Get switch case statement outdent node if any
-     * @param {ASTNode[]} caseChildren - case statement childs
-     * @returns {ASTNode} - outdent node
-     */
-    function getCaseOutdent(caseChildren) {
-        var outdentNode;
-        caseChildren.some(function(node) {
-            if (node.type === "BreakStatement") {
-                outdentNode = node;
-                return true;
-            }
-        });
-
-        return outdentNode;
-    }
-
-    /**
-     * Returns block containing node
-     * @param {ASTNode} node - targeted node
-     * @returns {ASTNode} - block node
-     */
-    function getBlockNodeToMark(node) {
-        var parent = node.parent;
-
-        // The parent of an else is the entire if/else block. To avoid over indenting
-        // in the case of a non-block if with a block else, mark push where the else starts,
-        // not where the if starts!
-        if (parent.type === "IfStatement" && parent.alternate === node) {
-            return node;
-        }
-
-        // The end line to check of a do while statement needs to be the location of the
-        // closing curly brace, not the while statement, to avoid marking the last line of
-        // a multiline while as a line to check.
-        if (parent.type === "DoWhileStatement") {
-            return node;
-        }
-
-        // Detect bare blocks: a block whose parent doesn"t expect blocks in its syntax specifically.
-        if (blockParents.indexOf(parent.type) === -1) {
-            return node;
-        }
-
-        return parent;
-    }
-
-    /**
-     * Get node's children
-     * @param {ASTNode} node - current node
-     * @returns {ASTNode[]} - children
-     */
-    function getChildren(node) {
-        var childrenProperty = indentableNodes[node.type];
-        return node[childrenProperty];
-    }
-
-    /**
-     * Gets indentation in line `i`
-     * @param {Number} i - number of line to get indentation
-     * @returns {Number} - count of indentation symbols
-     */
-    function getIndentationFromLine(i) {
-        var rNotIndentChar = new RegExp("[^" + indentChar + "]");
-        var firstContent = lines[i].search(rNotIndentChar);
-        if (firstContent === -1) {
-            firstContent = lines[i].length;
-        }
-        return firstContent;
-    }
-
-    /**
-     * Compares expected and actual indentation
-     * and reports any violations
-     * @param {ASTNode} node - node used only for reporting
-     * @returns {void}
-     */
-    function checkIndentations(node) {
-        linesToCheck.forEach(function(line, i) {
-            var actualIndentation = getIndentationFromLine(i);
-            var expectedIndentation = getExpectedIndentation(line, actualIndentation);
-
-            if (line.check) {
-
-                if (actualIndentation !== expectedIndentation) {
-                    context.report(node,
-                        {line: i + 1, column: expectedIndentation},
-                        "Expected indentation of " + expectedIndentation + " characters.");
-                    // correct the indentation so that future lines
-                    // can be validated appropriately
-                    actualIndentation = expectedIndentation;
-                }
-            }
-
-            if (line.push.length) {
-                pushExpectedIndentations(line, actualIndentation);
-            }
-        });
-    }
-
-    /**
-     * Counts expected indentation for given line number
-     * @param {Number} line - line number
-     * @param {Number} actual - actual indentation
-     * @returns {number} - expected indentation
-     */
-    function getExpectedIndentation(line, actual) {
-        var outdent = indentSize * Math.max.apply(null, line.pop);
-
-        var idx = indentStack.length - 1;
-        var expected = indentStack[idx];
-
-        if (!Array.isArray(expected)) {
-            expected = [expected];
-        }
-
-        expected = expected.map(function(value) {
-            if (line.pop.length) {
-                value -= outdent;
-            }
-
-            return value;
-        }).reduce(function(previous, current) {
-            // when the expected is an array, resolve the value
-            // back into a Number by checking both values are the actual indentation
-            return actual === current ? current : previous;
-        });
-
-        indentStack[idx] = expected;
-
-        line.pop.forEach(function() {
-            indentStack.pop();
-        });
-
-        return expected;
-    }
-
-    /**
-     * Store in stack expected indentations
-     * @param {Number} line - current line
-     * @param {Number} actualIndentation - actual indentation at current line
-     * @returns {void}
-     */
-    function pushExpectedIndentations(line, actualIndentation) {
-        var indents = Math.max.apply(null, line.push);
-        var expected = actualIndentation + (indentSize * indents);
-
-        // when a line has alternate indentations, push an array of possible values
-        // on the stack, to be resolved when checked against an actual indentation
-        if (line.pushAltLine.length) {
-            expected = [expected];
-            line.pushAltLine.forEach(function(altLine) {
-                expected.push(getIndentationFromLine(altLine) + (indentSize * indents));
-            });
-        }
-
-        line.push.forEach(function() {
-            indentStack.push(expected);
-        });
-    }
-
-    //--------------------------------------------------------------------------
-    // Public
-    //--------------------------------------------------------------------------
-
-    return {
-        "Program": function (node) {
-            lines = context.getSourceLines();
-            linesToCheck = lines.map(function () {
-                return {
-                    push: [],
-                    pushAltLine: [],
-                    pop: [],
-                    check: false
-                };
-            });
-
-            if (!isMultiline(node)) {
-                return;
-            }
-
-            markChildren(node);
-        },
-        "Program:exit": function (node) {
-            checkIndentations(node);
-        },
-
-        "BlockStatement": function (node) {
-            if (!isMultiline(node)) {
-                return;
-            }
-
-            markChildren(node);
-            markPop(node, 1);
-
-            markPushAndEndCheck(getBlockNodeToMark(node), 1);
-        },
-
-        "IfStatement": function (node) {
-            markAlternateBlockStatement(node, "alternate");
-        },
-
-        "TryStatement": function (node) {
-            markAlternateBlockStatement(node, "handler");
-            markAlternateBlockStatement(node, "finalizer");
-        },
-
-        "SwitchStatement": function (node) {
-            if (!isMultiline(node)) {
-                return;
-            }
-
-            var indents = 1;
-            var children = getChildren(node);
-
-            if (children.length && node.loc.start.column === children[0].loc.start.column) {
-                indents = 0;
-            }
-
-            markChildren(node);
-            markPop(node, indents);
-            markPushAndEndCheck(node, indents);
-        },
-
-        "SwitchCase": function (node) {
-            if (!options.indentSwitchCase) {
-                return;
-            }
-
-            if (!isMultiline(node)) {
-                return;
-            }
-
-            var children = getChildren(node);
-
-            if (children.length === 1 && children[0].type === "BlockStatement") {
-                return;
-            }
-
-            markPush(node, 1);
-            markCheck(node);
-            markChildren(node);
-
-            markCase(node, children);
-        },
-
-        // indentations inside of function expressions can be offset from
-        // either the start of the function or the end of the function, therefore
-        // mark all starting lines of functions as potential indentations
-        "FunctionDeclaration": function (node) {
-            markPushAlt(node);
-        },
-        "FunctionExpression": function (node) {
-            markPushAlt(node);
-        }
-    };
-
-};
-
-module.exports.schema = [
-    {
-        "oneOf": [
-            {
-                "enum": ["tab"]
-            },
-            {
-                "type": "integer"
-            }
-        ]
-    },
-    {
-        "type": "object",
-        "properties": {
-            "indentSwitchCase": {
-                "type": "boolean"
-            }
-        },
-        "additionalProperties": false
-    }
-];
+/**
+ * @fileoverview This option sets a specific tab width for your code
+ * This rule has been ported and modified from JSCS.
+ * @author Dmitriy Shekhovtsov
+ * @copyright 2015 Dmitriy Shekhovtsov. All rights reserved.
+ * @copyright 2013 Dulin Marat and other contributors.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+/*eslint no-use-before-define:[2, "nofunc"]*/
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function (context) {
+    // indentation defaults: 4 spaces
+    var indentChar = " ";
+    var indentSize = 4;
+    var options = {indentSwitchCase: false};
+
+    var lines = null;
+    var indentStack = [0];
+    var linesToCheck = null;
+    var breakIndents = null;
+
+    if (context.options.length) {
+        if (context.options[0] === "tab") {
+            indentChar = "\t";
+            indentSize = 1;
+        } else /* istanbul ignore else : this will be caught by options validation */ if (typeof context.options[0] === "number") {
+            indentSize = context.options[0];
+        }
+
+        if (context.options[1]) {
+            var opts = context.options[1];
+            options.indentSwitchCase = opts.indentSwitchCase === true;
+        }
+    }
+
+    var blockParents = [
+        "IfStatement",
+        "WhileStatement",
+        "DoWhileStatement",
+        "ForStatement",
+        "ForInStatement",
+        "ForOfStatement",
+        "FunctionDeclaration",
+        "FunctionExpression",
+        "ArrowExpression",
+        "CatchClause",
+        "WithStatement"
+    ];
+
+    var indentableNodes = {
+        BlockStatement: "body",
+        Program: "body",
+        ObjectExpression: "properties",
+        ArrayExpression: "elements",
+        SwitchStatement: "cases"
+    };
+
+    if (options.indentSwitchCase) {
+        indentableNodes.SwitchCase = "consequent";
+    }
+
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    /**
+     * Mark line to be checked
+     * @param {Number} line - line number
+     * @returns {void}
+     */
+    function markCheckLine(line) {
+        linesToCheck[line].check = true;
+    }
+
+    /**
+     * Mark line with targeted node to be checked
+     * @param {ASTNode} checkNode - targeted node
+     * @returns {void}
+     */
+    function markCheck(checkNode) {
+        markCheckLine(checkNode.loc.start.line - 1);
+    }
+
+    /**
+     * Sets pushing indent of current node
+     * @param {ASTNode} node - targeted node
+     * @param {Number} indents - indents count to push
+     * @returns {void}
+     */
+    function markPush(node, indents) {
+        linesToCheck[node.loc.start.line - 1].push.push(indents);
+    }
+
+    /**
+     * Marks line as outdent, end of block statement for example
+     * @param {ASTNode} node - targeted node
+     * @param {Number} outdents - count of outedents in targeted line
+     * @returns {void}
+     */
+    function markPop(node, outdents) {
+        linesToCheck[node.loc.end.line - 1].pop.push(outdents);
+    }
+
+    /**
+     * Set alt push for current node
+     * @param {ASTNode} node - targeted node
+     * @returns {void}
+     */
+    function markPushAlt(node) {
+        linesToCheck[node.loc.start.line - 1].pushAltLine.push(node.loc.end.line - 1);
+    }
+
+    /**
+     * Marks end of node block to be checked
+     * and marks targeted node as indent pushing
+     * @param {ASTNode} pushNode - targeted node
+     * @param {Number} indents - indent count to push
+     * @returns {void}
+     */
+    function markPushAndEndCheck(pushNode, indents) {
+        markPush(pushNode, indents);
+        markCheckLine(pushNode.loc.end.line - 1);
+    }
+
+    /**
+     * Mark node as switch case statement
+     * and set push\pop indentation changes
+     * @param {ASTNode} caseNode - targeted node
+     * @param {ASTNode[]} children - consequent child nodes of case node
+     * @returns {void}
+     */
+    function markCase(caseNode, children) {
+        var outdentNode = getCaseOutdent(children);
+
+        if (outdentNode) {
+            // If a case statement has a `break` as a direct child and it is the
+            // first one encountered, use it as the example for all future case indentation
+            if (breakIndents === null) {
+                breakIndents = (caseNode.loc.start.column === outdentNode.loc.start.column) ? 1 : 0;
+            }
+            markPop(outdentNode, breakIndents);
+        } else {
+            markPop(caseNode, 0);
+        }
+    }
+
+    /**
+     * Mark child nodes to be checked later of targeted node,
+     * only if child node not in same line as targeted one
+     * (if child and parent nodes wrote in single line)
+     * @param {ASTNode} node - targeted node
+     * @returns {void}
+     */
+    function markChildren(node) {
+        getChildren(node).forEach(function(childNode) {
+            if (childNode.loc.start.line !== node.loc.start.line || node.type === "Program") {
+                markCheck(childNode);
+            }
+        });
+    }
+
+    /**
+     * Mark child block as scope pushing and mark to check
+     * @param {ASTNode} node - target node
+     * @param {String} property - target node property containing child
+     * @returns {void}
+     */
+    function markAlternateBlockStatement(node, property) {
+        var child = node[property];
+        if (child && child.type === "BlockStatement") {
+            markCheck(child);
+        }
+    }
+
+    /**
+     * Checks whether node is multiline or single line
+     * @param {ASTNode} node - target node
+     * @returns {boolean} - is multiline node
+     */
+    function isMultiline(node) {
+        return node.loc.start.line !== node.loc.end.line;
+    }
+
+    /**
+     * Get switch case statement outdent node if any
+     * @param {ASTNode[]} caseChildren - case statement childs
+     * @returns {ASTNode} - outdent node
+     */
+    function getCaseOutdent(caseChildren) {
+        var outdentNode;
+        caseChildren.some(function(node) {
+            if (node.type === "BreakStatement") {
+                outdentNode = node;
+                return true;
+            }
+        });
+
+        return outdentNode;
+    }
+
+    /**
+     * Returns block containing node
+     * @param {ASTNode} node - targeted node
+     * @returns {ASTNode} - block node
+     */
+    function getBlockNodeToMark(node) {
+        var parent = node.parent;
+
+        // The parent of an else is the entire if/else block. To avoid over indenting
+        // in the case of a non-block if with a block else, mark push where the else starts,
+        // not where the if starts!
+        if (parent.type === "IfStatement" && parent.alternate === node) {
+            return node;
+        }
+
+        // The end line to check of a do while statement needs to be the location of the
+        // closing curly brace, not the while statement, to avoid marking the last line of
+        // a multiline while as a line to check.
+        if (parent.type === "DoWhileStatement") {
+            return node;
+        }
+
+        // Detect bare blocks: a block whose parent doesn"t expect blocks in its syntax specifically.
+        if (blockParents.indexOf(parent.type) === -1) {
+            return node;
+        }
+
+        return parent;
+    }
+
+    /**
+     * Get node's children
+     * @param {ASTNode} node - current node
+     * @returns {ASTNode[]} - children
+     */
+    function getChildren(node) {
+        var childrenProperty = indentableNodes[node.type];
+        return node[childrenProperty];
+    }
+
+    /**
+     * Gets indentation in line `i`
+     * @param {Number} i - number of line to get indentation
+     * @returns {Number} - count of indentation symbols
+     */
+    function getIndentationFromLine(i) {
+        var rNotIndentChar = new RegExp("[^" + indentChar + "]");
+        var firstContent = lines[i].search(rNotIndentChar);
+        if (firstContent === -1) {
+            firstContent = lines[i].length;
+        }
+        return firstContent;
+    }
+
+    /**
+     * Compares expected and actual indentation
+     * and reports any violations
+     * @param {ASTNode} node - node used only for reporting
+     * @returns {void}
+     */
+    function checkIndentations(node) {
+        linesToCheck.forEach(function(line, i) {
+            var actualIndentation = getIndentationFromLine(i);
+            var expectedIndentation = getExpectedIndentation(line, actualIndentation);
+
+            if (line.check) {
+
+                if (actualIndentation !== expectedIndentation) {
+                    context.report(node,
+                        {line: i + 1, column: expectedIndentation},
+                        "Expected indentation of " + expectedIndentation + " characters.");
+                    // correct the indentation so that future lines
+                    // can be validated appropriately
+                    actualIndentation = expectedIndentation;
+                }
+            }
+
+            if (line.push.length) {
+                pushExpectedIndentations(line, actualIndentation);
+            }
+        });
+    }
+
+    /**
+     * Counts expected indentation for given line number
+     * @param {Number} line - line number
+     * @param {Number} actual - actual indentation
+     * @returns {number} - expected indentation
+     */
+    function getExpectedIndentation(line, actual) {
+        var outdent = indentSize * Math.max.apply(null, line.pop);
+
+        var idx = indentStack.length - 1;
+        var expected = indentStack[idx];
+
+        if (!Array.isArray(expected)) {
+            expected = [expected];
+        }
+
+        expected = expected.map(function(value) {
+            if (line.pop.length) {
+                value -= outdent;
+            }
+
+            return value;
+        }).reduce(function(previous, current) {
+            // when the expected is an array, resolve the value
+            // back into a Number by checking both values are the actual indentation
+            return actual === current ? current : previous;
+        });
+
+        indentStack[idx] = expected;
+
+        line.pop.forEach(function() {
+            indentStack.pop();
+        });
+
+        return expected;
+    }
+
+    /**
+     * Store in stack expected indentations
+     * @param {Number} line - current line
+     * @param {Number} actualIndentation - actual indentation at current line
+     * @returns {void}
+     */
+    function pushExpectedIndentations(line, actualIndentation) {
+        var indents = Math.max.apply(null, line.push);
+        var expected = actualIndentation + (indentSize * indents);
+
+        // when a line has alternate indentations, push an array of possible values
+        // on the stack, to be resolved when checked against an actual indentation
+        if (line.pushAltLine.length) {
+            expected = [expected];
+            line.pushAltLine.forEach(function(altLine) {
+                expected.push(getIndentationFromLine(altLine) + (indentSize * indents));
+            });
+        }
+
+        line.push.forEach(function() {
+            indentStack.push(expected);
+        });
+    }
+
+    //--------------------------------------------------------------------------
+    // Public
+    //--------------------------------------------------------------------------
+
+    return {
+        "Program": function (node) {
+            lines = context.getSourceLines();
+            linesToCheck = lines.map(function () {
+                return {
+                    push: [],
+                    pushAltLine: [],
+                    pop: [],
+                    check: false
+                };
+            });
+
+            if (!isMultiline(node)) {
+                return;
+            }
+
+            markChildren(node);
+        },
+        "Program:exit": function (node) {
+            checkIndentations(node);
+        },
+
+        "BlockStatement": function (node) {
+            if (!isMultiline(node)) {
+                return;
+            }
+
+            markChildren(node);
+            markPop(node, 1);
+
+            markPushAndEndCheck(getBlockNodeToMark(node), 1);
+        },
+
+        "IfStatement": function (node) {
+            markAlternateBlockStatement(node, "alternate");
+        },
+
+        "TryStatement": function (node) {
+            markAlternateBlockStatement(node, "handler");
+            markAlternateBlockStatement(node, "finalizer");
+        },
+
+        "SwitchStatement": function (node) {
+            if (!isMultiline(node)) {
+                return;
+            }
+
+            var indents = 1;
+            var children = getChildren(node);
+
+            if (children.length && node.loc.start.column === children[0].loc.start.column) {
+                indents = 0;
+            }
+
+            markChildren(node);
+            markPop(node, indents);
+            markPushAndEndCheck(node, indents);
+        },
+
+        "SwitchCase": function (node) {
+            if (!options.indentSwitchCase) {
+                return;
+            }
+
+            if (!isMultiline(node)) {
+                return;
+            }
+
+            var children = getChildren(node);
+
+            if (children.length === 1 && children[0].type === "BlockStatement") {
+                return;
+            }
+
+            markPush(node, 1);
+            markCheck(node);
+            markChildren(node);
+
+            markCase(node, children);
+        },
+
+        // indentations inside of function expressions can be offset from
+        // either the start of the function or the end of the function, therefore
+        // mark all starting lines of functions as potential indentations
+        "FunctionDeclaration": function (node) {
+            markPushAlt(node);
+        },
+        "FunctionExpression": function (node) {
+            markPushAlt(node);
+        }
+    };
+
+};
+
+module.exports.schema = [
+    {
+        "oneOf": [
+            {
+                "enum": ["tab"]
+            },
+            {
+                "type": "integer"
+            }
+        ]
+    },
+    {
+        "type": "object",
+        "properties": {
+            "indentSwitchCase": {
+                "type": "boolean"
+            }
+        },
+        "additionalProperties": false
+    }
+];