Support Path Enumeration (Part 1)

Author: taooceros

Plugins/Flow.Launcher.Plugin.Explorer/Search/Everything/EverythingAPI.cs

@@ -101,15 +101,20 @@ public static bool IsFastSortOption(SortOption sortOption)
         /// </summary>
         /// <param name="keyword">The key word.</param>
         /// <param name="token">when cancelled the current search will stop and exit (and would not reset)</param>
+        /// <param name="parentPath">Search Within a parent folder</param>
+        /// <param name="recursive">Search Within sub folder of the parent folder</param>
         /// <param name="sortOption">Sort By</param>
         /// <param name="offset">The offset.</param>
         /// <param name="maxCount">The max count.</param>
         /// <returns></returns>
-        public static IEnumerable<SearchResult> SearchAsync(string keyword, CancellationToken token, SortOption sortOption = SortOption.NAME_ASCENDING, int offset = 0, int maxCount = 100)
+        public static IEnumerable<SearchResult> SearchAsync(string keyword,
+            CancellationToken token,
+            SortOption sortOption = SortOption.NAME_ASCENDING,
+            string parentPath = "",
+            bool recursive = false,
+            int offset = 0,
+            int maxCount = 100)
         {
-            if (string.IsNullOrEmpty(keyword))
-                throw new ArgumentNullException(nameof(keyword));
-
             if (offset < 0)
                 throw new ArgumentOutOfRangeException(nameof(offset));
 
@@ -124,6 +129,11 @@ public static IEnumerable<SearchResult> SearchAsync(string keyword, Cancellation
                     keyword = keyword[1..];
                 }
 
+                if (!string.IsNullOrEmpty(parentPath))
+                {
+                    keyword += $" {(recursive ? "" : "parent:")}\"{parentPath}\"";
+                }
+
                 EverythingApiDllImport.Everything_SetSearchW(keyword);
                 EverythingApiDllImport.Everything_SetOffset(offset);
                 EverythingApiDllImport.Everything_SetMax(maxCount);

Plugins/Flow.Launcher.Plugin.Explorer/Search/Everything/EverythingSearchManager.cs

@@ -5,7 +5,7 @@
 
 namespace Flow.Launcher.Plugin.Explorer.Search.Everything
 {
-    public class EverythingSearchManager : IIndexProvider
+    public class EverythingSearchManager : IIndexProvider, IContentIndexProvider, IPathEnumerable
     {
         private Settings Settings { get; }
 
@@ -15,13 +15,18 @@ public EverythingSearchManager(Settings settings)
         }
 
 
-        public ValueTask<IEnumerable<SearchResult>> SearchAsync(Query query, CancellationToken token)
+        public ValueTask<IEnumerable<SearchResult>> SearchAsync(string search, CancellationToken token)
         {
-            return ValueTask.FromResult(EverythingApi.SearchAsync(query.Search, token, Settings.SortOption));
+            return ValueTask.FromResult(EverythingApi.SearchAsync(search, token,  Settings.SortOption));
         }
-        public ValueTask<IEnumerable<SearchResult>> ContentSearchAsync(Query query, CancellationToken token)
+        public ValueTask<IEnumerable<SearchResult>> ContentSearchAsync(string search, CancellationToken token)
         {
             return new ValueTask<IEnumerable<SearchResult>>(new List<SearchResult>());
         }
+        public ValueTask<IEnumerable<SearchResult>> EnumerateAsync(string path, string search, bool recursive, CancellationToken token)
+        {
+            return new ValueTask<IEnumerable<SearchResult>>(
+                EverythingApi.SearchAsync("", token, Settings.SortOption, path, recursive));
+        }
     }
 }

Plugins/Flow.Launcher.Plugin.Explorer/Search/IContentIndexProvider.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Flow.Launcher.Plugin.Explorer.Search
+{
+    public interface IContentIndexProvider
+    {
+        public ValueTask<IEnumerable<SearchResult>> ContentSearchAsync(string search, CancellationToken token);
+    }
+}

Plugins/Flow.Launcher.Plugin.Explorer/Search/IIndexProvider.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Flow.Launcher.Plugin.Explorer.Search
+{
+    public interface IIndexProvider
+    {
+        public ValueTask<IEnumerable<SearchResult>> SearchAsync(string search, CancellationToken token);
+    }
+}

Plugins/Flow.Launcher.Plugin.Explorer/Search/IPathEnumerable.cs

@@ -1,9 +1,12 @@
-using System.Collections.Generic;
+using System.Collections;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace Flow.Launcher.Plugin.Explorer.Search
 {
     public interface IPathEnumerable
     {
-        public IEnumerable<SearchResult> Enumerate(string path, bool recursive);
+        public ValueTask<IEnumerable<SearchResult>> EnumerateAsync(string path, string search, bool recursive, CancellationToken token);
     }
 }

Plugins/Flow.Launcher.Plugin.Explorer/Search/SearchManager.cs

@@ -61,11 +61,11 @@ internal async Task<List<Result>> SearchAsync(Query query, CancellationToken tok
 
             if (IsFileContentSearch(query.ActionKeyword))
             {
-                searchResults = await Settings.IndexProvider.ContentSearchAsync(query, token);
+                searchResults = await Settings.ContentIndexProvider.ContentSearchAsync(query.Search, token);
             }
             else
             {
-                searchResults = await Settings.IndexProvider.SearchAsync(query, token);
+                searchResults = await Settings.IndexProvider.SearchAsync(query.Search, token);
             }
 
             if (ActionKeywordMatch(query, Settings.ActionKeyword.PathSearchActionKeyword) ||
@@ -120,12 +120,12 @@ public async Task<List<Result>> PathSearchAsync(Query query, CancellationToken t
             var isEnvironmentVariablePath = querySearch[1..].Contains("%\\");
 
             var locationPath = querySearch;
-
+            
             if (isEnvironmentVariablePath)
                 locationPath = EnvironmentVariables.TranslateEnvironmentVariablePath(locationPath);
 
             // Check that actual location exists, otherwise directory search will throw directory not found exception
-            if (!FilesFolders.LocationExists(FilesFolders.ReturnPreviousDirectoryIfIncompleteString(locationPath)))
+            if (!FilesFolders.ReturnPreviousDirectoryIfIncompleteString(locationPath).LocationExists())
                 return results.ToList();
 
             var useIndexSearch = UseWindowsIndexForDirectorySearch(locationPath);
@@ -134,16 +134,24 @@ public async Task<List<Result>> PathSearchAsync(Query query, CancellationToken t
 
             token.ThrowIfCancellationRequested();
 
-            // var directoryResult = await TopLevelDirectorySearchBehaviourAsync(WindowsIndexTopLevelFolderSearchAsync,
-            //     DirectoryInfoClassSearch,
-            //     useIndexSearch,
-            //     query,
-            //     locationPath,
-            //     token).ConfigureAwait(false);
+            IEnumerable<SearchResult> directoryResult;
+
+            if (query.Search.Contains('>'))
+            {
+                directoryResult =
+                    await Settings.PathEnumerator.EnumerateAsync(locationPath, "", false, token)
+                        .ConfigureAwait(false);
+            }
+            else
+            {
+                directoryResult = DirectoryInfoSearch.TopLevelDirectorySearch(query, query.Search, token);
+            }
+            
+            
 
             token.ThrowIfCancellationRequested();
 
-            // results.UnionWith(directoryResult);
+            results.UnionWith(directoryResult.Select(searchResult => ResultManager.CreateResult(query, searchResult)));
 
             return results.ToList();
         }
@@ -153,10 +161,6 @@ public bool IsFileContentSearch(string actionKeyword)
             return actionKeyword == Settings.FileContentSearchActionKeyword;
         }
 
-        private List<Result> DirectoryInfoClassSearch(Query query, string querySearch, CancellationToken token)
-        {
-            return DirectoryInfoSearch.TopLevelDirectorySearch(query, querySearch, token);
-        }
 
         public async Task<List<Result>> TopLevelDirectorySearchBehaviourAsync(
             Func<Query, string, CancellationToken, Task<List<Result>>> windowsIndexSearch,

Plugins/Flow.Launcher.Plugin.Explorer/Search/WindowsIndex/IIndexProvider.cs

@@ -19,7 +19,7 @@ internal static class WindowsIndex
         // Reserved keywords in oleDB
         private const string ReservedStringPattern = @"^[`\@\#\^,\&\/\\\$\%_;\[\]]+$";
 
-        private static async Task<List<SearchResult>> ExecuteWindowsIndexSearchAsync(string indexQueryString, string connectionString, Query query, CancellationToken token)
+        private static async Task<List<SearchResult>> ExecuteWindowsIndexSearchAsync(string indexQueryString, string connectionString, CancellationToken token)
         {
             var results = new List<SearchResult>();
 
@@ -82,7 +82,6 @@ internal static async ValueTask<List<SearchResult>> WindowsIndexSearchAsync(
             Func<CSearchQueryHelper> createQueryHelper,
             Func<string, string> constructQuery,
             List<AccessLink> exclusionList,
-            Query query,
             CancellationToken token)
         {
             var regexMatch = Regex.Match(searchString, ReservedStringPattern);
@@ -93,40 +92,18 @@ internal static async ValueTask<List<SearchResult>> WindowsIndexSearchAsync(
             var constructedQuery = constructQuery(searchString);
 
             return
-                await ExecuteWindowsIndexSearchAsync(constructedQuery, createQueryHelper().ConnectionString, query, token);
+                await ExecuteWindowsIndexSearchAsync(constructedQuery, createQueryHelper().ConnectionString, token);
         }
 
-        private static List<Result> RemoveResultsInExclusionList(List<Result> results, List<AccessLink> exclusionList, CancellationToken token)
+        private static void RemoveResultsInExclusionList(List<SearchResult> results, IReadOnlyList<AccessLink> exclusionList, CancellationToken token)
         {
             var indexExclusionListCount = exclusionList.Count;
 
             if (indexExclusionListCount == 0)
-                return results;
-
-            var filteredResults = new List<Result>();
-
-            for (var index = 0; index < results.Count; index++)
-            {
-                token.ThrowIfCancellationRequested();
-
-                var excludeResult = false;
-
-                for (var i = 0; i < indexExclusionListCount; i++)
-                {
-                    token.ThrowIfCancellationRequested();
-
-                    if (results[index].SubTitle.StartsWith(exclusionList[i].Path, StringComparison.OrdinalIgnoreCase))
-                    {
-                        excludeResult = true;
-                        break;
-                    }
-                }
-
-                if (!excludeResult)
-                    filteredResults.Add(results[index]);
-            }
-
-            return filteredResults;
+                return;
+            results.RemoveAll(searchResult =>
+                exclusionList.Any(exclude => searchResult.FullPath.StartsWith(exclude.Path, StringComparison.OrdinalIgnoreCase))
+            );
         }
 
         internal static bool PathIsIndexed(string path)

Plugins/Flow.Launcher.Plugin.Explorer/Search/WindowsIndex/WindowsIndex.cs

@@ -4,18 +4,18 @@
 
 namespace Flow.Launcher.Plugin.Explorer.Search.WindowsIndex
 {
-    public class WindowsIndexManager : IIndexProvider
+    public class WindowsIndexSearchManager : IIndexProvider, IContentIndexProvider, IPathEnumerable
     {
         private Settings Settings { get; }
         private QueryConstructor QueryConstructor { get; }
-        public WindowsIndexManager(Settings settings)
+        public WindowsIndexSearchManager(Settings settings)
         {
             Settings = settings;
             QueryConstructor = new QueryConstructor(Settings);
         }
 
 
-        private async Task<List<SearchResult>> WindowsIndexFileContentSearchAsync(Query query, string querySearchString,
+        private async Task<List<SearchResult>> WindowsIndexFileContentSearchAsync(string querySearchString,
             CancellationToken token)
         {
             if (string.IsNullOrEmpty(querySearchString))
@@ -26,26 +26,24 @@ private async Task<List<SearchResult>> WindowsIndexFileContentSearchAsync(Query
                 QueryConstructor.CreateQueryHelper,
                 QueryConstructor.QueryForFileContentSearch,
                 Settings.IndexSearchExcludedSubdirectoryPaths,
-                query,
                 token).ConfigureAwait(false);
         }
 
 
 
-        private async Task<List<SearchResult>> WindowsIndexFilesAndFoldersSearchAsync(Query query, string querySearchString,
+        private async Task<List<SearchResult>> WindowsIndexFilesAndFoldersSearchAsync(string querySearchString,
             CancellationToken token)
         {
             return await WindowsIndex.WindowsIndexSearchAsync(
                 querySearchString,
                 QueryConstructor.CreateQueryHelper,
                 QueryConstructor.QueryForAllFilesAndFolders,
                 Settings.IndexSearchExcludedSubdirectoryPaths,
-                query,
                 token).ConfigureAwait(false);
         }
 
 
-        private async Task<List<SearchResult>> WindowsIndexTopLevelFolderSearchAsync(Query query, string path,
+        private async Task<List<SearchResult>> WindowsIndexTopLevelFolderSearchAsync(string path,string search,
             CancellationToken token)
         {
             var queryConstructor = new QueryConstructor(Settings);
@@ -55,16 +53,21 @@ private async Task<List<SearchResult>> WindowsIndexTopLevelFolderSearchAsync(Que
                 queryConstructor.CreateQueryHelper,
                 queryConstructor.QueryForTopLevelDirectorySearch,
                 Settings.IndexSearchExcludedSubdirectoryPaths,
-                query,
                 token).ConfigureAwait(false);
         }
-        public ValueTask<IEnumerable<SearchResult>> SearchAsync(Query query, CancellationToken token)
+        public async ValueTask<IEnumerable<SearchResult>> SearchAsync(string search, CancellationToken token)
         {
-            return default;
+            return await WindowsIndexFilesAndFoldersSearchAsync(search, token);
         }
-        public ValueTask<IEnumerable<SearchResult>> ContentSearchAsync(Query query, CancellationToken token)
+        public async ValueTask<IEnumerable<SearchResult>> ContentSearchAsync(string search, CancellationToken token)
         {
-            return default;
+            return await WindowsIndexFileContentSearchAsync(search, token);
+        }
+        public async ValueTask<IEnumerable<SearchResult>> EnumerateAsync(string path, string search, bool recursive, CancellationToken token)
+        {
+            if(recursive)
+                return await WindowsIndexFilesAndFoldersSearchAsync(search, token).ConfigureAwait(false);
+            return await WindowsIndexTopLevelFolderSearchAsync(path, search, token);
         }
     }
 }