Merge pull request #3 from Kapersyx/fix/inlined-subclasses-with-designates_type

Fix polymorphism when loading the contents of a multivalued inlined_as_dict slot #85

Author: kervel

src/runtime/src/lib.rs

@@ -291,16 +291,18 @@ impl LinkMLValue {
                     })?;
                 let mut values = HashMap::new();
                 for (k, v) in map.into_iter() {
-                    let chosen = sv
+                    let base = sv
                         .get_class(&Identifier::new(range_cv.name()), conv)
                         .ok()
                         .flatten()
                         .unwrap_or_else(|| range_cv.clone());
                     let child = match v {
                         JsonValue::Object(m) => {
+                            // Select the most specific subclass using any type designator in the map
+                            let selected = Self::select_class(&m, &base, sv, conv);
                             let mut child_values = HashMap::new();
                             for (ck, cv) in m.into_iter() {
-                                let slot_tmp = chosen
+                                let slot_tmp = selected
                                     .slots()
                                     .iter()
                                     .find(|s| slot_matches_key(s, &ck))
@@ -315,7 +317,7 @@ impl LinkMLValue {
                                     key_name,
                                     Self::from_json_internal(
                                         cv,
-                                        chosen.clone(),
+                                        selected.clone(),
                                         slot_tmp,
                                         sv,
                                         conv,
@@ -326,14 +328,14 @@ impl LinkMLValue {
                             }
                             LinkMLValue::Object {
                                 values: child_values,
-                                class: chosen.clone(),
+                                class: selected,
                                 sv: sv.clone(),
                             }
                         }
                         other => {
                             // Scalar mapping value: attach it to a chosen scalar slot if any
                             let scalar_slot = Self::find_scalar_slot_for_inlined_map(
-                                &chosen,
+                                &base,
                                 range_cv
                                     .key_or_identifier_slot()
                                     .map(|s| s.name.as_str())
@@ -351,13 +353,13 @@ impl LinkMLValue {
                                 LinkMLValue::Scalar {
                                     value: other,
                                     slot: scalar_slot.clone(),
-                                    class: Some(chosen.clone()),
+                                    class: Some(base.clone()),
                                     sv: sv.clone(),
                                 },
                             );
                             LinkMLValue::Object {
                                 values: child_values,
-                                class: chosen.clone(),
+                                class: base.clone(),
                                 sv: sv.clone(),
                             }
                         }

src/runtime/tests/data/mapping_data.json

@@ -0,0 +1,15 @@
+{
+  "things": {
+    "alpha": {
+      "typeURI": "ThingA",
+      "a_only": "foo",
+      "common": "shared"
+    },
+    "beta": {
+      "typeURI": "ThingB",
+      "b_only": true,
+      "common": "shared"
+    }
+  }
+}
+

src/runtime/tests/data/mapping_schema.yaml

@@ -0,0 +1,39 @@
+id: https://example.org/mapping
+name: mapping
+prefixes:
+  ex: https://example.org/
+
+default_prefix: ex
+
+classes:
+  Bag:
+    attributes:
+      things:
+        range: Thing
+        multivalued: true
+        inlined: true
+        inlined_as_list: false
+
+  Thing:
+    attributes:
+      key:
+        range: string
+        key: true
+      typeURI:
+        range: string
+        designates_type: true
+      common:
+        range: string
+
+  ThingA:
+    is_a: Thing
+    attributes:
+      a_only:
+        range: string
+
+  ThingB:
+    is_a: Thing
+    attributes:
+      b_only:
+        range: boolean
+

src/runtime/tests/inlined_mapping_subclass.rs

@@ -0,0 +1,55 @@
+use linkml_runtime::{load_json_file, validate, LinkMLValue};
+use linkml_schemaview::identifier::{converter_from_schema, Identifier};
+use linkml_schemaview::io::from_yaml;
+use linkml_schemaview::schemaview::SchemaView;
+use std::path::{Path, PathBuf};
+
+fn data_path(name: &str) -> PathBuf {
+    let mut p = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    p.push("tests");
+    p.push("data");
+    p.push(name);
+    p
+}
+
+#[test]
+fn inlined_mapping_selects_subclass_by_typeuri() {
+    // Load simple schema
+    let schema = from_yaml(Path::new(&data_path("mapping_schema.yaml"))).unwrap();
+    let mut sv = SchemaView::new();
+    sv.add_schema(schema.clone()).unwrap();
+    let conv = converter_from_schema(&schema);
+
+    // Base container class
+    let bag = sv
+        .get_class(&Identifier::new("Bag"), &conv)
+        .unwrap()
+        .expect("class not found");
+
+    // Load JSON data
+    let v = load_json_file(Path::new(&data_path("mapping_data.json")), &sv, &bag, &conv).unwrap();
+
+    // Instance should validate
+    assert!(validate(&v).is_ok());
+
+    // Ensure inlined mapping children select subclasses based on typeURI
+    match v {
+        LinkMLValue::Object { values, .. } => {
+            let things = values.get("things").expect("things slot missing");
+            match things {
+                LinkMLValue::Mapping { values, .. } => {
+                    match values.get("alpha").expect("alpha missing") {
+                        LinkMLValue::Object { class, .. } => assert_eq!(class.name(), "ThingA"),
+                        _ => panic!("alpha should be an object"),
+                    }
+                    match values.get("beta").expect("beta missing") {
+                        LinkMLValue::Object { class, .. } => assert_eq!(class.name(), "ThingB"),
+                        _ => panic!("beta should be an object"),
+                    }
+                }
+                _ => panic!("things should be a mapping"),
+            }
+        }
+        _ => panic!("expected top-level object"),
+    }
+}