Add prefer-replace-all rule

docs/rules/prefer-replace-all.md

@@ -0,0 +1,24 @@
+# Prefer `String.prototype.replaceAll` over regex searches with the global flag.
+
+As the replaceAll method is being added to strings, there is no reason to use expensive regex searches when the search string is a string-literal.
+
+This rule is fixable.
+
+
+## Fail
+
+```js
+str.replace(/This has no special regex symbols/g, 'something');
+str.replace(/\(It also checks for escaped regex symbols\)/g, 'something');
+
+```
+
+
+## Pass
+
+```js
+str.replace(/Non-literal characters .*/g, 'something');
+str.replace(/Extra flags/gi, 'something');
+str.replace('Not a regex expression', 'something')
+str.replaceAll('literal characters only', 'something');
+```

index.js

@@ -55,6 +55,7 @@ module.exports = {
 				'unicorn/prefer-node-remove': 'error',
 				'unicorn/prefer-query-selector': 'error',
 				'unicorn/prefer-reflect-apply': 'error',
+				'unicorn/prefer-replace-all': 'off',
 				'unicorn/prefer-spread': 'error',
 				'unicorn/prefer-starts-ends-with': 'error',
 				'unicorn/prefer-string-slice': 'error',

readme.md

@@ -73,6 +73,7 @@ Configure it in `package.json`.
 			"unicorn/prefer-node-remove": "error",
 			"unicorn/prefer-query-selector": "error",
 			"unicorn/prefer-reflect-apply": "error",
+			"unicorn/prefer-replace-all": "off",
 			"unicorn/prefer-spread": "error",
 			"unicorn/prefer-starts-ends-with": "error",
 			"unicorn/prefer-string-slice": "error",
@@ -127,6 +128,7 @@ Configure it in `package.json`.
 - [prefer-node-remove](docs/rules/prefer-node-remove.md) - Prefer `node.remove()` over `parentNode.removeChild(node)` and `parentElement.removeChild(node)`. *(fixable)*
 - [prefer-query-selector](docs/rules/prefer-query-selector.md) - Prefer `.querySelector()` over `.getElementById()`, `.querySelectorAll()` over `.getElementsByClassName()` and `.getElementsByTagName()`. *(partly fixable)*
 - [prefer-reflect-apply](docs/rules/prefer-reflect-apply.md) - Prefer `Reflect.apply()` over `Function#apply()`. *(fixable)*
+- [prefer-replace-all](docs/rules/prefer-replace-all.md) - Prefer `String.prototype.replaceAll` over regex searches with the global flag. *(fixable)*
 - [prefer-spread](docs/rules/prefer-spread.md) - Prefer the spread operator over `Array.from()`. *(fixable)*
 - [prefer-starts-ends-with](docs/rules/prefer-starts-ends-with.md) - Prefer `String#startsWith()` & `String#endsWith()` over more complex alternatives.
 - [prefer-string-slice](docs/rules/prefer-string-slice.md) - Prefer `String#slice()` over `String#substr()` and `String#substring()`. *(partly fixable)*

rules/prefer-replace-all.js

@@ -0,0 +1,56 @@
+'use strict';
+const getDocumentationUrl = require('./utils/get-documentation-url');
+
+function checkReplace(node) {
+	return node.callee.property.name === 'replace';
+}
+
+function checkGlobalFlag(node) {
+	const searchPattern = node.arguments[0];
+	return Object.prototype.hasOwnProperty.call(searchPattern, 'regex') && searchPattern.regex.flags === 'g';
+}
+
+function checkLiteralCharactersOnly(node) {
+	const searchPattern = node.arguments[0].regex.pattern;
+	const specialCharacters = searchPattern.match(/[$()*+.?[\\\]^{}]/g);
+	const specialCharactersCount = specialCharacters ? specialCharacters.length : 0;
+	const escapedSpecialCharacters = searchPattern.match(/\\[$()*+.?[\\\]^{}]/g);
+	const escapedSpecialCharactersCount = escapedSpecialCharacters ? escapedSpecialCharacters.length : 0;
+	return specialCharactersCount === 2 * escapedSpecialCharactersCount;
+}
+
+function replaceNode(node, fixer) {
+	const stringName = node.callee.object.name;
+	const searchPattern = node.arguments[0].regex.pattern.replace(/\\(.)/g, '$1');
+	const replacePattern = node.arguments[1].value;
+	return fixer.replaceText(node, stringName + '.replaceAll("' + searchPattern + '", "' + replacePattern + '")');
+}
+
+function checkNode(context, node) {
+	if (checkReplace(node) && checkGlobalFlag(node) && checkLiteralCharactersOnly(node)) {
+		context.report({
+			node,
+			message: 'Use replaceAll method of string.',
+			fix: fixer => replaceNode(node, fixer)
+		});
+	}
+}
+
+const create = context => {
+	return {
+		CallExpression: node => {
+			checkNode(context, node);
+		}
+	};
+};
+
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			url: getDocumentationUrl(__filename)
+		},
+		fixable: 'code'
+	}
+};

test/prefer-replace-all.js

@@ -0,0 +1,54 @@
+import test from 'ava';
+import avaRuleTester from 'eslint-ava-rule-tester';
+const rule = require('../rules/prefer-replace-all');
+
+//------------------------------------------------------------------------------
+// Tests
+//------------------------------------------------------------------------------
+
+const ruleTester = avaRuleTester(test, {
+	env: {
+		es6: true
+	}
+});
+
+const error = {
+	ruleId: 'prefer-replace-all',
+	message: 'Use replaceAll method of string.'
+};
+
+ruleTester.run('prefer-replace-all', rule, {
+	valid: [
+		'str.replace(/No global flag/,"123")',
+		'str.replace(/[abc]/g,"123")',
+		'str.replace(/abc?/g,"123")',
+		'str.replace(/Non-literal characters .*/g, "something");',
+		'str.replace(/Other non-literal \\W/g, "something");',
+
+		'str.replace(/Extra flags/gi, "something");',
+		'str.replace("Not a regex expression", "something")',
+		'str.foo(/Wrong method name/g, "something");'
+	],
+	invalid: [
+		{
+			code: 'str.replace(/This has no special regex symbols/g, "something")',
+			output: 'str.replaceAll("This has no special regex symbols", "something")',
+			errors: [error]
+		},
+		{
+			code: 'str.replace(/\\(It also checks for escaped regex symbols\\)/g,"something")',
+			output: 'str.replaceAll("(It also checks for escaped regex symbols)", "something")',
+			errors: [error]
+		},
+		{
+			code: 'str.replace(/a\\\\bc\\?/g,"123")',
+			output: 'str.replaceAll("a\\bc?", "123")',
+			errors: [error]
+		},
+		{
+			code: 'console.log(str.replace(/a\\\\bc\\?/g,"123"))',
+			output: 'console.log(str.replaceAll("a\\bc?", "123"))',
+			errors: [error]
+		}
+	]
+});