Docs: Use parens in arrow functions, and overall reduce arrows funcs

Krinkle · Krinkle · commit 38d07f30bd41 · 2025-04-05T01:37:41.000-07:00
Cut back the use of arrow functins somewhat, especially in migration
guides from older versions, and in generic examples that aren't about
scope.

When we use them, consistency use parentheses around the arguments.

Remove the `hooks =&gt; ` and `assert =&gt; ` idiom from examples which
have not taken off in practice, and don't jive well with most
practical style guides. It may seem minimal, but it makes the code
not realistic and not directly portable. It also makes it harder to
adopt, e.g. to add an argument such as the case when using
`QUnit.test.each()`.
diff --git a/docs/api/QUnit/module.md b/docs/api/QUnit/module.md
@@ -249,7 +249,7 @@ QUnit.module.skip('Robot', (hooks) => {
     android = new Robot();
   });
 
-  QUnit.test('hello', (assert) => {
+  QUnit.test('hello', function (assert) {
     assert.strictEqual(android.hello(), 'Hello, my name is AN-2178!');
   });
 });
@@ -274,7 +274,7 @@ QUnit.module.only('Robot', (hooks) => {
     android = new Robot();
   });
 
-  QUnit.test('hello', (assert) => {
+  QUnit.test('hello', function (assert) {
     assert.strictEqual(android.hello(), 'Hello, my name is AN-2178!');
   });
 });
@@ -289,7 +289,7 @@ QUnit.module.todo('Robot', (hooks) => {
     android = new Robot();
   });
 
-  QUnit.test('hello', (assert) => {
+  QUnit.test('hello', function (assert) {
     assert.strictEqual(android.hello(), 'Hello');
     // TODO
     // Actual: Goodbye
diff --git a/docs/api/QUnit/test.md b/docs/api/QUnit/test.md
@@ -54,7 +54,7 @@ function square (x) {
   return x * x;
 }
 
-QUnit.test('square()', (assert) => {
+QUnit.test('square()', function (assert) {
   assert.equal(square(2), 4);
   assert.equal(square(3), 9);
 });
@@ -67,7 +67,7 @@ Following the example above, `QUnit.test` also supports JS [async functions][] s
 [async functions]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function
 
 ```js
-QUnit.test('Test with async-await', async (assert) => {
+QUnit.test('Test with async-await', async function (assert) {
   const a = await fetchSquare(2);
   const b = await fetchSquare(3);
 
diff --git a/docs/api/QUnit/test.only.md b/docs/api/QUnit/test.only.md
@@ -45,23 +45,23 @@ When debugging a larger area of code, you may want to expand your filter to run
 How to use `QUnit.test.only` to filter which tests are run.
 
 ```js
-QUnit.module('robot', hooks => {
+QUnit.module('robot', (hooks) => {
   let robot;
   hooks.beforeEach(() => {
     robot = new Robot();
   });
 
-  QUnit.test('say()', assert => {
+  QUnit.test('say()', (assert) => {
     assert.true(robot.say('Hello'));
   });
 
   // Run only this test
   // For example, you are working on changing this method.
-  QUnit.test.only('laser()', assert => {
+  QUnit.test.only('laser()', (assert) => {
     assert.true(robot.laser());
   });
 
-  QUnit.test('take()', assert => {
+  QUnit.test('take()', (assert) => {
     assert.true(robot.take(5));
   });
 });
diff --git a/docs/api/QUnit/test.skip.md b/docs/api/QUnit/test.skip.md
@@ -43,18 +43,18 @@ As a codebase becomes bigger, you may sometimes want to temporarily disable an e
 How to use `skip` as a placeholder for future tests, or to temporarily skip a broken test.
 
 ```js
-QUnit.module('robot', hooks => {
+QUnit.module('robot', (hooks) => {
   let robot;
   hooks.beforeEach(() => {
     robot = new Robot();
   });
 
-  QUnit.test('say', assert => {
+  QUnit.test('say', (assert) => {
     assert.strictEqual(robot.say(), 'Exterminate!');
   });
 
   // Robot does not yet have a laser() method yet, skip this test for now
-  QUnit.test.skip('laser', assert => {
+  QUnit.test.skip('laser', (assert) => {
     assert.true(robot.laser());
   });
 
diff --git a/docs/api/QUnit/test.todo.md b/docs/api/QUnit/test.todo.md
@@ -43,14 +43,14 @@ You can also use [`QUnit.module.todo()`](./module.md) to manage the "todo" state
 How to use `QUnit.test.todo` to denote code that is still under development.
 
 ```js
-QUnit.module('Robot', hooks => {
+QUnit.module('Robot', (hooks) => {
   let robot;
   hooks.beforeEach(() => {
     robot = new Robot();
   });
 
   // Robot is not yet finished
-  QUnit.test.todo('fireLazer', assert => {
+  QUnit.test.todo('fireLazer', (assert) => {
     const result = robot.fireLazer();
     assert.equal(result, "I'm firing my lazer!");
   });
diff --git a/docs/api/assert/async.md b/docs/api/assert/async.md
@@ -40,10 +40,10 @@ function fetchDouble (num, callback) {
   callback(double);
 }
 
-QUnit.test('async example', assert => {
+QUnit.test('async example', function (assert) {
   const done = assert.async();
 
-  fetchDouble(21, res => {
+  fetchDouble(21, (res) => {
     assert.strictEqual(res, 42, 'Result');
     done();
   });
@@ -54,15 +54,15 @@ QUnit.test('async example', assert => {
 Call `assert.async()` multiple times to wait for multiple async operations. Each `done` callback must be called exactly once for the test to pass.
 
 ```js
-QUnit.test('two async calls', assert => {
+QUnit.test('two async calls', function (assert) {
   const done1 = assert.async();
   const done2 = assert.async();
 
-  fetchDouble(3, res => {
+  fetchDouble(3, (res) => {
     assert.strictEqual(res, 6, 'double of 3');
     done1();
   });
-  fetchDouble(9, res => {
+  fetchDouble(9, (res) => {
     assert.strictEqual(res, 18, 'double of 9');
     done2();
   });
@@ -82,7 +82,7 @@ function uploadBatch (batch, notify, complete) {
   complete(null);
 }
 
-QUnit.test('multiple calls example', assert => {
+QUnit.test('multiple calls example', function (assert) {
   assert.timeout(1000);
 
   const notify = assert.async(3);
diff --git a/docs/api/assert/closeTo.md b/docs/api/assert/closeTo.md
@@ -31,7 +31,7 @@ To learn how floating-point numbers work internally, refer to [Double-precision
 ## Examples
 
 ```js
-QUnit.test('good example', assert => {
+QUnit.test('good example', function (assert) {
   const x = 0.1 + 0.2; // 0.30000000000000004
 
   // passing: must be between 0.299 and 0.301
@@ -42,7 +42,7 @@ QUnit.test('good example', assert => {
   assert.closeTo(y, 20.10, 0.05);
 });
 
-QUnit.test('bad example', assert => {
+QUnit.test('bad example', function (assert) {
   const x = 20.7;
   // failing: must be between 20.0 and 20.2 inclusive
   assert.closeTo(x, 20.1, 0.1);
diff --git a/docs/api/assert/deepEqual.md b/docs/api/assert/deepEqual.md
@@ -36,10 +36,10 @@ To assert strict equality on own properties only, refer to [`assert.propEqual()`
 
 ```js
 function makeComplexObject (name, extra, country) {
-  var children = new Set();
+  const children = new Set();
   children.add('Alice');
   children.add(extra);
-  var countryToCapital = { UK: 'London' };
+  const countryToCapital = { UK: 'London' };
   return {
     name: name,
     children: children,
@@ -51,7 +51,7 @@ function makeComplexObject (name, extra, country) {
 }
 
 QUnit.test('object example', function (assert) {
-  var result = makeComplexObject('Marty', 'Bob', 'UK');
+  const result = makeComplexObject('Marty', 'Bob', 'UK');
 
   // Succeeds!
   // While each object is distinct by strict equality (identity),
@@ -91,7 +91,7 @@ class BaseCoord {
 class PrimaryDimensionCoord extends BaseCoord {}
 class UpsideDownCoord extends BaseCoord {}
 
-QUnit.test('class example', assert => {
+QUnit.test('class example', function (assert) {
   eleven.goto('Enschede');
   eleven.enterGate();
   const loc = eleven.getLocation();
@@ -105,7 +105,7 @@ QUnit.test('class example', assert => {
 ```
 
 ```js
-QUnit.test('failing example', assert => {
+QUnit.test('failing example', function (assert) {
   const result = {
     a: 'Albert',
     b: 'Berta',
diff --git a/docs/api/assert/false.md b/docs/api/assert/false.md
@@ -27,7 +27,7 @@ This method is similar to the `assertFalse()` method found in xUnit-style framew
 ## Examples
 
 ```js
-QUnit.test('example', assert => {
+QUnit.test('example', function (assert) {
   // success
   assert.false(false, 'boolean false');
 
diff --git a/docs/api/assert/notDeepEqual.md b/docs/api/assert/notDeepEqual.md
@@ -31,7 +31,7 @@ This is the inverse of [`assert.deepEqual()`](./deepEqual.md).
 Compare the value of two objects.
 
 ```js
-QUnit.test('example', assert => {
+QUnit.test('example', function (assert) {
   const result = { foo: 'yep' };
 
   // succeeds, objects are similar but have a different foo value.
diff --git a/docs/api/assert/notEqual.md b/docs/api/assert/notEqual.md
@@ -31,14 +31,14 @@ The `notEqual` assertion uses the simple inverted comparison operator (`!=`) to
 The simplest assertion example:
 
 ```js
-QUnit.test('passing example', assert => {
+QUnit.test('passing example', function (assert) {
   const result = '2';
 
   // succeeds, 1 and 2 are different.
   assert.notEqual(result, 1);
 });
 
-QUnit.test('failing example', assert => {
+QUnit.test('failing example', function (assert) {
   const result = '2';
 
   // fails, the number 2 and the string "2" are considered equal when
diff --git a/docs/api/assert/notOk.md b/docs/api/assert/notOk.md
@@ -26,7 +26,7 @@ To strictly compare against boolean false, use [`assert.false()`](./false.md).
 ## Examples
 
 ```js
-QUnit.test('example', assert => {
+QUnit.test('example', function (assert) {
   // success
   assert.notOk(false, 'boolean false');
   assert.notOk('', 'empty string');
diff --git a/docs/api/assert/notPropContains.md b/docs/api/assert/notPropContains.md
@@ -30,7 +30,7 @@ This method is recursive and allows partial comparison of nested objects as well
 ## Examples
 
 ```js
-QUnit.test('example', assert => {
+QUnit.test('example', function (assert) {
   const result = {
     foo: 0,
     vehicle: {
diff --git a/docs/api/assert/notPropEqual.md b/docs/api/assert/notPropEqual.md
@@ -34,7 +34,7 @@ The test passes if there are properties with different values, or extra properti
 Compare the values of two objects properties.
 
 ```js
-QUnit.test('example', assert => {
+QUnit.test('example', function (assert) {
   class Foo {
     constructor () {
       this.x = '1';
diff --git a/docs/api/assert/notStrictEqual.md b/docs/api/assert/notStrictEqual.md
@@ -29,7 +29,7 @@ The `notStrictEqual` assertion uses the strict inverted comparison operator (`!=
 ## Examples
 
 ```js
-QUnit.test('example', assert => {
+QUnit.test('example', function (assert) {
   const result = '2';
 
   // succeeds, while the number 2 and string 2 are similar, they are strictly different.
diff --git a/docs/api/assert/ok.md b/docs/api/assert/ok.md
@@ -28,7 +28,7 @@ For the inverse of `ok()`, refer to [`assert.notOk()`](./notOk.md)
 ## Examples
 
 ```js
-QUnit.test('example', assert => {
+QUnit.test('example', function (assert) {
   // success
   assert.ok(true, 'boolean true');
   assert.ok('foo', 'non-empty string');
diff --git a/docs/api/assert/propContains.md b/docs/api/assert/propContains.md
@@ -32,7 +32,7 @@ This method is recursive and allows partial comparison of nested objects as well
 ## Examples
 
 ```js
-QUnit.test('example', assert => {
+QUnit.test('example', function (assert) {
   const result = {
     foo: 0,
     vehicle: {
diff --git a/docs/api/assert/propEqual.md b/docs/api/assert/propEqual.md
@@ -36,7 +36,7 @@ This method is recursive and can compare any nested or complex object via a plai
 Compare the property values of two objects.
 
 ```js
-QUnit.test('example', assert => {
+QUnit.test('example', function (assert) {
   class Foo {
     constructor () {
       this.x = 1;
@@ -69,10 +69,10 @@ QUnit.test('example', function (assert) {
   Foo.prototype.walk = function () {};
   Foo.prototype.run = function () {};
 
-  var foo = new Foo();
+  const foo = new Foo();
 
   // succeeds, own properties are strictly equal.
-  var expected = {
+  const expected = {
     x: 1,
     y: 2
   };
diff --git a/docs/api/assert/pushResult.md b/docs/api/assert/pushResult.md
@@ -44,7 +44,7 @@ QUnit.assert.between = function (actual, from, to, message) {
   });
 };
 
-QUnit.test('example', assert => {
+QUnit.test('example', function (assert) {
   const result = 42;
   assert.between(result, 1, 10, 'result');
   // Example test failure
@@ -58,7 +58,7 @@ QUnit.test('example', assert => {
 If there isn't a built-in QUnit assertion for something that you need to check, you can always freely express it using inline JavaScript within your test. It is recommended to, whenever possible, end your ad-hoc logic with two values that you can pass to [`assert.strictEqual()`](./strictEqual.md), or pass a boolean result to [`assert.true()`](./true.md).
 
 ```js
-QUnit.test('remainder example [bad]', assert => {
+QUnit.test('remainder example [bad]', function (assert) {
   const actual = 4;
 
   const result = (actual % 3) === 2;
@@ -69,7 +69,7 @@ QUnit.test('remainder example [bad]', assert => {
   // > Expected: true
 });
 
-QUnit.test('remainder example [good]', assert => {
+QUnit.test('remainder example [good]', function (assert) {
   const actual = 4;
 
   const result = (actual % 3);
@@ -81,7 +81,7 @@ QUnit.test('remainder example [good]', assert => {
   // > Expected: 2
 });
 
-QUnit.test('between example', assert => {
+QUnit.test('between example', function (assert) {
   const actual = 42;
 
   const isBetween = actual >= 1 && actual <= 10;
diff --git a/docs/api/assert/rejects.md b/docs/api/assert/rejects.md
@@ -37,7 +37,7 @@ Note: in order to avoid confusion between the `message` and the `expectedMatcher
 ## Examples
 
 ```js
-QUnit.test('rejects example', assert => {
+QUnit.test('rejects example', function (assert) {
   // simple check
   assert.rejects(Promise.reject('some error'));
 
diff --git a/docs/api/assert/strictEqual.md b/docs/api/assert/strictEqual.md
@@ -37,7 +37,7 @@ The `strictEqual()` assertion provides the most rigid comparison of type and val
 Compare the value of two primitives, having the same value and type.
 
 ```js
-QUnit.test('strictEqual example', assert => {
+QUnit.test('strictEqual example', function (assert) {
   const result = 2;
 
   assert.strictEqual(result, 2);
diff --git a/docs/api/assert/throws.md b/docs/api/assert/throws.md
@@ -41,7 +41,7 @@ The `expectedMatcher` argument can be:
 ## Examples
 
 ```js
-QUnit.test('throws example', assert => {
+QUnit.test('throws example', function (assert) {
   // simple check
   assert.throws(function () {
     throw new Error('boo');
diff --git a/docs/api/assert/timeout.md b/docs/api/assert/timeout.md
diff --git a/docs/api/assert/true.md b/docs/api/assert/true.md
diff --git a/docs/api/extension/QUnit.stack.md b/docs/api/extension/QUnit.stack.md
diff --git a/docs/upgrade-guide-2.x.md b/docs/upgrade-guide-2.x.md
