Update style for rule fail/pass examples (1/5) (#2753)

Author: stephenwade

docs/rules/better-regex.md

@@ -9,28 +9,62 @@
 
 Note: This rule uses [`regexp-tree`](https://github.com/DmitrySoshnikov/regexp-tree) and [`clean-regexp`](https://github.com/samverschueren/clean-regexp) under the hood.
 
-## Fail
+## Examples
 
 ```js
+// ❌
 const regex = /[0-9]/;
-const regex = /[^0-9]/;
-const regex = /[a-zA-Z0-9_]/;
-const regex = /[a-z0-9_]/i;
-const regex = /[^a-zA-Z0-9_]/;
-const regex = /[^a-z0-9_]/i;
-const regex = /[0-9]\.[a-zA-Z0-9_]\-[^0-9]/i;
-```
 
-## Pass
+// ✅
+const regex = /\d/;
+```
 
 ```js
-const regex = /\d/;
+// ❌
+const regex = /[^0-9]/;
+
+// ✅
 const regex = /\D/;
+```
+
+```js
+// ❌
+const regex = /[a-zA-Z0-9_]/;
+
+// ✅
 const regex = /\w/;
+```
+
+```js
+// ❌
+const regex = /[a-z0-9_]/i;
+
+// ✅
 const regex = /\w/i;
+```
+
+```js
+// ❌
+const regex = /[^a-zA-Z0-9_]/;
+
+// ✅
 const regex = /\W/;
+```
+
+```js
+// ❌
+const regex = /[^a-z0-9_]/i;
+
+// ✅
 const regex = /\W/i;
-const regex = /\d\.\w\-\D/i;
+```
+
+```js
+// ❌
+const regex = /[0-9]\.[a-zA-Z0-9_]\-[^0-9]/i;
+
+// ✅
+const regex = /\d\.\w-\D/i;
 ```
 
 ## Options

docs/rules/catch-error-name.md

@@ -21,54 +21,52 @@ The following names are ignored:
 - Descriptive names, for example, `fsError` or `authError`.
 - Names matching [`options.ignore`](#ignore).
 
-## Fail
+## Examples
 
 ```js
+// ❌
 try {} catch (badName) {}
-```
 
-```js
-// `_` is not allowed if it's used
-try {} catch (_) {
-	console.log(_);
-}
+// ✅
+try {} catch (error) {}
 ```
 
 ```js
+// ❌
 promise.catch(badName => {});
-```
-
-```js
-promise.then(undefined, badName => {});
-```
-
-## Pass
 
-```js
-try {} catch (error) {}
-```
-
-```js
+// ✅
 promise.catch(error => {});
 ```
 
 ```js
+// ❌
+promise.then(undefined, badName => {});
+
+// ✅
 promise.then(undefined, error => {});
 ```
 
 ```js
-// `_` is allowed when it's not used
+// ❌
+try {} catch (_) {
+	console.log(_);
+}
+
+// ✅
 try {} catch (_) {
 	console.log(foo);
 }
 ```
 
 ```js
+// ✅
 // Descriptive name is allowed
 try {} catch (fsError) {}
 ```
 
 ```js
+// ✅
 // `error_` is allowed because of shadowed variables
 try {} catch (error_) {
 	const error = new Error('🦄');

docs/rules/consistent-assert.md

@@ -18,7 +18,7 @@ assert.strictEqual(actual, expected);
 assert.deepStrictEqual(actual, expected);
 
 // ❌
-assert(divide(10, 2) === 5); // Inconsistent with other API styles
+assert(divide(10, 2) === 5);
 
 // ✅
 assert.ok(divide(10, 2) === 5);
@@ -31,7 +31,7 @@ assert.strictEqual(actual, expected);
 assert.deepStrictEqual(actual, expected);
 
 // ❌
-assert(divide(10, 2) === 5); // Inconsistent with other API styles
+assert(divide(10, 2) === 5);
 
 // ✅
 assert.ok(divide(10, 2) === 5);
@@ -44,7 +44,7 @@ assert.strictEqual(actual, expected);
 assert.deepStrictEqual(actual, expected);
 
 // ❌
-assert(divide(10, 2) === 5); // Inconsistent with other API styles
+assert(divide(10, 2) === 5);
 
 // ✅
 assert.ok(divide(10, 2) === 5);

docs/rules/consistent-destructuring.md

@@ -11,49 +11,57 @@ Enforces the use of already destructured objects and their variables over access
 
 This rule is partly fixable. It does not fix nested destructuring.
 
-## Fail
+## Examples
 
 ```js
+// ❌
 const {a} = foo;
 console.log(a, foo.b);
+
+// ✅
+const {a, b} = foo;
+console.log(a, b);
+
+// ✅
+console.log(foo.a, foo.b);
 ```
 
 ```js
+// ❌
 const {a} = foo;
 console.log(foo.a);
+
+// ✅
+const {a} = foo;
+console.log(a);
 ```
 
 ```js
+// ❌
 const {
-	a: {
-		b
-	}
+	a: {b},
 } = foo;
 console.log(foo.a.c);
 ```
 
 ```js
+// ❌
 const {bar} = foo;
 const {a} = foo.bar;
-```
-
-## Pass
 
-```js
-const {a} = foo;
-console.log(a);
-```
-
-```js
-console.log(foo.a, foo.b);
+// ✅
+const {bar} = foo;
+const {a} = bar;
 ```
 
 ```js
+// ✅
 const {a} = foo;
 console.log(a, foo.b());
 ```
 
 ```js
+// ✅
 const {a} = foo.bar;
 console.log(foo.bar);
 ```

docs/rules/consistent-empty-array-spread.md

@@ -9,32 +9,28 @@
 
 When spreading a ternary in an array, we can use both `[]` and `''` as fallbacks, but it's better to have consistent types in both branches.
 
-## Fail
+## Examples
 
 ```js
+// ❌
 const array = [
 	a,
 	...(foo ? [b, c] : ''),
 ];
-```
 
-```js
+// ❌
 const array = [
 	a,
 	...(foo ? 'bc' : []),
 ];
-```
-
-## Pass
 
-```js
+// ✅
 const array = [
 	a,
 	...(foo ? [b, c] : []),
 ];
-```
 
-```js
+// ✅
 const array = [
 	a,
 	...(foo ? 'bc' : ''),

docs/rules/consistent-function-scoping.md

@@ -7,9 +7,10 @@
 
 A function definition should be placed as close to the top-level scope as possible without breaking its captured values. This improves readability, [directly improves performance](https://stackoverflow.com/a/81329/207247) and allows JavaScript engines to [better optimize performance](https://ponyfoo.com/articles/javascript-performance-pitfalls-v8#optimization-limit).
 
-## Fail
+## Examples
 
 ```js
+// ❌
 export function doFoo(foo) {
 	// Does not capture anything from the scope, can be moved to the outer scope
 	function doBar(bar) {
@@ -19,24 +20,34 @@ export function doFoo(foo) {
 	return doBar;
 }
 
+// ✅
+function doBar(bar) {
+	return bar === 'bar';
+}
+
+export function doFoo(foo) {
+	return doBar;
+}
+```
+
+```js
+// ❌
 function doFoo(foo) {
 	const doBar = bar => {
 		return bar === 'bar';
 	};
 }
-```
 
-## Pass
-
-```js
-function doBar(bar) {
+// ✅
+const doBar = bar => {
 	return bar === 'bar';
-}
+};
 
-export function doFoo(foo) {
-	return doBar;
-}
+function doFoo(foo) {}
+```
 
+```js
+// ✅
 export function doFoo(foo) {
 	function doBar(bar) {
 		return bar === 'bar' && foo.doBar(bar);