Rename WorkspacePath to InitialWorkingDirectory

andyleejordan · andyleejordan · commit 101784e94b56 · 2023-02-10T15:07:25.000-08:00
And note where the API needs to be updated to get the workspace path for the
current open editor (since there could be multiple workspaces).
diff --git a/src/PowerShellEditorServices/Extensions/Api/WorkspaceService.cs b/src/PowerShellEditorServices/Extensions/Api/WorkspaceService.cs
@@ -45,7 +45,7 @@ public interface IEditorScriptFile
     public interface IWorkspaceService
     {
         /// <summary>
-        /// The root path of the workspace.
+        /// The root path of the workspace for the current editor.
         /// </summary>
         string WorkspacePath { get; }
 
@@ -116,7 +116,9 @@ internal WorkspaceService(
             ExcludedFileGlobs = _workspaceService.ExcludeFilesGlob.AsReadOnly();
         }
 
-        public string WorkspacePath => _workspaceService.WorkspacePath;
+        // TODO: This needs to use the associated EditorContext to get the workspace for the current
+        // editor instead of the initial working directory.
+        public string WorkspacePath => _workspaceService.InitialWorkingDirectory;
 
         public bool FollowSymlinks => _workspaceService.FollowSymlinks;
 
diff --git a/src/PowerShellEditorServices/Extensions/EditorWorkspace.cs b/src/PowerShellEditorServices/Extensions/EditorWorkspace.cs
@@ -18,7 +18,7 @@ public sealed class EditorWorkspace
         #region Properties
 
         /// <summary>
-        /// Gets the current workspace path if there is one or null otherwise.
+        /// Gets the current workspace path if there is one for the open editor or null otherwise.
         /// </summary>
         public string Path => editorOperations.GetWorkspacePath();
 
diff --git a/src/PowerShellEditorServices/Server/PsesLanguageServer.cs b/src/PowerShellEditorServices/Server/PsesLanguageServer.cs
@@ -133,7 +133,7 @@ public async Task StartAsync()
                                 // TODO: Support multi-workspace.
                                 foreach (WorkspaceFolder workspaceFolder in initializeParams.WorkspaceFolders)
                                 {
-                                    workspaceService.WorkspacePath = workspaceFolder.Uri.GetFileSystemPath();
+                                    workspaceService.InitialWorkingDirectory = workspaceFolder.Uri.GetFileSystemPath();
                                     break;
                                 }
                             }
@@ -152,7 +152,7 @@ public async Task StartAsync()
                                 LoadProfiles = initializationOptions?.GetValue("enableProfileLoading")?.Value<bool>() ?? true,
                                 // TODO: Consider deprecating the setting which sets this and
                                 // instead use WorkspacePath exclusively.
-                                InitialWorkingDirectory = initializationOptions?.GetValue("initialWorkingDirectory")?.Value<string>() ?? workspaceService.WorkspacePath,
+                                InitialWorkingDirectory = initializationOptions?.GetValue("initialWorkingDirectory")?.Value<string>() ?? workspaceService.InitialWorkingDirectory,
                                 ShellIntegrationEnabled = initializationOptions?.GetValue("shellIntegrationEnabled")?.Value<bool>() ?? false
                             };
 
diff --git a/src/PowerShellEditorServices/Services/Extension/EditorOperationsService.cs b/src/PowerShellEditorServices/Services/Extension/EditorOperationsService.cs
@@ -191,7 +191,9 @@ public async Task SaveFileAsync(string currentPath, string newSavePath)
             }).ReturningVoid(CancellationToken.None).ConfigureAwait(false);
         }
 
-        public string GetWorkspacePath() => _workspaceService.WorkspacePath;
+        // TODO: This should get the current editor's context and use it to determine which
+        // workspace it's in.
+        public string GetWorkspacePath() => _workspaceService.InitialWorkingDirectory;
 
         public string GetWorkspaceRelativePath(string filePath) => _workspaceService.GetRelativePath(filePath);
 
diff --git a/src/PowerShellEditorServices/Services/Workspace/Handlers/ConfigurationHandler.cs b/src/PowerShellEditorServices/Services/Workspace/Handlers/ConfigurationHandler.cs
@@ -58,7 +58,7 @@ public override async Task<Unit> Handle(DidChangeConfigurationParams request, Ca
 
             _configurationService.CurrentSettings.Update(
                 incomingSettings.Powershell,
-                _workspaceService.WorkspacePath,
+                _workspaceService.InitialWorkingDirectory,
                 _logger);
 
             // Run any events subscribed to configuration updates
diff --git a/src/PowerShellEditorServices/Services/Workspace/WorkspaceService.cs b/src/PowerShellEditorServices/Services/Workspace/WorkspaceService.cs
@@ -58,9 +58,14 @@ internal class WorkspaceService
         #region Properties
 
         /// <summary>
-        /// Gets or sets the root path of the workspace.
+        /// <para>Gets or sets the initial working directory.</para>
+        /// <para>
+        /// This is settable by the same key in the initialization options, and likely corresponds
+        /// to the root of the workspace if only one workspace folder is being used. However, in
+        /// multi-root workspaces this may be any workspace folder's root (or none if overridden).
+        /// </para>
         /// </summary>
-        public string WorkspacePath { get; set; }
+        public string InitialWorkingDirectory { get; set; }
 
         /// <summary>
         /// Gets or sets the default list of file globs to exclude during workspace searches.
@@ -299,9 +304,9 @@ public string GetRelativePath(string filePath)
         {
             string resolvedPath = filePath;
 
-            if (!IsPathInMemory(filePath) && !string.IsNullOrEmpty(WorkspacePath))
+            if (!IsPathInMemory(filePath) && !string.IsNullOrEmpty(InitialWorkingDirectory))
             {
-                Uri workspaceUri = new(WorkspacePath);
+                Uri workspaceUri = new(InitialWorkingDirectory);
                 Uri fileUri = new(filePath);
 
                 resolvedPath = workspaceUri.MakeRelativeUri(fileUri).ToString();
@@ -341,7 +346,7 @@ public IEnumerable<string> EnumeratePSFiles(
             bool ignoreReparsePoints
         )
         {
-            if (WorkspacePath is null || !Directory.Exists(WorkspacePath))
+            if (InitialWorkingDirectory is null || !Directory.Exists(InitialWorkingDirectory))
             {
                 yield break;
             }
@@ -351,7 +356,7 @@ bool ignoreReparsePoints
             foreach (string pattern in excludeGlobs) { matcher.AddExclude(pattern); }
 
             WorkspaceFileSystemWrapperFactory fsFactory = new(
-                WorkspacePath,
+                InitialWorkingDirectory,
                 maxDepth,
                 VersionUtils.IsNetCore ? s_psFileExtensionsCoreFramework : s_psFileExtensionsFullFramework,
                 ignoreReparsePoints,
@@ -363,7 +368,7 @@ bool ignoreReparsePoints
                 // item.Path always contains forward slashes in paths when it should be backslashes on Windows.
                 // Since we're returning strings here, it's important to use the correct directory separator.
                 string path = VersionUtils.IsWindows ? item.Path.Replace('/', Path.DirectorySeparatorChar) : item.Path;
-                yield return Path.Combine(WorkspacePath, path);
+                yield return Path.Combine(InitialWorkingDirectory, path);
             }
         }
 
@@ -423,7 +428,7 @@ internal static bool IsPathInMemory(string filePath)
             return isInMemory;
         }
 
-        internal string ResolveWorkspacePath(string path) => ResolveRelativeScriptPath(WorkspacePath, path);
+        internal string ResolveWorkspacePath(string path) => ResolveRelativeScriptPath(InitialWorkingDirectory, path);
 
         internal string ResolveRelativeScriptPath(string baseFilePath, string relativePath)
         {
diff --git a/test/PowerShellEditorServices.Test/Language/SymbolsServiceTests.cs b/test/PowerShellEditorServices.Test/Language/SymbolsServiceTests.cs
@@ -40,7 +40,7 @@ public SymbolsServiceTests()
             psesHost = PsesHostFactory.Create(NullLoggerFactory.Instance);
             workspace = new WorkspaceService(NullLoggerFactory.Instance)
             {
-                WorkspacePath = TestUtilities.GetSharedPath("References")
+                InitialWorkingDirectory = TestUtilities.GetSharedPath("References")
             };
             symbolsService = new SymbolsService(
                 NullLoggerFactory.Instance,
diff --git a/test/PowerShellEditorServices.Test/Session/WorkspaceTests.cs b/test/PowerShellEditorServices.Test/Session/WorkspaceTests.cs
@@ -39,7 +39,7 @@ public void CanResolveWorkspaceRelativePath()
             string expectedOutsidePath = TestUtilities.NormalizePath("../PeerPath/FilePath.ps1");
 
             // Test with a workspace path
-            workspace.WorkspacePath = workspacePath;
+            workspace.InitialWorkingDirectory = workspacePath;
             Assert.Equal(expectedInsidePath, workspace.GetRelativePath(testPathInside));
             Assert.Equal(expectedOutsidePath, workspace.GetRelativePath(testPathOutside));
             Assert.Equal(testPathAnotherDrive, workspace.GetRelativePath(testPathAnotherDrive));
@@ -49,7 +49,7 @@ internal static WorkspaceService FixturesWorkspace()
         {
             return new WorkspaceService(NullLoggerFactory.Instance)
             {
-                WorkspacePath = TestUtilities.NormalizePath("Fixtures/Workspace")
+                InitialWorkingDirectory = TestUtilities.NormalizePath("Fixtures/Workspace")
             };
         }
 
@@ -94,18 +94,18 @@ public void CanRecurseDirectoryTree()
 
             List<string> expected = new()
             {
-                Path.Combine(workspace.WorkspacePath, "nested", "donotfind.ps1"),
-                Path.Combine(workspace.WorkspacePath, "nested", "nestedmodule.psd1"),
-                Path.Combine(workspace.WorkspacePath, "nested", "nestedmodule.psm1"),
-                Path.Combine(workspace.WorkspacePath, "rootfile.ps1")
+                Path.Combine(workspace.InitialWorkingDirectory, "nested", "donotfind.ps1"),
+                Path.Combine(workspace.InitialWorkingDirectory, "nested", "nestedmodule.psd1"),
+                Path.Combine(workspace.InitialWorkingDirectory, "nested", "nestedmodule.psm1"),
+                Path.Combine(workspace.InitialWorkingDirectory, "rootfile.ps1")
             };
 
             // .NET Core doesn't appear to use the same three letter pattern matching rule although the docs
             // suggest it should be find the '.ps1xml' files because we search for the pattern '*.ps1'
             // ref https://docs.microsoft.com/en-us/dotnet/api/system.io.directory.getfiles?view=netcore-2.1#System_IO_Directory_GetFiles_System_String_System_String_System_IO_EnumerationOptions_
             if (RuntimeInformation.FrameworkDescription.StartsWith(".NET Framework"))
             {
-                expected.Insert(3, Path.Combine(workspace.WorkspacePath, "other", "other.ps1xml"));
+                expected.Insert(3, Path.Combine(workspace.InitialWorkingDirectory, "other", "other.ps1xml"));
             }
 
             Assert.Equal(expected, actual);
@@ -122,7 +122,7 @@ public void CanRecurseDirectoryTreeWithLimit()
                 maxDepth: 1,
                 ignoreReparsePoints: s_defaultIgnoreReparsePoints
             );
-            Assert.Equal(new[] { Path.Combine(workspace.WorkspacePath, "rootfile.ps1") }, actual);
+            Assert.Equal(new[] { Path.Combine(workspace.InitialWorkingDirectory, "rootfile.ps1") }, actual);
         }
 
         [Fact]
@@ -138,8 +138,8 @@ public void CanRecurseDirectoryTreeWithGlobs()
             );
 
             Assert.Equal(new[] {
-                    Path.Combine(workspace.WorkspacePath, "nested", "nestedmodule.psd1"),
-                    Path.Combine(workspace.WorkspacePath, "rootfile.ps1")
+                    Path.Combine(workspace.InitialWorkingDirectory, "nested", "nestedmodule.psd1"),
+                    Path.Combine(workspace.InitialWorkingDirectory, "rootfile.ps1")
                 }, actual);
         }
 
@@ -181,7 +181,7 @@ public void CanDetermineIsPathInMemory()
         public void CanOpenAndCloseFile()
         {
             WorkspaceService workspace = FixturesWorkspace();
-            string filePath = Path.GetFullPath(Path.Combine(workspace.WorkspacePath, "rootfile.ps1"));
+            string filePath = Path.GetFullPath(Path.Combine(workspace.InitialWorkingDirectory, "rootfile.ps1"));
 
             ScriptFile file = workspace.GetFile(filePath);
             Assert.Equal(workspace.GetOpenedFiles(), new[] { file });

Original file line number	Diff line number	Diff line change
`@@ -133,7 +133,7 @@ public async Task StartAsync()`
`133`	`133`	`// TODO: Support multi-workspace.`
`134`	`134`	`foreach (WorkspaceFolder workspaceFolder in initializeParams.WorkspaceFolders)`
`135`	`135`	`{`
`136`		`- workspaceService.WorkspacePath = workspaceFolder.Uri.GetFileSystemPath();`
	`136`	`+ workspaceService.InitialWorkingDirectory = workspaceFolder.Uri.GetFileSystemPath();`
`137`	`137`	`break;`
`138`	`138`	`}`
`139`	`139`	`}`
`@@ -152,7 +152,7 @@ public async Task StartAsync()`
`152`	`152`	`LoadProfiles = initializationOptions?.GetValue("enableProfileLoading")?.Value<bool>() ?? true,`
`153`	`153`	`// TODO: Consider deprecating the setting which sets this and`
`154`	`154`	`// instead use WorkspacePath exclusively.`
`155`		`- InitialWorkingDirectory = initializationOptions?.GetValue("initialWorkingDirectory")?.Value<string>() ?? workspaceService.WorkspacePath,`
	`155`	`+ InitialWorkingDirectory = initializationOptions?.GetValue("initialWorkingDirectory")?.Value<string>() ?? workspaceService.InitialWorkingDirectory,`
`156`	`156`	`ShellIntegrationEnabled = initializationOptions?.GetValue("shellIntegrationEnabled")?.Value<bool>() ?? false`
`157`	`157`	`};`
`158`	`158`
Original file line number	Diff line number	Diff line change
`@@ -191,7 +191,9 @@ public async Task SaveFileAsync(string currentPath, string newSavePath)`
`191`	`191`	`}).ReturningVoid(CancellationToken.None).ConfigureAwait(false);`
`192`	`192`	`}`
`193`	`193`
`194`		`- public string GetWorkspacePath() => _workspaceService.WorkspacePath;`
	`194`	`+ // TODO: This should get the current editor's context and use it to determine which`
	`195`	`+ // workspace it's in.`
	`196`	`+ public string GetWorkspacePath() => _workspaceService.InitialWorkingDirectory;`
`195`	`197`
`196`	`198`	`public string GetWorkspaceRelativePath(string filePath) => _workspaceService.GetRelativePath(filePath);`
`197`	`199`
Original file line number	Diff line number	Diff line change
`@@ -58,9 +58,14 @@ internal class WorkspaceService`
`58`	`58`	`#region Properties`
`59`	`59`
`60`	`60`	`/// <summary>`
`61`		`- /// Gets or sets the root path of the workspace.`
	`61`	`+ /// <para>Gets or sets the initial working directory.</para>`
	`62`	`+ /// <para>`
	`63`	`+ /// This is settable by the same key in the initialization options, and likely corresponds`
	`64`	`+ /// to the root of the workspace if only one workspace folder is being used. However, in`
	`65`	`+ /// multi-root workspaces this may be any workspace folder's root (or none if overridden).`
	`66`	`+ /// </para>`
`62`	`67`	`/// </summary>`
`63`		`- public string WorkspacePath { get; set; }`
	`68`	`+ public string InitialWorkingDirectory { get; set; }`
`64`	`69`
`65`	`70`	`/// <summary>`
`66`	`71`	`/// Gets or sets the default list of file globs to exclude during workspace searches.`
`@@ -299,9 +304,9 @@ public string GetRelativePath(string filePath)`
`299`	`304`	`{`
`300`	`305`	`string resolvedPath = filePath;`
`301`	`306`
`302`		`- if (!IsPathInMemory(filePath) && !string.IsNullOrEmpty(WorkspacePath))`
	`307`	`+ if (!IsPathInMemory(filePath) && !string.IsNullOrEmpty(InitialWorkingDirectory))`
`303`	`308`	`{`
`304`		`- Uri workspaceUri = new(WorkspacePath);`
	`309`	`+ Uri workspaceUri = new(InitialWorkingDirectory);`
`305`	`310`	`Uri fileUri = new(filePath);`
`306`	`311`
`307`	`312`	`resolvedPath = workspaceUri.MakeRelativeUri(fileUri).ToString();`
`@@ -341,7 +346,7 @@ public IEnumerable<string> EnumeratePSFiles(`
`341`	`346`	`bool ignoreReparsePoints`
`342`	`347`	`)`
`343`	`348`	`{`
`344`		`- if (WorkspacePath is null \|\| !Directory.Exists(WorkspacePath))`
	`349`	`+ if (InitialWorkingDirectory is null \|\| !Directory.Exists(InitialWorkingDirectory))`
`345`	`350`	`{`
`346`	`351`	`yield break;`
`347`	`352`	`}`
`@@ -351,7 +356,7 @@ bool ignoreReparsePoints`
`351`	`356`	`foreach (string pattern in excludeGlobs) { matcher.AddExclude(pattern); }`
`352`	`357`
`353`	`358`	`WorkspaceFileSystemWrapperFactory fsFactory = new(`
`354`		`- WorkspacePath,`
	`359`	`+ InitialWorkingDirectory,`
`355`	`360`	`maxDepth,`
`356`	`361`	`VersionUtils.IsNetCore ? s_psFileExtensionsCoreFramework : s_psFileExtensionsFullFramework,`
`357`	`362`	`ignoreReparsePoints,`
`@@ -363,7 +368,7 @@ bool ignoreReparsePoints`
`363`	`368`	`// item.Path always contains forward slashes in paths when it should be backslashes on Windows.`
`364`	`369`	`// Since we're returning strings here, it's important to use the correct directory separator.`
`365`	`370`	`string path = VersionUtils.IsWindows ? item.Path.Replace('/', Path.DirectorySeparatorChar) : item.Path;`
`366`		`- yield return Path.Combine(WorkspacePath, path);`
	`371`	`+ yield return Path.Combine(InitialWorkingDirectory, path);`
`367`	`372`	`}`
`368`	`373`	`}`
`369`	`374`
`@@ -423,7 +428,7 @@ internal static bool IsPathInMemory(string filePath)`
`423`	`428`	`return isInMemory;`
`424`	`429`	`}`
`425`	`430`
`426`		`- internal string ResolveWorkspacePath(string path) => ResolveRelativeScriptPath(WorkspacePath, path);`
	`431`	`+ internal string ResolveWorkspacePath(string path) => ResolveRelativeScriptPath(InitialWorkingDirectory, path);`
`427`	`432`
`428`	`433`	`internal string ResolveRelativeScriptPath(string baseFilePath, string relativePath)`
`429`	`434`	`{`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ public SymbolsServiceTests()`
`40`	`40`	`psesHost = PsesHostFactory.Create(NullLoggerFactory.Instance);`
`41`	`41`	`workspace = new WorkspaceService(NullLoggerFactory.Instance)`
`42`	`42`	`{`
`43`		`- WorkspacePath = TestUtilities.GetSharedPath("References")`
	`43`	`+ InitialWorkingDirectory = TestUtilities.GetSharedPath("References")`
`44`	`44`	`};`
`45`	`45`	`symbolsService = new SymbolsService(`
`46`	`46`	`NullLoggerFactory.Instance,`