wire expressiontool in workflow conversion

Author: caroott

src/ARCtrl/CWLRunResolver.fs

@@ -54,6 +54,8 @@ and private resolveWorkflowStepRunRecursiveWithResolver (workflowFilePath: strin
                     let nextVisited =
                         resolveWorkflowRunsRecursiveWithResolver resolvedRunPath visitedWithCurrent workflow tryResolveRunPath
                     Some (CWL.WorkflowStepRunOps.fromWorkflow workflow, nextVisited)
+                | Some (CWL.ExpressionTool expressionTool) ->
+                    Some (CWL.WorkflowStepRunOps.fromExpressionTool expressionTool, visited.Add key)
                 | None ->
                     None
         )
@@ -68,6 +70,8 @@ and private resolveWorkflowStepRunRecursiveWithResolver (workflowFilePath: strin
             run, visited
     | CWL.RunCommandLineTool _ ->
         run, visited
+    | CWL.RunExpressionTool _ ->
+        run, visited
 
 /// Resolve CWL WorkflowStep `run` references for a processing unit via path lookup.
 let resolveRunReferencesFromLookup (workflowFilePath: string) (processingUnit: CWL.CWLProcessingUnit) (tryResolveRunPath: string -> CWL.CWLProcessingUnit option) : CWL.CWLProcessingUnit =
@@ -78,6 +82,8 @@ let resolveRunReferencesFromLookup (workflowFilePath: string) (processingUnit: C
         CWL.Workflow workflow
     | CWL.CommandLineTool _ ->
         processingUnit
+    | CWL.ExpressionTool _ ->
+        processingUnit
 
 /// Resolve a single workflow step run value via path lookup.
 let resolveWorkflowStepRunFromLookup (workflowFilePath: string) (run: CWL.WorkflowStepRun) (tryResolveRunPath: string -> CWL.CWLProcessingUnit option) : CWL.WorkflowStepRun =

src/ARCtrl/Conversion/Workflow.fs

@@ -182,17 +182,24 @@ type WorkflowConversion =
             | None -> ResizeArray []
         | CWL.Workflow wf -> 
             wf.Inputs |> ResizeArray.map (fun i -> i)
+        | CWL.ExpressionTool et ->
+            match et.Inputs with
+            | Some inputs -> inputs |> ResizeArray.map (fun i -> i)
+            | None -> ResizeArray []
 
 
     static member toolDescriptionTypeName = "ToolDescription"
 
     static member workflowDescriptionTypeName = "WorkflowDescription"
 
+    static member expressionToolDescriptionTypeName = "ExpressionToolDescription"
+
     static member private runToIdentifier (run : CWL.WorkflowStepRun) : string =
         match run with
         | CWL.RunString runPath -> runPath
         | CWL.RunCommandLineTool _ -> "inline:CommandLineTool"
         | CWL.RunWorkflow _ -> "inline:Workflow"
+        | CWL.RunExpressionTool _ -> "inline:ExpressionTool"
 
     static member private tryDecodeProcessingUnitFromGraph(resolvedRunPath: string, ?graph: LDGraph, ?context: LDContext) : CWL.CWLProcessingUnit option =
         let tryDecodeWorkflowProtocol (protocol: LDNode) =
@@ -263,6 +270,41 @@ type WorkflowConversion =
             inputs = inputs
         )
 
+    static member composeWorkflowProtocolFromExpressionToolDescription (filePath : string, expressionTool : CWL.CWLExpressionToolDescription, ?workflowName : string, ?runName : string) =
+        let inputs =
+            expressionTool.Inputs
+            |> Option.map (ResizeArray.map (fun i -> WorkflowConversion.composeFormalParameterFromInput(i, ?workflowName = workflowName, ?runName = runName)))
+        let outputs =
+            expressionTool.Outputs
+            |> ResizeArray.map (fun o -> WorkflowConversion.composeFormalParameterFromOutput(o, ?workflowName = workflowName, ?runName = runName))
+        let protocol =
+            LDWorkflowProtocol.create(
+                id = filePath,
+                name = filePath,
+                ?inputs = inputs,
+                programmingLanguages = ResizeArray.singleton (LDComputerLanguage.createCWL()),
+                outputs = outputs,
+                additionalType = ResizeArray [WorkflowConversion.expressionToolDescriptionTypeName]
+            )
+        LDLabProtocol.setDescriptionAsString(protocol, expressionTool.Expression)
+        protocol
+
+    static member decomposeWorkflowProtocolToExpressionToolDescription (protocol : LDNode, ?context : LDContext, ?graph : LDGraph) =
+        let inputs =
+            LDComputationalWorkflow.getInputsAsFormalParameters(protocol, ?graph = graph, ?context = context)
+            |> ResizeArray.map (fun i -> WorkflowConversion.decomposeInputFromFormalParameter(i, ?context = context, ?graph = graph))
+        let outputs =
+            LDComputationalWorkflow.getOutputsAsFormalParameter(protocol, ?graph = graph, ?context = context)
+            |> ResizeArray.map (fun o -> WorkflowConversion.decomposeOutputFromFormalParameter(o, ?context = context, ?graph = graph))
+        let expression =
+            LDLabProtocol.tryGetDescriptionAsString(protocol, ?context = context)
+            |> Option.defaultValue "$(null)"
+        CWL.CWLExpressionToolDescription(
+            outputs = outputs,
+            expression = expression,
+            inputs = inputs
+        )
+
     static member composeWorkflowStep (step : CWL.WorkflowStep, workflowID) =
         let id = $"WorkflowStep_{workflowID}_{step.Id}"
         let cw = LDComputationalWorkflow.create(id = id, name = step.Id)
@@ -344,13 +386,18 @@ type WorkflowConversion =
             WorkflowConversion.composeWorkflowProtocolFromToolDescription(filePath, tool, ?workflowName = workflowName, ?runName = runName)
         | CWL.Workflow wf -> 
             WorkflowConversion.composeWorkflowProtocolFromWorkflow(filePath, wf, ?workflowName = workflowName, ?runName = runName)
+        | CWL.ExpressionTool et ->
+            WorkflowConversion.composeWorkflowProtocolFromExpressionToolDescription(filePath, et, ?workflowName = workflowName, ?runName = runName)
 
     static member decomposeWorkflowProtocolToProcessingUnit (protocol : LDNode, ?resolveRunReferences: bool, ?context : LDContext, ?graph : LDGraph) =
         let shouldResolveRunReferences = defaultArg resolveRunReferences true
         match LDComputationalWorkflow.getAdditionalTypeAsString(protocol, ?context = context) with
         | s when s = WorkflowConversion.workflowDescriptionTypeName ->
             WorkflowConversion.decomposeWorkflowProtocolToWorkflow(protocol, resolveRunReferences = shouldResolveRunReferences, ?context = context, ?graph = graph)
             |> CWL.Workflow
+        | s when s = WorkflowConversion.expressionToolDescriptionTypeName ->
+            WorkflowConversion.decomposeWorkflowProtocolToExpressionToolDescription(protocol, ?context = context, ?graph = graph)
+            |> CWL.ExpressionTool
         | s ->
             WorkflowConversion.decomposeWorkflowProtocolToToolDescription(protocol, ?context = context, ?graph = graph)
             |> CWL.CommandLineTool