Refactoring

src/config/normalize/lib/call.js

@@ -2,12 +2,47 @@ import { inspect } from 'util'
 
 import { wrapError } from '../../../error/wrap.js'
 
+// Call `keyword.test()`
+export const callTest = async function (test, input, info) {
+  return await callFunc({ func: test, input, info, hasInput: true, test })
+}
+
+// Call `keyword.normalize()`
+export const callNormalize = async function (normalize, definition, info) {
+  const func = () => normalize(definition)
+  return await callFunc({ func, info, hasInput: false })
+}
+
+// Call definition function
+export const callDefinition = async function ({
+  definition,
+  input,
+  info,
+  hasInput,
+  test,
+}) {
+  return await callFunc({ func: definition, input, info, hasInput, test })
+}
+
+// Call `keyword.main()`
+export const callMain = async function ({
+  main,
+  definition,
+  input,
+  info,
+  hasInput,
+  test,
+}) {
+  const func = main.bind(undefined, definition)
+  return await callFunc({ func, input, info, hasInput, test })
+}
+
 // Call a function from `test()`, `main()` or a definition.
 // They are all:
 //  - Optionally async
 //  - Called with same arguments
 //  - Error handled
-export const callFunc = async function ({
+const callFunc = async function ({
   func,
   input,
   info: { originalName },

src/config/normalize/lib/keywords/definition.js

@@ -1,4 +1,4 @@
-import { callFunc } from '../call.js'
+import { callDefinition, callNormalize } from '../call.js'
 
 // The property name is defined by `name`.
 // `aliases` can be defined to either:
@@ -16,15 +16,15 @@ export const getDefinition = function (rule, name, aliases) {
 }
 
 // Call definition when it is a function
-export const callDefinition = async function ({
+export const callDefinitionFunc = async function ({
   definition,
   input,
   info,
   hasInput,
   test,
 }) {
   return typeof definition === 'function'
-    ? await callFunc({ func: definition, input, info, hasInput, test })
+    ? await callDefinition({ definition, input, info, hasInput, test })
     : definition
 }
 
@@ -36,9 +36,5 @@ export const normalizeDefinition = async function (
 ) {
   return normalize === undefined
     ? definition
-    : await callFunc({
-        func: () => normalize(definition),
-        info,
-        hasInput: false,
-      })
+    : await callNormalize(normalize, definition, info)
 }

src/config/normalize/lib/keywords/main.js

@@ -1,8 +1,8 @@
-import { callFunc } from '../call.js'
+import { callMain } from '../call.js'
 
 import {
   getDefinition,
-  callDefinition,
+  callDefinitionFunc,
   normalizeDefinition,
 } from './definition.js'
 import { applyReturnValue } from './return.js'
@@ -99,7 +99,7 @@ const applyKeyword = async function ({
     return state
   }
 
-  const definitionA = await callDefinition({
+  const definitionA = await callDefinitionFunc({
     definition,
     input,
     info,
@@ -112,8 +112,9 @@ const applyKeyword = async function ({
   }
 
   const definitionB = await normalizeDefinition(definitionA, normalize, info)
-  const returnValue = await callFunc({
-    func: main.bind(undefined, definitionB),
+  const returnValue = await callMain({
+    main,
+    definition: definitionB,
     input,
     info,
     hasInput,

src/config/normalize/lib/keywords/skip.js

@@ -1,4 +1,4 @@
-import { callFunc } from '../call.js'
+import { callTest } from '../call.js'
 
 // `undefined` definitions are always skipped because:
 //  - It allows any keyword to be disabled by setting `definition` to
@@ -35,10 +35,7 @@ export const shouldSkipKeyword = async function ({
 //    need to check the input during `test()` but should not pass it during
 //    `main()` nor the definition function
 const hasSkippedTest = async function (test, input, info) {
-  return (
-    test !== undefined &&
-    !(await callFunc({ func: test, input, info, hasInput: true, test }))
-  )
+  return test !== undefined && !(await callTest(test, input, info))
 }
 
 // Function definitions returning `undefined` are skipped, unless