Add PSHostUserInterface support for IHostUISupportsMultipleChoiceSelection

This change adds support for multi-select choice prompts to our
PSHostUserInterface implementation by implementing the
IHostUISupportsMultipleChoiceSelection interface.

Resolves #318.

Author: daviwil

src/PowerShellEditorServices.Protocol/Messages/PromptEvents.cs

@@ -13,20 +13,22 @@ public static readonly
             RequestType<ShowChoicePromptRequest, ShowChoicePromptResponse> Type =
             RequestType<ShowChoicePromptRequest, ShowChoicePromptResponse>.Create("powerShell/showChoicePrompt");
 
+        public bool IsMultiChoice { get; set; }
+
         public string Caption { get; set; }
 
         public string Message { get; set; }
 
         public ChoiceDetails[] Choices { get; set; }
 
-        public int DefaultChoice { get; set; }
+        public int[] DefaultChoices { get; set; }
     }
 
     public class ShowChoicePromptResponse
     {
         public bool PromptCancelled { get; set; }
 
-        public string ChosenItem { get; set; }
+        public string ResponseText { get; set; }
     }
 
     public class ShowInputPromptRequest

src/PowerShellEditorServices.Protocol/Server/PromptHandlers.cs

@@ -40,30 +40,34 @@ public InputPromptHandler GetInputPromptHandler()
         }
     }
 
-    internal class ProtocolChoicePromptHandler : ChoicePromptHandler
+    internal class ProtocolChoicePromptHandler : ConsoleChoicePromptHandler
     {
         private IMessageSender messageSender;
         private ConsoleService consoleService;
 
         public ProtocolChoicePromptHandler(
             IMessageSender messageSender,
             ConsoleService consoleService)
+                : base(consoleService)
         {
             this.messageSender = messageSender;
             this.consoleService = consoleService;
         }
 
         protected override void ShowPrompt(PromptStyle promptStyle)
         {
+            base.ShowPrompt(promptStyle);
+
             messageSender
                 .SendRequest(
                     ShowChoicePromptRequest.Type,
                     new ShowChoicePromptRequest
                     {
+                        IsMultiChoice = this.IsMultiChoice,
                         Caption = this.Caption,
                         Message = this.Message,
                         Choices = this.Choices,
-                        DefaultChoice = this.DefaultChoice
+                        DefaultChoices = this.DefaultChoices
                     }, true)
                 .ContinueWith(HandlePromptResponse)
                 .ConfigureAwait(false);
@@ -79,7 +83,7 @@ private void HandlePromptResponse(
                 if (!response.PromptCancelled)
                 {
                     this.consoleService.ReceivePromptResponse(
-                        response.ChosenItem,
+                        response.ResponseText,
                         false);
                 }
                 else

src/PowerShellEditorServices/Console/ChoiceDetails.cs

@@ -118,6 +118,9 @@ public static ChoiceDetails Create(ChoiceDescription choiceDescription)
         /// <returns>True if the input string is a match for the choice.</returns>
         public bool MatchesInput(string inputString)
         {
+            // Make sure the input string is trimmed of whitespace
+            inputString = inputString.Trim();
+
             // Is it the hotkey?
             return
                 string.Equals(inputString, this.hotKeyString, StringComparison.CurrentCultureIgnoreCase) ||

src/PowerShellEditorServices/Console/ChoicePromptHandler.cs

@@ -4,6 +4,9 @@
 //
 
 using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -37,12 +40,17 @@ public abstract class ChoicePromptHandler : PromptHandler
     {
         #region Private Fields
 
-        private TaskCompletionSource<int> promptTask;
+        private TaskCompletionSource<int[]> promptTask;
 
         #endregion
 
         #region Properties
 
+        /// <summary>
+        /// Returns true if the choice prompt allows multiple selections.
+        /// </summary>
+        protected bool IsMultiChoice { get; private set; }
+
         /// <summary>
         /// Gets the caption (title) string to display with the prompt.
         /// </summary>
@@ -62,7 +70,7 @@ public abstract class ChoicePromptHandler : PromptHandler
         /// Gets the index of the default choice so that the user
         /// interface can make it easy to select this option.
         /// </summary>
-        protected int DefaultChoice { get; private set; }
+        protected int[] DefaultChoices { get; private set; }
 
         #endregion
 
@@ -102,18 +110,71 @@ public Task<int> PromptForChoice(
             this.Caption = promptCaption;
             this.Message = promptMessage;
             this.Choices = choices;
-            this.DefaultChoice = defaultChoice;
-            this.promptTask = new TaskCompletionSource<int>();
+            this.promptTask = new TaskCompletionSource<int[]>();
+
+            this.DefaultChoices =
+                defaultChoice == -1
+                ? new int[] { }
+                : new int[] { defaultChoice };
 
             // Cancel the TaskCompletionSource if the caller cancels the task
             cancellationToken.Register(this.CancelPrompt, true);
 
             // Show the prompt to the user
             this.ShowPrompt(PromptStyle.Full);
 
-            return this.promptTask.Task;
+            // Convert the int[] result to int
+            return this.promptTask.Task.ContinueWith(
+                t => t.Result.DefaultIfEmpty(-1).First());
         }
 
+        /// <summary>
+        /// Prompts the user to make a choice of one or more options using the
+        /// provided details.
+        /// </summary>
+        /// <param name="promptCaption">
+        /// The caption string which will be displayed to the user.
+        /// </param>
+        /// <param name="promptMessage">
+        /// The descriptive message which will be displayed to the user.
+        /// </param>
+        /// <param name="choices">
+        /// The list of choices from which the user will select.
+        /// </param>
+        /// <param name="defaultChoices">
+        /// The default choice(s) to highlight for the user.
+        /// </param>
+        /// <param name="cancellationToken">
+        /// A CancellationToken that can be used to cancel the prompt.
+        /// </param>
+        /// <returns>
+        /// A Task instance that can be monitored for completion to get
+        /// the user's choices.
+        /// </returns>
+        public Task<int[]> PromptForChoice(
+            string promptCaption,
+            string promptMessage,
+            ChoiceDetails[] choices,
+            int[] defaultChoices,
+            CancellationToken cancellationToken)
+        {
+            // TODO: Guard against multiple calls
+
+            this.Caption = promptCaption;
+            this.Message = promptMessage;
+            this.Choices = choices;
+            this.DefaultChoices = defaultChoices;
+            this.IsMultiChoice = true;
+            this.promptTask = new TaskCompletionSource<int[]>();
+
+            // Cancel the TaskCompletionSource if the caller cancels the task
+            cancellationToken.Register(this.CancelPrompt, true);
+
+            // Show the prompt to the user
+            this.ShowPrompt(PromptStyle.Full);
+
+            return this.promptTask.Task;
+        }
         /// <summary>
         /// Implements behavior to handle the user's response.
         /// </summary>
@@ -124,29 +185,41 @@ public Task<int> PromptForChoice(
         /// </returns>
         public override bool HandleResponse(string responseString)
         {
-            int choiceIndex = -1;
+            List<int> choiceIndexes = new List<int>();
 
-            // Clean up the response string
-            responseString = responseString.Trim();
+            // Clean up the response string and split it
+            var choiceStrings =
+                responseString.Trim().Split(
+                    new char[] { ',' },
+                    StringSplitOptions.RemoveEmptyEntries);
 
-            for (int i = 0; i < this.Choices.Length; i++)
+            foreach (string choiceString in choiceStrings)
             {
-                if (this.Choices[i].MatchesInput(responseString))
+                for (int i = 0; i < this.Choices.Length; i++)
                 {
-                    choiceIndex = i;
-                    break;
+                    if (this.Choices[i].MatchesInput(choiceString))
+                    {
+                        choiceIndexes.Add(i);
+
+                        // If this is a single-choice prompt, break out after
+                        // the first matched choice
+                        if (!this.IsMultiChoice)
+                        {
+                            break;
+                        }
+                    }
                 }
             }
 
-            if (choiceIndex == -1)
+            if (choiceIndexes.Count == 0)
             {
                 // The user did not respond with a valid choice,
                 // show the prompt again to give another chance
                 this.ShowPrompt(PromptStyle.Minimal);
                 return false;
             }
 
-            this.promptTask.SetResult(choiceIndex);
+            this.promptTask.SetResult(choiceIndexes.ToArray());
             return true;
         }
 

src/PowerShellEditorServices/Console/ConsoleChoicePromptHandler.cs

@@ -3,6 +3,8 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 //
 
+using System.Linq;
+
 namespace Microsoft.PowerShell.EditorServices.Console
 {
     /// <summary>
@@ -71,12 +73,20 @@ protected override void ShowPrompt(PromptStyle promptStyle)
 
             this.consoleHost.WriteOutput("[?] Help", false);
 
-            if (this.DefaultChoice > -1 && this.DefaultChoice < this.Choices.Length)
+            var validDefaultChoices =
+                this.DefaultChoices.Where(
+                    choice => choice > -1 && choice < this.Choices.Length);
+
+            if (validDefaultChoices.Any())
             {
+                var choiceString =
+                    string.Join(
+                        ", ",
+                        this.DefaultChoices
+                            .Select(choice => this.Choices[choice].Label));
+
                 this.consoleHost.WriteOutput(
-                    string.Format(
-                        " (default is \"{0}\"):",
-                        this.Choices[this.DefaultChoice].Label));
+                    $" (default is \"{choiceString}\"):");
             }
         }
 

src/PowerShellEditorServices/Session/SessionPSHostUserInterface.cs

@@ -21,7 +21,7 @@ namespace Microsoft.PowerShell.EditorServices
     /// for the ConsoleService and routes its calls to an IConsoleHost
     /// implementation.
     /// </summary>
-    internal class ConsoleServicePSHostUserInterface : PSHostUserInterface
+    internal class ConsoleServicePSHostUserInterface : PSHostUserInterface, IHostUISupportsMultipleChoiceSelection
     {
         #region Private Fields
 
@@ -310,6 +310,50 @@ public override void WriteProgress(
 
         #endregion
 
+        #region IHostUISupportsMultipleChoiceSelection Implementation
+
+        public Collection<int> PromptForChoice(
+            string promptCaption,
+            string promptMessage,
+            Collection<ChoiceDescription> choiceDescriptions,
+            IEnumerable<int> defaultChoices)
+        {
+            if (this.consoleHost != null)
+            {
+                ChoiceDetails[] choices =
+                    choiceDescriptions
+                        .Select(ChoiceDetails.Create)
+                        .ToArray();
+
+                CancellationTokenSource cancellationToken = new CancellationTokenSource();
+                Task<int[]> promptTask =
+                    this.consoleHost
+                        .GetChoicePromptHandler()
+                        .PromptForChoice(
+                            promptCaption,
+                            promptMessage,
+                            choices,
+                            defaultChoices.ToArray(),
+                            cancellationToken.Token);
+
+                // Run the prompt task and wait for it to return
+                this.WaitForPromptCompletion(
+                    promptTask,
+                    "PromptForChoice",
+                    cancellationToken);
+
+                // Return the result
+                return new Collection<int>(promptTask.Result.ToList());
+            }
+            else
+            {
+                // Notify the caller that there's no implementation
+                throw new NotImplementedException();
+            }
+        }
+
+        #endregion
+
         #region Private Methods
 
         private void WaitForPromptCompletion<TResult>(

test/PowerShellEditorServices.Test.Host/LanguageServerTests.cs

@@ -526,17 +526,17 @@ public async Task ServiceExecutesReplCommandAndReceivesChoicePrompt()
             ShowChoicePromptRequest showChoicePromptRequest = requestResponseContext.Item1;
             RequestContext<ShowChoicePromptResponse> requestContext = requestResponseContext.Item2;
 
-            Assert.Equal(1, showChoicePromptRequest.DefaultChoice);
+            Assert.Equal(1, showChoicePromptRequest.DefaultChoices[0]);
 
             // Respond to the prompt request
             await requestContext.SendResult(
                 new ShowChoicePromptResponse
                 {
-                    ChosenItem = "a"
+                    ResponseText = "a"
                 });
 
-            // Skip the initial script lines (6 script lines plus 2 blank lines)
-            string[] outputLines = await outputReader.ReadLines(8);
+            // Skip the initial script and prompt lines (6 script lines plus 2 blank lines and 3 prompt lines)
+            string[] outputLines = await outputReader.ReadLines(11);
 
             // Wait for the selection to appear as output
             await evaluateTask;