Add support for dotnet local tools

src/app/Fake.Core.Process/CreateProcess.fs

@@ -40,14 +40,17 @@ type ProcessResult<'a> = { Result : 'a; ExitCode : int }
 /// Handle for creating a process and returning potential results.
 type CreateProcess<'TRes> =
     internal {
-        Command : Command
+        InternalCommand : Command
         TraceCommand : bool
-        WorkingDirectory : string option
-        Environment : EnvMap option
+        InternalWorkingDirectory : string option
+        InternalEnvironment : EnvMap option
         Streams : StreamSpecs
         Hook : IProcessHook<'TRes>
     }
-    member x.CommandLine = x.Command.CommandLine
+    member x.CommandLine = x.InternalCommand.CommandLine
+    member x.Command = x.InternalCommand
+    member x.WorkingDirectory = x.InternalWorkingDirectory
+    member x.Environment = x.InternalEnvironment
 
 
 /// Module for creating and modifying CreateProcess<'TRes> instances.
@@ -102,11 +105,11 @@ module CreateProcess =
     ///     |> Proc.run
     ///     |> ignore
     let fromCommand command =
-        {   Command = command
-            WorkingDirectory = None
+        {   InternalCommand = command
+            InternalWorkingDirectory = None
             TraceCommand = true
             // Problem: Environment not allowed when using ShellCommand
-            Environment = None
+            InternalEnvironment = None
             Streams =
                 { // Problem: Redirection not allowed when using ShellCommand
                   StandardInput = Inherit
@@ -161,10 +164,10 @@ module CreateProcess =
 
     /// Create a CreateProcess from the given `ProcessStartInfo`
     let ofStartInfo (p:System.Diagnostics.ProcessStartInfo) =
-        {   Command = if p.UseShellExecute then ShellCommand p.FileName else RawCommand(p.FileName, Arguments.OfStartInfo p.Arguments)
+        {   InternalCommand = if p.UseShellExecute then ShellCommand p.FileName else RawCommand(p.FileName, Arguments.OfStartInfo p.Arguments)
             TraceCommand = true
-            WorkingDirectory = if System.String.IsNullOrWhiteSpace p.WorkingDirectory then None else Some p.WorkingDirectory
-            Environment = 
+            InternalWorkingDirectory = if System.String.IsNullOrWhiteSpace p.WorkingDirectory then None else Some p.WorkingDirectory
+            InternalEnvironment = 
                 p.Environment
                 |> Seq.map (fun kv -> kv.Key, kv.Value)
                 |> EnvMap.ofSeq
@@ -205,7 +208,7 @@ module CreateProcess =
     /// Set the working directory of the new process.
     let withWorkingDirectory workDir (c:CreateProcess<_>)=
         { c with
-            WorkingDirectory = Some workDir }
+            InternalWorkingDirectory = Some workDir }
 
     /// Disable the default trace of started processes.
     let disableTraceCommand (c:CreateProcess<_>)=
@@ -215,12 +218,12 @@ module CreateProcess =
     /// Set the command to the given one.
     let withCommand command (c:CreateProcess<_>)=
         { c with
-            Command = command }
+            InternalCommand = command }
 
     /// Replace the file-path
     let replaceFilePath newFilePath (c:CreateProcess<_>)=
         { c with
-            Command =
+            InternalCommand =
                 match c.Command with
                 | ShellCommand s -> failwith "Expected RawCommand"
                 | RawCommand (_, c) -> RawCommand(newFilePath, c) }
@@ -232,12 +235,13 @@ module CreateProcess =
 
 
     let internal withHook h (c:CreateProcess<_>) =
-      { Command = c.Command
+      { InternalCommand = c.Command
         TraceCommand = c.TraceCommand
-        WorkingDirectory = c.WorkingDirectory
-        Environment = c.Environment
+        InternalWorkingDirectory = c.InternalWorkingDirectory
+        InternalEnvironment = c.InternalEnvironment
         Streams = c.Streams
         Hook = h }
+
     let internal withHookImpl h (c:CreateProcess<_>) =
         c
         |> withHook (h |> ProcessHook.toRawHook)
@@ -260,6 +264,7 @@ module CreateProcess =
                 if not (isNull x.State1) then
                     x.State1.Dispose()
                 x.State2.Dispose()
+
     let internal hookAppendFuncs prepareState prepareStreams onStart onResult (c:IProcessHook<'TRes>) =    
         { new IProcessHookImpl<_, _> with
             member __.PrepareState () =
@@ -314,38 +319,39 @@ module CreateProcess =
     /// Execute the given function before the process is started 
     let addOnSetup f (c:CreateProcess<_>) =
         c
-        |> appendSimpleFuncs 
+        |> appendSimpleFuncs
             (fun _ -> f())
             (fun state p -> ())
             (fun prev state exitCode -> prev)
-            (fun _ -> ())
+            ignore
 
     /// Execute the given function when the process is cleaned up.        
     let addOnFinally f (c:CreateProcess<_>) =
         c
         |> appendSimpleFuncs 
-            (fun _ -> ())
+            ignore
             (fun state p -> ())
             (fun prev state exitCode -> prev)
             (fun _ -> f ())
     /// Execute the given function right after the process is started.          
     let addOnStarted f (c:CreateProcess<_>) =
         c
         |> appendSimpleFuncs 
-            (fun _ -> ())
+            ignore
             (fun state p -> f ())
             (fun prev state exitCode -> prev)
-            (fun _ -> ())
+            ignore
 
     /// Sets the given environment variables
     let withEnvironment (env: (string * string) list) (c:CreateProcess<_>)=
         { c with
-            Environment = Some (EnvMap.ofSeq env) }
+            InternalEnvironment = Some (EnvMap.ofSeq env) }
 
     /// Sets the given environment map.        
     let withEnvironmentMap (env: EnvMap) (c:CreateProcess<_>)=
         { c with
-            Environment = Some env }
+            InternalEnvironment = Some env }
+
     /// Retrieve the current environment map.    
     let getEnvironmentMap (c:CreateProcess<_>)=
         match c.Environment with
@@ -355,7 +361,7 @@ module CreateProcess =
     /// Set the given environment variable.
     let setEnvironmentVariable envKey (envVar:string) (c:CreateProcess<_>) =
         { c with
-            Environment =
+            InternalEnvironment =
                 getEnvironmentMap c
                 |> IMap.add envKey envVar
                 |> Some }
@@ -383,14 +389,14 @@ module CreateProcess =
     let map f c =
         c
         |> appendSimpleFuncs 
-            (fun _ -> ())
+            ignore
             (fun state p -> ())
             (fun prev state exitCode -> 
                 async {
                     let! old = prev
                     return f old
                 })
-            (fun _ -> ())
+            ignore
 
     /// Map only the result object and leave the exit code in the result type.
     let mapResult f (c:CreateProcess<ProcessResult<_>>) =

src/app/Fake.Core.Process/CreateProcessExt.fs

@@ -18,7 +18,7 @@ module CreateProcessExt =
             match Environment.isWindows, c.Command, Process.monoPath with
             | false, RawCommand(file, args), Some monoPath when file.ToLowerInvariant().EndsWith(".exe") ->
                 { c with
-                    Command = RawCommand(monoPath, Arguments.withPrefix ["--debug"; file] args) }
+                    InternalCommand = RawCommand(monoPath, Arguments.withPrefix ["--debug"; file] args) }
             | false, RawCommand(file, args), _ when file.ToLowerInvariant().EndsWith(".exe") ->
                 failwithf "trying to start a .NET process on a non-windows platform, but mono could not be found. Try to set the MONO environment variable or add mono to the PATH."
             | _ -> c

src/app/Fake.Core.Process/Process.fs

@@ -429,37 +429,47 @@ module Process =
             let hook = c.Hook
 
             let state = hook.PrepareState ()
-            let! exitCode =
+            let mutable stateNeedsDispose = true
+            try
+                let! exitCode =
+                    async {
+                        let procRaw =
+                          { Command = c.InternalCommand
+                            TraceCommand = c.TraceCommand
+                            WorkingDirectory = c.InternalWorkingDirectory
+                            Environment = c.InternalEnvironment
+                            Streams = c.Streams
+                            OutputHook =
+                                { new IRawProcessHook with
+                                    member x.Prepare streams = hook.PrepareStreams(state, streams)
+                                    member x.OnStart (p) = hook.ProcessStarted (state, p) } }
+
+                        let! e = processStarter.Start(procRaw)
+                        return e
+                    }
+
+                let output =
+                    hook.RetrieveResult (state, exitCode)
+                    |> Async.StartImmediateAsTask
                 async {
-                    let procRaw =
-                      { Command = c.Command
-                        TraceCommand = c.TraceCommand
-                        WorkingDirectory = c.WorkingDirectory
-                        Environment = c.Environment
-                        Streams = c.Streams
-                        OutputHook =
-                            { new IRawProcessHook with
-                                member x.Prepare streams = hook.PrepareStreams(state, streams)
-                                member x.OnStart (p) = hook.ProcessStarted (state, p) } }
-
-                    let! e = processStarter.Start(procRaw)
-                    return e
-                }
-
-            let output =
-                hook.RetrieveResult (state, exitCode)
-                |> Async.StartImmediateAsTask
-            async {
-                try
-                    let all = System.Threading.Tasks.Task.WhenAll([exitCode :> System.Threading.Tasks.Task; output:> System.Threading.Tasks.Task])
-                    let! streams =
-                        all.ContinueWith (new System.Func<System.Threading.Tasks.Task, unit> (fun t -> ()))
-                        |> Async.AwaitTaskWithoutAggregate
-                    if not (isNull state) then
-                        state.Dispose()
-                with e -> Trace.traceFAKE "Error in state dispose: %O" e }
-                |> Async.Start
-            return { Result = output; Raw = exitCode }
+                    let mutable needDispose = true
+                    try
+                        try
+                            let all = System.Threading.Tasks.Task.WhenAll([exitCode :> System.Threading.Tasks.Task; output:> System.Threading.Tasks.Task])
+                            let! streams =
+                                all.ContinueWith (new System.Func<System.Threading.Tasks.Task, unit> (fun t -> ()))
+                                |> Async.AwaitTaskWithoutAggregate
+                            needDispose <- false
+                            if not (isNull state) then
+                                state.Dispose()
+                        with e -> Trace.traceFAKE "Error in state dispose: %O" e
+                    finally
+                        if needDispose && not (isNull state) then state.Dispose() }
+                    |> Async.Start
+                stateNeedsDispose <- false
+                return { Result = output; Raw = exitCode }
+            finally
+                if stateNeedsDispose then state.Dispose()
           }
           // Immediate makes sure we set the ref cell before we return the task...
           |> Async.StartImmediateAsTask

src/app/Fake.Core.Process/RawProc.fs

@@ -32,13 +32,19 @@ module EnvMap =
         then ImmutableDictionary.Empty.WithComparers(StringComparer.OrdinalIgnoreCase) :> EnvMap
         else IMap.empty
 
-    let ofSeq l =
+    let ofSeq l : EnvMap =
         empty.AddRange(l |> Seq.map (fun (k, v) -> KeyValuePair<_,_>(k, v)))
 
     let create() =
         ofSeq (Environment.environVars ())
+
+    let addRange (l) (e:EnvMap) : EnvMap=
+        e.AddRange(l)
         //|> IMap.add defaultEnvVar defaultEnvVar
 
+    let ofMap (l) : EnvMap =
+        create()
+        |> addRange l
 
 /// The type of command to execute
 type Command =
@@ -53,6 +59,16 @@ type Command =
         | ShellCommand s -> s
         | RawCommand (f, arg) -> sprintf "%s %s" f arg.ToWindowsCommandLine
 
+    member x.Arguments =
+        match x with
+        | ShellCommand _ -> raise <| NotImplementedException "Cannot retrieve Arguments for ShellCommand"
+        | RawCommand (_, arg) -> arg
+
+    member x.Executable =
+        match x with
+        | ShellCommand _ -> raise <| NotImplementedException "Cannot retrieve Executable for ShellCommand"
+        | RawCommand (f, _) -> f
+
 /// Represents basically an "out" parameter, allows to retrieve a value after a certain point in time.
 /// Used to retrieve "pipes"
 type DataRef<'T> =
@@ -112,7 +128,7 @@ type internal RawCreateProcess =
         OutputHook : IRawProcessHook
     }
     member internal x.ToStartInfo =
-        let p = new System.Diagnostics.ProcessStartInfo()
+        let p = System.Diagnostics.ProcessStartInfo()
         match x.Command with
         | ShellCommand s ->
             p.UseShellExecute <- true