Merge pull request #15 from hed-standard/write-schema-loader-as-class

Write schema loader as class

Author: happy5214

browser/src/schema/init.js

@@ -4,62 +4,7 @@
  * This file is a copy of the original `src/schema/init.js` with the import path for the schema loader modified
  * to point to the browser-specific version.
  */
-import zip from 'lodash/zip'
-
-import { loadSchema } from './loader'
-import SchemaParser from '../../../src/schema/parser'
-import PartneredSchemaMerger from '../../../src/schema/schemaMerger'
-import { Schema, HedSchemas } from '../../../src/schema/containers'
-import { IssueError } from '../../../src/issues/issues'
-import { splitStringTrimAndRemoveBlanks } from '../../../src/utils/string'
-import { SchemasSpec } from '../../../src/schema/specs'
-
-/**
- * Build a single schema container object from an XML file.
- *
- * @param {Object} xmlData The schema's XML data
- * @returns {HedSchema} The HED schema object.
- */
-const buildSchemaObject = function (xmlData) {
-  const schemaEntries = new SchemaParser(xmlData.HED).parse()
-  return new Schema(xmlData, schemaEntries)
-}
-
-/**
- * Build a single merged schema container object from one or more XML files.
- *
- * @param {Object[]} xmlData The schemas' XML data.
- * @returns {HedSchema} The HED schema object.
- */
-const buildSchemaObjects = function (xmlData) {
-  const schemas = xmlData.map((data) => buildSchemaObject(data))
-  if (schemas.length === 1) {
-    return schemas[0]
-  }
-  const partneredSchemaMerger = new PartneredSchemaMerger(schemas)
-  return partneredSchemaMerger.mergeSchemas()
-}
-
-/**
- * Build a schema collection object from a schema specification.
- *
- * @param {SchemasSpec} schemaSpecs The description of which schemas to use.
- * @returns {Promise<HedSchemas>} The schema container object and any issues found.
- */
-export async function buildSchemas(schemaSpecs) {
-  const schemaPrefixes = Array.from(schemaSpecs.data.keys())
-  /* Data format example:
-   * [[xmlData, ...], [xmlData, xmlData, ...], ...] */
-  const schemaXmlData = await Promise.all(
-    schemaPrefixes.map((prefix) => {
-      const specs = schemaSpecs.data.get(prefix)
-      return Promise.all(specs.map((spec) => loadSchema(spec)))
-    }),
-  )
-  const schemaObjects = schemaXmlData.map(buildSchemaObjects)
-  const schemas = new Map(zip(schemaPrefixes, schemaObjects))
-  return new HedSchemas(schemas)
-}
+import HedSchemaLoader from './loader'
 
 /**
  * Build HED schemas from a version specification string.
@@ -69,8 +14,5 @@ export async function buildSchemas(schemaSpecs) {
  * @throws {IssueError} If the schema specification is invalid or schemas cannot be built.
  */
 export async function buildSchemasFromVersion(hedVersionString) {
-  hedVersionString ??= ''
-  const hedVersionSpecStrings = splitStringTrimAndRemoveBlanks(hedVersionString, ',')
-  const hedVersionSpecs = SchemasSpec.parseVersionSpecs(hedVersionSpecStrings)
-  return buildSchemas(hedVersionSpecs)
+  return new HedSchemaLoader().buildSchemasFromVersion(hedVersionString)
 }

browser/src/schema/loader.js

@@ -1,114 +1,66 @@
 /** HED schema loading functions. */
 
 /* Imports */
-import { IssueError } from '../../../src/issues/issues'
-import parseSchemaXML from '../../../src/utils/xml.js'
 import { schemaData } from './vite-importer'
+import { IssueError } from '../../../src/issues/issues'
+import AbstractHedSchemaLoader from '../../../src/schema/abstractLoader'
 
-/**
- * Load schema XML data from a schema version or path description.
- *
- * @param {SchemaSpec} schemaDef The description of which schema to use.
- * @returns {Promise<object>} The schema XML data.
- * @throws {IssueError} If the schema could not be loaded.
- */
-export async function loadSchema(schemaDef = null) {
-  const xmlData = await loadPromise(schemaDef)
-  if (xmlData === null) {
-    IssueError.generateAndThrow('invalidSchemaSpecification', { spec: JSON.stringify(schemaDef) })
+export default class HedSchemaLoader extends AbstractHedSchemaLoader {
+  /**
+   * Load schema XML data from a local file.
+   *
+   * @param {string} path - The path to the schema XML data.
+   * @returns {Promise<never>} The schema XML data.
+   * @throws {IssueError} If the schema could not be loaded.
+   * @override
+   */
+  async loadLocalSchema(path) {
+    IssueError.generateAndThrow('localSchemaLoadFailed', {
+      path,
+      error: 'Local schema loading is not supported in the browser.',
+    })
   }
-  return xmlData
-}
 
-/**
- * Choose the schema Promise from a schema version or path description.
- *
- * @param {SchemaSpec} schemaDef The description of which schema to use.
- * @returns {Promise<object>} The schema XML data.
- * @throws {IssueError} If the schema could not be loaded.
- */
-async function loadPromise(schemaDef) {
-  if (schemaDef === null) {
-    return null
-  } else if (schemaDef.localPath) {
-    return loadLocalSchema(schemaDef.localPath)
-  } else if (schemaDef.localName) {
-    return loadBundledSchema(schemaDef)
-  } else {
-    return loadRemoteSchema(schemaDef)
+  /**
+   * Determine whether this validator bundles a particular schema.
+   *
+   * @param {SchemaSpec} schemaDef - The description of which schema to use.
+   * @returns {boolean} Whether this validator bundles a particular schema.
+   * @override
+   */
+  hasBundledSchema(schemaDef) {
+    const localPath = `../../../src/data/schemas/${schemaDef.localName}.xml`
+    return localPath in schemaData
   }
-}
 
-/**
- * Load schema XML data from the HED GitHub repository.
- *
- * @param {SchemaSpec} schemaDef The standard schema version to load.
- * @returns {Promise<object>} The schema XML data.
- * @throws {IssueError} If the schema could not be loaded.
- */
-function loadRemoteSchema(schemaDef) {
-  let url
-  if (schemaDef.library) {
-    url = `https://raw.githubusercontent.com/hed-standard/hed-schemas/refs/heads/main/library_schemas/${schemaDef.library}/hedxml/HED_${schemaDef.library}_${schemaDef.version}.xml`
-  } else {
-    url = `https://raw.githubusercontent.com/hed-standard/hed-schemas/refs/heads/main/standard_schema/hedxml/HED${schemaDef.version}.xml`
+  /**
+   * Retrieve the contents of a bundled schema.
+   *
+   * @param {SchemaSpec} schemaDef - The description of which schema to use.
+   * @returns {Promise<string>} The raw schema XML data.
+   * @throws {IssueError} If the schema could not be loaded.
+   * @override
+   */
+  async getBundledSchema(schemaDef) {
+    const localPath = `../../../src/data/schemas/${schemaDef.localName}.xml`
+    const schemaLoader = schemaData[localPath]
+    if (!schemaLoader) {
+      // We've already verified this exists, so this is a consistency error.
+      IssueError.generateAndThrowInternalError('Schema loader has disappeared after already being checked')
+    }
+    return await schemaLoader()
   }
-  return loadSchemaFile(
-    fetch(url).then((res) => res.text()),
-    'remoteSchemaLoadFailed',
-    { spec: JSON.stringify(schemaDef) },
-  )
 }
 
 /**
- * Load schema XML data from a local file.
+ * Load schema XML data from a schema version or path description.
  *
- * @param {string} path The path to the schema XML data.
- * @returns {Promise<object>} The schema XML data.
- * @throws {IssueError} If the schema could not be loaded.
- */
-function loadLocalSchema(path) {
-  throw new Error('Local schema loading is not supported in the browser.')
-}
-
-/**
- * Load schema XML data from a bundled file.
+ * @deprecated
  *
  * @param {SchemaSpec} schemaDef The description of which schema to use.
  * @returns {Promise<object>} The schema XML data.
  * @throws {IssueError} If the schema could not be loaded.
  */
-async function loadBundledSchema(schemaDef) {
-  const localPath = `../../../src/data/schemas/${schemaDef.localName}.xml`
-  const schemaLoader = schemaData[localPath]
-  if (!schemaLoader) {
-    // This occurs in the test environment or if the schema is not found.
-    return
-  }
-  try {
-    const data = await schemaLoader()
-    return parseSchemaXML(data)
-  } catch (error) {
-    const issueArgs = { spec: JSON.stringify(schemaDef), error: error.message }
-    IssueError.generateAndThrow('bundledSchemaLoadFailed', issueArgs)
-  }
-}
-
-/**
- * Actually load the schema XML file.
- *
- * @param {Promise<string>} xmlDataPromise The Promise containing the unparsed XML data.
- * @param {string} issueCode The issue code.
- * @param {Object<string, string>} issueArgs The issue arguments passed from the calling function.
- *returns {Promise<object>} The parsed schema XML data.
- * @throws {IssueError} If the schema could not be loaded.
- */
-async function loadSchemaFile(xmlDataPromise, issueCode, issueArgs) {
-  try {
-    const data = await xmlDataPromise
-    return parseSchemaXML(data)
-  } catch (error) {
-    issueArgs.error = error.message
-    IssueError.generateAndThrow(issueCode, issueArgs)
-  }
+export async function loadSchema(schemaDef = null) {
+  return new HedSchemaLoader().loadSchema(schemaDef)
 }

browser/src/schema/loader.spec.js

@@ -1,14 +1,22 @@
-import { describe, it, expect } from 'vitest'
+import { describe, it, expect, vi } from 'vitest'
 import { loadSchema } from './loader'
 import { SchemaSpec } from '../../../src/schema/specs.ts'
 
+vi.mock(import('./vite-importer.js'), () => {
+  return {
+    schemaData: {
+      '../../../src/data/schemas/HED_HED8.0.0_8.0.0.xml': () =>
+        Promise.resolve('<?xml version="1.0" ?>\n<HED><schema></schema></HED>\n'),
+    },
+  }
+})
+
 describe('Browser Schema Loader', () => {
-  it('should return undefined when loading a bundled schema in test environment', async () => {
+  it('should return a parsed XML object when loading a dummy bundled schema in test environment', async () => {
     // Create a spec with localName to trigger bundled schema loading
     const spec = new SchemaSpec('', '8.0.0', 'HED8.0.0', '')
-    // In a test environment, this will return undefined since schemaData is empty
     const schema = await loadSchema(spec)
-    expect(schema).toBeUndefined()
+    expect(schema).toHaveProperty('HED')
   })
 
   it('should throw an error for local file loading', async () => {

src/issues/issues.ts

@@ -58,15 +58,15 @@ export class IssueError extends Error {
   }
 
   /**
-   * Generate and re-throw an error according to {@code generateFn}.
+   * Generate and re-throw an error according to `generateFn`.
    *
    * @remarks
-   * This method will pass {@code error} to {@code generateFn}, unless it is not an {@link Error} object (in which case,
-   * it will generate an internal error via {@link IssueError.generateAndThrowInternalError}). {@code generateFn} is
+   * This method will pass `error` to `generateFn`, unless it is not an {@link Error} object (in which case,
+   * it will generate an internal error via {@link IssueError.generateAndThrowInternalError}). generateFn` is
    * expected to return an internal issue code and parameter object, which will be passed to
    * {@link IssueError.generateAndThrow}. Failure to provide an internal issue code will also result in an internal error.
    *
-   * @param error This is expected to be an object of {@code Error} or a subclass.
+   * @param error This is expected to be an object of {@link Error} or a subclass.
    * @param generateFn A function which is passed the screened error object and returns an internal error code and parameter object.
    * @param illegalErrorTypeMessage A message to be used for an illegal error type.
    */