Parse run parameters and store their path/type

Author: Mark Robinson

src/main/java/org/commonwl/viewer/domain/CWLCollection.java

@@ -32,6 +32,8 @@
 import org.yaml.snakeyaml.Yaml;
 
 import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.util.*;
 
 /**
@@ -49,22 +51,20 @@ public class CWLCollection {
     private int singleFileSizeLimit;
 
     // Maps of ID to associated JSON
-    private Map<String, JsonNode> workflows = new HashMap<>();
+    private Map<String, JsonNode> cwlDocs = new HashMap<>();
 
     // The main workflow
     private String mainWorkflowKey;
 
     // Extension of CWL files
     private final String CWL_EXTENSION = "cwl";
 
-    // Github API specific strings
-    private final String DIR = "dir";
-    private final String FILE = "file";
-
     // CWL specific strings
     private final String DOC_GRAPH = "$graph";
     private final String CLASS = "class";
     private final String WORKFLOW = "Workflow";
+    private final String COMMANDLINETOOL = "CommandLineTool";
+    private final String EXPRESSIONTOOL = "ExpressionTool";
     private final String STEPS = "steps";
     private final String INPUTS = "inputs";
     private final String IN = "in";
@@ -117,7 +117,7 @@ private void addDocs(List<RepositoryContents> repoContents) throws IOException {
         for (RepositoryContents repoContent : repoContents) {
 
             // Parse subdirectories if they exist
-            if (repoContent.getType().equals(DIR)) {
+            if (repoContent.getType().equals(GitHubService.TYPE_DIR)) {
 
                 // Get the contents of the subdirectory
                 GithubDetails githubSubdir = new GithubDetails(githubInfo.getOwner(),
@@ -127,7 +127,7 @@ private void addDocs(List<RepositoryContents> repoContents) throws IOException {
                 // Add the files in the subdirectory to this new folder
                 addDocs(subdirectory);
 
-            } else if (repoContent.getType().equals(FILE)) {
+            } else if (repoContent.getType().equals(GitHubService.TYPE_FILE)) {
 
                 // Keep track of total file size for limit - only track files which
                 // will be added to the RO bundle due to being small enough
@@ -155,7 +155,7 @@ private void addDocs(List<RepositoryContents> repoContents) throws IOException {
                                 JsonNode cwlFile = mapper.valueToTree(reader.load(fileContent));
 
                                 // Add document to those being considered
-                                addDoc(cwlFile, repoContent.getName());
+                                addDoc(cwlFile, repoContent.getPath());
                             } else {
                                 throw new IOException("File '" + repoContent.getName() +  "' is over singleFileSizeLimit - " +
                                         FileUtils.byteCountToDisplaySize(repoContent.getSize()) + "/" +
@@ -181,15 +181,11 @@ private void addDoc(JsonNode newDoc, String fileName) {
         if (newDoc.has(DOC_GRAPH)) {
             // Add each of the sub documents
             for (JsonNode jsonNode : newDoc.get(DOC_GRAPH)) {
-                if (isWorkflow(jsonNode)) {
-                    workflows.put(extractID(jsonNode), jsonNode);
-                }
+                cwlDocs.put(extractID(jsonNode), jsonNode);
             }
         } else {
             // Otherwise just add the document itself with ID of document name
-            if (isWorkflow(newDoc)) {
-                workflows.put(fileName, newDoc);
-            }
+            cwlDocs.put(fileName, newDoc);
         }
     }
 
@@ -204,12 +200,12 @@ private String findMainWorkflow() {
 
         // Store the in degree of each workflow
         Map<String, Integer> inDegrees = new HashMap<String, Integer>();
-        for (String key : workflows.keySet()) {
+        for (String key : cwlDocs.keySet()) {
             inDegrees.put(key, 0);
         }
 
         // Loop through documents and calculate in degrees
-        for (Map.Entry<String, JsonNode> doc : workflows.entrySet()) {
+        for (Map.Entry<String, JsonNode> doc : cwlDocs.entrySet()) {
             JsonNode content = doc.getValue();
             if (content.get(CLASS).asText().equals(WORKFLOW)) {
                 // Parse workflow steps and see whether other workflows are run
@@ -269,16 +265,31 @@ public Workflow getWorkflow() {
                 return null;
             }
         }
-        JsonNode mainWorkflow = workflows.get(mainWorkflowKey);
+        JsonNode mainWorkflow = cwlDocs.get(mainWorkflowKey);
 
         // Use ID/filename for label if there is no defined one
         String label = extractLabel(mainWorkflow);
         if (label == null) {
             label = mainWorkflowKey;
         }
 
-        return new Workflow(label, extractDoc(mainWorkflow), getInputs(mainWorkflow),
-                            getOutputs(mainWorkflow), getSteps(mainWorkflow), getDockerLink(mainWorkflow));
+        Workflow workflowModel = new Workflow(label, extractDoc(mainWorkflow), getInputs(mainWorkflow),
+                getOutputs(mainWorkflow), getSteps(mainWorkflow), getDockerLink(mainWorkflow));
+        fillStepRunTypes(workflowModel);
+        return workflowModel;
+    }
+
+    /**
+     * Fill the step runtypes based on types of other documents
+     * @param workflow The workflow model to set runtypes for
+     */
+    private void fillStepRunTypes(Workflow workflow) {
+        Map<String, CWLStep> steps = workflow.getSteps();
+        for (CWLStep step : steps.values()) {
+            Path filePath = Paths.get(githubInfo.getPath()).resolve(step.getRun());
+            JsonNode runDoc = cwlDocs.get(filePath.toString());
+            step.setRunType(extractProcess(runDoc));
+        }
     }
 
     /**
@@ -295,7 +306,7 @@ private Map<String, CWLStep> getSteps(JsonNode cwlDoc) {
                 // Explicit ID and other fields within each input list
                 for (JsonNode step : steps) {
                     CWLStep stepObject = new CWLStep(extractLabel(step), extractDoc(step),
-                            extractTypes(step), getInputs(step), getOutputs(step));
+                            extractTypes(step), extractRun(step), getInputs(step), getOutputs(step));
                     returnMap.put(extractID(step), stepObject);
                 }
             } else if (steps.getClass() == ObjectNode.class) {
@@ -305,7 +316,8 @@ private Map<String, CWLStep> getSteps(JsonNode cwlDoc) {
                     Map.Entry<String, JsonNode> stepNode = iterator.next();
                     JsonNode stepJson = stepNode.getValue();
                     CWLStep stepObject = new CWLStep(extractLabel(stepJson), extractDoc(stepJson),
-                            extractTypes(stepJson), getInputs(stepJson), getOutputs(stepJson));
+                            extractTypes(stepJson), extractRun(stepJson), getInputs(stepJson),
+                            getOutputs(stepJson));
                     returnMap.put(stepNode.getKey(), stepObject);
                 }
             }
@@ -710,12 +722,23 @@ private String extractRun(JsonNode stepNode) {
     }
 
     /**
-     * Identify a JsonNode as a workflow
-     * @param rootNode The root node
-     * @return Whether or not the node is a workflow
+     * Extract the class parameter from a node representing a document
+     * @param rootNode The root node of a cwl document
+     * @return Which process this document represents
      */
-    private boolean isWorkflow(JsonNode rootNode) {
-        return (rootNode.has(CLASS)
-                && rootNode.get(CLASS).asText().equals(WORKFLOW));
+    private CWLProcess extractProcess(JsonNode rootNode) {
+        if (rootNode != null) {
+            if (rootNode.has(CLASS)) {
+                switch(rootNode.get(CLASS).asText()) {
+                    case WORKFLOW:
+                        return CWLProcess.WORKFLOW;
+                    case COMMANDLINETOOL:
+                        return CWLProcess.COMMANDLINETOOL;
+                    case EXPRESSIONTOOL:
+                        return CWLProcess.EXPRESSIONTOOL;
+                }
+            }
+        }
+        return null;
     }
 }

src/main/java/org/commonwl/viewer/domain/CWLProcess.java

@@ -0,0 +1,35 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.commonwl.viewer.domain;
+
+/**
+ * Enum for possible CWL processes
+ */
+public enum CWLProcess {
+    WORKFLOW,
+    COMMANDLINETOOL,
+    EXPRESSIONTOOL;
+
+    @Override
+    public String toString() {
+        String defaultString = super.toString();
+        return defaultString.substring(0, 1) + defaultString.substring(1).toLowerCase();
+    }
+}

src/main/java/org/commonwl/viewer/domain/CWLStep.java

@@ -29,14 +29,17 @@ public class CWLStep {
     private String label;
     private String doc;
     private String type;
+    private String run;
+    private CWLProcess runType;
     private Map<String, CWLElement> inputs;
     private Map<String, CWLElement> outputs;
 
-    public CWLStep(String label, String doc, String type,
+    public CWLStep(String label, String doc, String type, String run,
                    Map<String, CWLElement> inputs, Map<String, CWLElement> outputs) {
         this.label = label;
         this.doc = doc;
         this.type = type;
+        this.run = run;
         this.inputs = inputs;
         this.outputs = outputs;
     }
@@ -65,6 +68,22 @@ public void setType(String type) {
         this.type = type;
     }
 
+    public String getRun() {
+        return run;
+    }
+
+    public void setRun(String run) {
+        this.run = run;
+    }
+
+    public CWLProcess getRunType() {
+        return runType;
+    }
+
+    public void setRunType(CWLProcess runType) {
+        this.runType = runType;
+    }
+
     public Map<String, CWLElement> getInputs() {
         return inputs;
     }

src/main/java/org/commonwl/viewer/domain/ROBundle.java

@@ -121,7 +121,7 @@ private void addFiles(List<RepositoryContents> repoContents, Path path) throws I
         for (RepositoryContents repoContent : repoContents) {
 
             // Parse subdirectories if they exist
-            if (repoContent.getType().equals("dir")) {
+            if (repoContent.getType().equals(GitHubService.TYPE_DIR)) {
 
                 // Get the contents of the subdirectory
                 GithubDetails githubSubdir = new GithubDetails(githubInfo.getOwner(),
@@ -136,7 +136,7 @@ private void addFiles(List<RepositoryContents> repoContents, Path path) throws I
                 addFiles(subdirectory, subdirPath);
 
                 // Otherwise this is a file so add to the bundle
-            } else if (repoContent.getType().equals("file")) {
+            } else if (repoContent.getType().equals(GitHubService.TYPE_FILE)) {
 
                 try {
                     // Where to store the new file in bundle

src/main/java/org/commonwl/viewer/services/GitHubService.java

@@ -48,6 +48,10 @@
 @Service
 public class GitHubService {
 
+    // Github API specific strings
+    public static final String TYPE_DIR = "dir";
+    public static final String TYPE_FILE = "file";
+
     // Github API services
     private final ContentsService contentsService;
     private final UserService userService;

src/main/resources/templates/workflow.html

@@ -226,12 +226,17 @@ <h2>Steps</h2>
                     <th>ID</th>
                     <th>Label</th>
                     <th>Doc</th>
+                    <th>Runs</th>
                     </thead>
                     <tbody>
                     <tr th:each="step : ${workflow.steps}">
                         <td th:text="${step.key}">ID</td>
                         <td th:text="${step.value.label}">Label</td>
                         <td th:text="${step.value.doc}">Description</td>
+                        <td>
+                            <span th:text="${step.value.run}">run.cwl</span>
+                            (<span th:text="${step.value.runType}">Workflow</span>)
+                        </td>
                     </tr>
                     </tbody>
                 </table>