Execute the process and wait

tpetricek · tpetricek · commit 3f3627559044 · 2015-04-11T02:59:40.000+02:00
diff --git a/build.fsx b/build.fsx
@@ -1,11 +1,11 @@
 // --------------------------------------------------------------------------------------
-// FAKE build script 
+// FAKE build script
 // --------------------------------------------------------------------------------------
 
 #I "packages/FAKE/tools"
 #r "packages/FAKE/tools/FakeLib.dll"
 open System
-open Fake 
+open Fake
 open Fake.Git
 open Fake.ReleaseNotesHelper
 open Fake.AssemblyInfoFile
@@ -19,10 +19,10 @@ open Fake.AssemblyInfoFile
 #load "src/paket.fsx"
 #load "src/core.fsx"
 
-// Translate the type given as #1 using module name #2 
+// Translate the type given as #1 using module name #2
 // and save the result to a file specified in #3
-let atomModules = 
-  [ typeof<Core.Core>, "AtomFSharpCore", "src/core/lib/core.js"; 
+let atomModules =
+  [ typeof<Core.Core>, "AtomFSharpCore", "src/core/lib/core.js";
     typeof<Paket.Paket>, "AtomFSharpPaket", "src/paket/lib/paket.js" ]
 
 // --------------------------------------------------------------------------------------
@@ -36,11 +36,11 @@ open System.Reflection
 open Microsoft.FSharp.Quotations
 open FunScript.Compiler
 
-let translateModules() = 
+let translateModules() =
   for typ, moduleName, fileName in atomModules do
 
-    // We generate F# quotation that returns all the methods that we want to expose 
-    // from the class. This way, we can then wrap it into simple JS code that 
+    // We generate F# quotation that returns all the methods that we want to expose
+    // from the class. This way, we can then wrap it into simple JS code that
     // creates the module. The generated quotation looks something like this:
     //
     //   [| box (fun () -> new WordCount());
@@ -53,11 +53,11 @@ let translateModules() =
     /// Creates "(fun p1 .. pn -> <body>)" and "[p1; ..; pn]"
     /// (which is used when generating boxed lambdas that pass parameters to the actual function)
     let createParameterPassing (m:MethodBase) =
-      let paramVars = m.GetParameters() |> Array.mapi (fun i p -> Var(sprintf "p%d" i, p.ParameterType)) 
+      let paramVars = m.GetParameters() |> Array.mapi (fun i p -> Var(sprintf "p%d" i, p.ParameterType))
       let paramArgs = [ for v in paramVars -> Expr.Var(v) ]
       let lambdaConstr = paramVars |> Seq.fold (fun fn var -> fun body -> Expr.Lambda(var, fn body)) id
       lambdaConstr, paramArgs
-        
+
     let exportFunctions =
       [ for m in meths ->
           let tv = new Var("this", typ)
@@ -69,15 +69,15 @@ let translateModules() =
         ( Expr.Lambda(Var("ign", typeof<unit>), Expr.NewObject(typ.GetConstructor [||], [])),
           typeof<obj> )
 
-    let functionArray = 
-      Expr.NewArray(typeof<obj>, exportCtor::[ for f in exportFunctions -> Expr.Coerce(f, typeof<obj>)]) 
+    let functionArray =
+      Expr.NewArray(typeof<obj>, exportCtor::[ for f in exportFunctions -> Expr.Coerce(f, typeof<obj>)])
 
     let coreJS = Compiler.Compile(functionArray)
 
     // Now we just wrap the generated JavaScript into 'wrappedFunScript' function
     // Then we call the function and create a module export with all the public methods
-    // from the provided type (just by calling one of the functions from the array) 
-    let moduleJS = 
+    // from the provided type (just by calling one of the functions from the array)
+    let moduleJS =
       [ yield "var CompositeDisposable = require('atom').CompositeDisposable;"
         yield "var child_process = require('child_process');"
         yield "window.$ = require('jquery');"
@@ -110,8 +110,8 @@ let typings = __SOURCE_DIRECTORY__ @@ "typings"
 let typesZip = typings @@ "FunScript.TypeScript" @@ "Types.zip"
 let noInline = set [ "jquery.d.ts"; "node.d.ts"; "atom.d.ts" ]
 
-let fsharpBin = 
-  [ "/Library/Frameworks/Mono.framework/Versions/3.10.0/lib/mono/4.0" 
+let fsharpBin =
+  [ "/Library/Frameworks/Mono.framework/Versions/3.10.0/lib/mono/4.0"
     (* TODO: This needs to list many more locations where fsc.exe can be? *) ]
   |> List.tryFind (fun p -> File.Exists(p @@ "fsc.exe"))
 
@@ -122,15 +122,15 @@ Target "GenerateBindings" (fun () ->
     CleanDir (typings @@ "temp")
 
     // Get all definitions and their dependencies (and source code without <reference> tags)
-    let tsDefinitions = 
+    let tsDefinitions =
       let reg = System.Text.RegularExpressions.Regex("reference.*path=\"([^\"]*)\"") // "
       let defs = Directory.EnumerateFiles(typings, "*.d.ts", SearchOption.AllDirectories)
       [ for def in defs ->
           let lines = File.ReadAllLines(def)
-          let deps, lines = 
+          let deps, lines =
             [ for line in lines do
                 let mtch = reg.Match(line)
-                if mtch.Success then 
+                if mtch.Success then
                   let depName = Path.GetFileName(mtch.Groups.[1].Value)
                   if not (noInline.Contains depName) then yield true, depName
                  else yield false, line ] |> List.partition fst
@@ -153,10 +153,12 @@ Target "GenerateBindings" (fun () ->
     // Set the FSHARP_BIN variable and run FunScript codegen!
     fsharpBin |> Option.iter (fun fsharpBin ->
       System.Environment.SetEnvironmentVariable("FSHARP_BIN", fsharpBin))
-    ProcessHelper.StartProcess (fun p ->
+
+    (TimeSpan.FromMinutes 5.0)
+    |> ProcessHelper.ExecProcess (fun p ->
       p.FileName <- typings @@ "FunScript.TypeScript" @@ "FunScript.TypeScript.exe"
-      p.WorkingDirectory <- typings @@ "FunScript.TypeScript"
-    )
+      p.WorkingDirectory <- typings @@ "FunScript.TypeScript")
+    |> ignore
 )
 
 // --------------------------------------------------------------------------------------
