add expressiontool processing unit support

caroott · caroott · commit 8a4105547262 · 2026-02-11T14:15:40.000+01:00
diff --git a/src/CWL/ARCtrl.CWL.fsproj b/src/CWL/ARCtrl.CWL.fsproj
@@ -17,6 +17,7 @@
     <Compile Include="ParameterReference.fs" /> 
     <Compile Include="ToolDescription.fs" /> 
     <Compile Include="WorkflowDescription.fs" /> 
+    <Compile Include="ExpressionToolDescription.fs" />
     <Compile Include="CWLProcessingUnit.fs" /> 
     <Compile Include="Decode.fs" />
     <Compile Include="Encode.fs" />
diff --git a/src/CWL/CWLProcessingUnit.fs b/src/CWL/CWLProcessingUnit.fs
@@ -3,6 +3,7 @@ namespace ARCtrl.CWL
 type CWLProcessingUnit =
     | CommandLineTool of CWLToolDescription
     | Workflow of CWLWorkflowDescription
+    | ExpressionTool of CWLExpressionToolDescription
 
 [<RequireQualifiedAccess>]
 module WorkflowStepRunOps =
@@ -13,6 +14,9 @@ module WorkflowStepRunOps =
     let fromWorkflow (workflow: CWLWorkflowDescription) : WorkflowStepRun =
         RunWorkflow workflow
 
+    let fromExpressionTool (expressionTool: CWLExpressionToolDescription) : WorkflowStepRun =
+        RunExpressionTool expressionTool
+
     let tryGetTool (run: WorkflowStepRun) : CWLToolDescription option =
         match run with
         | RunCommandLineTool (:? CWLToolDescription as tool) -> Some tool
@@ -22,3 +26,8 @@ module WorkflowStepRunOps =
         match run with
         | RunWorkflow (:? CWLWorkflowDescription as workflow) -> Some workflow
         | _ -> None
+
+    let tryGetExpressionTool (run: WorkflowStepRun) : CWLExpressionToolDescription option =
+        match run with
+        | RunExpressionTool (:? CWLExpressionToolDescription as expressionTool) -> Some expressionTool
+        | _ -> None
diff --git a/src/CWL/Decode.fs b/src/CWL/Decode.fs
@@ -856,6 +856,7 @@ module Decode =
             match decodeCWLProcessingUnitElement normalizedRun with
             | CommandLineTool tool -> WorkflowStepRunOps.fromTool tool
             | Workflow workflow -> WorkflowStepRunOps.fromWorkflow workflow
+            | ExpressionTool expressionTool -> WorkflowStepRunOps.fromExpressionTool expressionTool
         | _ ->
             raise (System.ArgumentException($"Unsupported run value for workflow step: %A{runValue}"))
 
@@ -994,6 +995,68 @@ module Decode =
             description.Metadata <- Some metadata
         description
 
+    and expressionToolDecoder (yamlCWL: YAMLElement) =
+        let cwlVersion = versionDecoder yamlCWL
+        let outputs = outputsDecoder yamlCWL
+        let inputs = inputsDecoder yamlCWL
+        let requirements = requirementsDecoder yamlCWL
+        let hints = hintsDecoder yamlCWL
+        let doc = docDecoder yamlCWL
+        let label = labelDecoder yamlCWL
+        let expression =
+            Decode.object (fun get -> get.Required.Field "expression" decodeStringOrExpression) yamlCWL
+        let description =
+            CWLExpressionToolDescription(
+                outputs,
+                expression,
+                cwlVersion
+            )
+        let metadata =
+            let md = new DynamicObj ()
+            yamlCWL
+            |> Decode.object (fun get ->
+                overflowDecoder
+                    md
+                    (
+                        get.Overflow.FieldList [
+                            "inputs";
+                            "outputs";
+                            "class";
+                            "id";
+                            "label";
+                            "doc";
+                            "requirements";
+                            "hints";
+                            "cwlVersion";
+                            "expression";
+                        ]
+                    )
+            ) |> ignore
+            md
+        yamlCWL
+        |> Decode.object (fun get ->
+            overflowDecoder
+                description
+                (
+                    get.MultipleOptional.FieldList [
+                        "id";
+                    ]
+                )
+        ) |> ignore
+        if inputs.IsSome then
+            description.Inputs <- inputs
+        if requirements.IsSome then
+            description.Requirements <- requirements
+        if hints.IsSome then
+            description.Hints <- hints
+        if doc.IsSome then
+            description.Doc <- doc
+        if label.IsSome then
+            description.Label <- label
+        if metadata.GetProperties(false) |> Seq.length > 0 then
+            description.Metadata <- Some metadata
+        description
+
     and workflowDecoder (yamlCWL: YAMLElement) =
         let cwlVersion = versionDecoder yamlCWL
         let outputs = outputsDecoder yamlCWL
@@ -1062,6 +1125,7 @@ module Decode =
         match cls with
         | "CommandLineTool" -> CommandLineTool (commandLineToolDecoder yamlCWL)
         | "Workflow" -> Workflow (workflowDecoder yamlCWL)
+        | "ExpressionTool" -> ExpressionTool (expressionToolDecoder yamlCWL)
         | _ -> raise (System.ArgumentException($"Invalid or unsupported CWL class: {cls}"))
 
     let stepArrayDecoder = stepArrayDecoderWithVersion "v1.2"
@@ -1078,6 +1142,11 @@ module Decode =
         let yamlCWL = readSanitizedYaml cwl
         workflowDecoder yamlCWL
 
+    /// Decode a CWL file string written in the YAML format into a CWLExpressionToolDescription
+    let decodeExpressionTool (cwl: string) =
+        let yamlCWL = readSanitizedYaml cwl
+        expressionToolDecoder yamlCWL
+
     let decodeCWLProcessingUnit (cwl:string) =
         let yamlCWL = readSanitizedYaml cwl
         decodeCWLProcessingUnitElement yamlCWL
diff --git a/src/CWL/Encode.fs b/src/CWL/Encode.fs
@@ -478,6 +478,11 @@ module Encode =
             | Some workflow -> encodeWorkflowDescriptionElement workflow
             | None ->
                 raise (System.ArgumentException($"RunWorkflow must contain CWLWorkflowDescription but got %A{workflowObj}"))
+        | RunExpressionTool expressionToolObj ->
+            match WorkflowStepRunOps.tryGetExpressionTool run with
+            | Some expressionTool -> encodeExpressionToolDescriptionElement expressionTool
+            | None ->
+                raise (System.ArgumentException($"RunExpressionTool must contain CWLExpressionToolDescription but got %A{expressionToolObj}"))
 
     and encodeToolDescriptionElement (td: CWLToolDescription) : YAMLElement =
         let basePairs =
@@ -525,6 +530,49 @@ module Encode =
             | None -> withOutputs
         yMap withMetadata
 
+    and encodeExpressionToolDescriptionElement (et: CWLExpressionToolDescription) : YAMLElement =
+        let basePairs =
+            [ "cwlVersion", Encode.string et.CWLVersion
+              "class", Encode.string "ExpressionTool" ]
+            |> appendOptPair (et.Label |> Option.map encodeLabel)
+            |> appendOptPair (et.Doc |> Option.map encodeDoc)
+        let withHints =
+            match et.Hints with
+            | Some h when h.Count > 0 ->
+                basePairs @ [ "hints", (h |> Seq.map encodeRequirement |> List.ofSeq |> YAMLElement.Sequence) ]
+            | _ -> basePairs
+        let withRequirements =
+            match et.Requirements with
+            | Some r when r.Count > 0 ->
+                withHints @ [ "requirements", (r |> Seq.map encodeRequirement |> List.ofSeq |> YAMLElement.Sequence) ]
+            | _ -> withHints
+        let withInputs =
+            match et.Inputs with
+            | Some i when i.Count > 0 ->
+                withRequirements @ [ "inputs", (i |> Seq.map encodeCWLInput |> Seq.toList |> yMap) ]
+            | _ -> withRequirements
+        let withOutputs =
+            withInputs @ [ "outputs", (et.Outputs |> Seq.map encodeCWLOutput |> Seq.toList |> yMap) ]
+        let withExpression =
+            withOutputs @ [ "expression", Encode.string et.Expression ]
+        let withMetadata =
+            match et.Metadata with
+            | Some md ->
+                md.GetProperties(false)
+                |> Seq.fold (fun acc kvp ->
+                    let encodedValue =
+                        match kvp.Value with
+                        | :? string as s -> Encode.string s
+                        | :? bool as b -> yBool b
+                        | :? int as i -> Encode.int i
+                        | :? float as f -> Encode.float f
+                        | :? YAMLElement as y -> y
+                        | _ -> Encode.string (string kvp.Value)
+                    acc @ [ kvp.Key, encodedValue ]
+                ) withExpression
+            | None -> withExpression
+        yMap withMetadata
+
     and encodeWorkflowDescriptionElement (wd: CWLWorkflowDescription) : YAMLElement =
         let basePairs =
             [ "cwlVersion", Encode.string wd.CWLVersion
@@ -653,11 +701,16 @@ module Encode =
         encodeWorkflowDescriptionElement wd
         |> renderTopLevelElement ["cwlVersion"; "class"; "label"; "doc"] ["hints"; "requirements"; "inputs"; "steps"; "outputs"]
 
+    let encodeExpressionToolDescription (et:CWLExpressionToolDescription) : string =
+        encodeExpressionToolDescriptionElement et
+        |> renderTopLevelElement ["cwlVersion"; "class"; "label"; "doc"] ["hints"; "requirements"; "inputs"; "outputs"; "expression"]
+
 
     let encodeProcessingUnit (pu : CWLProcessingUnit) :string =
         match pu with
         | CommandLineTool td -> encodeToolDescription td
         | Workflow wd -> encodeWorkflowDescription wd
+        | ExpressionTool et -> encodeExpressionToolDescription et
 
     /// Encode a CWLType to a single-line YAML string using flow/inline style
     /// This produces YAML that doesn't contain newlines and can be embedded in JSON
diff --git a/src/CWL/ExpressionToolDescription.fs b/src/CWL/ExpressionToolDescription.fs
@@ -0,0 +1,64 @@
+namespace ARCtrl.CWL
+
+open DynamicObj
+open Fable.Core
+
+[<AttachMembers>]
+type CWLExpressionToolDescription (
+        outputs: ResizeArray<CWLOutput>,
+        expression: string,
+        ?cwlVersion: string,
+        ?requirements: ResizeArray<Requirement>,
+        ?hints: ResizeArray<Requirement>,
+        ?inputs: ResizeArray<CWLInput>,
+        ?metadata: DynamicObj,
+        ?label: string,
+        ?doc: string
+    ) =
+    inherit DynamicObj ()
+
+    let mutable _cwlVersion: string = cwlVersion |> Option.defaultValue "v1.2"
+    let mutable _outputs: ResizeArray<CWLOutput> = outputs
+    let mutable _expression: string = expression
+    let mutable _requirements: ResizeArray<Requirement> option = requirements
+    let mutable _hints: ResizeArray<Requirement> option = hints
+    let mutable _inputs: ResizeArray<CWLInput> option = inputs
+    let mutable _metadata: DynamicObj option = metadata
+    let mutable _label: string option = label
+    let mutable _doc: string option = doc
+
+    member this.CWLVersion
+        with get() = _cwlVersion
+        and set(version) = _cwlVersion <- version
+
+    member this.Outputs
+        with get() = _outputs
+        and set(outputs) = _outputs <- outputs
+
+    member this.Expression
+        with get() = _expression
+        and set(expression) = _expression <- expression
+
+    member this.Requirements
+        with get() = _requirements
+        and set(requirements) = _requirements <- requirements
+
+    member this.Hints
+        with get() = _hints
+        and set(hints) = _hints <- hints
+
+    member this.Inputs
+        with get() = _inputs
+        and set(inputs) = _inputs <- inputs
+
+    member this.Metadata
+        with get() = _metadata
+        and set(metadata) = _metadata <- metadata
+
+    member this.Label
+        with get() = _label
+        and set(label) = _label <- label
+
+    member this.Doc
+        with get() = _doc
+        and set(doc) = _doc <- doc
diff --git a/src/CWL/WorkflowSteps.fs b/src/CWL/WorkflowSteps.fs
@@ -115,6 +115,7 @@ type WorkflowStepRun =
     | RunString of string
     | RunCommandLineTool of obj
     | RunWorkflow of obj
+    | RunExpressionTool of obj
 
 [<AttachMembers>]
 type WorkflowStep (
