Create class to select mulitple options

Author: Kapil Borle

src/CheckboxQuickPick.ts

@@ -0,0 +1,93 @@
+/*---------------------------------------------------------
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ *--------------------------------------------------------*/
+
+import vscode = require('vscode');
+import QuickPickItem = vscode.QuickPickItem;
+const figures = require('figures');
+
+export interface Option {
+    name: string;
+    isSelected: boolean;
+}
+
+export class CheckboxQuickPick {
+    private options: Option[];
+    private readonly confirm: string;
+    private readonly checkboxOn: string;
+    private readonly checkboxOff: string;
+    private readonly confirmPlaceHolder: string;
+
+    constructor(options: Option[]) {
+        this.options = options;
+        this.confirm = figures.tick;
+        this.checkboxOn = "[ x ]";
+        this.checkboxOff = "[   ]";
+        this.confirmPlaceHolder = "Select " + this.confirm + " to confirm";
+    }
+
+    public show(callback: (options: Option[]) => void) {
+        let tempOptions = this.options.slice();
+        this.showInner(tempOptions, callback);
+    }
+
+    private showInner(tempOptions: Option[], callback: (options: Option[]) => void) {
+        vscode.window.showQuickPick(
+            this.getQuickPickItems(tempOptions),
+            { ignoreFocusOut: true, placeHolder: this.confirmPlaceHolder }).then((selection) => {
+                if (!selection) {
+                    return;
+                }
+
+                if (selection.label == this.confirm) {
+                    callback(tempOptions);
+                    this.options = tempOptions;
+                    return;
+                }
+
+                let index = this.getRuleIndex(tempOptions, selection.description);
+                // this.toggleOption(tempOptions[index]);
+                tempOptions[index].isSelected = this.toggleState(tempOptions[index].isSelected);
+                this.showInner(tempOptions, callback);
+            });
+    }
+
+    private getRuleIndex(options: Option[], optionLabel: string) {
+        return options.findIndex(opt => opt.name == optionLabel);
+    }
+
+    private getQuickPickItems(tempOptions: Option[]): QuickPickItem[] {
+        let quickPickItems: QuickPickItem[] = [];
+        tempOptions.forEach(option =>
+            quickPickItems.push({
+                label: this.convertToCheckBox(option.isSelected), description: option.name
+            }));
+        quickPickItems.push({ label: this.confirm, description: "Confirm" });
+        return quickPickItems;
+    }
+
+    private convertToState(checkBox: string): boolean {
+        return checkBox == this.checkboxOn;
+    }
+
+    private toggleOption(option: Option) {
+        option.isSelected = this.toggleState(option.isSelected);
+    }
+
+    private toggleState(state: boolean): boolean {
+        return !state;
+    }
+
+    private toggleCheckBox(checkBox: string): string {
+        return this.convertToCheckBox(this.toggleState(this.convertToState(checkBox)));
+    }
+
+    private convertToCheckBox(state: boolean): string {
+        if (state) {
+            return this.checkboxOn;
+        }
+        else {
+            return this.checkboxOff;
+        }
+    }
+}

src/features/SelectPSSARules.ts

@@ -6,19 +6,20 @@ import vscode = require('vscode');
 import { IFeature } from '../feature';
 import QuickPickItem = vscode.QuickPickItem;
 import { LanguageClient, RequestType, NotificationType } from 'vscode-languageclient';
+import { Option, CheckboxQuickPick } from '../checkboxQuickPick';
 const figures = require('figures');
 
 export namespace GetPSSARulesRequest {
     export const type: RequestType<any, any, void> = { get method() { return 'powerShell/getPSSARules'; } };
 }
 
 export namespace SetPSSARulesRequest {
-    export const type: RequestType<any, any, void> = { get method() {return 'powerShell/setPSSARules';}}
+    export const type: RequestType<any, any, void> = { get method() { return 'powerShell/setPSSARules'; } }
 }
 
 interface RuleInfo {
-    Name: string;
-    IsEnabled: boolean;
+    name: string;
+    isEnabled: boolean;
 }
 
 export class SelectPSSARulesFeature implements IFeature {
@@ -33,95 +34,20 @@ export class SelectPSSARulesFeature implements IFeature {
                 return;
             }
 
-            const editor = vscode.window.activeTextEditor;
-
-            var selection = editor.selection;
-            var doc = editor.document;
-            var cwr = doc.getWordRangeAtPosition(selection.active)
-            var text = doc.getText(cwr);
-
-            let rules: RuleInfo[] = [];
+            let options: Option[] = [];
             this.languageClient.sendRequest(GetPSSARulesRequest.type, null).then((returnedRules) => {
-                    for (var index = 0; index < returnedRules.length; index++) {
-                        var element = returnedRules[index];
-                        rules.push({Name : element.name, IsEnabled : element.isEnabled})
-                    }
-                    this.GetSelections(rules);
+                let options: Option[] = returnedRules.map(function (rule): Option {
+                    return { name: rule.name, isSelected: rule.isEnabled };
                 });
-        });
-    }
-
-    private GetSelections(rules: RuleInfo[])
-    {
-            vscode.window.showQuickPick(this.GetQuickPickItems(rules))
-                .then((selection) =>{
-                    if (!selection)
-                    {
-                        return;
-                    }
-
-                    if (selection.label == figures.tick)
-                    {
-                        this.languageClient.sendRequest(SetPSSARulesRequest.type, rules); //TODO handle error
-                        return;
-                    }
-
-                    let index = this.GetRuleIndex(rules, selection.description);
-                    rules[index].IsEnabled = this.ToggleState(rules[index].IsEnabled);
-                    this.GetSelections(rules);
+                (new CheckboxQuickPick(options)).show((updatedOptions) => {
+                    this.languageClient.sendRequest(
+                        SetPSSARulesRequest.type,
+                        updatedOptions.map(function (option): RuleInfo {
+                            return { name: option.name, isEnabled: option.isSelected };
+                        }));
                 });
-    }
-
-    private GetRuleIndex(rules: RuleInfo[], ruleName: string) : number
-    {
-        return rules.findIndex(rule => rule.Name == ruleName);
-    }
-
-    private GetCheckBoxOn() : string
-    {
-        return "[ x ]"; // this looks better than figure.checkboxOn
-    }
-
-    private GetCheckBoxOff() : string
-    {
-        return "[   ]"; // this looks better than figure.checkboxOff
-    }
-
-    private ConvertToState(checkBox: string) : boolean
-    {
-        return checkBox == this.GetCheckBoxOn();
-    }
-
-    private ToggleState(state: boolean) : boolean
-    {
-        return !state;
-    }
-
-    private ToggleCheckBox(checkBox: string): string
-    {
-        return this.ConvertToCheckBox(this.ToggleState(this.ConvertToState(checkBox)));
-    }
-
-    private ConvertToCheckBox(state: boolean): string
-    {
-        if (state)
-        {
-            return this.GetCheckBoxOn();
-        }
-        else
-        {
-            return this.GetCheckBoxOff();
-        }
-    }
-
-    private GetQuickPickItems(rules: RuleInfo[]): QuickPickItem[] {
-        let qItems: QuickPickItem[] = [];
-        for (var index = 0; index < rules.length; index++) {
-            var element = rules[index];
-            qItems.push({label: this.ConvertToCheckBox(element.IsEnabled), description: element.Name })
-        }
-        qItems.push({label: figures.tick, description: "confirm"});
-        return qItems;
+            });
+        });
     }
 
     public setLanguageClient(languageclient: LanguageClient) {