(todo) Use globbing library

glennsarti · glennsarti · commit 46fe7d4362aa · 2019-03-10T14:06:19.000+08:00
diff --git a/PowerShellEditorServices.build.ps1 b/PowerShellEditorServices.build.ps1
@@ -51,12 +51,14 @@ Schema is:
 }
 #>
 $script:RequiredBuildAssets = @{
+    # TODO: Add glob.cs.dll
     $script:ModuleBinPath = @{
         'PowerShellEditorServices' = @(
             'publish/Serilog.dll',
             'publish/Serilog.Sinks.Async.dll',
             'publish/Serilog.Sinks.Console.dll',
             'publish/Serilog.Sinks.File.dll',
+            'publish/Microsoft.Extensions.FileSystemGlobbing.dll',
             'Microsoft.PowerShell.EditorServices.dll',
             'Microsoft.PowerShell.EditorServices.pdb'
         )
diff --git a/src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs b/src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs
@@ -725,6 +725,9 @@ await this.RunScriptDiagnosticsAsync(
             }
         }
 
+        // NEED TO CHECK FILE GLOBBING HERE!!
+        // This is the handler for textDocument/definition - https://microsoft.github.io/language-server-protocol/specification#textDocument_definition
+        // It searches the workspace for a function reference, which is then used as the definition
         protected async Task HandleDefinitionRequestAsync(
             TextDocumentPositionParams textDocumentPosition,
             RequestContext<Location[]> requestContext)
@@ -748,6 +751,7 @@ protected async Task HandleDefinitionRequestAsync(
                     await editorSession.LanguageService.GetDefinitionOfSymbolAsync(
                         scriptFile,
                         foundSymbol,
+                        // Probably something here...
                         editorSession.Workspace);
 
                 if (definition != null)
@@ -764,6 +768,9 @@ await editorSession.LanguageService.GetDefinitionOfSymbolAsync(
             await requestContext.SendResultAsync(definitionLocations.ToArray());
         }
 
+        // NEED TO CHECK FILE GLOBBING HERE!!
+        // This is the handler for textDocument/References - https://microsoft.github.io/language-server-protocol/specification#textDocument_references
+        // It searches the workspace for a function reference
         protected async Task HandleReferencesRequestAsync(
             ReferencesParams referencesParams,
             RequestContext<Location[]> requestContext)
@@ -781,7 +788,9 @@ protected async Task HandleReferencesRequestAsync(
             FindReferencesResult referencesResult =
                 await editorSession.LanguageService.FindReferencesOfSymbolAsync(
                     foundSymbol,
+                    // Probably something here...
                     editorSession.Workspace.ExpandScriptReferences(scriptFile),
+                    // Probably something here...
                     editorSession.Workspace);
 
             Location[] referenceLocations = s_emptyLocationResult;
diff --git a/src/PowerShellEditorServices/Language/LanguageService.cs b/src/PowerShellEditorServices/Language/LanguageService.cs
@@ -337,6 +337,7 @@ public async Task<FindReferencesResult> FindReferencesOfSymbolAsync(
                 fileMap[scriptFile.FilePath] = scriptFile;
             }
 
+            // Probably something here...
             foreach (string filePath in workspace.EnumeratePSFiles())
             {
                 if (!fileMap.Contains(filePath))
@@ -451,6 +452,7 @@ public async Task<GetDefinitionResult> GetDefinitionOfSymbolAsync(
             if (foundDefinition == null)
             {
                 // Get a list of all powershell files in the workspace path
+                // Probably something here...
                 IEnumerable<string> allFiles = workspace.EnumeratePSFiles();
                 foreach (string file in allFiles)
                 {
diff --git a/src/PowerShellEditorServices/PowerShellEditorServices.csproj b/src/PowerShellEditorServices/PowerShellEditorServices.csproj
@@ -20,6 +20,7 @@
     <PackageReference Include="Serilog.Sinks.File" Version="4.0.0" />
     <PackageReference Include="Serilog.Sinks.Async" Version="1.3.0" />
     <PackageReference Include="System.Runtime.Extensions" Version="4.3.0" />
+    <PackageReference Include="Microsoft.Extensions.FileSystemGlobbing" Version="2.2.0" />
     <PackageReference Include="System.Runtime.InteropServices.RuntimeInformation" Version="4.3.0" />
   </ItemGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
diff --git a/src/PowerShellEditorServices/Workspace/Workspace.cs b/src/PowerShellEditorServices/Workspace/Workspace.cs
@@ -11,6 +11,8 @@
 using System.Security;
 using System.Text;
 using System.Runtime.InteropServices;
+using Microsoft.Extensions.FileSystemGlobbing;
+using Microsoft.Extensions.FileSystemGlobbing.Abstractions;
 
 namespace Microsoft.PowerShell.EditorServices
 {
@@ -22,11 +24,21 @@ public class Workspace
     {
         #region Private Fields
 
-        private static readonly string[] s_psFilePatterns = new []
+        private static readonly string[] s_psFileExtensions = new []
         {
-            "*.ps1",
-            "*.psm1",
-            "*.psd1"
+            ".ps1",
+            ".psm1",
+            ".psd1"
+        };
+        // .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_
+        private static readonly string[] s_psFileExtensionsDotNetFramework = new []
+        {
+            ".ps1",
+            ".psm1",
+            ".psd1",
+            ".ps1xml"
         };
 
         private ILogger logger;
@@ -282,135 +294,62 @@ public string GetRelativePath(string filePath)
         }
 
         /// <summary>
-        /// Enumerate all the PowerShell (ps1, psm1, psd1) files in the workspace in a recursive manner
+        /// Whether the current runtime is Dot Net Framework as opposed to Core or Native
         /// </summary>
-        /// <returns>An enumerator over the PowerShell files found in the workspace</returns>
-        public IEnumerable<string> EnumeratePSFiles()
+        private Boolean IsDotNetFrameWork()
         {
-            if (WorkspacePath == null || !Directory.Exists(WorkspacePath))
-            {
-                return Enumerable.Empty<string>();
-            }
-
-            var foundFiles = new List<string>();
-            this.RecursivelyEnumerateFiles(WorkspacePath, ref foundFiles);
-            return foundFiles;
+            return RuntimeInformation.FrameworkDescription.StartsWith(".NET Framework");
         }
 
-        #endregion
-
-        #region Private Methods
-
         /// <summary>
-        /// Find PowerShell files recursively down from a given directory path.
-        /// Currently collects files in depth-first order.
-        /// Directory.GetFiles(folderPath, pattern, SearchOption.AllDirectories) would provide this,
-        /// but a cycle in the filesystem will cause that to enter an infinite loop.
+        /// Enumerate all the PowerShell (ps1, psm1, psd1) files in the workspace in a recursive manner
         /// </summary>
-        /// <param name="folderPath">The path of the current directory to find files in</param>
-        /// <param name="foundFiles">The accumulator for files found so far.</param>
-        /// <param name="currDepth">The current depth of the recursion from the original base directory.</param>
-        private void RecursivelyEnumerateFiles(string folderPath, ref List<string> foundFiles, int currDepth = 0)
+        /// <returns>An enumerator over the PowerShell files found in the workspace</returns>
+        public IEnumerable<string> EnumeratePSFiles(
+            string[] excludeGlobs = null,
+            string[] includeGlobs = null,
+            int maxDepth = 64,
+            Boolean ignoreReparsePoints = false
+        )
         {
-            const int recursionDepthLimit = 64;
-
-            // Look for any PowerShell files in the current directory
-            foreach (string pattern in s_psFilePatterns)
-            {
-                string[] psFiles;
-                try
-                {
-                    psFiles = Directory.GetFiles(folderPath, pattern, SearchOption.TopDirectoryOnly);
-                }
-                catch (DirectoryNotFoundException e)
-                {
-                    this.logger.WriteHandledException(
-                        $"Could not enumerate files in the path '{folderPath}' due to it being an invalid path",
-                        e);
-
-                    continue;
-                }
-                catch (PathTooLongException e)
-                {
-                    this.logger.WriteHandledException(
-                        $"Could not enumerate files in the path '{folderPath}' due to the path being too long",
-                        e);
-
-                    continue;
-                }
-                catch (Exception e) when (e is SecurityException || e is UnauthorizedAccessException)
-                {
-                    this.logger.WriteHandledException(
-                        $"Could not enumerate files in the path '{folderPath}' due to the path not being accessible",
-                        e);
-
-                    continue;
-                }
-                catch (Exception e)
-                {
-                    this.logger.WriteHandledException(
-                        $"Could not enumerate files in the path '{folderPath}' due to an exception",
-                        e);
-                    
-                    continue;
-                }
-
-                foundFiles.AddRange(psFiles);
-            }
-
-            // Prevent unbounded recursion here
-            if (currDepth >= recursionDepthLimit)
-            {
-                this.logger.Write(LogLevel.Warning, $"Recursion depth limit hit for path {folderPath}");
-                return;
-            }
-
-            // Add the recursive directories to search next
-            string[] subDirs;
-            try
+            if (WorkspacePath == null || !Directory.Exists(WorkspacePath))
             {
-                subDirs = Directory.GetDirectories(folderPath);
+                yield break;
             }
-            catch (DirectoryNotFoundException e)
-            {
-                this.logger.WriteHandledException(
-                    $"Could not enumerate directories in the path '{folderPath}' due to it being an invalid path",
-                    e);
 
-                return;
-            }
-            catch (PathTooLongException e)
+            var matcher = new Microsoft.Extensions.FileSystemGlobbing.Matcher();
+            if (includeGlobs == null || includeGlobs.Length == 0)
             {
-                this.logger.WriteHandledException(
-                    $"Could not enumerate directories in the path '{folderPath}' due to the path being too long",
-                    e);
-
-                return;
+                // Include everything as the FileSystemWrapper will filter the
+                // files based on extension prematurely
+                matcher.AddInclude("**/*");
             }
-            catch (Exception e) when (e is SecurityException || e is UnauthorizedAccessException)
+            else
             {
-                this.logger.WriteHandledException(
-                    $"Could not enumerate directories in the path '{folderPath}' due to the path not being accessible",
-                    e);
-
-                return;
+                foreach (string pattern in includeGlobs) { matcher.AddInclude(pattern); }
             }
-            catch (Exception e)
+            if (excludeGlobs != null)
             {
-                this.logger.WriteHandledException(
-                    $"Could not enumerate directories in the path '{folderPath}' due to an exception",
-                    e);
-                
-                return;
+                foreach (string pattern in excludeGlobs) { matcher.AddExclude(pattern); }
             }
 
-
-            foreach (string subDir in subDirs)
+            var fsFactory = new WorkspaceFileSystemWrapperFactory(
+                WorkspacePath,
+                maxDepth,
+                this.IsDotNetFrameWork() ? s_psFileExtensionsDotNetFramework : s_psFileExtensions,
+                ignoreReparsePoints,
+                this.logger
+            );
+            var result = matcher.Execute(fsFactory.RootDirectory);
+            foreach (FilePatternMatch item in result.Files)
             {
-                RecursivelyEnumerateFiles(subDir, ref foundFiles, currDepth: currDepth + 1);
+                yield return Path.Combine(WorkspacePath, item.Path.Replace('/', Path.DirectorySeparatorChar));
             }
         }
 
+        #endregion
+
+        #region Private Methods
         /// <summary>
         /// Recusrively searches through referencedFiles in scriptFiles
         /// and builds a Dictonary of the file references
diff --git a/src/PowerShellEditorServices/Workspace/WorkspaceFileSystemWrapper.cs b/src/PowerShellEditorServices/Workspace/WorkspaceFileSystemWrapper.cs
diff --git a/test/PowerShellEditorServices.Test/Session/WorkspaceTests.cs b/test/PowerShellEditorServices.Test/Session/WorkspaceTests.cs

Original file line number	Diff line number	Diff line change
`@@ -337,6 +337,7 @@ public async Task<FindReferencesResult> FindReferencesOfSymbolAsync(`
`337`	`337`	`fileMap[scriptFile.FilePath] = scriptFile;`
`338`	`338`	`}`
`339`	`339`
	`340`	`+ // Probably something here...`
`340`	`341`	`foreach (string filePath in workspace.EnumeratePSFiles())`
`341`	`342`	`{`
`342`	`343`	`if (!fileMap.Contains(filePath))`
`@@ -451,6 +452,7 @@ public async Task<GetDefinitionResult> GetDefinitionOfSymbolAsync(`
`451`	`452`	`if (foundDefinition == null)`
`452`	`453`	`{`
`453`	`454`	`// Get a list of all powershell files in the workspace path`
	`455`	`+ // Probably something here...`
`454`	`456`	`IEnumerable<string> allFiles = workspace.EnumeratePSFiles();`
`455`	`457`	`foreach (string file in allFiles)`
`456`	`458`	`{`