Implement paste action on button click

Author: Matthias Gessinger

src/cmd_line/commands/register.ts

@@ -6,18 +6,21 @@ import { Register, RegisterContent } from '../../register/register';
 import { RecordedState } from '../../state/recordedState';
 import { VimState } from '../../state/vimState';
 import { ExCommand } from '../../vimscript/exCommand';
+import { IPutCommandArguments, PutExCommand } from './put';
 
 class RegisterDisplayItem implements vscode.QuickPickItem {
   public readonly label: string;
   public readonly description: string;
+  public readonly buttons: readonly vscode.QuickInputButton[];
 
+  public readonly key: string;
   public readonly content: RegisterContent | undefined;
   public readonly stringContent: string;
 
-  public readonly buttons: readonly vscode.QuickInputButton[];
-
   constructor(registerKey: string, content: RegisterContent | undefined) {
     this.label = registerKey;
+    this.key = registerKey;
+
     this.content = content;
     this.stringContent = '';
     this.description = '';
@@ -26,15 +29,14 @@ class RegisterDisplayItem implements vscode.QuickPickItem {
     if (typeof content === 'string') {
       this.stringContent = content;
       this.description = this.stringContent;
-    } else if (content instanceof Array) {
-      this.stringContent = content.join('\n');
-      this.description = this.stringContent;
     } else if (content instanceof RecordedState) {
       this.description = content.actionsRun.map((x) => x.keysPressed.join('')).join('');
     }
 
-    // maximum length of 100 characters for the description
-    this.description = this.description.slice(0, 100);
+    if (this.description.length > 100) {
+      // maximum length of 100 characters for the description
+      this.description = this.description.slice(0, 97) + '...';
+    }
 
     if (this.stringContent !== '') {
       this.buttons = [
@@ -58,27 +60,15 @@ export class RegisterCommand extends ExCommand {
 
   constructor(registers: string[]) {
     super();
-    this.registerKeys = Register.getKeys()
-      .filter((reg) => reg !== '_' && (registers.length === 0 || registers.includes(reg)))
-      .sort((reg1: string, reg2: string) => this.regSortOrder(reg1) - this.regSortOrder(reg2));
-  }
 
-  private regSortOrder(register: string): number {
-    const specials = ['-', '*', '+', '.', ':', '%', '#', '/', '='];
-    if (register === '"') {
-      return 0;
-    } else if (register >= '0' && register <= '9') {
-      return 10 + parseInt(register, 10);
-    } else if (register >= 'a' && register <= 'z') {
-      return 100 + (register.charCodeAt(0) - 'a'.charCodeAt(0));
-    } else if (specials.includes(register)) {
-      return 1000 + specials.indexOf(register);
-    } else {
-      throw new Error(`Unexpected register ${register}`);
+    this.registerKeys = Register.getKeysSorted().filter((r) => !Register.isBlackHoleRegister(r));
+
+    if (registers.length > 0) {
+      this.registerKeys = this.registerKeys.filter((r) => registers.includes(r));
     }
   }
 
-  async execute(_: VimState): Promise<void> {
+  async execute(vimState: VimState): Promise<void> {
     const quickPick = vscode.window.createQuickPick<RegisterDisplayItem>();
 
     quickPick.items = await Promise.all(
@@ -92,27 +82,53 @@ export class RegisterCommand extends ExCommand {
       if (items.length === 0) {
         return;
       }
-      const item = items[0];
 
-      vscode.window.showInformationMessage(`${item.label} ${item.stringContent}`);
+      RegisterCommand.showRegisterContent(vimState, items[0]);
       quickPick.dispose();
     });
 
-    quickPick.onDidTriggerItemButton((event) => {
-      const content = event.item.stringContent;
-
-      if (content !== '') {
-        const editor = vscode.window.activeTextEditor;
-        if (editor) {
-          editor.edit((editBuilder) => {
-            editBuilder.insert(editor.selection.active, content);
-          });
-        }
-      }
-
+    quickPick.onDidTriggerItemButton(async (event) => {
+      void RegisterCommand.paste(vimState, event.item);
       quickPick.dispose();
     });
 
     quickPick.show();
   }
+
+  private static showRegisterContent(vimState: VimState, item: RegisterDisplayItem) {
+    const paste: vscode.MessageItem = {
+      title: 'Paste',
+      isCloseAffordance: false,
+    };
+
+    void vscode.window
+      .showInformationMessage(`${item.label} ${item.stringContent}`, paste)
+      .then((action) => {
+        if (!action || action !== paste) {
+          return;
+        }
+
+        void RegisterCommand.paste(vimState, item);
+      });
+  }
+
+  private static async paste(vimState: VimState, item: RegisterDisplayItem) {
+    // TODO: Can I reuse PutCommand here?
+
+    const content = item.stringContent;
+    if (content === '') {
+      return;
+    }
+
+    const editor = vscode.window.activeTextEditor;
+    if (!editor) {
+      return;
+    }
+
+    vimState.recordedState.registerKey = item.key;
+
+    editor.edit((builder) => {
+      builder.insert(vimState.cursorStopPosition, content);
+    });
+  }
 }

src/register/register.ts

@@ -94,7 +94,7 @@ export class Register {
     return /^[a-zA-Z0-9:]$/.test(register);
   }
 
-  private static isBlackHoleRegister(registerName: string): boolean {
+  public static isBlackHoleRegister(registerName: string): boolean {
     return registerName === '_';
   }
 
@@ -322,6 +322,12 @@ export class Register {
     return [...Register.registers.keys()];
   }
 
+  public static getKeysSorted(): string[] {
+    return this.getKeys().sort(
+      (reg1: string, reg2: string) => this.sortIndex(reg1) - this.sortIndex(reg2),
+    );
+  }
+
   public static clearAllRegisters(): void {
     Register.registers.clear();
   }
@@ -367,4 +373,19 @@ export class Register {
       Register.registers = new Map();
     }
   }
+
+  private static sortIndex(register: string): number {
+    const specials = ['-', '*', '+', '.', ':', '%', '#', '/', '='];
+    if (register === '"') {
+      return 0;
+    } else if (register >= '0' && register <= '9') {
+      return 10 + parseInt(register, 10);
+    } else if (register >= 'a' && register <= 'z') {
+      return 100 + (register.charCodeAt(0) - 'a'.charCodeAt(0));
+    } else if (specials.includes(register)) {
+      return 1000 + specials.indexOf(register);
+    } else {
+      throw new Error(`Unexpected register ${register}`);
+    }
+  }
 }