Update style for rule fail/pass examples (3/5) (#2755)

Author: stephenwade

docs/rules/no-unreadable-iife.md

@@ -7,29 +7,28 @@
 
 [IIFE](https://en.wikipedia.org/wiki/Immediately_invoked_function_expression) with parenthesized arrow function body is considered unreadable.
 
-## Fail
+## Examples
 
 ```js
+// ❌
 const foo = (bar => (bar ? bar.baz : baz))(getBar());
-```
 
-```js
-const foo = ((bar, baz) => ({bar, baz}))(bar, baz);
-```
-
-## Pass
-
-```js
+// ✅
 const bar = getBar();
 const foo = bar ? bar.baz : baz;
-```
 
-```js
+// ✅
 const getBaz = bar => (bar ? bar.baz : baz);
 const foo = getBaz(getBar());
 ```
 
 ```js
+// ❌
+const foo = ((bar, baz) => ({bar, baz}))(bar, baz);
+```
+
+```js
+// ✅
 const foo = (bar => {
 	return bar ? bar.baz : baz;
 })(getBar());

docs/rules/no-unused-properties.md

@@ -32,32 +32,32 @@ const ClassName = {
 };
 ```
 
-## Fail
+## Examples
 
 ```js
-const enum = {
+// ❌
+const myEnum = {
 	used: 1,
-	unused: 2 // <- Property `unused` is defined but never used.
+	unused: 2, // <- Property `unused` is defined but never used.
 };
 
-console.log(enum.used);
+console.log(myEnum.used);
 
-const {used} = enum;
+const {used} = myEnum;
 ```
 
-## Pass
-
 ```js
-const enum = {
+// ✅
+const myEnum = {
 	used: 1,
-	usedToo: 2
+	usedToo: 2,
 };
 
-console.log(enum); // The whole object is used
+console.log(myEnum); // The whole object is used
 
-console.log(enum.used, enum.usedToo); // Every property is used individually
+console.log(myEnum.used, myEnum.usedToo); // Every property is used individually
 
-enum[x] // Unpredictable, all properties are considered to be used
+myEnum[x] // Unpredictable, all properties are considered to be used
 
 // Objects with methods are skipped too, all properties are considered used
 const foo = {

docs/rules/no-useless-error-capture-stack-trace.md

@@ -12,19 +12,54 @@ Calling [`Error.captureStackTrace(…)`](https://developer.mozilla.org/en-US/doc
 ## Examples
 
 ```js
+// ❌
 class MyError extends Error {
 	constructor() {
-		// ❌
 		Error.captureStackTrace(this, MyError);
-		// ❌
+	}
+}
+```
+
+```js
+// ❌
+class MyError extends Error {
+	constructor() {
 		Error.captureStackTrace?.(this, MyError);
-		// ❌
+	}
+}
+```
+
+```js
+// ❌
+class MyError extends Error {
+	constructor() {
 		Error.captureStackTrace(this, this.constructor);
-		// ❌
+	}
+}
+```
+
+```js
+// ❌
+class MyError extends Error {
+	constructor() {
 		Error.captureStackTrace?.(this, this.constructor);
-		// ❌
+	}
+}
+```
+
+```js
+// ❌
+class MyError extends Error {
+	constructor() {
 		Error.captureStackTrace(this, new.target);
-		// ❌
+	}
+}
+```
+
+```js
+// ❌
+class MyError extends Error {
+	constructor() {
 		Error.captureStackTrace?.(this, new.target);
 	}
 }

docs/rules/no-useless-fallback-in-spread.md

@@ -9,26 +9,25 @@
 
 Spreading [falsy values](https://developer.mozilla.org/en-US/docs/Glossary/Falsy) in object literals won't add any unexpected properties, so it's unnecessary to add an empty object as fallback.
 
-## Fail
+## Examples
 
 ```js
+// ❌
 const object = {...(foo || {})};
-```
 
-```js
+// ❌
 const object = {...(foo ?? {})};
-```
 
-## Pass
-
-```js
+// ✅
 const object = {...foo};
 ```
 
 ```js
+// ✅
 const object = {...(foo && {})};
 ```
 
 ```js
+// ✅
 const array = [...(foo || [])];
 ```

docs/rules/no-useless-length-check.md

@@ -12,46 +12,48 @@
 
 We only check `.length === 0`, `.length !== 0`, and `.length > 0`. These zero and non-zero length check styles are allowed in the [`unicorn/explicit-length-check`](./explicit-length-check.md#options) rule. It is recommended to use them together.
 
-## Fail
+## Examples
 
 ```js
+// ❌
 if (array.length === 0 || array.every(Boolean));
 ```
 
 ```js
+// ❌
 if (array.length !== 0 && array.some(Boolean));
-```
-
-```js
-if (array.length > 0 && array.some(Boolean));
-```
 
-```js
-const isAllTrulyOrEmpty = array.length === 0 || array.every(Boolean);
-```
-
-## Pass
-
-```js
+// ✅
 if (array.every(Boolean));
 ```
 
 ```js
+// ❌
+if (array.length > 0 && array.some(Boolean));
+
+// ✅
 if (array.some(Boolean));
 ```
 
 ```js
+// ❌
+const isAllTrulyOrEmpty = array.length === 0 || array.every(Boolean);
+
+// ✅
 const isAllTrulyOrEmpty = array.every(Boolean);
 ```
 
 ```js
+// ✅
 if (array.length === 0 || anotherCheck() || array.every(Boolean));
 ```
 
 ```js
+// ✅
 const isNonEmptyAllTrulyArray = array.length > 0 && array.every(Boolean);
 ```
 
 ```js
+// ✅
 const isEmptyArrayOrAllTruly = array.length === 0 || array.some(Boolean);
 ```

docs/rules/no-useless-promise-resolve-reject.md

@@ -9,9 +9,10 @@
 
 Wrapping a return value in `Promise.resolve` in an async function or a `Promise#then`/`catch`/`finally` callback is unnecessary as all return values in async functions and promise callback functions are already wrapped in a `Promise`. Similarly, returning an error wrapped in `Promise.reject` is equivalent to simply `throw`ing the error. This is the same for `yield`ing in async generators as well.
 
-## Fail
+## Examples
 
 ```js
+// ❌
 const main = async foo => {
 	if (foo > 4) {
 		return Promise.reject(new Error('🤪'));
@@ -20,40 +21,43 @@ const main = async foo => {
 	return Promise.resolve(result);
 };
 
+// ✅
+const main = async foo => {
+	if (foo > 4) {
+		throw new Error('🤪');
+	}
+
+	return result;
+};
+```
+
+```js
+// ❌
 async function * generator() {
 	yield Promise.resolve(result);
 	yield Promise.reject(error);
 }
 
+// ✅
+async function * generator() {
+	yield result;
+	throw error;
+}
+```
+
+```js
+// ❌
 promise
 	.then(x => {
 		if (x % 2 == 0) {
 			return Promise.resolve(x / 2);
 		}
 
 		return Promise.reject(new Error('odd number'));
-	});
+	})
 	.catch(error => Promise.reject(new FancyError(error)));
 
-promise.finally(() => Promise.reject(new Error('oh no')));
-```
-
-## Pass
-
-```js
-const main = async foo => {
-	if (foo > 4) {
-		throw new Error('🤪');
-	}
-
-	return result;
-};
-
-async function * generator() {
-	yield result;
-	throw error;
-}
-
+// ✅
 promise
 	.then(x => {
 		if (x % 2 == 0) {
@@ -65,7 +69,13 @@ promise
 	.catch(error => {
 		throw new FancyError(error);
 	});
+```
+
+```js
+// ❌
+promise.finally(() => Promise.reject(new Error('oh no')));
 
+// ✅
 promise.finally(() => {
 	throw new Error('oh no');
 });