Add InternalException Event

hawkerm · hawkerm · commit 1185e4bd68da · 2017-11-13T19:50:55.000-08:00
Better track some of the internal exceptions.
diff --git a/MonacoEditorComponent/CodeEditor.Events.cs b/MonacoEditorComponent/CodeEditor.Events.cs
@@ -31,6 +31,11 @@ public partial class CodeEditor
         /// </summary>
         public event TypedEventHandler<WebView, WebViewNewWindowRequestedEventArgs> OpenLinkRequested;
 
+        /// <summary>
+        /// Called when an internal exception is encountered while executing a command. (for testing/reporting issues)
+        /// </summary>
+        public event TypedEventHandler<CodeEditor, Exception> InternalException;
+
         /// <summary>
         /// Custom Keyboard Handler.
         /// </summary>
@@ -40,7 +45,9 @@ public partial class CodeEditor
 
         private void WebView_DOMContentLoaded(WebView sender, WebViewDOMContentLoadedEventArgs args)
         {
+            #if DEBUG
             Debug.WriteLine("DOM Content Loaded");
+            #endif
             this._initialized = true;
         }
 
@@ -64,7 +71,9 @@ private async void WebView_NavigationCompleted(WebView sender, WebViewNavigation
 
         private void WebView_NavigationStarting(WebView sender, WebViewNavigationStartingEventArgs args)
         {
+            #if DEBUG
             Debug.WriteLine("Navigation Starting");
+            #endif
             _parentAccessor = new ParentAccessor(this);
             _parentAccessor.RegisterAction("Loaded", async () =>
             {
diff --git a/MonacoEditorComponent/CodeEditor.cs b/MonacoEditorComponent/CodeEditor.cs
@@ -1,9 +1,11 @@
 ﻿using Collections.Generic;
 using Monaco.Editor;
+using Monaco.Extensions;
 using Monaco.Helpers;
 using System;
 using System.Collections.ObjectModel;
 using System.ComponentModel;
+using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using Windows.Foundation;
@@ -64,7 +66,8 @@ public CodeEditor()
                 // Register for changes
                 this.Options.PropertyChanged += async (s, p) =>
                 {
-                    await this.InvokeScriptAsync("updateOptions", new string[] { (s as IEditorConstructionOptions)?.ToJson() });
+                    // TODO: Check for Language property and call other method instead?
+                    await this.InvokeScriptAsync("updateOptions", new string[] { (s as IEditorConstructionOptions)?.ToJson() });                    
                 };
             }
 
@@ -99,20 +102,27 @@ protected override void OnApplyTemplate()
             base.OnApplyTemplate();
         }
 
-        internal async Task<string> SendScriptAsync(string script)
+        internal async Task<string> SendScriptAsync(string script, 
+            [CallerMemberName] string member = null,
+            [CallerFilePath] string file = null,
+            [CallerLineNumber] int line = 0)
         {
             if (_initialized)
             {
-                if (Dispatcher.HasThreadAccess)
+                try
                 {
-                    return await this._view.InvokeScriptAsync("eval", new string[] { script });
+                    return await this._view.RunScriptAsync(script);
                 }
-                else
+                catch (Exception e)
                 {
-                    return await Dispatcher.RunTaskAsync(async () => {
-                        return await _view.InvokeScriptAsync("eval", new string[] { script });
-                    });
-                }                
+                    InternalException?.Invoke(this, new JavaScriptExecutionException(member, file, line, script, e));
+                }
+            }
+            else
+            {
+                #if DEBUG
+                Debug.WriteLine("WARNING: Tried to call '" + script + "' before initialized.");
+                #endif
             }
 
             return string.Empty;
@@ -124,16 +134,37 @@ internal async Task<string> InvokeScriptAsync(string method, params string[] arg
             {
                 if (Dispatcher.HasThreadAccess)
                 {
-                    return await this._view.InvokeScriptAsync(method, args);
+                    try
+                    {
+                        return await this._view.InvokeScriptAsync(method, args);
+                    }
+                    catch (Exception e)
+                    {
+                        InternalException?.Invoke(this, e);
+                    }
                 }
                 else
                 {
                     return await Dispatcher.RunTaskAsync(async () =>
                     {
-                        return await this._view.InvokeScriptAsync(method, args);
+                        try
+                        {
+                            return await this._view.InvokeScriptAsync(method, args);
+                        }
+                        catch (Exception e)
+                        {
+                            InternalException?.Invoke(this, e);
+                            return string.Empty;
+                        }
                     });
                 }
             }
+            else
+            {
+                #if DEBUG
+                Debug.WriteLine("WARNING: Tried to call " + method + " before initialized.");
+                #endif
+            }
 
             return string.Empty;
         }
diff --git a/MonacoEditorComponent/Extensions/WebViewExtensions.cs b/MonacoEditorComponent/Extensions/WebViewExtensions.cs
@@ -0,0 +1,96 @@
+﻿using Monaco.Helpers;
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+using Windows.Data.Json;
+using Windows.UI.Xaml.Controls;
+
+namespace Monaco.Extensions
+{
+    internal static class WebViewExtensions
+    {
+        public static async Task<string> RunScriptAsync(
+            this WebView _view, 
+            string script, 
+            [CallerMemberName] string member = null,
+            [CallerFilePath] string file = null,
+            [CallerLineNumber] int line = 0)
+        {
+            var fullscript = "try {\n" +
+                                script +
+                             "\n} catch (err) { JSON.stringify({ wv_internal_error: true, message: err.message, description: err.description, number: err.number, stack: err.stack }); }";
+
+            if (_view.Dispatcher.HasThreadAccess)
+            {
+                try
+                {
+                    return await RunScriptHelperAsync(_view, fullscript);
+                }
+                catch (Exception e)
+                {
+                    throw new JavaScriptExecutionException(member, file, line, script, e);
+                }
+            }
+            else
+            {
+                return await _view.Dispatcher.RunTaskAsync(async () =>
+                {
+                    try
+                    {
+                        return await RunScriptHelperAsync(_view, fullscript);
+                    }
+                    catch (Exception e)
+                    {
+                        throw new JavaScriptExecutionException(member, file, line, script, e);
+                    }
+                });
+            }
+        }
+
+        private static async Task<string> RunScriptHelperAsync(WebView _view, string script)
+        {            
+            var returnstring = await _view.InvokeScriptAsync("eval", new string[] { script });
+
+            if (JsonObject.TryParse(returnstring, out JsonObject result))
+            {
+                if (result.ContainsKey("wv_internal_error") && result["wv_internal_error"].ValueType == JsonValueType.Boolean && result["wv_internal_error"].GetBoolean())
+                {
+                    throw new JavaScriptInnerException(result["message"].GetString(), result["stack"].GetString());
+                }
+            }
+
+            return returnstring;
+        }
+    }
+
+    internal sealed class JavaScriptExecutionException : Exception
+    {
+        public string Script { get; private set; }
+
+        public string Member { get; private set; }
+
+        public string FileName { get; private set; }
+
+        public int LineNumber { get; private set; }
+
+        public JavaScriptExecutionException(string member, string filename, int line, string script, Exception inner)
+            : base("Error Executing JavaScript Code", inner)
+        {
+            this.Member = member;
+            this.FileName = filename;
+            this.LineNumber = line;
+            this.Script = script;
+        }
+    }
+
+    internal sealed class JavaScriptInnerException : Exception
+    {
+        public string JavaScriptStackTrace { get; private set; } // TODO Use Enum of JS error types https://www.w3schools.com/js/js_errors.asp
+
+        public JavaScriptInnerException(string message, string stack)
+            : base(message)
+        {
+            this.JavaScriptStackTrace = stack;
+        }
+    }
+}
diff --git a/MonacoEditorComponent/Helpers/DebugLogger.cs b/MonacoEditorComponent/Helpers/DebugLogger.cs
@@ -8,7 +8,9 @@ public sealed class DebugLogger
     {
         public void Log(string message)
         {
+            #if DEBUG
             Debug.WriteLine(message);
+            #endif
         }
     }
 }
diff --git a/MonacoEditorComponent/Helpers/ThemeListener.cs b/MonacoEditorComponent/Helpers/ThemeListener.cs
@@ -44,7 +44,9 @@ public ThemeListener()
 
         private void _accessible_HighContrastChanged(AccessibilitySettings sender, object args)
         {
+            #if DEBUG
             Debug.WriteLine("HighContrast Changed");
+            #endif
 
             UpdateProperties();
         }
@@ -59,7 +61,9 @@ await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.Co
                 if (CurrentTheme != Application.Current.RequestedTheme ||
                     IsHighContrast != _accessible.HighContrast)
                 {
+                    #if DEBUG
                     Debug.WriteLine("Color Values Changed");
+                    #endif
 
                     UpdateProperties();
                 }
@@ -71,7 +75,9 @@ private void CoreWindow_Activated(Windows.UI.Core.CoreWindow sender, Windows.UI.
             if (CurrentTheme != Application.Current.RequestedTheme ||
                 IsHighContrast != _accessible.HighContrast)
             {
+                #if DEBUG
                 Debug.WriteLine("CoreWindow Activated Changed");
+                #endif
 
                 UpdateProperties();
             }
diff --git a/MonacoEditorComponent/MonacoEditor.html b/MonacoEditorComponent/MonacoEditor.html
@@ -28,13 +28,15 @@
         var contexts = {};
         var decorations = [];
 
-        Debug.log("Starting");
+        Debug.log("Starting Monaco Load");
         require.config({ paths: { 'vs': 'ms-appx-web:///Monaco/monaco-editor/min/vs' }});
         require(['vs/editor/editor.main'], function () {
+            Debug.log("Grabbing Monaco Options");
+
             let opt = getOptions();
             opt["value"] = Parent.getValue("Text");
 
-		    editor = monaco.editor.create(document.getElementById('container'), opt);
+            editor = monaco.editor.create(document.getElementById('container'), opt);
             model = editor.getModel();
 
             // Listen for Content Changes
@@ -54,7 +56,7 @@
             window.addEventListener("resize", () => {
                 editor.layout();
             });
-
+            
             // Disable WebView Scrollbar so Monaco Scrollbar can do heavy lifting
             document.body.style.overflow = 'hidden';
 
diff --git a/MonacoEditorComponent/MonacoEditorComponent.csproj b/MonacoEditorComponent/MonacoEditorComponent.csproj
@@ -114,6 +114,7 @@
     <Compile Include="CodeEditor.cs" />
     <Compile Include="CodeEditor.Methods.cs" />
     <Compile Include="CodeEditor.Properties.cs" />
+    <Compile Include="Extensions\WebViewExtensions.cs" />
     <Compile Include="Helpers\DebugLogger.cs" />
     <Compile Include="Helpers\DispatcherTaskExtensions.cs" />
     <Compile Include="Helpers\KeyboardListener.cs" />
diff --git a/MonacoEditorTestApp/MainPage.xaml.cs b/MonacoEditorTestApp/MainPage.xaml.cs
@@ -43,9 +43,16 @@ public MainPage()
             Editor.Loaded += Editor_Loaded;
             Editor.OpenLinkRequested += Editor_OpenLinkRequest;
 
+            Editor.InternalException += Editor_InternalException;
+
             this.ButtonHighlightRange_Click(null, null);
         }
 
+        private void Editor_InternalException(CodeEditor sender, Exception args)
+        {
+            // This shouldn't happen, if it does, then it's a bug.
+        }
+
         private async void Editor_Loading(object sender, RoutedEventArgs e)
         {
             // Ready for Code

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,9 @@ public sealed class DebugLogger`
`8`	`8`	`{`
`9`	`9`	`public void Log(string message)`
`10`	`10`	`{`
	`11`	`+ #if DEBUG`
`11`	`12`	`Debug.WriteLine(message);`
	`13`	`+ #endif`
`12`	`14`	`}`
`13`	`15`	`}`
`14`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,9 @@ public ThemeListener()`
`44`	`44`
`45`	`45`	`private void _accessible_HighContrastChanged(AccessibilitySettings sender, object args)`
`46`	`46`	`{`
	`47`	`+ #if DEBUG`
`47`	`48`	`Debug.WriteLine("HighContrast Changed");`
	`49`	`+ #endif`
`48`	`50`
`49`	`51`	`UpdateProperties();`
`50`	`52`	`}`
`@@ -59,7 +61,9 @@ await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.Co`
`59`	`61`	`if (CurrentTheme != Application.Current.RequestedTheme \|\|`
`60`	`62`	`IsHighContrast != _accessible.HighContrast)`
`61`	`63`	`{`
	`64`	`+ #if DEBUG`
`62`	`65`	`Debug.WriteLine("Color Values Changed");`
	`66`	`+ #endif`
`63`	`67`
`64`	`68`	`UpdateProperties();`
`65`	`69`	`}`
`@@ -71,7 +75,9 @@ private void CoreWindow_Activated(Windows.UI.Core.CoreWindow sender, Windows.UI.`
`71`	`75`	`if (CurrentTheme != Application.Current.RequestedTheme \|\|`
`72`	`76`	`IsHighContrast != _accessible.HighContrast)`
`73`	`77`	`{`
	`78`	`+ #if DEBUG`
`74`	`79`	`Debug.WriteLine("CoreWindow Activated Changed");`
	`80`	`+ #endif`
`75`	`81`
`76`	`82`	`UpdateProperties();`
`77`	`83`	`}`