Address nojaf feedback by making more fault tolerant

Author: nhirschey

src/FSharp.Formatting.Literate/ParsePynb.fs

@@ -31,45 +31,44 @@ module internal ParsePynb =
             match x.TryGetProperty("text/html") with
             | true, html ->
                 let html = html.EnumerateArray() |> Seq.map (fun x -> x.GetString()) |> String.concat "\n"
-                Some("""<p>""" + html + """</p>""")
+                Some $"<p>{html}</p>"
             | _ -> None
 
         let (|TextPlain|_|) (x: JsonElement) =
             match x.TryGetProperty("text/plain") with
             | true, text ->
                 let text = text.EnumerateArray() |> Seq.map (fun x -> x.GetString()) |> String.concat ""
-
-                Some(
-                    """<table class="pre"><tbody><tr><td><pre><code>"""
-                    + text
-                    + """</code></pre></td></tr></tbody></table>"""
-                )
+                Some $"""<table class="pre"><tbody><tr><td><pre><code>{text}</code></pre></td></tr></tbody></table>"""
             | _ -> None
 
         let (|DisplayData|_|) (x: JsonElement) =
-            if x.GetProperty("output_type").GetString() = "display_data" then
-                match x.GetProperty("data") with
-                | TextHtml html -> html
-                | TextPlain text -> text
-                | s -> failwith $"unknown ouptut {s}"
-                |> Some
-            else
-                None
+            match x.TryGetProperty("output_type") with
+            | true, outputType ->
+                if outputType.GetString() = "display_data" then
+                    match x.TryGetProperty("data") with
+                    | true, TextHtml html -> html
+                    | true, TextPlain text -> text
+                    | true, s -> failwith $"unknown output {s}"
+                    | false, _ -> failwith "no data property"
+                    |> Some
+                else
+                    None
+            | _ -> failwith "no output_type property"
 
         let (|Stream|_|) (x: JsonElement) =
-            if x.GetProperty("output_type").GetString() = "stream" then
-                let text =
-                    x.GetProperty("text").EnumerateArray()
-                    |> Seq.map (fun x -> x.GetString())
-                    |> String.concat ""
-
-                Some(
-                    """<table class="pre"><tbody><tr><td><pre><code>"""
-                    + text
-                    + """</code></pre></td></tr></tbody></table>"""
-                )
-            else
-                None
+            match x.TryGetProperty("output_type") with
+            | true, outputType ->
+                if outputType.GetString() = "stream" then
+                    let text =
+                        match x.TryGetProperty("text") with
+                        | true, xs -> xs.EnumerateArray() |> Seq.map (fun x -> x.GetString()) |> String.concat ""
+                        | _ -> failwith "no text property"
+
+                    Some
+                        $"""<table class="pre"><tbody><tr><td><pre><code>{text}</code></pre></td></tr></tbody></table>"""
+                else
+                    None
+            | _ -> failwith "no output_type property"
 
         let parse (output: JsonElement) =
             match output with

src/fsdocs-tool/BuildCommand.fs

@@ -185,12 +185,12 @@ type internal DocContent
 
           if name.StartsWith('.') then
               printfn "skipping file %s" inputFileFullPath
-          elif not (name.StartsWith("_template", StringComparison.Ordinal)) then
-              let isFsx = inputFileFullPath.EndsWith(".fsx", true, CultureInfo.InvariantCulture)
+          elif not (name.StartsWith "_template") then
+              let isFsx = inputFileFullPath.EndsWith(".fsx", StringComparison.OrdinalIgnoreCase)
 
-              let isMd = inputFileFullPath.EndsWith(".md", true, CultureInfo.InvariantCulture)
+              let isMd = inputFileFullPath.EndsWith(".md", StringComparison.OrdinalIgnoreCase)
 
-              let isPynb = inputFileFullPath.EndsWith(".ipynb", true, CultureInfo.InvariantCulture)
+              let isPynb = inputFileFullPath.EndsWith(".ipynb", StringComparison.OrdinalIgnoreCase)
 
               // A _template.tex or _template.pynb is needed to generate those files
               match outputKind, template with
@@ -351,19 +351,58 @@ type internal DocContent
                           printfn "  preparing %s --> %s" inputFileFullPath outputFileRelativeToRoot
 
                           let evaluateNotebook ipynbFile =
+                              let args =
+                                  $"repl --run {ipynbFile} --default-kernel fsharp --exit-after-run --output-path {ipynbFile}"
+
                               let psi =
                                   ProcessStartInfo(
                                       fileName = "dotnet",
-                                      arguments =
-                                          $"repl --run {ipynbFile} --default-kernel fsharp --exit-after-run --output-path {ipynbFile}",
+                                      arguments = args,
                                       UseShellExecute = false,
                                       CreateNoWindow = true
                                   )
 
-                              let p = Process.Start(psi)
-                              p.WaitForExit()
+                              try
+                                  let p = Process.Start(psi)
+                                  p.WaitForExit()
+                              with _ ->
+                                  let msg =
+                                      $"Failed to evaluate notebook {ipynbFile} using dotnet-repl\n"
+                                      + $"""try running "{args}" at the command line and inspect the error"""
+
+                                  failwith msg
+
+                          let checkDotnetReplInstall () =
+                              let failmsg =
+                                  "'dotnet-repl' is not installed. Please install it using 'dotnet tool install dotnet-repl'"
+
+                              try
+                                  let psi =
+                                      ProcessStartInfo(
+                                          fileName = "dotnet",
+                                          arguments = "tool list --local",
+                                          UseShellExecute = false,
+                                          CreateNoWindow = true,
+                                          RedirectStandardOutput = true
+                                      )
+
+                                  let p = Process.Start(psi)
+                                  let ol = p.StandardOutput.ReadToEnd()
+                                  p.WaitForExit()
+                                  psi.Arguments <- "tool list --global"
+                                  p.Start() |> ignore
+                                  let og = p.StandardOutput.ReadToEnd()
+                                  let output = $"{ol}\n{og}"
+
+                                  if not (output.Contains("dotnet-repl")) then
+                                      failwith failmsg
+
+                                  p.WaitForExit()
+                              with _ ->
+                                  failwith failmsg
 
                           if evaluate then
+                              checkDotnetReplInstall ()
                               printfn $"  evaluating {inputFileFullPath} with dotnet-repl"
                               evaluateNotebook inputFileFullPath