Merge pull request #201 from bids-standard/enh/use_association_selectors

Use schema.meta.associations during buildAssociations.

Author: rwblair

changelog.d/20250502_103250_rosswilsonblair_use_association_selectors.md

@@ -0,0 +1,47 @@
+<!--
+A new scriv changelog fragment.
+
+Uncomment the section that is right (remove the HTML comment wrapper).
+For top level release notes, leave all the headers commented out.
+-->
+
+<!--
+### Added
+
+- A bullet item for the Added category.
+
+-->
+### Changed
+
+- Rely on `schema.meta.associations` to load context associations instead of relying on list maintained in validator.
+
+<!--
+### Fixed
+
+- A bullet item for the Fixed category.
+
+-->
+<!--
+### Deprecated
+
+- A bullet item for the Deprecated category.
+
+-->
+<!--
+### Removed
+
+- A bullet item for the Removed category.
+
+-->
+<!--
+### Security
+
+- A bullet item for the Security category.
+
+-->
+<!--
+### Infrastructure
+
+- A bullet item for the Infrastructure category.
+
+-->

src/schema/associations.ts

@@ -10,13 +10,17 @@ import type {
   Magnitude,
   Magnitude1,
 } from '@bids/schema/context'
+import type { Schema as MetaSchema } from '@bids/schema/metaschema'
+
 import type { BIDSFile, FileTree } from '../types/filetree.ts'
 import type { BIDSContext } from './context.ts'
 import type { DatasetIssues } from '../issues/datasetIssues.ts'
 import type { readEntities } from './entities.ts'
 import { loadTSV } from '../files/tsv.ts'
 import { parseBvalBvec } from '../files/dwi.ts'
 import { walkBack } from '../files/inheritance.ts'
+import { evalCheck } from './applyRules.ts'
+import { expressionFunctions } from './expressionLanguage.ts'
 
 // type AssociationsLookup = Record<keyof ContextAssociations, { extensions: string[], inherit: boolean, load: ... }
 
@@ -32,158 +36,129 @@ import { walkBack } from '../files/inheritance.ts'
  * returning promises for now.
  */
 const associationLookup = {
-  events: {
-    suffix: 'events',
-    extensions: ['.tsv'],
-    inherit: true,
-    load: async (file: BIDSFile, options: { maxRows: number }): Promise<Events> => {
-      const columns = await loadTSV(file, options.maxRows)
-        .catch((e) => {
-          return new Map()
-        })
-      return {
-        path: file.path,
-        onset: columns.get('onset') || [],
-      }
-    },
+  events: async (file: BIDSFile, options: { maxRows: number }): Promise<Events> => {
+    const columns = await loadTSV(file, options.maxRows)
+      .catch((e) => {
+        return new Map()
+      })
+    return {
+      path: file.path,
+      onset: columns.get('onset') || [],
+    }
   },
-  aslcontext: {
-    suffix: 'aslcontext',
-    extensions: ['.tsv'],
-    inherit: true,
-    load: async (
-      file: BIDSFile,
-      options: { maxRows: number },
-    ): Promise<Aslcontext> => {
-      const columns = await loadTSV(file, options.maxRows)
-        .catch((e) => {
-          return new Map()
-        })
-      return {
-        path: file.path,
-        n_rows: columns.get('volume_type')?.length || 0,
-        volume_type: columns.get('volume_type') || [],
-      }
-    },
+  aslcontext: async (
+    file: BIDSFile,
+    options: { maxRows: number },
+  ): Promise<Aslcontext> => {
+    const columns = await loadTSV(file, options.maxRows)
+      .catch((e) => {
+        return new Map()
+      })
+    return {
+      path: file.path,
+      n_rows: columns.get('volume_type')?.length || 0,
+      volume_type: columns.get('volume_type') || [],
+    }
   },
-  m0scan: {
-    suffix: 'm0scan',
-    extensions: ['.nii', '.nii.gz'],
-    inherit: false,
-    load: (file: BIDSFile, options: any): Promise<M0Scan> => {
-      return Promise.resolve({ path: file.path })
-    },
+  m0scan: (file: BIDSFile, options: any): Promise<M0Scan> => {
+    return Promise.resolve({ path: file.path })
   },
-  magnitude: {
-    suffix: 'magnitude',
-    extensions: ['.nii', '.nii.gz'],
-    inherit: false,
-    load: (file: BIDSFile, options: any): Promise<Magnitude> => {
-      return Promise.resolve({ path: file.path })
-    },
+  magnitude: (file: BIDSFile, options: any): Promise<Magnitude> => {
+    return Promise.resolve({ path: file.path })
   },
-  magnitude1: {
-    suffix: 'magnitude1',
-    extensions: ['.nii', '.nii.gz'],
-    inherit: false,
-    load: (file: BIDSFile, options: any): Promise<Magnitude1> => {
-      return Promise.resolve({ path: file.path })
-    },
+  magnitude1: (file: BIDSFile, options: any): Promise<Magnitude1> => {
+    return Promise.resolve({ path: file.path })
   },
-  bval: {
-    suffix: 'dwi',
-    extensions: ['.bval'],
-    inherit: true,
-    load: async (file: BIDSFile, options: any): Promise<Bval> => {
-      const contents = await file.text()
-      const rows = parseBvalBvec(contents)
-      return {
-        path: file.path,
-        n_cols: rows ? rows[0].length : 0,
-        n_rows: rows ? rows.length : 0,
-        // @ts-expect-error values is expected to be a number[], coerce lazily
-        values: rows[0],
-      }
-    },
+  bval: async (file: BIDSFile, options: any): Promise<Bval> => {
+    const contents = await file.text()
+    const rows = parseBvalBvec(contents)
+    return {
+      path: file.path,
+      n_cols: rows ? rows[0].length : 0,
+      n_rows: rows ? rows.length : 0,
+      // @ts-expect-error values is expected to be a number[], coerce lazily
+      values: rows[0],
+    }
   },
-  bvec: {
-    suffix: 'dwi',
-    extensions: ['.bvec'],
-    inherit: true,
-    load: async (file: BIDSFile, options: any): Promise<Bvec> => {
-      const contents = await file.text()
-      const rows = parseBvalBvec(contents)
+  bvec: async (file: BIDSFile, options: any): Promise<Bvec> => {
+    const contents = await file.text()
+    const rows = parseBvalBvec(contents)
 
-      if (rows.some((row) => row.length !== rows[0].length)) {
-        throw { key: 'BVEC_ROW_LENGTH' }
-      }
+    if (rows.some((row) => row.length !== rows[0].length)) {
+      throw { key: 'BVEC_ROW_LENGTH' }
+    }
 
-      return {
-        path: file.path,
-        n_cols: rows ? rows[0].length : 0,
-        n_rows: rows ? rows.length : 0,
-      }
-    },
+    return {
+      path: file.path,
+      n_cols: rows ? rows[0].length : 0,
+      n_rows: rows ? rows.length : 0,
+    }
   },
-  channels: {
-    suffix: 'channels',
-    extensions: ['.tsv'],
-    inherit: true,
-    load: async (file: BIDSFile, options: { maxRows: number }): Promise<Channels> => {
-      const columns = await loadTSV(file, options.maxRows)
-        .catch((e) => {
-          return new Map()
-        })
-      return {
-        path: file.path,
-        type: columns.get('type'),
-        short_channel: columns.get('short_channel'),
-        sampling_frequency: columns.get('sampling_frequency'),
-      }
-    },
+  channels: async (file: BIDSFile, options: { maxRows: number }): Promise<Channels> => {
+    const columns = await loadTSV(file, options.maxRows)
+      .catch((e) => {
+        return new Map()
+      })
+    return {
+      path: file.path,
+      type: columns.get('type'),
+      short_channel: columns.get('short_channel'),
+      sampling_frequency: columns.get('sampling_frequency'),
+    }
   },
-  coordsystem: {
-    suffix: 'coordsystem',
-    extensions: ['.json'],
-    inherit: true,
-    load: (file: BIDSFile, options: any): Promise<Coordsystem> => {
-      return Promise.resolve({ path: file.path })
-    },
+  coordsystem: (file: BIDSFile, options: any): Promise<Coordsystem> => {
+    return Promise.resolve({ path: file.path })
   },
 }
 
 export async function buildAssociations(
-  source: BIDSFile,
-  issues: DatasetIssues,
-  maxRows: number = -1,
+  context: BIDSContext,
 ): Promise<Associations> {
   const associations: Associations = {}
 
-  for (const [key, value] of Object.entries(associationLookup)) {
-    const { suffix, extensions, inherit, load } = value
+  const schema: MetaSchema = context.dataset.schema as MetaSchema
+
+  Object.assign(context, expressionFunctions)
+  // @ts-expect-error
+  context.exists.bind(context)
+
+  for (const [key, rule] of Object.entries(schema.meta.associations)) {
+    if (!rule.selectors!.every((x) => evalCheck(x, context))) {
+      continue
+    }
     let file
+    let extension: string[] = []
+    if (typeof rule.target.extension === 'string') {
+      extension = [rule.target.extension]
+    } else if (Array.isArray(rule.target.extension)) {
+      extension = rule.target.extension
+    }
     try {
-      file = walkBack(source, inherit, extensions, suffix).next().value
+      file = walkBack(context.file, rule.inherit, extension, rule.target.suffix).next().value
     } catch (error) {
       if (
         error && typeof error === 'object' && 'code' in error &&
         error.code === 'MULTIPLE_INHERITABLE_FILES'
       ) {
         // @ts-expect-error
-        issues.add(error)
+        context.dataset.issues.add(error)
         break
       } else {
         throw error
       }
     }
 
     if (file) {
-      // @ts-expect-error Matching load return value to key is hard
-      associations[key] = await load(file, { maxRows }).catch((error) => {
-        if (error.key) {
-          issues.add({ code: error.key, location: file.path })
-        }
-      })
+      // @ts-expect-error
+      const load = associationLookup[key]
+      // @ts-expect-error
+      associations[key] = await load(file, { maxRows: context.dataset.options?.maxRows }).catch(
+        (error: any) => {
+          if (key in error) {
+            context.dataset.issues.add({ code: error.key, location: file.path })
+          }
+        },
+      )
     }
   }
   return Promise.resolve(associations)

src/schema/context.ts

@@ -261,9 +261,7 @@ export class BIDSContext implements Context {
 
   async loadAssociations(): Promise<void> {
     this.associations = await buildAssociations(
-      this.file,
-      this.dataset.issues,
-      this.dataset.options?.maxRows,
+      this,
     )
     return
   }