dotnet · colombod · Aug 29, 2019 · Aug 28, 2019 · Aug 28, 2019 · Aug 28, 2019
diff --git a/MLS.Agent.Tests/XplotKernelExtensionTests.cs b/MLS.Agent.Tests/XplotKernelExtensionTests.cs
@@ -31,7 +31,7 @@ public async Task When_a_chart_is_returned_the_value_produced_has_html_with_the_
 
             KernelEvents
                 .ValuesOnly()
-                .OfType<ValueProduced>()
+                .OfType<ReturnValueProduced>()
                 .Should().
                 ContainSingle(valueProduced =>
                     valueProduced.FormattedValues.Any(formattedValue =>

diff --git a/Microsoft.DotNet.Interactive.FSharp/FSharpKernel.fs b/Microsoft.DotNet.Interactive.FSharp/FSharpKernel.fs
@@ -29,7 +29,7 @@ type FSharpKernel() =
             | Ok(Some(value)) ->
                 let value = value.ReflectionValue
                 let formattedValues = FormattedValue.FromObject(value)
-                context.OnNext(ValueProduced(value, codeSubmission, true, formattedValues))
+                context.OnNext(ReturnValueProduced(value, codeSubmission, formattedValues))
             | Ok(None) -> ()
             | Error(ex) -> context.OnError(ex)
             context.OnNext(CodeSubmissionEvaluated(codeSubmission))

diff --git a/Microsoft.DotNet.Interactive.Jupyter.Tests/ExecuteRequestHandlerTests.cs b/Microsoft.DotNet.Interactive.Jupyter.Tests/ExecuteRequestHandlerTests.cs
@@ -82,7 +82,25 @@ public async Task sends_ExecuteReply_with_error_message_on_CodeSubmissionEvaluat
         }
 
         [Fact]
-        public async Task sends_ExecuteReply_message_on_ValueProduced()
+        public async Task sends_DisplayData_message_on_ValueProduced()
+        {
+            var kernel = new CSharpKernel();
+
+            var handler = new ExecuteRequestHandler(kernel);
+            var request = Message.Create(new ExecuteRequest("Console.WriteLine(2+2);"), null);
+            await handler.Handle(new JupyterRequestContext(_serverChannel, _ioPubChannel, request, _kernelStatus));
+
+            _serverRecordingSocket.DecodedMessages
+                .Should().Contain(message =>
+                    message.Contains(MessageTypeValues.ExecuteReply));
+
+            _ioRecordingSocket.DecodedMessages
+                .Should().Contain(message =>
+                    message.Contains(MessageTypeValues.DisplayData));
+        }
+
+        [Fact]
+        public async Task sends_ExecuteReply_message_on_ReturnValueProduced()
         {
             var kernel = new CSharpKernel();
 

diff --git a/Microsoft.DotNet.Interactive.Jupyter.Tests/MagicCommandTests.cs b/Microsoft.DotNet.Interactive.Jupyter.Tests/MagicCommandTests.cs
@@ -44,9 +44,9 @@ public async Task lsmagic_lists_registered_magic_commands()
             await kernel.SendAsync(new SubmitCode("%lsmagic"));
 
             events.Should()
-                  .ContainSingle(e => e is ValueProduced)
+                  .ContainSingle(e => e is Events.DisplayedValueProduced)
                   .Which
-                  .As<ValueProduced>()
+                  .As<Events.DisplayedValueProduced>()
                   .Value
                   .ToDisplayString("text/html")
                   .Should()
@@ -75,7 +75,7 @@ public async Task lsmagic_lists_registered_magic_commands_in_subkernels()
 
             await compositeKernel.SendAsync(new SubmitCode("%lsmagic"));
 
-            var valueProduceds = events.OfType<ValueProduced>().ToArray();
+            var valueProduceds = events.OfType<Events.DisplayedValueProduced>().ToArray();
 
             valueProduceds[0].Value
                              .ToDisplayString("text/html")
@@ -112,7 +112,7 @@ await kernel.SendAsync(new SubmitCode(
 
             var formatted =
                 events
-                    .OfType<ValueProduced>()
+                    .OfType<Events.DisplayedValueProduced>()
                     .SelectMany(v => v.FormattedValues)
                     .ToArray();
 
@@ -140,7 +140,7 @@ await kernel.SendAsync(new SubmitCode(
 
             var formatted =
                 events
-                    .OfType<ValueProduced>()
+                    .OfType<Events.DisplayedValueProduced>()
                     .SelectMany(v => v.FormattedValues)
                     .ToArray();
 

diff --git a/Microsoft.DotNet.Interactive.Jupyter/ExecuteRequestHandler.cs b/Microsoft.DotNet.Interactive.Jupyter/ExecuteRequestHandler.cs
@@ -56,8 +56,8 @@ protected override void OnKernelEvent(IKernelEvent @event)
         {
             switch (@event)
             {
-                case ValueProduced valueProduced:
-                    OnValueProduced(valueProduced);
+                case ValueProducedEventBase valueProductionEvent:
+                    OnValueProductionEvent(valueProductionEvent);
                     break;
                 case CodeSubmissionEvaluated codeSubmissionEvaluated:
                     OnCodeSubmissionEvaluated(codeSubmissionEvaluated);
@@ -114,72 +114,69 @@ private void OnCommandFailed(CommandFailed commandFailed)
             openRequest.Dispose();
         }
 
-        private void OnValueProduced(ValueProduced valueProduced)
+        private void SendDisplayData(DisplayData displayData, InflightRequest openRequest)
         {
-            if (!InFlightRequests.TryGetValue(valueProduced.Command, out var openRequest))
+            if (!openRequest.Request.Silent)
+            {
+                // send on io
+                var executeResultMessage = Message.Create(
+                    displayData,
+                    openRequest.Context.Request.Header);
+                openRequest.Context.IoPubChannel.Send(executeResultMessage);
+            }
+        }
+
+        private void OnValueProductionEvent(ValueProducedEventBase eventBase)
+        {
+            if (!InFlightRequests.TryGetValue(eventBase.Command, out var openRequest))
             {
                 return;
             }
 
-            try
+            var transient = CreateTransient(eventBase.ValueId);
+
+            var formattedValues = eventBase
+                .FormattedValues
+                .ToDictionary(k => k.MimeType, v => v.Value);
+
+            var value = eventBase.Value;
+
+            CreateDefaultFormattedValueIfEmpty(formattedValues, value);
+
+            DisplayData executeResultData;
+
+            switch (eventBase)
             {
-                var transient = CreateTransient(valueProduced.ValueId);
-
-                var formattedValues = valueProduced
-                                      .FormattedValues
-                                      .ToDictionary(k => k.MimeType, v => v.Value);
-
-                if (formattedValues.Count == 0)
-                {
-                    formattedValues.Add( 
-                        HtmlFormatter.MimeType,
-                        valueProduced.Value.ToDisplayString("text/html"));
-                }
-
-                var executeResultData =
-                    valueProduced.IsReturnValue
-                        ? new ExecuteResult(
-                            openRequest.ExecutionCount,
-                            transient: transient,
-                            data: formattedValues)
-                        : valueProduced.IsUpdatedValue
-                            ? new UpdateDisplayData(
-                                transient: transient,
-                                data: formattedValues)
-                            : new DisplayData(
-                                transient: transient,
-                                data: formattedValues);
-
-                if (!openRequest.Request.Silent)
-                {
-                    // send on io
-                    var executeResultMessage = Message.Create(
-                        executeResultData,
-                        openRequest.Context.Request.Header);
-                    openRequest.Context.IoPubChannel.Send(executeResultMessage);
-                }
+                case Events.DisplayedValueProduced _:
+                    executeResultData = new DisplayData(
+                        transient: transient,
+                        data: formattedValues);
+                    break;
+                case ReturnValueProduced _:
+                    executeResultData = new ExecuteResult(
+                        openRequest.ExecutionCount,
+                        transient: transient,
+                        data: formattedValues);
+                    break;
+                case DisplayedValueUpdated _:
+                    executeResultData = new UpdateDisplayData(
+                        transient: transient,
+                        data: formattedValues);
+                    break;
+                default:
+                    throw new ArgumentException("Unsupported event type", nameof(eventBase));
             }
-            catch (Exception e)
+
+            SendDisplayData(executeResultData, openRequest);
+        }
+
+        private static void CreateDefaultFormattedValueIfEmpty(Dictionary<string, object> formattedValues, object value)
+        {
+            if (formattedValues.Count == 0)
             {
-                var errorContent = new Error(
-                    eName: "Unhandled Exception",
-                    eValue: $"{e.Message}");
-
-                if (!openRequest.Request.Silent)
-                {
-                    // send on io
-                    var error = Message.Create(
-                        errorContent,
-                        openRequest.Context.Request.Header);
-                    openRequest.Context.IoPubChannel.Send(error);
-
-                    // send on stderr
-                    var stdErr = new StdErrStream(errorContent.EValue);
-                    var stream = Message.Create(
-                        stdErr,
-                        openRequest.Context.Request.Header);
-                    openRequest.Context.IoPubChannel.Send(stream);
-                }
+                formattedValues.Add(
+                    HtmlFormatter.MimeType,
+                    value.ToDisplayString("text/html"));
             }
         }
 

diff --git a/Microsoft.DotNet.Interactive.Jupyter/KernelExtensions.cs b/Microsoft.DotNet.Interactive.Jupyter/KernelExtensions.cs
@@ -42,7 +42,7 @@ private static T UseHtml<T>(this T kernel)
                                                       .Trim();
 
 
-                        context.OnNext(new ValueProduced(
+                        context.OnNext(new Events.DisplayedValueProduced(
                                            htmlContent,
                                            context.Command,
                                            formattedValues: new[]
@@ -106,7 +106,7 @@ private static Command lsmagic()
 
                     supportedDirectives.Commands.AddRange(context.CurrentKernel.Directives);
 
-                    context.OnNext(new ValueProduced(supportedDirectives));
+                    context.OnNext(new Events.DisplayedValueProduced(supportedDirectives));
 
                     await context.CurrentKernel.VisitSubkernelsAsync(async k =>
                     {
@@ -137,7 +137,7 @@ private static Command javascript()
                                     scriptContent))
                                 .ToString();
 
-                        context.OnNext(new ValueProduced(
+                        context.OnNext(new Events.DisplayedValueProduced(
                                            scriptContent,
                                            context.Command,
                                            formattedValues: new[]

diff --git a/...soft.DotNet.Interactive/DisplayedValue.cs → ...Net.Interactive/DisplayedValueProduced.cs b/...soft.DotNet.Interactive/DisplayedValue.cs → ...Net.Interactive/DisplayedValueProduced.cs
diff --git a/Microsoft.DotNet.Interactive/Events/DisplayedValueProduced.cs b/Microsoft.DotNet.Interactive/Events/DisplayedValueProduced.cs
@@ -0,0 +1,20 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Collections.Generic;
+using Microsoft.DotNet.Interactive.Commands;
+
+namespace Microsoft.DotNet.Interactive.Events
+{
+    public class DisplayedValueProduced : ValueProducedEventBase
+    {
+        public DisplayedValueProduced(
+            object value,
+            IKernelCommand command = null,
+            IReadOnlyCollection<FormattedValue> formattedValues = null,
+            string valueId = null) : base(value, command,formattedValues, valueId)
+        {
+
+        }
+    }
+}
diff --git a/Microsoft.DotNet.Interactive/Events/DisplayedValueUpdated.cs b/Microsoft.DotNet.Interactive/Events/DisplayedValueUpdated.cs
@@ -0,0 +1,25 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using Microsoft.DotNet.Interactive.Commands;
+
+namespace Microsoft.DotNet.Interactive.Events
+{
+    public class DisplayedValueUpdated : ValueProducedEventBase
+    {
+        public DisplayedValueUpdated(
+            object value,
+            string valueId,
+            IKernelCommand command = null,
+            IReadOnlyCollection<FormattedValue> formattedValues = null) : base(value,command,formattedValues,valueId)
+        {
+            if (string.IsNullOrWhiteSpace(valueId))
+            {
+                throw new ArgumentException("Value cannot be null or whitespace.", nameof(valueId));
+            }
+
+        }
+    }
+}
diff --git a/Microsoft.DotNet.Interactive/Events/ReturnValueProduced.cs b/Microsoft.DotNet.Interactive/Events/ReturnValueProduced.cs
@@ -0,0 +1,21 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using Microsoft.DotNet.Interactive.Commands;
+
+namespace Microsoft.DotNet.Interactive.Events
+{
+    public class ReturnValueProduced : ValueProducedEventBase
+    {
+        public ReturnValueProduced(
+            object value,
+            IKernelCommand command = null,
+            IReadOnlyCollection<FormattedValue> formattedValues = null,
+            string valueId = null) : base(value,command, formattedValues, valueId)
+        {
+
+        }
+    }
+}
diff --git a/...otNet.Interactive/Events/ValueProduced.cs → ...eractive/Events/ValueProducedEventBase.cs b/...otNet.Interactive/Events/ValueProduced.cs → ...eractive/Events/ValueProducedEventBase.cs
@@ -7,40 +7,23 @@
 
 namespace Microsoft.DotNet.Interactive.Events
 {
-    public class ValueProduced : KernelEventBase
+    public abstract class ValueProducedEventBase : KernelEventBase
     {
-        public ValueProduced(
+        protected ValueProducedEventBase(
             object value,
             IKernelCommand command = null,
-            bool isReturnValue = false,
             IReadOnlyCollection<FormattedValue> formattedValues = null,
-            string valueId = null,
-            bool isUpdatedValue = false) : base(command)
+            string valueId = null) : base(command)
         {
-            if (isUpdatedValue && valueId == null)
-            {
-                throw new ArgumentException($"{nameof(isUpdatedValue)} cannot be true with a null {nameof(valueId)}", nameof(valueId));
-            }
-
             Value = value;
-            IsReturnValue = isReturnValue;
             FormattedValues = formattedValues ?? Array.Empty<FormattedValue>();
             ValueId = valueId;
-            IsUpdatedValue = valueId switch
-            {
-                null => false,
-                _ => isUpdatedValue
-            };
         }
 
         public object Value { get; }
 
-        public bool IsReturnValue { get; }
-
         public IReadOnlyCollection<FormattedValue> FormattedValues { get; }
 
         public string ValueId { get; }
-
-        public bool IsUpdatedValue { get; }
     }
 }
diff --git a/Microsoft.DotNet.Interactive/KernelBase.cs b/Microsoft.DotNet.Interactive/KernelBase.cs
@@ -179,7 +179,7 @@ private async Task HandleDisplayValue(
             displayValue.Handler = invocationContext =>
             {
                 invocationContext.OnNext(
-                    new ValueProduced(
+                    new Events.DisplayedValueProduced(
                         displayValue.FormattedValue,
                         displayValue,
                         formattedValues: new[] { displayValue.FormattedValue },
@@ -201,12 +201,12 @@ private async Task HandleUpdateDisplayValue(
             displayedValue.Handler = invocationContext =>
             {
                 invocationContext.OnNext(
-                    new ValueProduced(
+                    new DisplayedValueUpdated(
                         displayedValue.FormattedValue,
-                        displayedValue,
-                        formattedValues: new[] { displayedValue.FormattedValue },
                         valueId: displayedValue.ValueId,
-                        isUpdatedValue: true));
+                        command: displayedValue,
+                        formattedValues: new[] { displayedValue.FormattedValue }
+                        ));
 
                 invocationContext.OnCompleted();