Accept RDF lists as argument values, #47

Author: rubensworks

index.ts

@@ -1,5 +1,6 @@
 export * from './lib/construction/argument/ArgumentConstructorHandlerArray';
 export * from './lib/construction/argument/ArgumentConstructorHandlerHash';
+export * from './lib/construction/argument/ArgumentConstructorHandlerList';
 export * from './lib/construction/argument/ArgumentConstructorHandlerPrimitive';
 export * from './lib/construction/argument/ArgumentConstructorHandlerReference';
 export * from './lib/construction/argument/ArgumentConstructorHandlerUndefined';

lib/construction/ConfigConstructor.ts

@@ -3,6 +3,7 @@ import type { IModuleState } from '../loading/ModuleStateBuilder';
 import { ErrorResourcesContext } from '../util/ErrorResourcesContext';
 import { ArgumentConstructorHandlerArray } from './argument/ArgumentConstructorHandlerArray';
 import { ArgumentConstructorHandlerHash } from './argument/ArgumentConstructorHandlerHash';
+import { ArgumentConstructorHandlerList } from './argument/ArgumentConstructorHandlerList';
 import { ArgumentConstructorHandlerPrimitive } from './argument/ArgumentConstructorHandlerPrimitive';
 import { ArgumentConstructorHandlerReference } from './argument/ArgumentConstructorHandlerReference';
 import { ArgumentConstructorHandlerUndefined } from './argument/ArgumentConstructorHandlerUndefined';
@@ -32,6 +33,7 @@ export class ConfigConstructor<Instance> implements IArgumentsConstructor<Instan
     new ArgumentConstructorHandlerUndefined(),
     new ArgumentConstructorHandlerHash(),
     new ArgumentConstructorHandlerArray(),
+    new ArgumentConstructorHandlerList(),
     new ArgumentConstructorHandlerValue(),
     new ArgumentConstructorHandlerReference(),
     new ArgumentConstructorHandlerPrimitive(),
@@ -58,6 +60,16 @@ export class ConfigConstructor<Instance> implements IArgumentsConstructor<Instan
       return this.getArgumentValue(values[0], settings);
     }
 
+    // Unwrap RDF list-based values out of the array
+    if (values.length > 0 && values.some(value => value.list)) {
+      if (values.length > 1) {
+        throw new ErrorResourcesContext(`Detected multiple values for an argument while only a single RDF list is allowed`, {
+          arguments: values.flatMap(value => value.list ? value.list : [ value ]),
+        });
+      }
+      return this.getArgumentValue(values[0], settings);
+    }
+
     // Otherwise, keep the array form
     const elements = await Promise.all(values.map(element => this.getArgumentValue(element, settings)));
     return this.constructionStrategy.createArray({ settings, elements });

lib/construction/argument/ArgumentConstructorHandlerList.ts

@@ -0,0 +1,29 @@
+import type { Resource } from 'rdf-object';
+import type { IConstructionSettings } from '../IConstructionSettings';
+import type { IArgumentConstructorHandler } from './IArgumentConstructorHandler';
+import type { IArgumentsConstructor } from './IArgumentsConstructor';
+
+/**
+ * Handles arguments with RDF list values.
+ */
+export class ArgumentConstructorHandlerList implements IArgumentConstructorHandler {
+  public canHandle<Instance>(
+    value: Resource,
+    settings: IConstructionSettings,
+    argsCreator: IArgumentsConstructor<Instance>,
+  ): boolean {
+    return Boolean(value.list);
+  }
+
+  public async handle<Instance>(
+    argument: Resource,
+    settings: IConstructionSettings,
+    argsCreator: IArgumentsConstructor<Instance>,
+  ): Promise<Instance> {
+    // Recursively handle all sub-args in the list
+    const elements = await Promise.all(argument.list!
+      .map((entry: Resource) => argsCreator.getArgumentValue(entry, settings)));
+
+    return argsCreator.constructionStrategy.createArray({ settings, elements });
+  }
+}

test/unit/construction/ConfigConstructor-test.ts

@@ -101,6 +101,39 @@ describe('ConfigConstructor', () => {
       expect(constructionStrategy.createPrimitive).toHaveBeenCalledWith({ settings, value: 'DEF' });
       expect(constructionStrategy.createPrimitive).toHaveBeenCalledWith({ settings, value: 'GHI' });
     });
+
+    it('should handle an RDF list', async() => {
+      const values = [
+        objectLoader.createCompactedResource({
+          list: [
+            '"ABC"',
+            '"DEF"',
+            '"GHI"',
+          ],
+        }),
+      ];
+      expect(await constructor.getArgumentValues(values, settings)).toEqual([
+        'ABC',
+        'DEF',
+        'GHI',
+      ]);
+      expect(constructionStrategy.createArray).toHaveBeenCalledWith({ settings, elements: [ 'ABC', 'DEF', 'GHI' ]});
+    });
+
+    it('should throw on an RDF list and anything else', async() => {
+      const values = [
+        objectLoader.createCompactedResource({
+          list: [
+            '"ABC"',
+            '"DEF"',
+            '"GHI"',
+          ],
+        }),
+        objectLoader.createCompactedResource('"ABC"'),
+      ];
+      await expect(constructor.getArgumentValues(values, settings)).rejects
+        .toThrowError(`Detected multiple values for an argument while only a single RDF list is allowed`);
+    });
   });
 
   describe('getArgumentValue', () => {
@@ -308,6 +341,48 @@ describe('ConfigConstructor', () => {
       });
     });
 
+    describe('for RDF lists', () => {
+      it('should handle one element', async() => {
+        const resource = objectLoader.createCompactedResource({
+          list: [
+            '"ABC"',
+          ],
+        });
+        expect(await constructor.getArgumentValue(resource, settings)).toEqual([
+          'ABC',
+        ]);
+        expect(constructionStrategy.createArray).toHaveBeenCalledWith({
+          settings,
+          elements: [
+            'ABC',
+          ],
+        });
+      });
+
+      it('should handle multiple elements', async() => {
+        const resource = objectLoader.createCompactedResource({
+          list: [
+            '"ABC"',
+            '"DEF"',
+            '"GHI"',
+          ],
+        });
+        expect(await constructor.getArgumentValue(resource, settings)).toEqual([
+          'ABC',
+          'DEF',
+          'GHI',
+        ]);
+        expect(constructionStrategy.createArray).toHaveBeenCalledWith({
+          settings,
+          elements: [
+            'ABC',
+            'DEF',
+            'GHI',
+          ],
+        });
+      });
+    });
+
     describe('for references', () => {
       it('should handle an IRI with value', async() => {
         const resource = objectLoader.createCompactedResource({