1466-instantiate-csv-data-as-rdf: Added alternate shortcut YARRRML keys for parsing

Author: qhouyee

stack-clients/src/main/java/com/cmclinnovations/stack/clients/utils/YarrrmlFile.java

@@ -28,8 +28,13 @@ public final class YarrrmlFile {
     private static final String TARGETS_KEY = "targets";
     private static final String TARGET_REF_KEY = "target-ref";
     private static final String MAPPING_KEY = "mappings";
+    private static final String MAPPING_ALT_KEY = "mapping";
+    private static final String MAPPING_ALT_TWO_KEY = "m";
     private static final String SUBJECT_KEY = "s";
+    private static final String SUBJECT_ALT_KEY = "subject";
+    private static final String SUBJECT_ALT_TWO_KEY = "subjects";
     private static final String PRED_OBJ_KEY = "po";
+    private static final String PRED_OBJ_ALT_KEY = "predicateobjects";
     private static final String ACCESS_KEY = "access";
 
     /**
@@ -78,6 +83,13 @@ public String getFileName() {
         return this.fileName;
     }
 
+    /**
+     * Get the rules content.
+     */
+    public Map<String, Object> getRules() {
+        return this.rules;
+    }
+
     /**
      * Writes the file content into a byte array for further usage.
      */
@@ -149,19 +161,23 @@ private void appendTargets(Map<String, Object> output, String endpoint) {
      * @param output The target YAML output.
      */
     private void updateMappings(Map<String, Object> output) {
-        Map<String, Object> ruleMappings = this.castToMapStringObject(output.get(MAPPING_KEY));
+        Map<String, Object> ruleMappings = this.castToMapStringObject(
+                this.getObjectWithOneOfManyKeys(output, MAPPING_KEY, MAPPING_ALT_KEY, MAPPING_ALT_TWO_KEY));
         ruleMappings.forEach((field, value) -> {
             // Addition of sources and their reference
             Map<String, Object> mappingValue = this.castToMapStringObject(value);
             mappingValue.put(SOURCES_KEY, SOURCE_REF_KEY);
 
             // Addition of targets and their reference
-            Object subjectVal = mappingValue.get(SUBJECT_KEY);
+            Object subjectVal = this.getObjectWithOneOfManyKeys(mappingValue, SUBJECT_KEY, SUBJECT_ALT_KEY,
+                    SUBJECT_ALT_TWO_KEY);
             if (subjectVal instanceof String) {
                 Map<String, Object> newSubjectMap = new HashMap<>();
                 newSubjectMap.put("value", subjectVal);
                 newSubjectMap.put(TARGETS_KEY, TARGET_REF_KEY);
                 mappingValue.put(SUBJECT_KEY, newSubjectMap);
+                mappingValue.remove(SUBJECT_ALT_KEY);
+                mappingValue.remove(SUBJECT_ALT_TWO_KEY);
             } else if (subjectVal instanceof Map<?, ?>) {
                 Map<String, Object> stringObjectMap = this.castToMapStringObject(subjectVal);
                 stringObjectMap.put(TARGETS_KEY, TARGET_REF_KEY);
@@ -172,7 +188,8 @@ private void updateMappings(Map<String, Object> output) {
             // BUT YARRRML parser only accepts -[] as a shortcut and should be updated
             // accordingly
             List<Map<String, String>> transformedPo = new ArrayList<>();
-            List<Object> originalPo = this.castToListObject(mappingValue.get(PRED_OBJ_KEY));
+            List<Object> originalPo = this
+                    .castToListObject(this.getObjectWithOneOfManyKeys(mappingValue, PRED_OBJ_KEY, PRED_OBJ_ALT_KEY));
             for (Object predObj : originalPo) {
                 if (predObj instanceof List) {
                     List<Object> nestedPredObjList = this.castToListObject(predObj);
@@ -187,8 +204,27 @@ private void updateMappings(Map<String, Object> output) {
             }
             if (!transformedPo.isEmpty()) {
                 mappingValue.put(PRED_OBJ_KEY, transformedPo);
+                mappingValue.remove(PRED_OBJ_ALT_KEY);
             }
         });
+        output.put(MAPPING_KEY, ruleMappings);
+        output.remove(MAPPING_ALT_KEY);
+        output.remove(MAPPING_ALT_TWO_KEY);
+    }
+
+    /**
+     * Gets the object from the mappings based on any of the shortcut key inputs.
+     * 
+     * @param mappings     The target mappings.
+     * @param shortcutKeys The possible shortcut keys available in YARRRML.
+     */
+    private Object getObjectWithOneOfManyKeys(Map<String, Object> mappings, String... shortcutKeys) {
+        for (String shortcut : shortcutKeys) {
+            if (mappings.containsKey(shortcut)) {
+                return mappings.get(shortcut);
+            }
+        }
+        throw new IllegalArgumentException("Invalid input. Object is not a Map.");
     }
 
     private Map<String, Object> castToMapStringObject(Object obj) throws ClassCastException {

stack-clients/src/test/java/com/cmclinnovations/stack/clients/utils/YarrrmlFileTest.java

@@ -1,34 +1,29 @@
 package com.cmclinnovations.stack.clients.utils;
 
-import java.io.ByteArrayOutputStream;
 import java.io.IOException;
-import java.io.OutputStreamWriter;
-import java.io.Writer;
-import java.net.URI;
 import java.net.URISyntaxException;
-import java.nio.charset.StandardCharsets;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
-import java.util.LinkedHashMap;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
-import org.yaml.snakeyaml.DumperOptions;
-import org.yaml.snakeyaml.Yaml;
+
+import com.google.common.base.Objects;
 
 class YarrrmlFileTest {
     private static final String TEST_ENDPOINT = "https://example.org/kg/sparql";
     private static final String TEST_ONE_FILE_NAME = "rules.yml";
     private static final String TEST_TWO_FILE_NAME = "rules2.yml";
 
     @Test
-    void testDefaultConstructor() throws IOException {
+    void testDefaultConstructor() {
         YarrrmlFile yarrrmlFile = new YarrrmlFile();
         String expected = "";
-        checkRules(yarrrmlFile, expected, expected);
+        checkRules(yarrrmlFile, expected, new HashMap<>());
     }
 
     @Test
@@ -54,82 +49,53 @@ void testAddRules_SuccessShortcutFormat() throws IOException, URISyntaxException
         checkRules(yarrrmlFile, TEST_TWO_FILE_NAME, this.genExpectedYarrrmlContents(TEST_TWO_FILE_NAME));
     }
 
-    private void checkRules(YarrrmlFile yarrrmlFile, String expectedFileName, String expectedContents)
-            throws IOException {
+    private void checkRules(YarrrmlFile yarrrmlFile, String expectedFileName, Map<String, Object> expectedContents) {
         Assertions.assertEquals(expectedFileName, yarrrmlFile.getFileName());
-        Assertions.assertEquals(expectedContents, new String(yarrrmlFile.write(), StandardCharsets.UTF_8));
+        Assertions.assertTrue(Objects.equal(expectedContents, yarrrmlFile.getRules()));
     }
 
-    private String genExpectedYarrrmlContents(String fileName) throws IOException {
-        DumperOptions options = new DumperOptions();
-        options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
-        options.setPrettyFlow(true);
-        Yaml yaml = new Yaml(options);
-        Map<String, Object> yamlData = new LinkedHashMap<>();
-
-        Map<String, String> prefixes = new LinkedHashMap<>();
-        prefixes.put("rdfs", "http://www.w3.org/2000/01/rdf-schema#");
-        prefixes.put("base", "https://theworldavatar.io/kg/");
-        yamlData.put("prefixes", prefixes);
-
-        Map<String, Map<String, Object>> mappings = new LinkedHashMap<>();
-
-        Map<String, Object> personMapping = new LinkedHashMap<>();
-        Map<String, Object> personS = new LinkedHashMap<>();
-        personS.put("value", "base:person/$(id)");
-        personS.put("targets", "target-ref");
-        personMapping.put("s", personS);
-
-        List<Map<String, Object>> personPO = new ArrayList<>();
-        this.genExpectedYarrrmlPredObj(personPO, "a", "base:Person");
-        this.genExpectedYarrrmlPredObj(personPO, "base:hasName", "base:person/name/$(id)~iri");
-        personMapping.put("po", personPO);
+    private Map<String, Object> genExpectedYarrrmlContents(String fileName) {
+        Map<String, Object> yamlData = new HashMap<>();
 
-        personMapping.put("sources", "source-ref");
-        mappings.put("person", personMapping);
+        yamlData.put("prefixes", Map.of(
+                "rdfs", "http://www.w3.org/2000/01/rdf-schema#",
+                "base", "https://theworldavatar.io/kg/"));
 
-        Map<String, Object> personNameMapping = new LinkedHashMap<>();
-        Map<String, Object> personNameS = new LinkedHashMap<>();
-        personNameS.put("value", "base:person/name/$(id)");
-        personNameS.put("targets", "target-ref");
-        personNameMapping.put("s", personNameS);
+        Map<String, Map<String, Object>> mappings = new HashMap<>();
 
-        List<Map<String, Object>> personNamePO = new ArrayList<>();
-        this.genExpectedYarrrmlPredObj(personNamePO, "a", "base:PersonName");
-        this.genExpectedYarrrmlPredObj(personNamePO, "rdfs:label", "$(name)");
-        personNameMapping.put("po", personNamePO);
+        mappings.put("person", Map.of(
+                "sources", "source-ref",
+                "s", Map.of(
+                        "value", "base:person/$(id)",
+                        "targets", "target-ref"),
+                "po", List.of(this.genExpectedYarrrmlPredObj("a", "base:Person"),
+                        this.genExpectedYarrrmlPredObj("base:hasName", "base:person/name/$(id)~iri"))));
 
-        personNameMapping.put("sources", "source-ref");
-        mappings.put("person-name", personNameMapping);
+        mappings.put("person-name", Map.of(
+                "sources", "source-ref",
+                "s", Map.of(
+                        "value", "base:person/name/$(id)",
+                        "targets", "target-ref"),
+                "po", List.of(this.genExpectedYarrrmlPredObj("a", "base:PersonName"),
+                        this.genExpectedYarrrmlPredObj("rdfs:label", "$(name)"))));
 
         yamlData.put("mappings", mappings);
 
-        Map<String, Map<String, Object>> sources = new LinkedHashMap<>();
-        Map<String, Object> sourceRef = new LinkedHashMap<>();
-        sourceRef.put("referenceFormulation", "csv");
-        sourceRef.put("access", FileUtils.replaceExtension(fileName, "csv"));
-        sources.put("source-ref", sourceRef);
-        yamlData.put("sources", sources);
-
-        Map<String, Map<String, Object>> targets = new LinkedHashMap<>();
-        Map<String, Object> targetRef = new LinkedHashMap<>();
-        targetRef.put("serialization", "turtle");
-        targetRef.put("access", "https://example.org/kg/sparql");
-        targetRef.put("type", "sd");
-        targets.put("target-ref", targetRef);
-        yamlData.put("targets", targets);
-
-        try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
-                Writer writer = new OutputStreamWriter(outputStream)) {
-            yaml.dump(yamlData, writer);
-            return outputStream.toString();
-        }
+        yamlData.put("sources", Map.of(
+                "source-ref", Map.of(
+                        "referenceFormulation", "csv",
+                        "access", FileUtils.replaceExtension(fileName, "csv"))));
+        yamlData.put("targets", Map.of(
+                "target-ref", Map.of(
+                        "serialization", "turtle",
+                        "access", "https://example.org/kg/sparql",
+                        "type", "sd")));
+        return yamlData;
     }
 
-    private void genExpectedYarrrmlPredObj(List<Map<String, Object>> output, String predVal, String objVal) {
-        Map<String, Object> predObjMap = new LinkedHashMap<>();
-        predObjMap.put("p", predVal);
-        predObjMap.put("o", objVal);
-        output.add(predObjMap);
+    private Map<String, Object> genExpectedYarrrmlPredObj(String predVal,
+            String objVal) {
+        return Map.of("p", predVal,
+                "o", objVal);
     }
 }

stack-clients/src/test/resources/com/cmclinnovations/stack/clients/utils/rules2.yml

@@ -2,14 +2,14 @@ prefixes:
   rdfs: "http://www.w3.org/2000/01/rdf-schema#"
   base: "https://theworldavatar.io/kg/"
 
-mappings:
+mapping:
   person:
-    s: base:person/$(id)
-    po:
+    subjects: base:person/$(id)
+    predicateobjects:
       - [a, base:Person]
       - [base:hasName, base:person/name/$(id)~iri]
   person-name:
-    s: base:person/name/$(id)
+    subject: base:person/name/$(id)
     po:
       - [a, base:PersonName]
       - [rdfs:label, $(name)]