Accept a scalar when a list is expected.

When deserialising, if we expect a list a scalars, we already accept a
single scalar instead (this is the behaviour recommended by the LinkML
spec).

This commit implements the same behaviour in two other cases: (1) when
we expect a list of identifiers (for a multivalued, non-inlined slot)
and (2) when we expect a list of type designators.

Author: gouttegd

core/src/main/java/org/incenp/linkml/core/ObjectConverter.java

@@ -169,7 +169,7 @@ public Object convert(Map<String, Object> raw, ConverterContext ctx) throws Link
 
                 if ( designatorSlot.isMultivalued() ) {
                     ArrayList<String> designatorNames = new ArrayList<>();
-                    for ( Object rawDesignator : toList(designator) ) {
+                    for ( Object rawDesignator : toList(designator, true) ) {
                         designatorNames.add(designatorConverter.convert(rawDesignator, ctx).toString());
                     }
                     designatedClass = resolver.resolve(designatorNames, klass);
@@ -293,7 +293,7 @@ protected String getGlobalIdentifier(Object raw, ConverterContext ctx) throws Li
     protected List<String> getGlobalIdentifierList(Object raw, ConverterContext ctx) throws LinkMLRuntimeException {
         IConverter conv = ctx.getConverter(klass.getIdentifierSlot());
         ArrayList<String> list = new ArrayList<>();
-        for ( Object rawItem : toList(raw) ) {
+        for ( Object rawItem : toList(raw, true) ) {
             list.add(conv.convert(rawItem, ctx).toString());
         }
         return list;
@@ -366,7 +366,7 @@ public Map<String, Object> serialise(Object object, boolean withIdentifier, Conv
     public Object serialiseForSlot(Object object, Slot slot, ConverterContext ctx) throws LinkMLRuntimeException {
         InliningMode inlining = slot.getInliningMode();
         if ( slot.isMultivalued() ) {
-            List<Object> items = toList(object);
+            List<Object> items = toList(object, false);
             if ( inlining == InliningMode.LIST ) {
                 List<Object> list = new ArrayList<>();
                 for ( Object item : items ) {
@@ -445,18 +445,33 @@ protected Map<String, Object> toMap(Object value) throws LinkMLRuntimeException
     }
 
     /**
-     * Checks that a raw object is a list, and casts it as such.
+     * Turns a raw object into a list.
+     * <p>
+     * This checks that the given object is a list, and casts it as such. If it is
+     * not a list, then an exception is thrown, unless the <code>wrap</code>
+     * argument is set to <code>true</code>, in which case the value is wrapped into
+     * a single item list.
      * 
      * @param value The raw object to cast.
-     * @return The input object, cast into a list.
-     * @throws LinkMLRuntimeException If the raw object is not in fact a list.
+     * @param wrap  If <code>true</code> and <code>value</code> is not a list, then
+     *              return a newly created list containing only the value.
+     * @return The input object as a list.
+     * @throws LinkMLRuntimeException If the raw object is not in fact a list and
+     *                                <code>wrap</code> is <code>false</code>.
      */
     @SuppressWarnings("unchecked")
-    protected List<Object> toList(Object value) throws LinkMLRuntimeException {
+    protected List<Object> toList(Object value, boolean wrap) throws LinkMLRuntimeException {
         if ( !(value instanceof List) ) {
-            throw new LinkMLValueError(LIST_EXPECTED);
+            if ( wrap ) {
+                List<Object> l = new ArrayList<>();
+                l.add(value);
+                return l;
+            } else {
+                throw new LinkMLValueError(LIST_EXPECTED);
+            }
+        } else {
+            return (List<Object>) value;
         }
-        return (List<Object>) value;
     }
 
     /**

core/src/test/java/org/incenp/linkml/core/ObjectConverterTest.java

@@ -216,6 +216,15 @@ void testNormalisingLists() throws IOException {
         Assertions.assertEquals("value3", msd.getValues().get(0));
     }
 
+    @Test
+    void testScalarAsSingleItemList() throws IOException, LinkMLRuntimeException {
+        String text = "multiple: sic2\n";
+        ContainerOfReferences cor = parseString(text, ContainerOfReferences.class);
+        ctx.finalizeAssignments();
+
+        Assertions.assertEquals("sic2", cor.getMultiple().get(0).getId());
+    }
+
     @Test
     void testConvertingContainerOfReferences() throws IOException {
         // First read the inlined objects
@@ -454,6 +463,20 @@ void testMultivaluedTypeDesignator() throws IOException, LinkMLRuntimeException
         Assertions.assertEquals("DerivedMultiSelfDesignatedClass", types.get(1));
     }
 
+    @Test
+    void testSingleMultivaluedTypeDesignator() throws IOException {
+        // Slot is multivalued but is here provided with a scalar value
+        String text = "foo: A string\nbar: Another string\ntype: DerivedMultiSelfDesignatedClass\n";
+        BaseMultiSelfDesignatedClass bmsdc = parseString(text, BaseMultiSelfDesignatedClass.class);
+
+        Assertions.assertInstanceOf(DerivedMultiSelfDesignatedClass.class, bmsdc);
+        DerivedMultiSelfDesignatedClass derived = (DerivedMultiSelfDesignatedClass) bmsdc;
+        Assertions.assertEquals("A string", derived.getFoo());
+        Assertions.assertEquals("Another string", derived.getBar());
+
+        roundtrip(derived);
+    }
+
     @Test
     void testReferenceToIRIIdentifiers() throws IOException, LinkMLRuntimeException {
         ctx.addPrefix("PFX", "https://example.org/");