]>
Commit | Line | Data |
---|---|---|
eb39fafa DC |
1 | /** |
2 | * @fileoverview enforce consistent line breaks inside function parentheses | |
3 | * @author Teddy Katz | |
4 | */ | |
5 | "use strict"; | |
6 | ||
7 | //------------------------------------------------------------------------------ | |
8 | // Requirements | |
9 | //------------------------------------------------------------------------------ | |
10 | ||
11 | const astUtils = require("./utils/ast-utils"); | |
12 | ||
13 | //------------------------------------------------------------------------------ | |
14 | // Rule Definition | |
15 | //------------------------------------------------------------------------------ | |
16 | ||
34eeec05 | 17 | /** @type {import('../shared/types').Rule} */ |
eb39fafa DC |
18 | module.exports = { |
19 | meta: { | |
20 | type: "layout", | |
21 | ||
22 | docs: { | |
23 | description: "enforce consistent line breaks inside function parentheses", | |
eb39fafa DC |
24 | recommended: false, |
25 | url: "https://eslint.org/docs/rules/function-paren-newline" | |
26 | }, | |
27 | ||
28 | fixable: "whitespace", | |
29 | ||
30 | schema: [ | |
31 | { | |
32 | oneOf: [ | |
33 | { | |
34 | enum: ["always", "never", "consistent", "multiline", "multiline-arguments"] | |
35 | }, | |
36 | { | |
37 | type: "object", | |
38 | properties: { | |
39 | minItems: { | |
40 | type: "integer", | |
41 | minimum: 0 | |
42 | } | |
43 | }, | |
44 | additionalProperties: false | |
45 | } | |
46 | ] | |
47 | } | |
48 | ], | |
49 | ||
50 | messages: { | |
51 | expectedBefore: "Expected newline before ')'.", | |
52 | expectedAfter: "Expected newline after '('.", | |
53 | expectedBetween: "Expected newline between arguments/params.", | |
54 | unexpectedBefore: "Unexpected newline before ')'.", | |
55 | unexpectedAfter: "Unexpected newline after '('." | |
56 | } | |
57 | }, | |
58 | ||
59 | create(context) { | |
60 | const sourceCode = context.getSourceCode(); | |
61 | const rawOption = context.options[0] || "multiline"; | |
62 | const multilineOption = rawOption === "multiline"; | |
63 | const multilineArgumentsOption = rawOption === "multiline-arguments"; | |
64 | const consistentOption = rawOption === "consistent"; | |
65 | let minItems; | |
66 | ||
67 | if (typeof rawOption === "object") { | |
68 | minItems = rawOption.minItems; | |
69 | } else if (rawOption === "always") { | |
70 | minItems = 0; | |
71 | } else if (rawOption === "never") { | |
72 | minItems = Infinity; | |
73 | } else { | |
74 | minItems = null; | |
75 | } | |
76 | ||
77 | //---------------------------------------------------------------------- | |
78 | // Helpers | |
79 | //---------------------------------------------------------------------- | |
80 | ||
81 | /** | |
82 | * Determines whether there should be newlines inside function parens | |
83 | * @param {ASTNode[]} elements The arguments or parameters in the list | |
84 | * @param {boolean} hasLeftNewline `true` if the left paren has a newline in the current code. | |
85 | * @returns {boolean} `true` if there should be newlines inside the function parens | |
86 | */ | |
87 | function shouldHaveNewlines(elements, hasLeftNewline) { | |
88 | if (multilineArgumentsOption && elements.length === 1) { | |
89 | return hasLeftNewline; | |
90 | } | |
91 | if (multilineOption || multilineArgumentsOption) { | |
92 | return elements.some((element, index) => index !== elements.length - 1 && element.loc.end.line !== elements[index + 1].loc.start.line); | |
93 | } | |
94 | if (consistentOption) { | |
95 | return hasLeftNewline; | |
96 | } | |
97 | return elements.length >= minItems; | |
98 | } | |
99 | ||
100 | /** | |
101 | * Validates parens | |
102 | * @param {Object} parens An object with keys `leftParen` for the left paren token, and `rightParen` for the right paren token | |
103 | * @param {ASTNode[]} elements The arguments or parameters in the list | |
104 | * @returns {void} | |
105 | */ | |
106 | function validateParens(parens, elements) { | |
107 | const leftParen = parens.leftParen; | |
108 | const rightParen = parens.rightParen; | |
109 | const tokenAfterLeftParen = sourceCode.getTokenAfter(leftParen); | |
110 | const tokenBeforeRightParen = sourceCode.getTokenBefore(rightParen); | |
111 | const hasLeftNewline = !astUtils.isTokenOnSameLine(leftParen, tokenAfterLeftParen); | |
112 | const hasRightNewline = !astUtils.isTokenOnSameLine(tokenBeforeRightParen, rightParen); | |
113 | const needsNewlines = shouldHaveNewlines(elements, hasLeftNewline); | |
114 | ||
115 | if (hasLeftNewline && !needsNewlines) { | |
116 | context.report({ | |
117 | node: leftParen, | |
118 | messageId: "unexpectedAfter", | |
119 | fix(fixer) { | |
120 | return sourceCode.getText().slice(leftParen.range[1], tokenAfterLeftParen.range[0]).trim() | |
121 | ||
122 | // If there is a comment between the ( and the first element, don't do a fix. | |
123 | ? null | |
124 | : fixer.removeRange([leftParen.range[1], tokenAfterLeftParen.range[0]]); | |
125 | } | |
126 | }); | |
127 | } else if (!hasLeftNewline && needsNewlines) { | |
128 | context.report({ | |
129 | node: leftParen, | |
130 | messageId: "expectedAfter", | |
131 | fix: fixer => fixer.insertTextAfter(leftParen, "\n") | |
132 | }); | |
133 | } | |
134 | ||
135 | if (hasRightNewline && !needsNewlines) { | |
136 | context.report({ | |
137 | node: rightParen, | |
138 | messageId: "unexpectedBefore", | |
139 | fix(fixer) { | |
140 | return sourceCode.getText().slice(tokenBeforeRightParen.range[1], rightParen.range[0]).trim() | |
141 | ||
142 | // If there is a comment between the last element and the ), don't do a fix. | |
143 | ? null | |
144 | : fixer.removeRange([tokenBeforeRightParen.range[1], rightParen.range[0]]); | |
145 | } | |
146 | }); | |
147 | } else if (!hasRightNewline && needsNewlines) { | |
148 | context.report({ | |
149 | node: rightParen, | |
150 | messageId: "expectedBefore", | |
151 | fix: fixer => fixer.insertTextBefore(rightParen, "\n") | |
152 | }); | |
153 | } | |
154 | } | |
155 | ||
156 | /** | |
157 | * Validates a list of arguments or parameters | |
158 | * @param {Object} parens An object with keys `leftParen` for the left paren token, and `rightParen` for the right paren token | |
159 | * @param {ASTNode[]} elements The arguments or parameters in the list | |
160 | * @returns {void} | |
161 | */ | |
162 | function validateArguments(parens, elements) { | |
163 | const leftParen = parens.leftParen; | |
164 | const tokenAfterLeftParen = sourceCode.getTokenAfter(leftParen); | |
165 | const hasLeftNewline = !astUtils.isTokenOnSameLine(leftParen, tokenAfterLeftParen); | |
166 | const needsNewlines = shouldHaveNewlines(elements, hasLeftNewline); | |
167 | ||
168 | for (let i = 0; i <= elements.length - 2; i++) { | |
169 | const currentElement = elements[i]; | |
170 | const nextElement = elements[i + 1]; | |
171 | const hasNewLine = currentElement.loc.end.line !== nextElement.loc.start.line; | |
172 | ||
173 | if (!hasNewLine && needsNewlines) { | |
174 | context.report({ | |
175 | node: currentElement, | |
176 | messageId: "expectedBetween", | |
177 | fix: fixer => fixer.insertTextBefore(nextElement, "\n") | |
178 | }); | |
179 | } | |
180 | } | |
181 | } | |
182 | ||
183 | /** | |
184 | * Gets the left paren and right paren tokens of a node. | |
185 | * @param {ASTNode} node The node with parens | |
609c276f | 186 | * @throws {TypeError} Unexecpted node type. |
eb39fafa DC |
187 | * @returns {Object} An object with keys `leftParen` for the left paren token, and `rightParen` for the right paren token. |
188 | * Can also return `null` if an expression has no parens (e.g. a NewExpression with no arguments, or an ArrowFunctionExpression | |
189 | * with a single parameter) | |
190 | */ | |
191 | function getParenTokens(node) { | |
192 | switch (node.type) { | |
193 | case "NewExpression": | |
194 | if (!node.arguments.length && !( | |
195 | astUtils.isOpeningParenToken(sourceCode.getLastToken(node, { skip: 1 })) && | |
196 | astUtils.isClosingParenToken(sourceCode.getLastToken(node)) | |
197 | )) { | |
198 | ||
199 | // If the NewExpression does not have parens (e.g. `new Foo`), return null. | |
200 | return null; | |
201 | } | |
202 | ||
203 | // falls through | |
204 | ||
205 | case "CallExpression": | |
206 | return { | |
207 | leftParen: sourceCode.getTokenAfter(node.callee, astUtils.isOpeningParenToken), | |
208 | rightParen: sourceCode.getLastToken(node) | |
209 | }; | |
210 | ||
211 | case "FunctionDeclaration": | |
212 | case "FunctionExpression": { | |
213 | const leftParen = sourceCode.getFirstToken(node, astUtils.isOpeningParenToken); | |
214 | const rightParen = node.params.length | |
215 | ? sourceCode.getTokenAfter(node.params[node.params.length - 1], astUtils.isClosingParenToken) | |
216 | : sourceCode.getTokenAfter(leftParen); | |
217 | ||
218 | return { leftParen, rightParen }; | |
219 | } | |
220 | ||
221 | case "ArrowFunctionExpression": { | |
6f036462 | 222 | const firstToken = sourceCode.getFirstToken(node, { skip: (node.async ? 1 : 0) }); |
eb39fafa DC |
223 | |
224 | if (!astUtils.isOpeningParenToken(firstToken)) { | |
225 | ||
226 | // If the ArrowFunctionExpression has a single param without parens, return null. | |
227 | return null; | |
228 | } | |
229 | ||
230 | return { | |
231 | leftParen: firstToken, | |
232 | rightParen: sourceCode.getTokenBefore(node.body, astUtils.isClosingParenToken) | |
233 | }; | |
234 | } | |
235 | ||
236 | case "ImportExpression": { | |
237 | const leftParen = sourceCode.getFirstToken(node, 1); | |
238 | const rightParen = sourceCode.getLastToken(node); | |
239 | ||
240 | return { leftParen, rightParen }; | |
241 | } | |
242 | ||
243 | default: | |
244 | throw new TypeError(`unexpected node with type ${node.type}`); | |
245 | } | |
246 | } | |
247 | ||
248 | //---------------------------------------------------------------------- | |
249 | // Public | |
250 | //---------------------------------------------------------------------- | |
251 | ||
252 | return { | |
253 | [[ | |
254 | "ArrowFunctionExpression", | |
255 | "CallExpression", | |
256 | "FunctionDeclaration", | |
257 | "FunctionExpression", | |
258 | "ImportExpression", | |
259 | "NewExpression" | |
260 | ]](node) { | |
261 | const parens = getParenTokens(node); | |
262 | let params; | |
263 | ||
264 | if (node.type === "ImportExpression") { | |
265 | params = [node.source]; | |
266 | } else if (astUtils.isFunction(node)) { | |
267 | params = node.params; | |
268 | } else { | |
269 | params = node.arguments; | |
270 | } | |
271 | ||
272 | if (parens) { | |
273 | validateParens(parens, params); | |
274 | ||
275 | if (multilineArgumentsOption) { | |
276 | validateArguments(parens, params); | |
277 | } | |
278 | } | |
279 | } | |
280 | }; | |
281 | } | |
282 | }; |