Merge pull request #150 from rkeithhill/rkeithhill/is149-scriptpath-spaces

Fixes #149 script paths with spaces

Author: rkeithhill

src/PowerShellEditorServices.Protocol/Server/DebugAdapter.cs

@@ -85,6 +85,7 @@ protected async Task HandleLaunchRequest(
             // In case that is null, use the the folder of the script to be executed.  If the resulting 
             // working dir path is a file path then extract the directory and use that.
             string workingDir = launchParams.Cwd ?? launchParams.Program;
+            workingDir = PowerShellContext.UnescapePath(workingDir);
             try
             {
                 if ((File.GetAttributes(workingDir) & FileAttributes.Directory) != FileAttributes.Directory)
@@ -94,16 +95,11 @@ protected async Task HandleLaunchRequest(
             }
             catch (Exception ex)
             {
-                Logger.Write(LogLevel.Error, "cwd path is bad: " + ex.Message);
+                Logger.Write(LogLevel.Error, "cwd path is invalid: " + ex.Message);
                 workingDir = Environment.CurrentDirectory;
             }
 
-            var setWorkingDirCommand = new PSCommand();
-            setWorkingDirCommand.AddCommand(@"Microsoft.PowerShell.Management\Set-Location")
-                .AddParameter("LiteralPath", workingDir);
-
-            await editorSession.PowerShellContext.ExecuteCommand(setWorkingDirCommand);
-
+            editorSession.PowerShellContext.SetWorkingDirectory(workingDir);
             Logger.Write(LogLevel.Verbose, "Working dir set to: " + workingDir);
 
             // Prepare arguments to the script - if specified

src/PowerShellEditorServices/Debugging/DebugService.cs

@@ -79,7 +79,8 @@ public async Task<BreakpointDetails[]> SetBreakpoints(
             {
                 // Fix for issue #123 - file paths that contain wildcard chars [ and ] need to
                 // quoted and have those wildcard chars escaped.
-                string escapedScriptPath = PowerShellContext.EscapeWildcardsInPath(scriptFile.FilePath);
+                string escapedScriptPath = 
+                    PowerShellContext.EscapePath(scriptFile.FilePath, escapeSpaces: false);
 
                 PSCommand psCommand = new PSCommand();
                 psCommand.AddCommand("Set-PSBreakpoint");

src/PowerShellEditorServices/Session/PowerShellContext.cs

@@ -12,6 +12,7 @@
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Text;
+using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -457,7 +458,7 @@ public async Task ExecuteScriptAtPath(string scriptPath, string arguments = null
             // If we don't escape wildcard characters in the script path, the script can
             // fail to execute if say the script name was foo][.ps1.
             // Related to issue #123.
-            string escapedScriptPath = EscapeWildcardsInPath(scriptPath);
+            string escapedScriptPath = EscapePath(scriptPath, escapeSpaces: true);
 
             if (arguments != null)
             {
@@ -577,13 +578,48 @@ internal void ReleaseRunspaceHandle(RunspaceHandle runspaceHandle)
         }
 
         /// <summary>
-        /// Returns the passed in path with the [ and ] wildcard characters escaped.
+        /// Sets the current working directory of the powershell context.  The path should be
+        /// unescaped before calling this method.
+        /// </summary>
+        /// <param name="path"></param>
+        public void SetWorkingDirectory(string path)
+        {
+            this.currentRunspace.SessionStateProxy.Path.SetLocation(path);
+        }
+
+        /// <summary>
+        /// Returns the passed in path with the [ and ] characters escaped. Escaping spaces is optional.
         /// </summary>
         /// <param name="path">The path to process.</param>
+        /// <param name="escapeSpaces">Specify True to escape spaces in the path, otherwise False.</param>
         /// <returns>The path with [ and ] escaped.</returns>
-        internal static string EscapeWildcardsInPath(string path)
+        public static string EscapePath(string path, bool escapeSpaces)
         {
-            return path.Replace("[", "`[").Replace("]", "`]");
+            string escapedPath = Regex.Replace(path, @"(?<!`)\[", "`[");
+            escapedPath = Regex.Replace(escapedPath, @"(?<!`)\]", "`]");
+
+            if (escapeSpaces)
+            {
+                escapedPath = Regex.Replace(escapedPath, @"(?<!`) ", "` ");
+            }
+
+            return escapedPath;
+        }
+
+        /// <summary>
+        /// Unescapes any escaped [, ] or space characters. Typically use this before calling a
+        /// .NET API that doesn't understand PowerShell escaped chars.
+        /// </summary>
+        /// <param name="path">The path to unescape.</param>
+        /// <returns>The path with the ` character before [, ] and spaces removed.</returns>
+        public static string UnescapePath(string path)
+        {
+            if (!path.Contains("`"))
+            {
+                return path;
+            }
+
+            return Regex.Replace(path, @"`(?=[ \[\]])", "");
         }
 
         #endregion

src/PowerShellEditorServices/Workspace/Workspace.cs

@@ -210,6 +210,11 @@ private string ResolveFilePath(string filePath)
                 // Some clients send paths with UNIX-style slashes, replace those if necessary
                 filePath = filePath.Replace('/', '\\');
 
+                // Clients could specify paths with escaped space, [ and ] characters which .NET APIs
+                // will not handle.  These paths will get appropriately escaped just before being passed
+                // into the PowerShell engine.
+                filePath = PowerShellContext.UnescapePath(filePath);
+
                 // Get the absolute file path
                 filePath = Path.GetFullPath(filePath);
             }

test/PowerShellEditorServices.Test.Shared/Debugging/DebugWithParamsTest.ps1 renamed to test/PowerShellEditorServices.Test.Shared/Debugging/Debug With Params [Test].ps1

@@ -64,7 +64,7 @@
     <None Include="Completion\CompletionExamples.psm1">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
-    <None Include="Debugging\DebugWithParamsTest.ps1" />
+    <None Include="Debugging\Debug With Params [Test].ps1" />
     <None Include="Debugging\VariableTest.ps1" />
     <None Include="SymbolDetails\SymbolDetails.ps1" />
     <None Include="Symbols\MultipleSymbols.ps1" />

test/PowerShellEditorServices.Test.Shared/PowerShellEditorServices.Test.Shared.csproj

@@ -87,9 +87,12 @@ public static IEnumerable<object[]> DebuggerAcceptsScriptArgsTestData
         [MemberData("DebuggerAcceptsScriptArgsTestData")]
         public async Task DebuggerAcceptsScriptArgs(string[] args)
         {
+            // The path is intentionally odd (some escaped chars but not all) because we are testing
+            // the internal path escaping mechanism - it should escape certains chars ([, ] and space) but
+            // it should not escape already escaped chars.
             ScriptFile debugWithParamsFile =
                 this.workspace.GetFile(
-                    @"..\..\..\PowerShellEditorServices.Test.Shared\Debugging\DebugWithParamsTest.ps1");
+                    @"..\..\..\PowerShellEditorServices.Test.Shared\Debugging\Debug` With Params `[Test].ps1");
 
             await this.debugService.SetBreakpoints(
                 debugWithParamsFile,