eslint-etc

More utils for use with eslint.

I use these utils to implement and test my own ESLint rules. That's their primary purpose, so the documentation is ... light.

fromFixture

fromFixture allows TSLint-like fixtures to be used to test ESlint rules. Using fixtures means that you don't have to specify lines and columns. Instead, you underline the failure locations within the fixture, like this:

1{
2  invalid: [
3    fromFixture(stripIndent`
4      const name = "alice";
5            ~~~~            [foo { "identifier": "name" }]
6                   ~~~~~~~  [bar]
7      const role = 'cto';
8            ~~~~            [foo { "identifier": "role" }]
9    `),
10    fromFixture(stripIndent`
11      const name = "alice";
12            ~~~~            [foo { "identifier": "name" }]
13      const role = 'cto';
14            ~~~~            [foo { "identifier": "role" }]
15    `, {
16      options: [{ bar: false }]
17    }),
18  ]
19}

which is equivalent to the following:

1{
2  invalid: [{
3    code: `const name = "alice";
4const role = 'cto';`,
5    errors: [{
6      column: 7,
7      endColumn: 11,
8      line: 1,
9      endLine: 1,
10      messageId: "foo",
11      data: {
12        identifier: "name",
13      },
14    }, {
15      column: 14,
16      endColumn: 21,
17      line: 1,
18      endLine: 1,
19      messageId: "bar",
20      data: {},
21    }, {
22      column: 7,
23      endColumn: 11,
24      line: 2,
25      endLine: 2,
26      messageId: "foo",
27      data: {
28        identifier: "role",
29      },
30    }]
31  }, {
32    code: `const name = "alice";
33const role = 'cto';`,
34    errors: [{
35      column: 7,
36      endColumn: 11,
37      line: 1,
38      endLine: 1,
39      messageId: "foo",
40      data: {
41        identifier: "name",
42      },
43    }, {
44      column: 7,
45      endColumn: 11,
46      line: 2,
47      endLine: 2,
48      messageId: "foo",
49      data: {
50        identifier: "role",
51      },
52    }],
53    options: [{
54      bar: false
55    }]
56  }]
57}

Specifying data in the fixture is optional. If it's omitted, data defaults to {}.

The second, optional, argument passed to fromFixture can be used to pass additional test case properties - options and output, etc.

Suggestions

A suggestions array can be passed to fromFixture via its second, optional parameter and, when passed, a suggest annotation can be used within the fixture, like this:

1fromFixture(stripIndent`
2  const a = "alice";
3            ~~~~~~~ [foo suggest]
4`, {
5  suggestions: [{
6    messageId: "suggestionForFoo",
7    output: "/* suggestion output goes here */"
8  }]
9}),

And it's possible to include multiple suggest annotations and suggestions in a single fixture:

1fromFixture(stripIndent`
2  const a = "alice";
3            ~~~~~~~ [foo suggest 0]
4  const b = "bob";
5            ~~~~~ [bar suggest 1]
6`, {
7  suggestions: [{
8    messageId: "suggestionForFoo",
9    output: "/* suggestion for foo output goes here */"
10  }, {
11    messageId: "suggestionForBar",
12    output: "/* suggestion for bar output goes here */"
13  }]
14}),

The suggest annotations work with the suggestions array in the following manner:

• If suggest is specified with no indices, all suggestions are associated with the annotated error.
• If suggest is specified with indices, suggestions at those indices are associated with the annotated error.
• If suggest is not specified, no suggestions are associated with the annotated error.
• And if suggestions are specified without a suggest annotation being used, fromFixture will throw an error.

And if the rule has both a fixer and suggestions, you can specify an output - for the fixer - in conjunction with a suggestions array:

1fromFixture(stripIndent`
2  const a = "alice";
3            ~~~~~~~ [foo suggest]
4`, {
5  output: "/* fixer output goes here */",
6  suggestions: [{
7    messageId: "suggestionForFoo",
8    output: "/* suggestion output goes here */"
9  }]
10}),