Support multi-root workspaces for CurrentFile.RelativePath

Author: andyleejordan

src/PowerShellEditorServices/Extensions/FileContext.cs

@@ -58,8 +58,7 @@ public sealed class FileContext
         /// <summary>
         /// Gets the workspace-relative path of the file.
         /// </summary>
-        public string WorkspacePath => editorOperations.GetWorkspaceRelativePath(
-                        scriptFile.FilePath);
+        public string WorkspacePath => editorOperations.GetWorkspaceRelativePath(scriptFile);
 
         #endregion
 

src/PowerShellEditorServices/Extensions/IEditorOperations.cs

@@ -29,9 +29,8 @@ internal interface IEditorOperations
         /// <summary>
         /// Resolves the given file path relative to the current workspace path.
         /// </summary>
-        /// <param name="filePath">The file path to be resolved.</param>
         /// <returns>The resolved file path.</returns>
-        string GetWorkspaceRelativePath(string filePath);
+        string GetWorkspaceRelativePath(ScriptFile scriptFile);
 
         /// <summary>
         /// Causes a new untitled file to be created in the editor.

src/PowerShellEditorServices/Services/Extension/EditorOperationsService.cs

@@ -192,7 +192,7 @@ public async Task SaveFileAsync(string currentPath, string newSavePath)
         // from another for the extension API.
         public string GetWorkspacePath() => _workspaceService.InitialWorkingDirectory;
 
-        public string GetWorkspaceRelativePath(string filePath) => _workspaceService.GetRelativePath(filePath);
+        public string GetWorkspaceRelativePath(ScriptFile scriptFile) => _workspaceService.GetRelativePath(scriptFile);
 
         public async Task ShowInformationMessageAsync(string message)
         {

src/PowerShellEditorServices/Services/PowerShell/Handlers/GetCommentHelpHandler.cs

@@ -51,7 +51,7 @@ public async Task<CommentHelpRequestResult> Handle(CommentHelpRequestParams requ
             {
                 // check if the previous character is `<` because it invalidates
                 // the param block the follows it.
-                IList<string> lines = ScriptFile.GetLinesInternal(funcText);
+                IList<string> lines = ScriptFile.GetLines(funcText);
                 int relativeTriggerLine0b = triggerLine - funcExtent.StartLineNumber;
                 if (relativeTriggerLine0b > 0 && lines[relativeTriggerLine0b].IndexOf("<", StringComparison.OrdinalIgnoreCase) > -1)
                 {
@@ -68,7 +68,7 @@ public async Task<CommentHelpRequestResult> Handle(CommentHelpRequestParams requ
                 return result;
             }
 
-            List<string> helpLines = ScriptFile.GetLinesInternal(helpText);
+            List<string> helpLines = ScriptFile.GetLines(helpText);
 
             if (helpLocation?.Equals("before", StringComparison.OrdinalIgnoreCase) == false)
             {

src/PowerShellEditorServices/Services/TextDocument/ScriptFile.cs

@@ -31,13 +31,6 @@ internal sealed class ScriptFile
 
         #region Properties
 
-        /// <summary>
-        /// Gets a unique string that identifies this file.  At this time,
-        /// this property returns a normalized version of the value stored
-        /// in the FilePath property.
-        /// </summary>
-        public string Id => FilePath.ToLower();
-
         /// <summary>
         /// Gets the path at which this file resides.
         /// </summary>
@@ -173,14 +166,7 @@ internal ScriptFile(
         /// </summary>
         /// <param name="text">Input string to be split up into lines.</param>
         /// <returns>The lines in the string.</returns>
-        internal static IList<string> GetLines(string text) => GetLinesInternal(text);
-
-        /// <summary>
-        /// Get the lines in a string.
-        /// </summary>
-        /// <param name="text">Input string to be split up into lines.</param>
-        /// <returns>The lines in the string.</returns>
-        internal static List<string> GetLinesInternal(string text)
+        internal static List<string> GetLines(string text)
         {
             if (text == null)
             {
@@ -520,7 +506,7 @@ internal void SetFileContents(string fileContents)
         {
             // Split the file contents into lines and trim
             // any carriage returns from the strings.
-            FileLines = GetLinesInternal(fileContents);
+            FileLines = GetLines(fileContents);
 
             // Parse the contents to get syntax tree and errors
             ParseFileContents();

src/PowerShellEditorServices/Services/Workspace/WorkspaceService.cs

@@ -306,27 +306,31 @@ public void CloseFile(ScriptFile scriptFile)
         /// <summary>
         /// Gets the workspace-relative path of the given file path.
         /// </summary>
-        /// <param name="filePath">The original full file path.</param>
         /// <returns>A relative file path</returns>
-        public string GetRelativePath(string filePath)
+        public string GetRelativePath(ScriptFile scriptFile)
         {
-            string resolvedPath = filePath;
-
-            if (!IsPathInMemory(filePath) && !string.IsNullOrEmpty(InitialWorkingDirectory))
+            Uri fileUri = scriptFile.DocumentUri.ToUri();
+            if (!scriptFile.IsInMemory)
             {
-                Uri workspaceUri = new(InitialWorkingDirectory);
-                Uri fileUri = new(filePath);
-
-                resolvedPath = workspaceUri.MakeRelativeUri(fileUri).ToString();
-
-                // Convert the directory separators if necessary
-                if (Path.DirectorySeparatorChar == '\\')
+                // Support calculating out-of-workspace relative paths in the common case of a
+                // single workspace folder. Otherwise try to get the matching folder.
+                foreach (WorkspaceFolder workspaceFolder in WorkspaceFolders)
                 {
-                    resolvedPath = resolvedPath.Replace('/', '\\');
+                    Uri workspaceUri = workspaceFolder.Uri.ToUri();
+                    if (WorkspaceFolders.Count == 1 || workspaceUri.IsBaseOf(fileUri))
+                    {
+                        return workspaceUri.MakeRelativeUri(fileUri).ToString();
+                    }
                 }
             }
 
-            return resolvedPath;
+            // Default to the absolute file path if possible, otherwise just return the URI. This
+            // removes the scheme and initial slash when possible.
+            if (fileUri.IsAbsoluteUri)
+            {
+                return fileUri.AbsolutePath;
+            }
+            return fileUri.ToString();
         }
 
         /// <summary>
@@ -407,42 +411,6 @@ internal static string ReadFileContents(DocumentUri uri)
             return reader.ReadToEnd();
         }
 
-        internal static bool IsPathInMemory(string filePath)
-        {
-            bool isInMemory = false;
-
-            // In cases where a "virtual" file is displayed in the editor,
-            // we need to treat the file differently than one that exists
-            // on disk.  A virtual file could be something like a diff
-            // view of the current file or an untitled file.
-            try
-            {
-                // File system absolute paths will have a URI scheme of file:.
-                // Other schemes like "untitled:" and "gitlens-git:" will return false for IsFile.
-                Uri uri = new(filePath);
-                isInMemory = !uri.IsFile;
-            }
-            catch (UriFormatException)
-            {
-                // Relative file paths cause a UriFormatException.
-                // In this case, fallback to using Path.GetFullPath().
-                try
-                {
-                    Path.GetFullPath(filePath);
-                }
-                catch (Exception ex) when (ex is ArgumentException or NotSupportedException)
-                {
-                    isInMemory = true;
-                }
-                catch (PathTooLongException)
-                {
-                    // If we ever get here, it should be an actual file so, not in memory
-                }
-            }
-
-            return isInMemory;
-        }
-
         internal string ResolveWorkspacePath(string path) => ResolveRelativeScriptPath(InitialWorkingDirectory, path);
 
         internal string ResolveRelativeScriptPath(string baseFilePath, string relativePath)

test/PowerShellEditorServices.Test/Session/WorkspaceTests.cs

@@ -10,6 +10,9 @@
 using Microsoft.PowerShell.EditorServices.Test.Shared;
 using Microsoft.PowerShell.EditorServices.Services.TextDocument;
 using Xunit;
+using Microsoft.PowerShell.EditorServices.Utility;
+using OmniSharp.Extensions.LanguageServer.Protocol.Models;
+using OmniSharp.Extensions.LanguageServer.Protocol;
 
 namespace PowerShellEditorServices.Test.Session
 {
@@ -22,27 +25,51 @@ public class WorkspaceTests
             ? s_lazyDriveLetter.Value
             : string.Empty;
 
+        internal static ScriptFile CreateScriptFile(string path) => new(path, "", VersionUtils.PSVersion);
+
+
         [Fact]
         public void CanResolveWorkspaceRelativePath()
         {
-            string workspacePath = TestUtilities.NormalizePath("c:/Test/Workspace/");
-            string testPathInside = TestUtilities.NormalizePath("c:/Test/Workspace/SubFolder/FilePath.ps1");
-            string testPathOutside = TestUtilities.NormalizePath("c:/Test/PeerPath/FilePath.ps1");
-            string testPathAnotherDrive = TestUtilities.NormalizePath("z:/TryAndFindMe/FilePath.ps1");
+            string workspacePath = "c:/Test/Workspace/";
+            ScriptFile testPathInside = CreateScriptFile("c:/Test/Workspace/SubFolder/FilePath.ps1");
+            ScriptFile testPathOutside = CreateScriptFile("c:/Test/PeerPath/FilePath.ps1");
+            ScriptFile testPathAnotherDrive = CreateScriptFile("z:/TryAndFindMe/FilePath.ps1");
 
             WorkspaceService workspace = new(NullLoggerFactory.Instance);
 
-            // Test without a workspace path
-            Assert.Equal(testPathOutside, workspace.GetRelativePath(testPathOutside));
+            // Test with zero workspace folders
+            Assert.Equal(
+                testPathOutside.DocumentUri.ToUri().AbsolutePath,
+                workspace.GetRelativePath(testPathOutside));
 
-            string expectedInsidePath = TestUtilities.NormalizePath("SubFolder/FilePath.ps1");
-            string expectedOutsidePath = TestUtilities.NormalizePath("../PeerPath/FilePath.ps1");
+            string expectedInsidePath = "SubFolder/FilePath.ps1";
+            string expectedOutsidePath = "../PeerPath/FilePath.ps1";
+
+            // Test with a single workspace folder
+            workspace.WorkspaceFolders.Add(new WorkspaceFolder
+            {
+                Uri = DocumentUri.FromFileSystemPath(workspacePath)
+            });
 
-            // Test with a workspace path
-            workspace.InitialWorkingDirectory = workspacePath;
             Assert.Equal(expectedInsidePath, workspace.GetRelativePath(testPathInside));
             Assert.Equal(expectedOutsidePath, workspace.GetRelativePath(testPathOutside));
-            Assert.Equal(testPathAnotherDrive, workspace.GetRelativePath(testPathAnotherDrive));
+            Assert.Equal(
+                testPathAnotherDrive.DocumentUri.ToUri().AbsolutePath,
+                workspace.GetRelativePath(testPathAnotherDrive));
+
+            // Test with two workspace folders
+            string anotherWorkspacePath = "c:/Test/AnotherWorkspace/";
+            ScriptFile anotherTestPathInside = CreateScriptFile("c:/Test/AnotherWorkspace/DifferentFolder/FilePath.ps1");
+            string anotherExpectedInsidePath = "DifferentFolder/FilePath.ps1";
+
+            workspace.WorkspaceFolders.Add(new WorkspaceFolder
+            {
+                Uri = DocumentUri.FromFileSystemPath(anotherWorkspacePath)
+            });
+
+            Assert.Equal(expectedInsidePath, workspace.GetRelativePath(testPathInside));
+            Assert.Equal(anotherExpectedInsidePath, workspace.GetRelativePath(anotherTestPathInside));
         }
 
         internal static WorkspaceService FixturesWorkspace()
@@ -143,40 +170,6 @@ public void CanRecurseDirectoryTreeWithGlobs()
                 }, actual);
         }
 
-        [Fact]
-        public void CanDetermineIsPathInMemory()
-        {
-            string tempDir = Path.GetTempPath();
-            string shortDirPath = Path.Combine(tempDir, "GitHub", "PowerShellEditorServices");
-            string shortFilePath = Path.Combine(shortDirPath, "foo.ps1");
-            const string shortUriForm = "git:/c%3A/Users/Keith/GitHub/dahlbyk/posh-git/src/PoshGitTypes.ps1?%7B%22path%22%3A%22c%3A%5C%5CUsers%5C%5CKeith%5C%5CGitHub%5C%5Cdahlbyk%5C%5Cposh-git%5C%5Csrc%5C%5CPoshGitTypes.ps1%22%2C%22ref%22%3A%22~%22%7D";
-            const string longUriForm = "gitlens-git:c%3A%5CUsers%5CKeith%5CGitHub%5Cdahlbyk%5Cposh-git%5Csrc%5CPoshGitTypes%3Ae0022701.ps1?%7B%22fileName%22%3A%22src%2FPoshGitTypes.ps1%22%2C%22repoPath%22%3A%22c%3A%2FUsers%2FKeith%2FGitHub%2Fdahlbyk%2Fposh-git%22%2C%22sha%22%3A%22e0022701fa12e0bc22d0458673d6443c942b974a%22%7D";
-
-            string[] inMemoryPaths = new[] {
-                // Test short non-file paths
-                "untitled:untitled-1",
-                shortUriForm,
-                "inmemory://foo.ps1",
-                // Test long non-file path
-                longUriForm
-            };
-
-            Assert.All(inMemoryPaths, (p) => Assert.True(WorkspaceService.IsPathInMemory(p)));
-
-            string[] notInMemoryPaths = new[] {
-                // Test short file absolute paths
-                shortDirPath,
-                shortFilePath,
-                new Uri(shortDirPath).ToString(),
-                new Uri(shortFilePath).ToString(),
-                // Test short file relative paths
-                "foo.ps1",
-                Path.Combine(new[] { "..", "foo.ps1" })
-            };
-
-            Assert.All(notInMemoryPaths, (p) => Assert.False(WorkspaceService.IsPathInMemory(p)));
-        }
-
         [Fact]
         public void CanOpenAndCloseFile()
         {