indent-legacy

Enforce consistent indentation

This rule was deprecated in ESLint v4.0.0.

ESLint 4.0.0 introduced a rewrite of the indent rule, which now reports more errors than it did in previous versions. To ease the process of migrating to 4.0.0, the indent-legacy rule was introduced as a snapshot of the indent rule from ESLint 3.x. If your build is failing after the upgrade to 4.0.0, you can disable indent and enable indent-legacy as a quick fix. Eventually, you should switch back to the indent rule to get bugfixes and improvements in future versions.

There are several common guidelines which require specific indentation of nested blocks and statements, like:

function hello(indentSize, type) {
    if (indentSize === 4 && type !== 'tab') {
        console.log('Each next indentation will increase on 4 spaces');
    }
}
1
2
3
4
5

These are the most common scenarios recommended in different style guides:

• Two spaces, not longer and no tabs: Google, npm, Node.js, Idiomatic, Felix
• Tabs: jQuery
• Four spaces: Crockford

Rule Details

This rule enforces a consistent indentation style. The default style is 4 spaces.

Options

This rule has a mixed option:

For example, for 2-space indentation:

{
    "indent-legacy": ["error", 2]
}
1
2
3

Or for tabbed indentation:

{
    "indent-legacy": ["error", "tab"]
}
1
2
3

Examples of incorrect code for this rule with the default options:

/*eslint indent-legacy: "error"*/

if (a) {
  b=c;
  function foo(d) {
    e=f;
  }
}
1
2
3
4
5
6
7
8

Examples of correct code for this rule with the default options:

/*eslint indent-legacy: "error"*/

if (a) {
    b=c;
    function foo(d) {
        e=f;
    }
}
1
2
3
4
5
6
7
8

This rule has an object option:

• "SwitchCase" (default: 0) enforces indentation level for case clauses in switch statements
• "VariableDeclarator" (default: 1) enforces indentation level for var declarators; can also take an object to define separate rules for var, let and const declarations.
• "outerIIFEBody" (default: 1) enforces indentation level for file-level IIFEs.
• "MemberExpression" (off by default) enforces indentation level for multi-line property chains (except in variable declarations and assignments)
• "FunctionDeclaration" takes an object to define rules for function declarations.
  • parameters (off by default) enforces indentation level for parameters in a function declaration. This can either be a number indicating indentation level, or the string "first" indicating that all parameters of the declaration must be aligned with the first parameter.
  • body (default: 1) enforces indentation level for the body of a function declaration.
• "FunctionExpression" takes an object to define rules for function expressions.
  • parameters (off by default) enforces indentation level for parameters in a function expression. This can either be a number indicating indentation level, or the string "first" indicating that all parameters of the expression must be aligned with the first parameter.
  • body (default: 1) enforces indentation level for the body of a function expression.
• "CallExpression" takes an object to define rules for function call expressions.
  • arguments (off by default) enforces indentation level for arguments in a call expression. This can either be a number indicating indentation level, or the string "first" indicating that all arguments of the expression must be aligned with the first argument.
• "ArrayExpression" (default: 1) enforces indentation level for elements in arrays. It can also be set to the string "first", indicating that all the elements in the array should be aligned with the first element.
• "ObjectExpression" (default: 1) enforces indentation level for properties in objects. It can be set to the string "first", indicating that all properties in the object should be aligned with the first property.

Level of indentation denotes the multiple of the indent specified. Example:

• Indent of 4 spaces with VariableDeclarator set to 2 will indent the multi-line variable declarations with 8 spaces.
• Indent of 2 spaces with VariableDeclarator set to 2 will indent the multi-line variable declarations with 4 spaces.
• Indent of 2 spaces with VariableDeclarator set to {"var": 2, "let": 2, "const": 3} will indent the multi-line variable declarations with 4 spaces for var and let, 6 spaces for const statements.
• Indent of tab with VariableDeclarator set to 2 will indent the multi-line variable declarations with 2 tabs.
• Indent of 2 spaces with SwitchCase set to 0 will not indent case clauses with respect to switch statements.
• Indent of 2 spaces with SwitchCase set to 1 will indent case clauses with 2 spaces with respect to switch statements.
• Indent of 2 spaces with SwitchCase set to 2 will indent case clauses with 4 spaces with respect to switch statements.
• Indent of tab with SwitchCase set to 2 will indent case clauses with 2 tabs with respect to switch statements.
• Indent of 2 spaces with MemberExpression set to 0 will indent the multi-line property chains with 0 spaces.
• Indent of 2 spaces with MemberExpression set to 1 will indent the multi-line property chains with 2 spaces.
• Indent of 2 spaces with MemberExpression set to 2 will indent the multi-line property chains with 4 spaces.
• Indent of 4 spaces with MemberExpression set to 0 will indent the multi-line property chains with 0 spaces.
• Indent of 4 spaces with MemberExpression set to 1 will indent the multi-line property chains with 4 spaces.
• Indent of 4 spaces with MemberExpression set to 2 will indent the multi-line property chains with 8 spaces.

tab

Examples of incorrect code for this rule with the "tab" option:

/*eslint indent-legacy: ["error", "tab"]*/

if (a) {
     b=c;
function foo(d) {
           e=f;
 }
}
1
2
3
4
5
6
7
8

Examples of correct code for this rule with the "tab" option:

/*eslint indent-legacy: ["error", "tab"]*/

if (a) {
	b=c;
	function foo(d) {
		e=f;
	}
}
1
2
3
4
5
6
7
8

SwitchCase

Examples of incorrect code for this rule with the 2, { "SwitchCase": 1 } options:

/*eslint indent-legacy: ["error", 2, { "SwitchCase": 1 }]*/

switch(a){
case "a":
    break;
case "b":
    break;
}
1
2
3
4
5
6
7
8

Examples of correct code for this rule with the 2, { "SwitchCase": 1 } option:

/*eslint indent-legacy: ["error", 2, { "SwitchCase": 1 }]*/

switch(a){
  case "a":
    break;
  case "b":
    break;
}
1
2
3
4
5
6
7
8

VariableDeclarator

Examples of incorrect code for this rule with the 2, { "VariableDeclarator": 1 } options:

/*eslint indent-legacy: ["error", 2, { "VariableDeclarator": 1 }]*/

var a,
    b,
    c;
let d,
    e,
    f;
const g = 1,
    h = 2,
    i = 3;
1
2
3
4
5
6
7
8
9
10
11

Examples of correct code for this rule with the 2, { "VariableDeclarator": 1 } options:

/*eslint indent-legacy: ["error", 2, { "VariableDeclarator": 1 }]*/

var a,
  b,
  c;
let d,
  e,
  f;
const g = 1,
  h = 2,
  i = 3;
1
2
3
4
5
6
7
8
9
10
11

Examples of correct code for this rule with the 2, { "VariableDeclarator": 2 } options:

/*eslint indent-legacy: ["error", 2, { "VariableDeclarator": 2 }]*/

var a,
    b,
    c;
let d,
    e,
    f;
const g = 1,
    h = 2,
    i = 3;
1
2
3
4
5
6
7
8
9
10
11

Examples of correct code for this rule with the 2, { "VariableDeclarator": { "var": 2, "let": 2, "const": 3 } } options:

/*eslint indent-legacy: ["error", 2, { "VariableDeclarator": { "var": 2, "let": 2, "const": 3 } }]*/

var a,
    b,
    c;
let e,
    f,
    g;
const h = 1,
      i = 2,
      j = 3;
1
2
3
4
5
6
7
8
9
10
11

outerIIFEBody

Examples of incorrect code for this rule with the options 2, { "outerIIFEBody": 0 }:

/*eslint indent-legacy: ["error", 2, { "outerIIFEBody": 0 }]*/

(function() {

  function foo(x) {
    return x + 1;
  }

})();

if(y) {
console.log('foo');
}
1
2
3
4
5
6
7
8
9
10
11
12
13

Examples of correct code for this rule with the options 2, {"outerIIFEBody": 0}:

/*eslint indent-legacy: ["error", 2, { "outerIIFEBody": 0 }]*/

(function() {

function foo(x) {
  return x + 1;
}

})();

if(y) {
   console.log('foo');
}
1
2
3
4
5
6
7
8
9
10
11
12
13

MemberExpression

Examples of incorrect code for this rule with the 2, { "MemberExpression": 1 } options:

/*eslint indent-legacy: ["error", 2, { "MemberExpression": 1 }]*/

foo
.bar
.baz()
1
2
3
4
5

Examples of correct code for this rule with the 2, { "MemberExpression": 1 } option:

/*eslint indent-legacy: ["error", 2, { "MemberExpression": 1 }]*/

foo
  .bar
  .baz();

// Any indentation is permitted in variable declarations and assignments.
var bip = aardvark.badger
                  .coyote;
1
2
3
4
5
6
7
8
9

FunctionDeclaration

Examples of incorrect code for this rule with the 2, { "FunctionDeclaration": {"body": 1, "parameters": 2} } option:

/*eslint indent-legacy: ["error", 2, { "FunctionDeclaration": {"body": 1, "parameters": 2} }]*/

function foo(bar,
  baz,
  qux) {
    qux();
}
1
2
3
4
5
6
7

Examples of correct code for this rule with the 2, { "FunctionDeclaration": {"body": 1, "parameters": 2} } option:

/*eslint indent-legacy: ["error", 2, { "FunctionDeclaration": {"body": 1, "parameters": 2} }]*/

function foo(bar,
    baz,
    qux) {
  qux();
}
1
2
3
4
5
6
7

Examples of incorrect code for this rule with the 2, { "FunctionDeclaration": {"parameters": "first"} } option:

/*eslint indent-legacy: ["error", 2, {"FunctionDeclaration": {"parameters": "first"}}]*/

function foo(bar, baz,
  qux, boop) {
  qux();
}
1
2
3
4
5
6

Examples of correct code for this rule with the 2, { "FunctionDeclaration": {"parameters": "first"} } option:

/*eslint indent-legacy: ["error", 2, {"FunctionDeclaration": {"parameters": "first"}}]*/

function foo(bar, baz,
             qux, boop) {
  qux();
}
1
2
3
4
5
6

FunctionExpression

Examples of incorrect code for this rule with the 2, { "FunctionExpression": {"body": 1, "parameters": 2} } option:

/*eslint indent-legacy: ["error", 2, { "FunctionExpression": {"body": 1, "parameters": 2} }]*/

var foo = function(bar,
  baz,
  qux) {
    qux();
}
1
2
3
4
5
6
7

Examples of correct code for this rule with the 2, { "FunctionExpression": {"body": 1, "parameters": 2} } option:

/*eslint indent-legacy: ["error", 2, { "FunctionExpression": {"body": 1, "parameters": 2} }]*/

var foo = function(bar,
    baz,
    qux) {
  qux();
}
1
2
3
4
5
6
7

Examples of incorrect code for this rule with the 2, { "FunctionExpression": {"parameters": "first"} } option:

/*eslint indent-legacy: ["error", 2, {"FunctionExpression": {"parameters": "first"}}]*/

var foo = function(bar, baz,
  qux, boop) {
  qux();
}
1
2
3
4
5
6

Examples of correct code for this rule with the 2, { "FunctionExpression": {"parameters": "first"} } option:

/*eslint indent-legacy: ["error", 2, {"FunctionExpression": {"parameters": "first"}}]*/

var foo = function(bar, baz,
                   qux, boop) {
  qux();
}
1
2
3
4
5
6

CallExpression

Examples of incorrect code for this rule with the 2, { "CallExpression": {"arguments": 1} } option:

/*eslint indent-legacy: ["error", 2, { "CallExpression": {"arguments": 1} }]*/

foo(bar,
    baz,
      qux
);
1
2
3
4
5
6

Examples of correct code for this rule with the 2, { "CallExpression": {"arguments": 1} } option:

/*eslint indent-legacy: ["error", 2, { "CallExpression": {"arguments": 1} }]*/

foo(bar,
  baz,
  qux
);
1
2
3
4
5
6

Examples of incorrect code for this rule with the 2, { "CallExpression": {"arguments": "first"} } option:

/*eslint indent-legacy: ["error", 2, {"CallExpression": {"arguments": "first"}}]*/

foo(bar, baz,
  baz, boop, beep);
1
2
3
4

Examples of correct code for this rule with the 2, { "CallExpression": {"arguments": "first"} } option:

/*eslint indent-legacy: ["error", 2, {"CallExpression": {"arguments": "first"}}]*/

foo(bar, baz,
    baz, boop, beep);
1
2
3
4

ArrayExpression

Examples of incorrect code for this rule with the 2, { "ArrayExpression": 1 } option:

/*eslint indent-legacy: ["error", 2, { "ArrayExpression": 1 }]*/

var foo = [
    bar,
baz,
      qux
];
1
2
3
4
5
6
7

Examples of correct code for this rule with the 2, { "ArrayExpression": 1 } option:

/*eslint indent-legacy: ["error", 2, { "ArrayExpression": 1 }]*/

var foo = [
  bar,
  baz,
  qux
];
1
2
3
4
5
6
7

Examples of incorrect code for this rule with the 2, { "ArrayExpression": "first" } option:

/*eslint indent-legacy: ["error", 2, {"ArrayExpression": "first"}]*/

var foo = [bar,
  baz,
  qux
];
1
2
3
4
5
6

Examples of correct code for this rule with the 2, { "ArrayExpression": "first" } option:

/*eslint indent-legacy: ["error", 2, {"ArrayExpression": "first"}]*/

var foo = [bar,
           baz,
           qux
];
1
2
3
4
5
6

ObjectExpression

Examples of incorrect code for this rule with the 2, { "ObjectExpression": 1 } option:

/*eslint indent-legacy: ["error", 2, { "ObjectExpression": 1 }]*/

var foo = {
    bar: 1,
baz: 2,
      qux: 3
};
1
2
3
4
5
6
7

Examples of correct code for this rule with the 2, { "ObjectExpression": 1 } option:

/*eslint indent-legacy: ["error", 2, { "ObjectExpression": 1 }]*/

var foo = {
  bar: 1,
  baz: 2,
  qux: 3
};
1
2
3
4
5
6
7

Examples of incorrect code for this rule with the 2, { "ObjectExpression": "first" } option:

/*eslint indent-legacy: ["error", 2, {"ObjectExpression": "first"}]*/

var foo = { bar: 1,
  baz: 2 };
1
2
3
4

Examples of correct code for this rule with the 2, { "ObjectExpression": "first" } option:

/*eslint indent-legacy: ["error", 2, {"ObjectExpression": "first"}]*/

var foo = { bar: 1,
            baz: 2 };
1
2
3
4

Compatibility

• JSHint: indent
• JSCS: validateIndentation

Version

This rule was introduced in ESLint v4.0.0-alpha.0.

Resources

• Rule source
• Tests source