Expose open workspace documents on PSEditor workspace API

Agent-Logs-Url: https://github.com/PowerShell/PowerShellEditorServices/sessions/76ae345c-b025-4fa0-8a0c-f6f8fa243d80

Co-authored-by: JustinGrote <15258962+JustinGrote@users.noreply.github.com>

Author: Copilot

src/PowerShellEditorServices/Extensions/EditorWorkspace.cs

@@ -3,6 +3,35 @@
 
 namespace Microsoft.PowerShell.EditorServices.Extensions
 {
+    /// <summary>
+    /// A document currently open in the editor workspace.
+    /// </summary>
+    public sealed class EditorWorkspaceDocument
+    {
+        private readonly EditorWorkspace _workspace;
+
+        internal EditorWorkspaceDocument(EditorWorkspace workspace, string path)
+        {
+            _workspace = workspace;
+            Path = path;
+        }
+
+        /// <summary>
+        /// Gets the path of the document.
+        /// </summary>
+        public string Path { get; }
+
+        /// <summary>
+        /// Opens this document in the editor.
+        /// </summary>
+        public void Open() => _workspace.OpenFile(Path);
+
+        /// <summary>
+        /// Saves this document in the editor.
+        /// </summary>
+        public void Save() => _workspace.SaveFile(Path);
+    }
+
     /// <summary>
     /// Provides a PowerShell-facing API which allows scripts to
     /// interact with the editor's workspace.
@@ -28,6 +57,24 @@ public sealed class EditorWorkspace
         /// </summary>
         public string[] Paths => editorOperations.GetWorkspacePaths();
 
+        /// <summary>
+        /// Get all currently open documents in the workspace.
+        /// </summary>
+        public EditorWorkspaceDocument[] Documents
+        {
+            get
+            {
+                string[] openDocumentPaths = editorOperations.GetWorkspaceOpenDocumentPaths();
+                EditorWorkspaceDocument[] documents = new EditorWorkspaceDocument[openDocumentPaths.Length];
+                for (int i = 0; i < openDocumentPaths.Length; i++)
+                {
+                    documents[i] = new EditorWorkspaceDocument(this, openDocumentPaths[i]);
+                }
+
+                return documents;
+            }
+        }
+
         #endregion
 
         #region Constructors

src/PowerShellEditorServices/Extensions/IEditorOperations.cs

@@ -32,6 +32,12 @@ internal interface IEditorOperations
         /// <returns></returns>
         string[] GetWorkspacePaths();
 
+        /// <summary>
+        /// Get all open document paths in the current workspace session.
+        /// </summary>
+        /// <returns>All currently open document paths.</returns>
+        string[] GetWorkspaceOpenDocumentPaths();
+
         /// <summary>
         /// Resolves the given file path relative to the current workspace path.
         /// </summary>

src/PowerShellEditorServices/Services/Extension/EditorOperationsService.cs

@@ -198,6 +198,8 @@ public async Task SaveFileAsync(string currentPath, string newSavePath)
 
         public string[] GetWorkspacePaths() => _workspaceService.WorkspacePaths.ToArray();
 
+        public string[] GetWorkspaceOpenDocumentPaths() => _workspaceService.GetOpenedFiles().Select(static scriptFile => scriptFile.FilePath).ToArray();
+
         public string GetWorkspaceRelativePath(ScriptFile scriptFile) => _workspaceService.GetRelativePath(scriptFile);
 
         public async Task ShowInformationMessageAsync(string message)

test/PowerShellEditorServices.Test/Extensions/EditorWorkspaceTests.cs

@@ -0,0 +1,110 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.PowerShell.EditorServices.Extensions;
+using Microsoft.PowerShell.EditorServices.Services.TextDocument;
+using Xunit;
+
+namespace PowerShellEditorServices.Test.Extensions
+{
+    [Trait("Category", "Extensions")]
+    public class EditorWorkspaceTests
+    {
+        [Fact]
+        public void DocumentsReturnsOpenWorkspaceDocuments()
+        {
+            TestEditorOperations editorOperations = new()
+            {
+                OpenDocumentPaths = new[] { @"C:\test\one.ps1", @"C:\test\two.ps1" }
+            };
+
+            EditorWorkspace workspace = new(editorOperations);
+
+            EditorWorkspaceDocument[] documents = workspace.Documents;
+
+            Assert.Collection(
+                documents,
+                document => Assert.Equal(@"C:\test\one.ps1", document.Path),
+                document => Assert.Equal(@"C:\test\two.ps1", document.Path));
+        }
+
+        [Fact]
+        public void DocumentOpenAndSaveUseWorkspaceOperations()
+        {
+            const string filePath = @"C:\test\file.ps1";
+            TestEditorOperations editorOperations = new()
+            {
+                OpenDocumentPaths = new[] { filePath }
+            };
+
+            EditorWorkspace workspace = new(editorOperations);
+            EditorWorkspaceDocument document = Assert.Single(workspace.Documents);
+
+            document.Open();
+            document.Save();
+
+            Assert.Collection(
+                editorOperations.Calls,
+                call => Assert.Equal("OpenFile:" + filePath, call),
+                call => Assert.Equal("SaveFile:" + filePath, call));
+        }
+
+        private sealed class TestEditorOperations : IEditorOperations
+        {
+            public string[] OpenDocumentPaths { get; set; } = Array.Empty<string>();
+
+            public List<string> Calls { get; } = new();
+
+            public Task<EditorContext> GetEditorContextAsync() => Task.FromResult(default(EditorContext));
+
+            public string GetWorkspacePath() => @"C:\test";
+
+            public string[] GetWorkspacePaths() => new[] { @"C:\test" };
+
+            public string[] GetWorkspaceOpenDocumentPaths() => OpenDocumentPaths;
+
+            public string GetWorkspaceRelativePath(ScriptFile scriptFile) => scriptFile.FilePath;
+
+            public Task NewFileAsync() => Task.CompletedTask;
+
+            public Task NewFileAsync(string content) => Task.CompletedTask;
+
+            public Task OpenFileAsync(string filePath)
+            {
+                Calls.Add("OpenFile:" + filePath);
+                return Task.CompletedTask;
+            }
+
+            public Task OpenFileAsync(string filePath, bool preview) => Task.CompletedTask;
+
+            public Task CloseFileAsync(string filePath) => Task.CompletedTask;
+
+            public Task SaveFileAsync(string filePath)
+            {
+                Calls.Add("SaveFile:" + filePath);
+                return Task.CompletedTask;
+            }
+
+            public Task SaveFileAsync(string oldFilePath, string newFilePath) => Task.CompletedTask;
+
+            public Task InsertTextAsync(string filePath, string insertText, BufferRange insertRange) => Task.CompletedTask;
+
+            public Task SetSelectionAsync(BufferRange selectionRange) => Task.CompletedTask;
+
+            public Task ShowInformationMessageAsync(string message) => Task.CompletedTask;
+
+            public Task ShowErrorMessageAsync(string message) => Task.CompletedTask;
+
+            public Task ShowWarningMessageAsync(string message) => Task.CompletedTask;
+
+            public Task SetStatusBarMessageAsync(string message, int? timeout) => Task.CompletedTask;
+
+            public void ClearTerminal()
+            {
+            }
+        }
+    }
+}