368 lines
11 KiB
JavaScript
368 lines
11 KiB
JavaScript
/**
|
|
* @fileoverview Rule to require or disallow line breaks inside braces.
|
|
* @author Toru Nagashima
|
|
* @deprecated in ESLint v8.53.0
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Requirements
|
|
//------------------------------------------------------------------------------
|
|
|
|
const astUtils = require('./utils/ast-utils');
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Helpers
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Schema objects.
|
|
const OPTION_VALUE = {
|
|
oneOf: [
|
|
{
|
|
enum: ['always', 'never'],
|
|
},
|
|
{
|
|
type: 'object',
|
|
properties: {
|
|
multiline: {
|
|
type: 'boolean',
|
|
},
|
|
minProperties: {
|
|
type: 'integer',
|
|
minimum: 0,
|
|
},
|
|
consistent: {
|
|
type: 'boolean',
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
minProperties: 1,
|
|
},
|
|
],
|
|
};
|
|
|
|
/**
|
|
* Normalizes a given option value.
|
|
* @param {string|Object|undefined} value An option value to parse.
|
|
* @returns {{multiline: boolean, minProperties: number, consistent: boolean}} Normalized option object.
|
|
*/
|
|
function normalizeOptionValue(value) {
|
|
let multiline = false;
|
|
let minProperties = Number.POSITIVE_INFINITY;
|
|
let consistent = false;
|
|
|
|
if (value) {
|
|
if (value === 'always') {
|
|
minProperties = 0;
|
|
} else if (value === 'never') {
|
|
minProperties = Number.POSITIVE_INFINITY;
|
|
} else {
|
|
multiline = Boolean(value.multiline);
|
|
minProperties = value.minProperties || Number.POSITIVE_INFINITY;
|
|
consistent = Boolean(value.consistent);
|
|
}
|
|
} else {
|
|
consistent = true;
|
|
}
|
|
|
|
return { multiline, minProperties, consistent };
|
|
}
|
|
|
|
/**
|
|
* Checks if a value is an object.
|
|
* @param {any} value The value to check
|
|
* @returns {boolean} `true` if the value is an object, otherwise `false`
|
|
*/
|
|
function isObject(value) {
|
|
return typeof value === 'object' && value !== null;
|
|
}
|
|
|
|
/**
|
|
* Checks if an option is a node-specific option
|
|
* @param {any} option The option to check
|
|
* @returns {boolean} `true` if the option is node-specific, otherwise `false`
|
|
*/
|
|
function isNodeSpecificOption(option) {
|
|
return isObject(option) || typeof option === 'string';
|
|
}
|
|
|
|
/**
|
|
* Normalizes a given option value.
|
|
* @param {string|Object|undefined} options An option value to parse.
|
|
* @returns {{
|
|
* ObjectExpression: {multiline: boolean, minProperties: number, consistent: boolean},
|
|
* ObjectPattern: {multiline: boolean, minProperties: number, consistent: boolean},
|
|
* ImportDeclaration: {multiline: boolean, minProperties: number, consistent: boolean},
|
|
* ExportNamedDeclaration : {multiline: boolean, minProperties: number, consistent: boolean}
|
|
* }} Normalized option object.
|
|
*/
|
|
function normalizeOptions(options) {
|
|
if (isObject(options) && Object.values(options).some(isNodeSpecificOption)) {
|
|
return {
|
|
ObjectExpression: normalizeOptionValue(options.ObjectExpression),
|
|
ObjectPattern: normalizeOptionValue(options.ObjectPattern),
|
|
ImportDeclaration: normalizeOptionValue(options.ImportDeclaration),
|
|
ExportNamedDeclaration: normalizeOptionValue(options.ExportDeclaration),
|
|
};
|
|
}
|
|
|
|
const value = normalizeOptionValue(options);
|
|
|
|
return {
|
|
ObjectExpression: value,
|
|
ObjectPattern: value,
|
|
ImportDeclaration: value,
|
|
ExportNamedDeclaration: value,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Determines if ObjectExpression, ObjectPattern, ImportDeclaration or ExportNamedDeclaration
|
|
* node needs to be checked for missing line breaks
|
|
* @param {ASTNode} node Node under inspection
|
|
* @param {Object} options option specific to node type
|
|
* @param {Token} first First object property
|
|
* @param {Token} last Last object property
|
|
* @returns {boolean} `true` if node needs to be checked for missing line breaks
|
|
*/
|
|
function areLineBreaksRequired(node, options, first, last) {
|
|
let objectProperties;
|
|
|
|
if (node.type === 'ObjectExpression' || node.type === 'ObjectPattern') {
|
|
objectProperties = node.properties;
|
|
} else {
|
|
// is ImportDeclaration or ExportNamedDeclaration
|
|
objectProperties = node.specifiers.filter(
|
|
(s) => s.type === 'ImportSpecifier' || s.type === 'ExportSpecifier'
|
|
);
|
|
}
|
|
|
|
return (
|
|
objectProperties.length >= options.minProperties ||
|
|
(options.multiline &&
|
|
objectProperties.length > 0 &&
|
|
first.loc.start.line !== last.loc.end.line)
|
|
);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Rule Definition
|
|
//------------------------------------------------------------------------------
|
|
|
|
/** @type {import('../types').Rule.RuleModule} */
|
|
module.exports = {
|
|
meta: {
|
|
deprecated: {
|
|
message: 'Formatting rules are being moved out of ESLint core.',
|
|
url: 'https://eslint.org/blog/2023/10/deprecating-formatting-rules/',
|
|
deprecatedSince: '8.53.0',
|
|
availableUntil: '10.0.0',
|
|
replacedBy: [
|
|
{
|
|
message:
|
|
'ESLint Stylistic now maintains deprecated stylistic core rules.',
|
|
url: 'https://eslint.style/guide/migration',
|
|
plugin: {
|
|
name: '@stylistic/eslint-plugin-js',
|
|
url: 'https://eslint.style/packages/js',
|
|
},
|
|
rule: {
|
|
name: 'object-curly-newline',
|
|
url: 'https://eslint.style/rules/js/object-curly-newline',
|
|
},
|
|
},
|
|
],
|
|
},
|
|
type: 'layout',
|
|
|
|
docs: {
|
|
description:
|
|
'Enforce consistent line breaks after opening and before closing braces',
|
|
recommended: false,
|
|
url: 'https://eslint.org/docs/latest/rules/object-curly-newline',
|
|
},
|
|
|
|
fixable: 'whitespace',
|
|
|
|
schema: [
|
|
{
|
|
oneOf: [
|
|
OPTION_VALUE,
|
|
{
|
|
type: 'object',
|
|
properties: {
|
|
ObjectExpression: OPTION_VALUE,
|
|
ObjectPattern: OPTION_VALUE,
|
|
ImportDeclaration: OPTION_VALUE,
|
|
ExportDeclaration: OPTION_VALUE,
|
|
},
|
|
additionalProperties: false,
|
|
minProperties: 1,
|
|
},
|
|
],
|
|
},
|
|
],
|
|
|
|
messages: {
|
|
unexpectedLinebreakBeforeClosingBrace:
|
|
'Unexpected line break before this closing brace.',
|
|
unexpectedLinebreakAfterOpeningBrace:
|
|
'Unexpected line break after this opening brace.',
|
|
expectedLinebreakBeforeClosingBrace:
|
|
'Expected a line break before this closing brace.',
|
|
expectedLinebreakAfterOpeningBrace:
|
|
'Expected a line break after this opening brace.',
|
|
},
|
|
},
|
|
|
|
create(context) {
|
|
const sourceCode = context.sourceCode;
|
|
const normalizedOptions = normalizeOptions(context.options[0]);
|
|
|
|
/**
|
|
* Reports a given node if it violated this rule.
|
|
* @param {ASTNode} node A node to check. This is an ObjectExpression, ObjectPattern, ImportDeclaration or ExportNamedDeclaration node.
|
|
* @returns {void}
|
|
*/
|
|
function check(node) {
|
|
const options = normalizedOptions[node.type];
|
|
|
|
if (
|
|
(node.type === 'ImportDeclaration' &&
|
|
!node.specifiers.some(
|
|
(specifier) => specifier.type === 'ImportSpecifier'
|
|
)) ||
|
|
(node.type === 'ExportNamedDeclaration' &&
|
|
!node.specifiers.some(
|
|
(specifier) => specifier.type === 'ExportSpecifier'
|
|
))
|
|
) {
|
|
return;
|
|
}
|
|
|
|
const openBrace = sourceCode.getFirstToken(
|
|
node,
|
|
(token) => token.value === '{'
|
|
);
|
|
|
|
let closeBrace;
|
|
|
|
if (node.typeAnnotation) {
|
|
closeBrace = sourceCode.getTokenBefore(node.typeAnnotation);
|
|
} else {
|
|
closeBrace = sourceCode.getLastToken(
|
|
node,
|
|
(token) => token.value === '}'
|
|
);
|
|
}
|
|
|
|
let first = sourceCode.getTokenAfter(openBrace, {
|
|
includeComments: true,
|
|
});
|
|
let last = sourceCode.getTokenBefore(closeBrace, {
|
|
includeComments: true,
|
|
});
|
|
|
|
const needsLineBreaks = areLineBreaksRequired(node, options, first, last);
|
|
|
|
const hasCommentsFirstToken = astUtils.isCommentToken(first);
|
|
const hasCommentsLastToken = astUtils.isCommentToken(last);
|
|
|
|
/*
|
|
* Use tokens or comments to check multiline or not.
|
|
* But use only tokens to check whether line breaks are needed.
|
|
* This allows:
|
|
* var obj = { // eslint-disable-line foo
|
|
* a: 1
|
|
* }
|
|
*/
|
|
first = sourceCode.getTokenAfter(openBrace);
|
|
last = sourceCode.getTokenBefore(closeBrace);
|
|
|
|
if (needsLineBreaks) {
|
|
if (astUtils.isTokenOnSameLine(openBrace, first)) {
|
|
context.report({
|
|
messageId: 'expectedLinebreakAfterOpeningBrace',
|
|
node,
|
|
loc: openBrace.loc,
|
|
fix(fixer) {
|
|
if (hasCommentsFirstToken) {
|
|
return null;
|
|
}
|
|
|
|
return fixer.insertTextAfter(openBrace, '\n');
|
|
},
|
|
});
|
|
}
|
|
if (astUtils.isTokenOnSameLine(last, closeBrace)) {
|
|
context.report({
|
|
messageId: 'expectedLinebreakBeforeClosingBrace',
|
|
node,
|
|
loc: closeBrace.loc,
|
|
fix(fixer) {
|
|
if (hasCommentsLastToken) {
|
|
return null;
|
|
}
|
|
|
|
return fixer.insertTextBefore(closeBrace, '\n');
|
|
},
|
|
});
|
|
}
|
|
} else {
|
|
const consistent = options.consistent;
|
|
const hasLineBreakBetweenOpenBraceAndFirst =
|
|
!astUtils.isTokenOnSameLine(openBrace, first);
|
|
const hasLineBreakBetweenCloseBraceAndLast =
|
|
!astUtils.isTokenOnSameLine(last, closeBrace);
|
|
|
|
if (
|
|
(!consistent && hasLineBreakBetweenOpenBraceAndFirst) ||
|
|
(consistent &&
|
|
hasLineBreakBetweenOpenBraceAndFirst &&
|
|
!hasLineBreakBetweenCloseBraceAndLast)
|
|
) {
|
|
context.report({
|
|
messageId: 'unexpectedLinebreakAfterOpeningBrace',
|
|
node,
|
|
loc: openBrace.loc,
|
|
fix(fixer) {
|
|
if (hasCommentsFirstToken) {
|
|
return null;
|
|
}
|
|
|
|
return fixer.removeRange([openBrace.range[1], first.range[0]]);
|
|
},
|
|
});
|
|
}
|
|
if (
|
|
(!consistent && hasLineBreakBetweenCloseBraceAndLast) ||
|
|
(consistent &&
|
|
!hasLineBreakBetweenOpenBraceAndFirst &&
|
|
hasLineBreakBetweenCloseBraceAndLast)
|
|
) {
|
|
context.report({
|
|
messageId: 'unexpectedLinebreakBeforeClosingBrace',
|
|
node,
|
|
loc: closeBrace.loc,
|
|
fix(fixer) {
|
|
if (hasCommentsLastToken) {
|
|
return null;
|
|
}
|
|
|
|
return fixer.removeRange([last.range[1], closeBrace.range[0]]);
|
|
},
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
return {
|
|
ObjectExpression: check,
|
|
ObjectPattern: check,
|
|
ImportDeclaration: check,
|
|
ExportNamedDeclaration: check,
|
|
};
|
|
},
|
|
};
|