Tool to analyse/migrate .eslintrc.cjs and say which rules Rome has an equivalent of etc

[jpike88]

My .eslintrc.cjs looks like this:

module.exports = {
	env: {
		browser: true,
		es6: true,
	},
	extends: [
		'plugin:@typescript-eslint/recommended',
		'plugin:@typescript-eslint/recommended-requiring-type-checking',
	],
	ignorePatterns: ['*.js', 'node_modules/'],
	parserOptions: {
		project: [
			'./client/tsconfig.json',
			'./server/src/tsconfig.json',
			'./seed/src/tsconfig.json',
		],
		sourceType: 'module',
		warnOnUnsupportedTypeScriptVersion: false,
	},
	parser: '@typescript-eslint/parser',
	plugins: [
		'@typescript-eslint',
		'ban',
		'import',
		'jsdoc',
		'typescript-sort-keys',
		'regex',
	],
	rules: {
		'@typescript-eslint/adjacent-overload-signatures': 'error',
		'@typescript-eslint/ban-ts-ignore': 'off',
		'@typescript-eslint/array-type': [
			'error',
			{
				default: 'array-simple',
			},
		],
		'@typescript-eslint/camelcase': 'off',
		'@typescript-eslint/await-thenable': 'error',
		'typescript-sort-keys/string-enum': 'error',
		'@typescript-eslint/ban-types': 'off',
		'@typescript-eslint/no-unsafe-assignment': 'off',
		'@typescript-eslint/explicit-module-boundary-types': 'off',
		'@typescript-eslint/no-unsafe-call': 'off',
		'@typescript-eslint/ban-ts-comment': 'off',
		'@typescript-eslint/no-unsafe-member-access': 'off',
		'no-constant-condition': 'error',
		'no-duplicate-case': 'error',
		'@typescript-eslint/no-unsafe-return': 'off',
		'@typescript-eslint/naming-convention': [
			'error',
			{
				selector: 'class',
				format: ['PascalCase'],
			},
			{
				selector: 'enumMember',
				format: ['PascalCase'],
				custom: {
					regex: '[^A-z0-9]',
					match: false,
				},
			},
		],
		'@typescript-eslint/switch-exhaustiveness-check': 'error',
		'@typescript-eslint/consistent-type-assertions': 'error',
		indent: 'off',
		'@typescript-eslint/indent': [
			'error',
			'tab',
			{ FunctionDeclaration: { body: 2 } },
		],
		'@typescript-eslint/explicit-function-return-type': 'off',
		'@typescript-eslint/interface-name-prefix': 'off',
		'@typescript-eslint/unbound-method': 'off',
		'@typescript-eslint/member-delimiter-style': [
			'error',
			{
				multiline: {
					delimiter: 'semi',
					requireLast: true,
				},
				singleline: {
					delimiter: 'semi',
					requireLast: false,
				},
			},
		],
		'@typescript-eslint/member-ordering': 'off',
		'@typescript-eslint/no-empty-function': 'error',
		'@typescript-eslint/no-empty-interface': 'error',
		'@typescript-eslint/prefer-regexp-exec': 'off',
		'@typescript-eslint/no-explicit-any': 'off',
		'@typescript-eslint/no-misused-promises': [
			'error',
			{
				checksVoidReturn: false,
			},
		],
		'@typescript-eslint/no-misused-new': 'error',
		'@typescript-eslint/no-namespace': 'off',
		'@typescript-eslint/no-parameter-properties': 'off',
		'@typescript-eslint/no-use-before-define': 'off',
		'@typescript-eslint/no-unsafe-argument': 'off',
		'@typescript-eslint/no-var-requires': 'error',
		'@typescript-eslint/prefer-for-of': 'error',
		'@typescript-eslint/prefer-function-type': 'error',
		'@typescript-eslint/prefer-namespace-keyword': 'error',
		'ban/ban': [
			2,
			{
				name: ['*', 'forEach'],
				message: "Don't use foreach on an array, use forof",
			},
			{
				name: 'String',
				message: 'Use string primitive',
			},
			{
				name: 'Number',
				message: 'Use number primitive',
			},
			{
				name: 'Boolean',
				message: 'Use boolean primitive',
			},
			{
				name: ['Object', 'assign'],
				message: "Don't use Object.assign as it creates type ambiguity",
			},
			{
				name: ['*', 'waitForTimeout'],
				message:
					'waitForTimeout is not acceptable when writing tests, pinpoint why a delay is needed and wait for the right element to show or hide.',
			},
		],
		'@typescript-eslint/quotes': ['error', 'single', { avoidEscape: true }],
		'@typescript-eslint/semi': ['off'],
		'@typescript-eslint/triple-slash-reference': [
			'error',
			{
				path: 'always',
				types: 'prefer-import',
				lib: 'always',
			},
		],
		'@typescript-eslint/unified-signatures': 'error',
		'arrow-parens': ['off', 'always'],
		camelcase: 'off',
		'comma-dangle': 'off',
		complexity: 'off',
		'constructor-super': 'error',
		'dot-notation': 'error',
		eqeqeq: ['error', 'smart'],
		'guard-for-in': 'error',
		'id-blacklist': [
			'error',
			'any',
			'Number',
			'number',
			'String',
			'string',
			'Boolean',
			'boolean',
		],
		'no-underscore-dangle': ['error', { allow: ['_id'] }],
		'id-match': 'error',
		'import/no-deprecated': 'error',
		'import/order': 'off',
		'jsdoc/check-alignment': 'error',
		'jsdoc/check-indentation': 'error',
		'prefer-arrow-callback': 'error',
		'jsdoc/newline-after-description': 'error',
		'max-classes-per-file': 'off',
		'max-len': [
			'error',
			{
				ignorePattern: '\t',
				tabWidth: 1,
				ignoreStrings: true,
				code: 120,
			},
		],
		'new-parens': 'error',
		'no-bitwise': 'error',
		'no-caller': 'error',
		'prefer-spread': 'off',
		'@typescript-eslint/no-unused-vars': ['error', { argsIgnorePattern: '_' }],
		'no-cond-assign': 'error',
		'no-console': [
			'error',
			{
				allow: [
					'warn',
					'dir',
					'timeLog',
					'assert',
					'clear',
					'count',
					'countReset',
					'group',
					'groupEnd',
					'table',
					'info',
					'dirxml',
					'error',
					'groupCollapsed',
					'Console',
					'profile',
					'profileEnd',
					'timeStamp',
					'context',
				],
			},
		],
		'no-debugger': 'error',
		'no-empty': 'error',
		'no-unreachable': 'error',
		'no-eval': 'error',
		'no-fallthrough': 'off',
		'no-invalid-this': 'off',
		'no-multiple-empty-lines': 'error',
		'no-new-wrappers': 'error',
		'@typescript-eslint/indent': 'off',
		'no-restricted-imports': [
			'error',
			{
				paths: [
					'@angular/compiler/src/core',
					'@ngx-translate/core/public_api',
					{
						name: 'ag-grid-community',
						importNames: ['Environment'],
					},
				],
			},
		],
		'no-restricted-syntax': [
			'error',
			'ForInStatement',
			'AwaitExpression > AwaitExpression.argument',
			'ObjectExpression > SpreadElement',
		],
		'no-return-await': 'error',
		'no-shadow': [
			'off',
			{
				hoist: 'all',
			},
		],
		'no-throw-literal': 'off',
		'no-trailing-spaces': 'error',
		'no-undef-init': 'error',
		'no-underscore-dangle': 'off',
		'no-unsafe-finally': 'error',
		'no-unused-expressions': 'error',
		'no-unused-labels': 'error',
		'no-var': 'error',
		'object-shorthand': 'error',
		'one-var': ['error', 'never'],
		'prefer-const': 'error',
		'quote-props': ['error', 'consistent-as-needed'],
		radix: 'error',
		'space-before-function-paren': [
			'error',
			{
				anonymous: 'always',
				named: 'never',
				asyncArrow: 'always',
			},
		],
		'spaced-comment': [
			'error',
			'always',
			{
				markers: ['/'],
			},
		],
		'use-isnan': 'error',
		'valid-typeof': 'off',
		'regex/invalid': [
			'error',
			[
				{
					regex: "[A-z]\\['[\\w]+?-",
					message: 'Index references must not contain hyphens.',
				},
			],
		],
	},
};

It's very difficult to answer these questions right now:

• does Rome have rules which are identical/equivalent to my existing rules?
• do I use rules in eslint that Rome has not implemented yet?
• is there an easy way to migrate this ruleset to a configuration file for Rome?

Without such a tool, migrating to Rome would be a very difficult task with lots of unknowns. I think Rome will benefit from such a tool.

Eslint has 23M weekly downloads versus Rome having 15,000. I think a strategy geared specifically towards eslint market share would be a good idea for Rome

[MichaReiser]

You bring up many good pain points, and I really like your idea. It should be a breeze to migrate from eslint to Rome, particularly for projects only using the standard eslint rules.

[jeysal]

I agree that this could be a major adoption factor. I've written some migration docs this week in #3767 and for lint rules I pretty much just had to say "if you use ESLint recommended, our recommended will probably be fine, but if you're into customizing, hey here's our rules list" because anything else would have blown up the scope. But it would definitely be a good next step as the linter approaches feature parity.

Maybe as a first https://github.com/rome-community project? 🤔

[ematipico]

Interestingly, Rome classic already had some references to ESLint rules: https://github.com/rome/tools/blob/archived-js/website/src/docs/lint/rules/js/noFunctionAssign.md

We had the eslint-rule field

[jeysal]

Yeah integrating with core Rome instead of a community proj (which was just a random idea I spontaneously had 😄) would also have some advantages, like being able to colocate the ESLint equivalency information with our actual rule impls

[jpike88]

why not make it a submodule with its own tests? that way contributions can happen more rapidly

[jpike88]

@MichaReiser can you add me to community organisation, I’m keen to participate. I represent a worst case scenario dev, a guy with a big angular project with a solid eslint file and prettier. If it can handle me it will literally smoke eslint and prettier.

[ematipico]

We plan to have a command called auto-config, which will serve for this purpose. Unfortunately I can't give you a timeline for when it will be available.

The command would allow to pick up configuration from other tools like prettier, eslint, TypeScript, etc. and update the rome.json accordingly.

[jpike88]

Unrelated but maybe related: eslint/eslint#16557

[Conaclos]

In my view, ESLint is too much customizable and its defaults are not enough strict. I spend hours for reviewing every rule and tuning it. The burden of maintenance was terrible. I would like to avoid getting the same experience with Rome. I am expecting a linter that enables most of its rules (recommended rules) and that avoids providing too many settings. A user could still opt out of some rules.

Thus, in my view, the transition of ESLint to Rome should not be smooth if you extensively customized ESLint. Rome could provide a tool for migration and could report incompatibility.

[jpike88]

My eslint config file is above… please look carefully at each individual rule and tell me which one is useless or not a nice to have. I’ll listen.

[jeysal]

@jpike88 I think you missed the point, @Conaclos did not advocate for fewer rules or even fewer rules by default.

I agree with the general sentiment of @Conaclos suggestion, zero-config hype is over but convention over configuration with configuration kept simple is still good.

[jpike88]

We should not overlook one of the key things that made eslint ubiquitous. And that was the amount of customisability it had. And I use prettier with default settings. I appreciate the ability for something to just work. But coding conventions are a massive spectrum of things, any serious approach needs to bear that in mind or risking a large portion of developers who are (rightly) discerning about what kind of linting restrictions they want to enforce on their code. Loosely generally, more is better, leading to more robust code. Eslint should continue to allow for that or risk something else eating it’s lunch.

[Conaclos]

The point is not to argue whether the configurations you chose are good or not.

The point is that I would like Rome to be the Prettier of linter: good defaults with reasonable configurations. ESLint has chosen the path of configuring everything. Rome doesn't need to choose the same path. In my opinion, the "everything is customizable" is a bad experience and provides fragmentation. I agree that we need some configuration to accommodate the more controversial rules (which is why I've always advocated adding semicolons, quote, and indents parameters for the formatter).

For instance, for the parameter-properties, why allow configuring which parameter property is allowed? A rule that prohibits them seems better and simpler.

Bringing in some standardization, like Rust Clippy did for example, is the way to go in my opinion. And I might advocate strict defaults (thus enabling most of the rules provided). Excluding rules from the recommended category makes them almost useless for the community. I could compare it to a strong type checker that defaults to a weak typing.