Add prefer-starts-ends-with rule - fixes #13 (#64)

Author: anglee

docs/rules/prefer-starts-ends-with.md

@@ -0,0 +1,19 @@
+# Prefer `String#startsWidth` & `String#endsWidth` over more complex alternatives
+
+There are several ways of checking whether a string starts or ends with a certain string, such as `string.indexOf('foo') === 0` or using regexes with `/^foo/` or `/foo$/`. ES2015 introduced simpler alternatives named [`String#startsWith`](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith) and [`String#endsWith`](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith). This rule enforces the use of those whenever possible.
+
+
+## Fail
+
+```js
+/^bar/.test(foo);
+/bar$/.test(foo);
+```
+
+
+## Pass
+
+```js
+foo.startsWith('bar');
+foo.endsWith('bar');
+```

index.js

@@ -24,7 +24,8 @@ module.exports = {
 				'unicorn/no-array-instanceof': 'error',
 				'unicorn/no-new-buffer': 'error',
 				'unicorn/no-hex-escape': 'error',
-				'unicorn/custom-error-definition': 'error'
+				'unicorn/custom-error-definition': 'error',
+				'unicorn/prefer-starts-ends-with': 'error'
 			}
 		}
 	}

readme.md

@@ -44,7 +44,8 @@ Configure it in `package.json`.
 			"unicorn/no-array-instanceof": "error",
 			"unicorn/no-new-buffer": "error",
 			"unicorn/no-hex-escape": "error",
-			"unicorn/custom-error-definition": "error"
+			"unicorn/custom-error-definition": "error",
+			"unicorn/prefer-starts-ends-with": "error"
 		}
 	}
 }
@@ -65,6 +66,7 @@ Configure it in `package.json`.
 - [no-new-buffer](docs/rules/no-new-buffer.md) - Enforce the use of `Buffer.from()` and `Buffer.alloc()` instead of the deprecated `new Buffer()`. *(fixable)*
 - [no-hex-escape](docs/rules/no-hex-escape.md) - Enforce the use of unicode escapes instead of hexadecimal escapes. *(fixable)*
 - [custom-error-definition](docs/rules/custom-error-definition.md) - Enforces the only valid way of `Error` subclassing. *(fixable)*
+- [prefer-starts-ends-with](docs/rules/prefer-starts-ends-with.md) - Prefer `String#startsWidth` & `String#endsWidth` over more complex alternatives.
 
 
 ## Recommended config

rules/prefer-starts-ends-with.js

@@ -0,0 +1,48 @@
+'use strict';
+const doesNotContain = (string, chars) => chars.every(char => !string.includes(char));
+
+const isSimpleString = string => doesNotContain(
+	string,
+	['^', '$', '+', '[', '{', '(', '\\', '.', '?', '*']
+);
+
+const create = context => {
+	return {
+		CallExpression(node) {
+			const callee = node.callee;
+			const args = node.arguments;
+
+			let regex;
+			if (callee.property.name === 'test' && callee.object.regex) {
+				regex = callee.object.regex;
+			} else if (callee.property.name === 'match' && args && args[0] && args[0].regex) {
+				regex = args[0].regex;
+			} else {
+				return;
+			}
+
+			if (regex.flags && regex.flags.includes('i')) {
+				return;
+			}
+
+			const pattern = regex.pattern;
+			if (pattern.startsWith('^') && isSimpleString(pattern.slice(1))) {
+				context.report({
+					node,
+					message: 'Prefer `String#startsWith` over a regex with `^`.'
+				});
+			} else if (pattern.endsWith('$') && isSimpleString(pattern.slice(0, -1))) {
+				context.report({
+					node,
+					message: 'Prefer `String#endsWith` over a regex with `$`.'
+				});
+			}
+		}
+	};
+};
+
+module.exports = {
+	create,
+	meta: {}
+};
+

test/prefer-starts-ends-with.js

@@ -0,0 +1,62 @@
+import test from 'ava';
+import avaRuleTester from 'eslint-ava-rule-tester';
+import rule from '../rules/prefer-starts-ends-with';
+
+const ruleTester = avaRuleTester(test, {
+	env: {
+		es6: true
+	}
+});
+
+const errors = {
+	startsWith: [{
+		ruleId: 'prefer-starts-ends-with',
+		message: 'Prefer `String#startsWith` over a regex with `^`.'
+	}],
+	endsWith: [{
+		ruleId: 'prefer-starts-ends-with',
+		message: 'Prefer `String#endsWith` over a regex with `$`.'
+	}]
+};
+
+const validRegex = [
+	/foo/,
+	/^foo$/,
+	/^foo+/,
+	/foo+$/,
+	/^[f,a]/,
+	/[f,a]$/,
+	/^\w/,
+	/\w$/,
+	/^foo./,
+	/foo.$/,
+	/\^foo/,
+	/^foo/i
+];
+
+const invalidRegex = [
+	/^foo/,
+	/foo$/,
+	/^!/,
+	/!$/,
+	/^ /,
+	/ $/
+];
+
+ruleTester.run('prefer-starts-ends-with', rule, {
+	valid: [
+		'foo.startsWith("bar")',
+		'foo.endsWith("bar")'
+	]
+		.concat(validRegex.map(re => `${re}.test(bar)`))
+		.concat(validRegex.map(re => `bar.match(${re})`)),
+	invalid: []
+		.concat(invalidRegex.map(re => ({
+			code: `${re}.test(bar)`,
+			errors: errors[`${re}`.startsWith('/^') ? 'startsWith' : 'endsWith']
+		})))
+		.concat(invalidRegex.map(re => ({
+			code: `bar.match(${re})`,
+			errors: errors[`${re}`.startsWith('/^') ? 'startsWith' : 'endsWith']
+		})))
+});