Add config selectors for precision and outliers

src/combination/tasks/find.js

@@ -22,10 +22,8 @@ export const findTasks = async function ({
     const [{ taskIds: ids }] = await measureCombinations(
       [{ dimensions: { runner }, taskPath, inputsList: [] }],
       {
-        precision: 0,
-        cwd,
+        config: { precision: 0, cwd, outliers: true },
         previewState: { quiet: true },
-        outliers: true,
         stage: 'init',
         noDimensions,
       },

src/config/select/apply.js

@@ -12,12 +12,12 @@ import { SELECTABLE_PROPS } from './normalize.js'
 export const applyConfigSelectors = function (combination, config) {
   return mapObj(config, (name, configValue) => [
     name,
-    applyConfigPropSelectors(combination, configValue),
+    applyConfigPropSelectors(combination, configValue, name),
   ])
 }
 
-const applyConfigPropSelectors = function (combination, configValue) {
-  if (!isParsedConfigSelector(configValue)) {
+const applyConfigPropSelectors = function (combination, configValue, name) {
+  if (!isParsedConfigSelector(configValue, name)) {
     return configValue
   }
 
@@ -28,7 +28,7 @@ const applyConfigPropSelectors = function (combination, configValue) {
 }
 
 // Make the logic a noop if the configuration property does not use selectors
-const isParsedConfigSelector = function (name, configValue) {
+const isParsedConfigSelector = function (configValue, name) {
   return (
     SELECTABLE_PROPS.has(name) &&
     Array.isArray(configValue) &&

src/dev/main.js

@@ -18,10 +18,8 @@ const combinationDev = async function (combination, noDimensions, { cwd }) {
   printCombinationName(combination, noDimensions)
 
   await measureCombinations([combination], {
-    precision: 0,
-    cwd,
+    config: { precision: 0, cwd, outliers: true },
     previewState: { quiet: true },
-    outliers: true,
     stage: 'dev',
     noDimensions,
   })

src/run/main.js

@@ -55,7 +55,6 @@ const previewAndMeasure = async function ({
   noDimensions,
   previewState,
   config,
-  config: { cwd, precision, outliers },
 }) {
   const previewStateA = await startPreview({
     newResult,
@@ -68,10 +67,8 @@ const previewAndMeasure = async function ({
 
   try {
     const combinations = await measureCombinations(newResult.combinations, {
-      precision,
-      cwd,
+      config,
       previewState: previewStateA,
-      outliers,
       stage: 'main',
       noDimensions,
     })

src/run/measure/loop.js

@@ -28,11 +28,10 @@ import { isRemainingCombination } from './remaining.js'
 // In that case, the task complexity should be increased, for example by using
 // bigger `inputs`.
 export const performMeasureLoop = async function ({
-  precision,
+  config: { precision, outliers },
   previewState,
   stopState,
   stage,
-  outliers,
   server,
   logsFd,
   minLoopDuration,

src/run/measure/single.js

@@ -1,4 +1,5 @@
 import { getCombinationPrefix } from '../../combination/ids/name.js'
+import { applyConfigSelectors } from '../../config/select/apply.js'
 import { startLogs, stopLogs, hasLogs } from '../logs/create.js'
 import { addErrorTaskLogs } from '../logs/error.js'
 import { startLogsStream, stopLogsStream } from '../logs/stream.js'
@@ -16,8 +17,9 @@ import { throwIfStopped } from '../stop/error.js'
 import { runEvents } from './events.js'
 
 // Measure a single combination
-export const measureCombination = async function ({ index, ...args }) {
+export const measureCombination = async function ({ index, config, ...args }) {
   const { previewState, combination, noDimensions } = args
+  const configA = applyConfigSelectors(combination, config)
 
   try {
     await startCombinationPreview({
@@ -26,7 +28,7 @@ export const measureCombination = async function ({ index, ...args }) {
       index,
       noDimensions,
     })
-    const { stats, taskIds } = await logAndMeasure(args)
+    const { stats, taskIds } = await logAndMeasure({ ...args, config: configA })
     await endCombinationPreview(previewState)
     return { ...combination, stats, taskIds }
   } finally {
@@ -62,15 +64,9 @@ const logStreamAndMeasure = async function (args) {
 }
 
 // Spawn combination processes, then measure them
-const spawnAndMeasure = async function ({
-  cwd,
-  serverUrl,
-  logsStream,
-  ...args
-}) {
+const spawnAndMeasure = async function ({ serverUrl, logsStream, ...args }) {
   const { childProcess, onTaskExit } = await spawnRunnerProcess({
     ...args,
-    cwd,
     serverUrl,
     logsStream,
   })

src/run/process/runner.js

@@ -40,7 +40,7 @@ export const spawnRunnerProcess = async function ({
       },
     },
   },
-  cwd,
+  config: { cwd },
   server,
   serverUrl,
   logsStream,