Support for showing history in a preview window to better search for …

package.json

@@ -84,6 +84,11 @@
                     "dark": "resources/dark/remove.svg",
                     "light": "resources/light/remove.svg"
                 }
+            },
+            {
+                "command": "clipboard-manager.history.show-buffer",
+                "title": "Show History in Buffer",
+                "category": "Clipboard Manager"
             }
         ],
         "menus": {

src/commads/common.ts

@@ -7,4 +7,5 @@ export enum commandList {
   removeClipboardHistory = "clipboard-manager.history.remove",
   setClipboardValue = "clipboard-manager.setClipboardValue",
   showClipboardInFile = "clipboard-manager.editor.showClipboardInFile",
+  showClipboardHistory = "clipboard-manager.history.show-buffer",
 }

src/commads/showClipboardHistory.ts

@@ -0,0 +1,57 @@
+import * as vscode from "vscode";
+import { ClipboardManager, IClipboardItem } from "../manager";
+import { commandList } from "./common";
+export class ClipboardHistoryProvider
+  implements vscode.TextDocumentContentProvider
+{
+  constructor(protected _manager: ClipboardManager) {}
+
+  protected createClipsString(clips: IClipboardItem[]): string {
+    return clips
+      .map(clip => {
+        const createdAt = new Date(clip.createdAt).toLocaleString();
+        const language = clip.language ? `${clip.language}` : "";
+        const statusLine = `${createdAt} - ${language} - ${clip.createdLocation?.uri.toString()}`;
+        const clipText = clip.value.trim();
+        const dashLine = "-".repeat(statusLine.length);
+        return `${statusLine}\n${dashLine}\n${clipText}`;
+      })
+      .join("\n\n");
+  }
+
+  public provideTextDocumentContent(_uri: vscode.Uri): string {
+    return this.createClipsString(this._manager.clips);
+  }
+}
+
+export class ShowClipboardHistory implements vscode.Disposable {
+  private _disposable: vscode.Disposable[] = [];
+
+  constructor(protected _manager: ClipboardManager) {
+    this._disposable.push(
+      vscode.commands.registerCommand(
+        commandList.showClipboardHistory,
+        this.execute,
+        this
+      )
+    );
+  }
+
+  protected async execute() {
+    const timestamp = Date.now();
+    const uri = vscode.Uri.parse(
+      `clipboard-history://history/clipboard-buffer.txt?${timestamp}`
+    );
+
+    const document = await vscode.workspace.openTextDocument(uri);
+
+    await vscode.window.showTextDocument(document, {
+      preview: true,
+      viewColumn: vscode.ViewColumn.Active,
+    });
+  }
+
+  public dispose() {
+    this._disposable.forEach(d => d.dispose());
+  }
+}

src/extension.ts

@@ -13,6 +13,10 @@ import { ClipboardManager } from "./manager";
 import { Monitor } from "./monitor";
 import { ClipboardTreeDataProvider } from "./tree/history";
 import { CopyToHistoryCommand } from "./commads/copyToHistory";
+import {
+  ShowClipboardHistory,
+  ClipboardHistoryProvider,
+} from "./commads/showClipboardHistory";
 
 let manager: ClipboardManager;
 
@@ -60,6 +64,7 @@ export async function activate(context: vscode.ExtensionContext) {
   disposable.push(new ShowClipboardInFile(manager));
   disposable.push(new ClearClipboardHistory(manager));
   disposable.push(new CopyToHistoryCommand(monitor));
+  disposable.push(new ShowClipboardHistory(manager));
 
   const completion = new ClipboardCompletion(manager);
   // disposable.push(completion);
@@ -87,6 +92,14 @@ export async function activate(context: vscode.ExtensionContext) {
   const clipboardTreeDataProvider = new ClipboardTreeDataProvider(manager);
   disposable.push(clipboardTreeDataProvider);
 
+  const clipboardHistoryProvider = new ClipboardHistoryProvider(manager);
+  disposable.push(
+    vscode.workspace.registerTextDocumentContentProvider(
+      "clipboard-history",
+      clipboardHistoryProvider
+    )
+  );
+
   disposable.push(
     vscode.window.registerTreeDataProvider(
       "clipboardHistory",

src/test/showClipboardHistory.test.ts

@@ -0,0 +1,41 @@
+import * as assert from "assert";
+import * as sinon from "sinon";
+import * as vscode from "vscode";
+import { ClipboardManager } from "../manager";
+import { ShowClipboardHistory } from "../commads/showClipboardHistory";
+import { activateExtension, getExtension } from "./common";
+
+suite("Show Clipboard History Tests", function () {
+  let sandbox: sinon.SinonSandbox;
+  let clipboardManager: ClipboardManager | undefined;
+  let showClipboardHistory: ShowClipboardHistory;
+
+  suiteSetup(async function () {
+    if (!(await activateExtension())) {
+      this.skip();
+    }
+  });
+
+  setup(function () {
+    sandbox = sinon.createSandbox();
+    clipboardManager = getExtension()?.exports.manager;
+    if(clipboardManager) {
+      showClipboardHistory = new ShowClipboardHistory(clipboardManager);
+    }
+  });
+
+  teardown(function () {
+    sandbox.restore();
+    showClipboardHistory.dispose();
+  });
+
+  test("Show Clipboard History Command Execution", async function () {
+    const showTextDocumentStub = sandbox.stub(vscode.window, "showTextDocument");
+    const openTextDocumentStub = sandbox.stub(vscode.workspace, "openTextDocument");
+
+    await vscode.commands.executeCommand("clipboard-manager.history.show-buffer");
+
+    assert.ok(openTextDocumentStub.calledOnce, "openTextDocument should be called once");
+    assert.ok(showTextDocumentStub.calledOnce, "showTextDocument should be called once");
+  });
+});