Fix #105: "multiple conformsTo values"

src/main/java/edu/kit/datamanager/ro_crate/reader/RoCrateReader.java

@@ -20,7 +20,10 @@
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Optional;
 import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.StreamSupport;
 
 /**
  * This class allows reading crates from the outside into the library in order
@@ -31,6 +34,19 @@
  */
 public class RoCrateReader {
 
+  private static final String FILE_PREVIEW_FILES = "ro-crate-preview_files";
+  private static final String FILE_PREVIEW_HTML = "ro-crate-preview.html";
+  private static final String FILE_METADATA_JSON = "ro-crate-metadata.json";
+
+  protected static final String SPECIFICATION_PREFIX = "https://w3id.org/ro/crate/";
+
+  protected static final String PROP_ABOUT = "about";
+  protected static final String PROP_CONTEXT = "@context";
+  protected static final String PROP_CONFORMS_TO = "conformsTo";
+  protected static final String PROP_GRAPH = "@graph";
+  protected static final String PROP_HAS_PART = "hasPart";
+  protected static final String PROP_ID = "@id";
+
   private final ReaderStrategy reader;
 
   public RoCrateReader(ReaderStrategy reader) {
@@ -45,32 +61,32 @@ public RoCrateReader(ReaderStrategy reader) {
    * @return the read RO-crate
    */
   public RoCrate readCrate(String location) {
-    RoCrate crate = new RoCrate();
     // get the ro-crate-medata.json
     ObjectNode metadataJson = reader.readMetadataJson(location);
     // get the content of the crate
     File files = reader.readContent(location);
-
+    
     // this set will contain the files that are associated with entities
     HashSet<String> usedFiles = new HashSet<>();
-    usedFiles.add(new File(location).toPath().resolve("ro-crate-metadata.json").toFile().getPath());
-    usedFiles.add(new File(location).toPath().resolve("ro-crate-preview.html").toFile().getPath());
-    usedFiles.add(new File(location).toPath().resolve("ro-crate-preview_files").toFile().getPath());
-
-    JsonNode context = metadataJson.get("@context");
-
+    usedFiles.add(new File(location).toPath().resolve(FILE_METADATA_JSON).toFile().getPath());
+    usedFiles.add(new File(location).toPath().resolve(FILE_PREVIEW_HTML).toFile().getPath());
+    usedFiles.add(new File(location).toPath().resolve(FILE_PREVIEW_FILES).toFile().getPath());
+    
+    JsonNode context = metadataJson.get(PROP_CONTEXT);
+    
     CrateMetadataContext crateContext = new RoCrateMetadataContext(context);
+    RoCrate crate = new RoCrate();
     crate.setMetadataContext(crateContext);
-    JsonNode graph = metadataJson.get("@graph");
+    JsonNode graph = metadataJson.get(PROP_GRAPH);
 
     if (graph.isArray()) {
 
       graph = setRootEntities(crate, (ArrayNode) graph);
       for (JsonNode node : graph) {
         // if the id is in the root hasPart list, we know this entity is a data entity
         RootDataEntity root = crate.getRootDataEntity();
-        if (root != null && root.hasInHasPart(node.get("@id").asText())) {
-          File loc = checkFolderHasFile(node.get("@id").asText(), files);
+        if (root != null && root.hasInHasPart(node.get(PROP_ID).asText())) {
+          File loc = checkFolderHasFile(node.get(PROP_ID).asText(), files);
           if (loc != null) {
             usedFiles.add(loc.getPath());
           }
@@ -100,62 +116,102 @@ public RoCrate readCrate(String location) {
     return crate;
   }
 
-  private File checkFolderHasFile(String id, File file) {
+  protected File checkFolderHasFile(String id, File file) {
     Path path = file.toPath().resolve(URLDecoder.decode(id, StandardCharsets.UTF_8));
     if (path.toFile().exists()) {
       return path.toFile();
     }
     return null;
   }
 
-  // gets the entities that every crate should have
-  // we will need the root dataset to distinguish between data entities and contextual entities
-  private ArrayNode setRootEntities(RoCrate crate, ArrayNode graph) {
-
-    // for now, we make an empty ArrayNode and putt all the entities
-    // that still need to be processed there
+  /**
+   * Sets the entities that every crate should have.
+   * 
+   * Extracts the root data entity and the Metadata File Descriptor (JSON
+   * descriptor) from the graph and inserts them into the crate object.
+   * We will need the root dataset to distinguish between data entities and
+   * contextual entities.
+   * 
+   * @param crate the crate, which will have the entities set, if available in the
+   *              graph.
+   * @param graph the graph of the Metadata JSON file, where the entities are
+   *              extracted from.
+   * @return the given graph, but without the root data entity and the Metadata
+   *         File Descriptor (JSON descriptor).
+   */
+  protected ArrayNode setRootEntities(RoCrate crate, ArrayNode graph) {
     var graphCopy = graph.deepCopy();
-    // use the algorithm described here: https://www.researchobject.org/ro-crate/1.1/root-data-entity.html#finding-the-root-data-entity
-    for (int i = 0; i < graph.size(); i++) {
-      JsonNode node = graph.get(i);
-      JsonNode type = node.get("conformsTo");
-      if (type != null) {
-        String uri = type.get("@id").asText();
-        if (uri.startsWith("https://w3id.org/ro/crate/")) {
-          crate.setJsonDescriptor(
-              new ContextualEntity.ContextualEntityBuilder().setAll(node.deepCopy()).build());
-          graphCopy.remove(i);
-          String id = node.get("about").get("@id").asText();
-          for (int j = 0; j < graphCopy.size(); j++) {
-            ObjectNode secondIteration = graphCopy.get(j).deepCopy();
-            if (secondIteration.get("@id").asText().equals(id)) {
-              // root data entity
-              JsonNode hasPartNode = secondIteration.get("hasPart");
-              Set<String> hasPartSet = new HashSet<>();
-              if (hasPartNode != null) {
-                if (hasPartNode.isArray()) {
-                  for (var e : hasPartNode) {
-                    hasPartSet.add(e.get("@id").asText());
-                  }
-                } else if (hasPartNode.isObject()) {
-                  hasPartSet.add(hasPartNode.get("@id").asText());
-                }
-              }
-              secondIteration.remove("hasPart");
-              crate.setRootDataEntity(
-                  new RootDataEntity.RootDataEntityBuilder()
-                      .setAll(secondIteration.deepCopy())
-                      .setHasPart(hasPartSet)
-                      .build()
-              );
-              graphCopy.remove(j);
-              break;
-            }
-          }
-        }
+    // use the algorithm described here:
+    // https://www.researchobject.org/ro-crate/1.1/root-data-entity.html#finding-the-root-data-entity
+    Optional<JsonNode> maybeDescriptor = StreamSupport.stream(graph.spliterator(), false)
+        // "2. if the conformsTo property is a URI that starts with
+        // https://w3id.org/ro/crate/"
+        .filter(node -> node.path(PROP_CONFORMS_TO).path(PROP_ID).asText().startsWith(SPECIFICATION_PREFIX))
+        // "3. from this entity’s about object keep the @id URI as variable root"
+        .filter(node -> node.path(PROP_ABOUT).path(PROP_ID).isTextual())
+        // There should be only one descriptor. If multiple exist, we take the first
+        // one.
+        .findFirst();
+
+    maybeDescriptor.ifPresent(descriptor -> {
+      removeJsonNodeFromArrayNode(graphCopy, descriptor);
+      setCrateDescriptor(crate, descriptor);
+
+      Optional<ObjectNode> maybeRoot = extractRoot(graphCopy, descriptor);
+
+      maybeRoot.ifPresent(root -> {
+        Set<String> hasPartIds = extractHasPartIds(root);
+
+        crate.setRootDataEntity(
+            new RootDataEntity.RootDataEntityBuilder()
+                .setAll(root.deepCopy())
+                .setHasPart(hasPartIds)
+                .build());
+
+        removeJsonNodeFromArrayNode(graphCopy, root);
+      });
+    });
+
+    return graphCopy;
+  }
+
+  private Optional<ObjectNode> extractRoot(ArrayNode graph, JsonNode descriptor) {
+    String rootId = descriptor.get(PROP_ABOUT).get(PROP_ID).asText();
+    return StreamSupport.stream(graph.spliterator(), false)
+        // convert to object note, if it is an object
+        .filter(JsonNode::isObject)
+        .map(JsonNode::<ObjectNode>deepCopy)
+        // "5. if the entity has an @id URI that matches root return it"
+        .filter(node -> node.path(PROP_ID).asText().equals(rootId))
+        .findFirst();
+  }
+
+  private Set<String> extractHasPartIds(ObjectNode root) {
+    JsonNode hasPartNode = root.path(PROP_HAS_PART);
+    Set<String> hasPartIds = StreamSupport.stream(hasPartNode.spliterator(), false)
+        .map(hasPart -> hasPart.path(PROP_ID).asText())
+        .filter(text -> !text.isBlank())
+        .collect(Collectors.toSet());
+    if (hasPartIds.isEmpty() && hasPartNode.path(PROP_ID).isTextual()) {
+      hasPartIds.add(hasPartNode.path(PROP_ID).asText());
+    }
+    return hasPartIds;
+  }
+
+  private void removeJsonNodeFromArrayNode(ArrayNode array, JsonNode node) {
+    for (int i = 0; i < array.size(); i++) {
+      if (array.get(i).equals(node)) {
+        array.remove(i);
+        return;
       }
     }
-    return graphCopy;
+  }
+
+  private void setCrateDescriptor(RoCrate crate, JsonNode descriptor) {
+    ContextualEntity descriptorEntity = new ContextualEntity.ContextualEntityBuilder()
+        .setAll(descriptor.deepCopy())
+        .build();
+    crate.setJsonDescriptor(descriptorEntity);
   }
 }