Add text input prompt support

This change adds a PSHostUserInterface implementation for both the Prompt
and ReadLine methods so that input can be requested from the user.  The
implementation is made with the IPromptHandler interface so that the
prompt handling strategy can be changed based on the context of the
user's session.

Author: daviwil

src/PowerShellEditorServices.Protocol/Server/PromptHandlers.cs

@@ -3,6 +3,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 //
 
+using System;
 using Microsoft.PowerShell.EditorServices.Console;
 using Microsoft.PowerShell.EditorServices.Protocol.Messages;
 
@@ -21,6 +22,11 @@ public ChoicePromptHandler GetChoicePromptHandler()
         {
             return new ProtocolChoicePromptHandler(this.eventWriter);
         }
+
+        public InputPromptHandler GetInputPromptHandler()
+        {
+            throw new NotImplementedException();
+        }
     }
 
     internal class ProtocolChoicePromptHandler : ChoicePromptHandler

src/PowerShellEditorServices/Console/ChoicePromptHandler.cs

@@ -147,8 +147,8 @@ public virtual bool HandleResponse(string responseString)
         /// </summary>
         public void CancelPrompt()
         {
-            // Setting the result to -1 will cause the prompt to be cancelled
-            this.promptTask.SetResult(-1);
+            // Cancel the prompt task
+            this.promptTask.TrySetCanceled();
         }
 
         #endregion

src/PowerShellEditorServices/Console/ConsoleInputPromptHandler.cs

@@ -0,0 +1,95 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+
+namespace Microsoft.PowerShell.EditorServices.Console
+{
+    /// <summary>
+    /// Provides a standard implementation of InputPromptHandler
+    /// for use in the interactive console (REPL).
+    /// </summary>
+    public class ConsoleInputPromptHandler : InputPromptHandler
+    {
+        #region Private Fields
+
+        private IConsoleHost consoleHost;
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Creates an instance of the ConsoleInputPromptHandler class.
+        /// </summary>
+        /// <param name="consoleHost">
+        /// The IConsoleHost implementation to use for writing to the
+        /// console.
+        /// </param>
+        public ConsoleInputPromptHandler(IConsoleHost consoleHost)
+        {
+            this.consoleHost = consoleHost;
+        }
+
+        #endregion
+
+        #region Public Methods
+
+        /// <summary>
+        /// Called when the prompt caption and message should be
+        /// displayed to the user.
+        /// </summary>
+        /// <param name="caption">The caption string to be displayed.</param>
+        /// <param name="message">The message string to be displayed.</param>
+        protected override void ShowPromptMessage(string caption, string message)
+        {
+            if (!string.IsNullOrEmpty(caption))
+            {
+                this.consoleHost.WriteOutput(caption, true);
+            }
+
+            if (!string.IsNullOrEmpty(message))
+            {
+                this.consoleHost.WriteOutput(message, true);
+            }
+        }
+
+        /// <summary>
+        /// Called when a prompt should be displayed for a specific
+        /// input field.
+        /// </summary>
+        /// <param name="fieldDetails">The details of the field to be displayed.</param>
+        protected override void ShowFieldPrompt(FieldDetails fieldDetails)
+        {
+            // For a simple prompt there won't be any field name.
+            // In this case don't write anything
+            if (!string.IsNullOrEmpty(fieldDetails.Name))
+            {
+                this.consoleHost.WriteOutput(
+                    fieldDetails.Name + ": ",
+                    false);
+            }
+        }
+
+        /// <summary>
+        /// Called when an error should be displayed, such as when the
+        /// user types in a string with an incorrect format for the
+        /// current field.
+        /// </summary>
+        /// <param name="e">
+        /// The Exception containing the error to be displayed.
+        /// </param>
+        protected override void ShowErrorMessage(Exception e)
+        {
+            this.consoleHost.WriteOutput(
+                e.Message,
+                true,
+                OutputType.Error);
+        }
+
+        #endregion
+    }
+}
+

src/PowerShellEditorServices/Console/ConsolePromptHandlerContext.cs

@@ -50,6 +50,18 @@ public ChoicePromptHandler GetChoicePromptHandler()
             return new ConsoleChoicePromptHandler(this.consoleHost);
         }
 
+        /// <summary>
+        /// Creates a new InputPromptHandler instance so that
+        /// the caller can display an input prompt to the user.
+        /// </summary>
+        /// <returns>
+        /// A new InputPromptHandler instance.
+        /// </returns>
+        public InputPromptHandler GetInputPromptHandler()
+        {
+            return new ConsoleInputPromptHandler(this.consoleHost);
+        }
+
         #endregion
     }
 }

src/PowerShellEditorServices/Console/ConsoleService.cs

@@ -87,6 +87,11 @@ public void ReceiveInputString(string inputString, bool echoToConsole)
         {
             if (this.activePromptHandler != null)
             {
+                if (echoToConsole)
+                {
+                    this.WriteOutput(inputString, true);
+                }
+
                 if (this.activePromptHandler.HandleResponse(inputString))
                 {
                     // If the prompt handler is finished, clear it for
@@ -197,6 +202,12 @@ ChoicePromptHandler IConsoleHost.GetChoicePromptHandler()
                 factory => factory.GetChoicePromptHandler());
         }
 
+        InputPromptHandler IConsoleHost.GetInputPromptHandler()
+        {
+            return this.GetPromptHandler(
+                factory => factory.GetInputPromptHandler());
+        }
+
         private TPromptHandler GetPromptHandler<TPromptHandler>(
             Func<IPromptHandlerContext, TPromptHandler> factoryInvoker)
                 where TPromptHandler : IPromptHandler

src/PowerShellEditorServices/Console/FieldDetails.cs

@@ -0,0 +1,145 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using Microsoft.PowerShell.EditorServices.Utility;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Management.Automation;
+using System.Management.Automation.Host;
+
+namespace Microsoft.PowerShell.EditorServices.Console
+{
+    /// <summary>
+    /// Contains the details of an input field shown from an
+    /// InputPromptHandler.  This class is meant to be
+    /// serializable to the user's UI.
+    /// </summary>
+    public class FieldDetails
+    {
+        #region Properties
+
+        /// <summary>
+        /// Gets or sets the name of the field.
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// Gets or sets the descriptive label for the field.
+        /// </summary>
+        public string Label { get; set; }
+
+        /// <summary>
+        /// Gets or sets the field's value type.
+        /// </summary>
+        public Type FieldType { get; set; }
+
+        /// <summary>
+        /// Gets or sets the field's help message.
+        /// </summary>
+        public string HelpMessage { get; set; }
+
+        /// <summary>
+        /// Gets or sets a boolean that is true if the user
+        /// must enter a value for the field.
+        /// </summary>
+        public bool IsMandatory { get; set; }
+
+        /// <summary>
+        /// Gets or sets the default value for the field.
+        /// </summary>
+        public object DefaultValue { get; set; }
+
+        /// <summary>
+        /// Gets or sets a boolean that is true if the field
+        /// represents a collection of values.
+        /// </summary>
+        public bool IsCollection { get; set; }
+
+        /// <summary>
+        /// Gets or sets the expected type for individual items 
+        /// in the field's collection.
+        /// </summary>
+        public Type ElementType { get; set; }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Creates an instance of the FieldDetails class.
+        /// </summary>
+        /// <param name="name">The field's name.</param>
+        /// <param name="label">The field's label.</param>
+        /// <param name="fieldType">The field's value type.</param>
+        /// <param name="isMandatory">If true, marks the field as mandatory.</param>
+        /// <param name="defaultValue">The field's default value.</param>
+        public FieldDetails(
+            string name,
+            string label,
+            Type fieldType,
+            bool isMandatory,
+            object defaultValue)
+        {
+            this.Name = name;
+            this.Label = label;
+            this.FieldType = fieldType;
+            this.IsMandatory = isMandatory;
+            this.DefaultValue = defaultValue;
+
+            if (typeof(IList).IsAssignableFrom(fieldType))
+            {
+                this.IsCollection = true;
+                this.ElementType = typeof(object);
+
+                if (fieldType.IsArray)
+                {
+                    this.ElementType = fieldType.GetElementType();
+                }
+            }
+            else if (fieldType.IsGenericType)
+            {
+                throw new PSArgumentException(
+                    "Generic types are not supported for input fields at this time.");
+            }
+        }
+
+        #endregion
+
+        #region Internal Methods
+
+        internal static FieldDetails Create(FieldDescription fieldDescription)
+        {
+            return new FieldDetails(
+                fieldDescription.Name,
+                fieldDescription.Label,
+                GetFieldTypeFromTypeName(fieldDescription.ParameterAssemblyFullName),
+                fieldDescription.IsMandatory,
+                fieldDescription.DefaultValue);
+        }
+
+        private static Type GetFieldTypeFromTypeName(string assemblyFullName)
+        {
+            Type fieldType = typeof(string); 
+
+            if (!string.IsNullOrEmpty(assemblyFullName))
+            {
+                if (!LanguagePrimitives.TryConvertTo<Type>(assemblyFullName, out fieldType))
+                {
+                    Logger.Write(
+                        LogLevel.Warning,
+                        string.Format(
+                            "Could not resolve type of field: {0}",
+                            assemblyFullName));
+                }
+            }
+
+            return fieldType;
+        }
+
+        #endregion
+    }
+}
+

src/PowerShellEditorServices/Console/IConsoleHost.cs

@@ -47,6 +47,13 @@ void WriteOutput(
         /// <returns>A new ChoicePromptHandler instance.</returns>
         ChoicePromptHandler GetChoicePromptHandler();
 
+        /// <summary>
+        /// Creates an InputPrompt handle to use for displaying input
+        /// prompts to the user.
+        /// </summary>
+        /// <returns>A new InputPromptHandler instance.</returns>
+        InputPromptHandler GetInputPromptHandler();
+
         /// <summary>
         /// Sends a progress update event to the user.
         /// </summary>

src/PowerShellEditorServices/Console/IPromptHandlerContext.cs

@@ -19,6 +19,15 @@ public interface IPromptHandlerContext
         /// A new ChoicePromptHandler instance.
         /// </returns>
         ChoicePromptHandler GetChoicePromptHandler();
+
+        /// <summary>
+        /// Creates a new InputPromptHandler instance so that
+        /// the caller can display an input prompt to the user.
+        /// </summary>
+        /// <returns>
+        /// A new InputPromptHandler instance.
+        /// </returns>
+        InputPromptHandler GetInputPromptHandler();
     }
 }