Take 1

WoofWorkflows/Pipeline.fs

@@ -2,36 +2,100 @@ namespace WoofWorkflows
 
 open System.IO
 
+type Stdout = Stdout of string Comp
+
+type PipelineModifier =
+    private
+    | WithEnv of key : string * value : string Comp
+    | WorkingDir of dir : DirectoryInfo Comp
+    | Remote of image : string Comp
+
+type Pipeline =
+    | Empty
+    | ShellScript of script : string * andThen : Pipeline
+    | ShellScriptBind of script : string * consumeStdout : (Stdout -> Pipeline)
+    | WithModifier of Pipeline * PipelineModifier list
+    | Sequence of first : Pipeline * second : Pipeline
+
 [<Sealed ; Class>]
-type Declarative<'plat> (codeRoot : DirectoryInfo Comp) =
-    member _.Return (sd : StepDag<'a, 'plat>) = StepDag.seal sd
-    [<CustomOperation ("sh", MaintainsVariableSpaceUsingBind = true)>] //, IsLikeZip = true
-    member _.RunShell
-        (command : StepDag<'prev, 'plat>, [<ProjectionParameter>] toRun : StepDag<'prev, 'plat> -> string)
-        : StepDag<'a, 'plat>
+type Pipeline<'plat> () =
+    [<CustomOperation "withEnv">]
+    member _.WithEnv
+        (mods : PipelineModifier list, (key : string, value : string Comp))
+        : PipelineModifier list
         =
-        failwith ""
-    // For binding in other StepDags
-    member _.Bind<'a, 'b> (toRun : string, cont : StepDag<'a, 'plat> -> SealedStepDag<'b, 'plat>) : StepDag<'b, 'plat> =
-        failwith ""
-    // For binding in other StepDags
-    member _.Bind (prev : 'args, cont : unit -> SealedStepDag<_, 'plat>) : SealedStepDag<_, _> =
-        failwith ""
-    member _.Yield<'a> (x : 'a) =
-        StepDag.empty<_, 'plat> x
-    //member _.For (m, cont : 'b -> 'c) : 'e =
-    //    failwith ""
+        PipelineModifier.WithEnv (key, value) :: mods
+
+    [<CustomOperation "withEnv">]
+    member _.WithEnv
+        (() : unit, (key : string, value : string Comp))
+        : PipelineModifier list
+        =
+        [PipelineModifier.WithEnv (key, value)]
+
+    [<CustomOperation "workingDir">]
+    member _.WorkingDir
+        (mods : PipelineModifier list, (dir : DirectoryInfo Comp))
+        : PipelineModifier list
+        =
+        PipelineModifier.WorkingDir dir :: mods
+
+    [<CustomOperation "workingDir">]
+    member _.WorkingDir
+        (() : unit, dir : DirectoryInfo Comp)
+        : PipelineModifier list
+        =
+        [PipelineModifier.WorkingDir dir]
+
+    [<CustomOperation "remote">]
+    member _.Remote
+        (() : unit, image : string Comp)
+        : PipelineModifier list
+        =
+        [PipelineModifier.Remote image]
+
+    [<CustomOperation "remote">]
+    member _.Remote
+        (mods : PipelineModifier list, image : string Comp)
+        : PipelineModifier list
+        =
+        PipelineModifier.Remote image :: mods
+
+    member _.Return (() : unit) = Pipeline.Empty
+
+    /// For running a script, capturing stdout
+    member _.Bind<'b> (toRun : string, cont : Stdout -> Pipeline) : Pipeline =
+        Pipeline.ShellScriptBind (toRun, cont)
+    /// For running a script, without capturing stdout
+    member _.Bind (toRun : string, cont : unit -> Pipeline) : Pipeline =
+        Pipeline.ShellScript (toRun, cont ())
+    member _.Bind (p : Pipeline, cont : unit -> Pipeline) : Pipeline =
+        Pipeline.Sequence (p, cont ())
+    member _.Yield (() : unit) : unit = ()
+    member _.For (expr : PipelineModifier list, cont : unit -> Pipeline) : Pipeline =
+        Pipeline.WithModifier (cont (), expr)
 
 [<AutoOpen>]
 module Pipeline =
-    let readOnlyPipeline<'plat> (codeRoot : DirectoryInfo Comp) = Declarative<'plat> codeRoot
+    let pipeline<'plat> = Pipeline<'plat> ()
+    let toStepDag (p : Pipeline) : SealedStepDag<unit, unit> = failwith "TODO"
 
-    let foo<'a> : SealedStepDag<'a, unit> =
-        readOnlyPipeline (Comp.make (DirectoryInfo "code root here")) {
-            let! (foo : StepDag<int, string>) = "sh script here"
-            sh "a shell script"
-            return (StepDag.empty 4)
+    let foo : SealedStepDag<unit, unit> =
+        pipeline {
+            withEnv ("hi", Comp.make "bye")
+            workingDir (Comp.make (DirectoryInfo "code root here"))
+            withEnv ("foo", Comp.make "bar")
+            remote (Comp.make "some-image")
+            let! (Stdout stdout) = "sh script here"
+            do! pipeline {
+                withEnv ("foo", stdout)
+                do! "git config --foo"
+                return ()
+            }
+            do! "a shell script"
+            return ()
         }
+        |> toStepDag
 
         (*
          declarative.Bind<object, a, SealedStepDag<a, Unit>>(

WoofWorkflows/Program.fs

@@ -3,6 +3,6 @@
 module Program =
     [<EntryPoint>]
     let main argv =
-        Pipeline.foo<uint32>
+        Pipeline.foo
         |> ignore
         0