Implement remote library schema loading

Also re-enable existing test for loading remote library schemas.

Author: happy5214

common/schema/loader.js

@@ -24,9 +24,9 @@ const loadSchema = function (schemaDef = {}, useFallback = true) {
   let schemaPromise
   if (schemaDef.path) {
     schemaPromise = loadLocalSchema(schemaDef.path)
-  } /* else if (schemaDef.library) {
+  } else if (schemaDef.library) {
     return loadRemoteLibrarySchema(schemaDef.library, schemaDef.version)
-  } */ else if (schemaDef.version) {
+  } else if (schemaDef.version) {
     schemaPromise = loadRemoteBaseSchema(schemaDef.version)
   } else {
     return Promise.reject(new Error('Invalid schema definition format.'))
@@ -63,7 +63,7 @@ const loadRemoteBaseSchema = function (version = 'Latest') {
  * @return {Promise<object>} The library schema XML data.
  */
 const loadRemoteLibrarySchema = function (library, version = 'Latest') {
-  const url = `https://github.com/raw/hed-standard/hed-schema-library/master/hedxml/HED_${library}_${version}.xml`
+  const url = `https://github.com/raw/hed-standard/hed-schema-library/main/library_schemas/${library}/hedxml/HED_${library}_${version}.xml`
   return loadSchemaFile(
     files.readHTTPSFile(url),
     stringTemplate`Could not load HED library schema ${1}, version "${2}", from remote repository - "${0}".`,

common/schema/types.js

@@ -120,8 +120,9 @@ class Schemas {
   /**
    * Constructor.
    * @param {Schema} baseSchema The base HED schema.
+   * @param {Map<string, Schema>} librarySchemas The imported library HED schemas.
    */
-  constructor(baseSchema) {
+  constructor(baseSchema, librarySchemas = undefined) {
     /**
      * The base HED schema.
      * @type {Schema}
@@ -131,7 +132,7 @@ class Schemas {
      * The imported library HED schemas.
      * @type {Map<string, Schema>}
      */
-    this.librarySchemas = new Map()
+    this.librarySchemas = librarySchemas || new Map()
   }
 
   /**

tests/schema.spec.js

@@ -29,21 +29,27 @@ describe('HED schemas', () => {
     })
   })
 
-  describe.skip('Remote HED library schemas', () => {
+  describe('Remote HED library schemas', () => {
     it('can be loaded from a central GitHub repository', () => {
-      const remoteHedSchemaLibrary = 'test'
-      const remoteHedSchemaVersion = '0.0.1'
+      const remoteHedSchemaVersion = '8.0.0'
+      const remoteHedSchemaLibrary = 'testlib'
+      const remoteHedSchemaLibraryVersion = '1.0.2'
       return schema
         .buildSchema({
-          library: remoteHedSchemaLibrary,
           version: remoteHedSchemaVersion,
+          libraries: {
+            testlib: {
+              library: remoteHedSchemaLibrary,
+              version: remoteHedSchemaLibraryVersion,
+            },
+          },
         })
         .then((hedSchemas) => {
           const hedSchema = hedSchemas.librarySchemas.get(
             remoteHedSchemaLibrary,
           )
           assert.strictEqual(hedSchema.library, remoteHedSchemaLibrary)
-          assert.strictEqual(hedSchema.version, remoteHedSchemaVersion)
+          assert.strictEqual(hedSchema.version, remoteHedSchemaLibraryVersion)
         })
     })
   })

validator/schema/init.js

@@ -1,3 +1,5 @@
+const zip = require('lodash/zip')
+
 const semver = require('semver')
 
 const loadSchema = require('../../common/schema/loader')
@@ -9,6 +11,19 @@ const { setParent } = require('../../utils/xml2js')
 const { Hed2SchemaParser } = require('./hed2')
 const { HedV8SchemaParser } = require('./hed3')
 
+/**
+ * Determine whether a HED schema is based on the HED 3 spec.
+ *
+ * @param {object} xmlData HED XML data.
+ * @returns {boolean} Whether the schema is a HED 3 schema.
+ */
+const isHed3Schema = function (xmlData) {
+  return (
+    xmlData.HED.$.library !== undefined ||
+    semver.gte(xmlData.HED.$.version, '8.0.0-alpha.3')
+  )
+}
+
 /**
  * Build a schema attributes object from schema XML data.
  *
@@ -18,32 +33,56 @@ const { HedV8SchemaParser } = require('./hed3')
 const buildSchemaAttributesObject = function (xmlData) {
   const rootElement = xmlData.HED
   setParent(rootElement, null)
-  if (semver.gte(rootElement.$.version, '8.0.0-alpha.3')) {
+  if (isHed3Schema(xmlData)) {
     return new HedV8SchemaParser(rootElement).parse()
   } else {
     return new Hed2SchemaParser(rootElement).parse()
   }
 }
 
 /**
- * Build a schema container object from a base schema version or path description.
+ * Build a single schema container object from a base schema version or path description.
+ *
+ * @param {object} xmlData The schema's XML data
+ * @returns {Schema} The HED schema object.
+ */
+const buildSchemaObject = function (xmlData) {
+  const schemaAttributes = buildSchemaAttributesObject(xmlData)
+  const mapping = buildMappingObject(xmlData)
+  let schema
+  if (isHed3Schema(xmlData)) {
+    schema = new Hed3Schema(xmlData, schemaAttributes, mapping)
+  } else {
+    schema = new Hed2Schema(xmlData, schemaAttributes, mapping)
+  }
+  return schema
+}
+
+/**
+ * Build a schema collection object from a schema specification.
  *
- * @param {{path: string?, version: string?}} schemaDef The description of which base schema to use.
+ * @param {{path: string?, version: string?, libraries: object}} schemaDef The description of which base schema to use.
  * @param {boolean} useFallback Whether to use a bundled fallback schema if the requested schema cannot be loaded.
  * @return {Promise<never>|Promise<Schemas>} The schema container object or an error.
  */
 const buildSchema = function (schemaDef = {}, useFallback = true) {
   return loadSchema(schemaDef, useFallback).then((xmlData) => {
-    const schemaAttributes = buildSchemaAttributesObject(xmlData)
-    const mapping = buildMappingObject(xmlData)
-    const rootElement = xmlData.HED
-    let baseSchema
-    if (semver.gte(rootElement.$.version, '8.0.0-alpha.3')) {
-      baseSchema = new Hed3Schema(xmlData, schemaAttributes, mapping)
-    } else {
-      baseSchema = new Hed2Schema(xmlData, schemaAttributes, mapping)
+    const baseSchema = buildSchemaObject(xmlData)
+    if (schemaDef.libraries === undefined) {
+      return new Schemas(baseSchema)
     }
-    return new Schemas(baseSchema)
+    const [libraryKeys, libraryDefs] = zip(
+      ...Object.entries(schemaDef.libraries),
+    )
+    return Promise.all(
+      libraryDefs.map((libraryDef) => {
+        return loadSchema(libraryDef, false)
+      }),
+    ).then((libraryXmlData) => {
+      const librarySchemaObjects = libraryXmlData.map(buildSchemaObject)
+      const librarySchemas = new Map(zip(libraryKeys, librarySchemaObjects))
+      return new Schemas(baseSchema, librarySchemas)
+    })
   })
 }