Add workspace path information to psEditor.Workspace API

This change adds a new Path property to the EditorWorkspace class which
gets exposed through to the psEditor API.  This is useful for extension
authors who want to perform operations based on the workspace path.

Resolves #236.

Author: daviwil

src/PowerShellEditorServices.Protocol/Server/LanguageServerEditorOperations.cs

@@ -7,7 +7,6 @@
 using Microsoft.PowerShell.EditorServices.Protocol.LanguageServer;
 using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol;
 using System.Threading.Tasks;
-using System;
 
 namespace Microsoft.PowerShell.EditorServices.Protocol.Server
 {
@@ -111,6 +110,16 @@ public Task OpenFile(string filePath)
                     true);
         }
 
+        public string GetWorkspacePath()
+        {
+            return this.editorSession.Workspace.WorkspacePath;
+        }
+
+        public string GetWorkspaceRelativePath(string filePath)
+        {
+            return this.editorSession.Workspace.GetRelativePath(filePath);
+        }
+
         public Task ShowInformationMessage(string message)
         {
             return

src/PowerShellEditorServices/Extensions/EditorWorkspace.cs

@@ -17,6 +17,18 @@ public class EditorWorkspace
 
         #endregion
 
+        #region Properties
+
+        /// <summary>
+        /// Gets the current workspace path if there is one or null otherwise.
+        /// </summary>
+        public string Path
+        {
+            get { return this.editorOperations.GetWorkspacePath(); }
+        }
+
+        #endregion
+
         #region Constructors
 
         internal EditorWorkspace(IEditorOperations editorOperations)

src/PowerShellEditorServices/Extensions/FileContext.cs

@@ -32,6 +32,19 @@ public string Path
             get { return this.scriptFile.FilePath; }
         }
 
+        /// <summary>
+        /// Gets the workspace-relative path of the file.
+        /// </summary>
+        public string WorkspacePath
+        {
+            get
+            {
+                return
+                    this.editorOperations.GetWorkspaceRelativePath(
+                        this.scriptFile.FilePath);
+            }
+        }
+
         /// <summary>
         /// Gets the parsed abstract syntax tree for the file.
         /// </summary>

src/PowerShellEditorServices/Extensions/IEditorOperations.cs

@@ -20,6 +20,19 @@ public interface IEditorOperations
         /// <returns>A new EditorContext object.</returns>
         Task<EditorContext> GetEditorContext();
 
+        /// <summary>
+        /// Gets the path to the editor's active workspace.
+        /// </summary>
+        /// <returns>The workspace path or null if there isn't one.</returns>
+        string GetWorkspacePath();
+
+        /// <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);
+
         /// <summary>
         /// Causes a file to be opened in the editor.  If the file is
         /// already open, the editor must switch to the file.

src/PowerShellEditorServices/Workspace/Workspace.cs

@@ -176,6 +176,32 @@ public ScriptFile[] ExpandScriptReferences(ScriptFile scriptFile)
             return expandedReferences.ToArray();
         }
 
+        /// <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)
+        {
+            string resolvedPath = filePath;
+
+            if (!IsPathInMemory(filePath) && !string.IsNullOrEmpty(this.WorkspacePath))
+            {
+                Uri workspaceUri = new Uri(this.WorkspacePath);
+                Uri fileUri = new Uri(filePath);
+
+                resolvedPath = workspaceUri.MakeRelativeUri(fileUri).ToString();
+
+                // Convert the directory separators if necessary
+                if (System.IO.Path.DirectorySeparatorChar == '\\')
+                {
+                    resolvedPath = resolvedPath.Replace('/', '\\');
+                }
+            }
+
+            return resolvedPath;
+        }
+
         #endregion
 
         #region Private Methods

test/PowerShellEditorServices.Test/Extensions/ExtensionServiceTests.cs

@@ -168,6 +168,16 @@ await this.extensionEventQueue.EnqueueAsync(
 
     public class TestEditorOperations : IEditorOperations
     {
+        public string GetWorkspacePath()
+        {
+            throw new NotImplementedException();
+        }
+
+        public string GetWorkspaceRelativePath(string filePath)
+        {
+            throw new NotImplementedException();
+        }
+
         public Task OpenFile(string filePath)
         {
             throw new NotImplementedException();

test/PowerShellEditorServices.Test/PowerShellEditorServices.Test.csproj

@@ -73,6 +73,7 @@
     <Compile Include="Console\ConsoleServiceTests.cs" />
     <Compile Include="Console\ChoicePromptHandlerTests.cs" />
     <Compile Include="Session\ScriptFileTests.cs" />
+    <Compile Include="Session\WorkspaceTests.cs" />
     <Compile Include="Utility\AsyncDebouncerTests.cs" />
     <Compile Include="Utility\AsyncLockTests.cs" />
     <Compile Include="Utility\AsyncQueueTests.cs" />

test/PowerShellEditorServices.Test/Session/WorkspaceTests.cs

@@ -0,0 +1,38 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using Microsoft.PowerShell.EditorServices;
+using System;
+using System.IO;
+using System.Linq;
+using Xunit;
+
+namespace Microsoft.PowerShell.EditorServices.Test.Session
+{
+    public class WorkspaceTests
+    {
+        private static readonly Version PowerShellVersion = new Version("5.0"); 
+
+        [Fact]
+        public void CanResolveWorkspaceRelativePath()
+        {
+            string workspacePath = @"c:\Test\Workspace\";
+            string testPathInside = @"c:\Test\Workspace\SubFolder\FilePath.ps1";
+            string testPathOutside = @"c:\Test\PeerPath\FilePath.ps1";
+            string testPathAnotherDrive = @"z:\TryAndFindMe\FilePath.ps1";
+
+            Workspace workspace = new Workspace(PowerShellVersion);
+
+            // Test without a workspace path
+            Assert.Equal(testPathOutside, workspace.GetRelativePath(testPathOutside));
+
+            // Test with a workspace path
+            workspace.WorkspacePath = workspacePath;
+            Assert.Equal(@"SubFolder\FilePath.ps1", workspace.GetRelativePath(testPathInside));
+            Assert.Equal(@"..\PeerPath\FilePath.ps1", workspace.GetRelativePath(testPathOutside));
+            Assert.Equal(testPathAnotherDrive, workspace.GetRelativePath(testPathAnotherDrive));
+        }
+    }
+}