[FEATURE] Folder and File Action Keywords

Plugins/Flow.Launcher.Plugin.Explorer/Languages/en.xaml

@@ -58,6 +58,8 @@
     <system:String x:Key="plugin_explorer_actionkeywordview_filecontentsearch">File Content Search:</system:String>
     <system:String x:Key="plugin_explorer_actionkeywordview_indexsearch">Index Search:</system:String>
     <system:String x:Key="plugin_explorer_actionkeywordview_quickaccess">Quick Access:</system:String>
+    <system:String x:Key="plugin_explorer_actionkeywordview_foldersearch">Folder Search:</system:String>
+    <system:String x:Key="plugin_explorer_actionkeywordview_filesearch">File Search:</system:String>
     <system:String x:Key="plugin_explorer_actionkeyword_current">Current Action Keyword</system:String>
     <system:String x:Key="plugin_explorer_actionkeyword_done">Done</system:String>
     <system:String x:Key="plugin_explorer_actionkeyword_enabled">Enabled</system:String>
@@ -74,7 +76,7 @@
     <system:String x:Key="plugin_explorer_Directory_Recursive_Search_Engine">Directory Recursive Search Engine</system:String>
     <system:String x:Key="plugin_explorer_Index_Search_Engine">Index Search Engine</system:String>
     <system:String x:Key="plugin_explorer_Open_Window_Index_Option">Open Windows Index Option</system:String>
     <system:String x:Key="plugin_explorer_Excluded_File_Types">Excluded File Types (comma seperated)</system:String>
     <system:String x:Key="plugin_explorer_Excluded_File_Types_Tooltip">For example: exe,jpg,png</system:String>
     <system:String x:Key="plugin_explorer_Maximum_Results">Maximum results</system:String>
     <system:String x:Key="plugin_explorer_Maximum_Results_Tooltip">The maximum number of results requested from active search engine</system:String>

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

@@ -1,13 +1,14 @@
-using Flow.Launcher.Plugin.Explorer.Search.DirectoryInfo;
-using Flow.Launcher.Plugin.Explorer.Search.Everything;
-using Flow.Launcher.Plugin.Explorer.Search.QuickAccessLinks;
-using Flow.Launcher.Plugin.SharedCommands;
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Flow.Launcher.Plugin.Explorer.Exceptions;
+using Flow.Launcher.Plugin.Explorer.Search.DirectoryInfo;
+using Flow.Launcher.Plugin.Explorer.Search.Everything;
+using Flow.Launcher.Plugin.Explorer.Search.QuickAccessLinks;
+using Flow.Launcher.Plugin.SharedCommands;
+using static Flow.Launcher.Plugin.Explorer.Settings;
 using Path = System.IO.Path;
 
 namespace Flow.Launcher.Plugin.Explorer.Search
@@ -18,6 +19,13 @@
 
         internal Settings Settings;
 
+        private readonly Dictionary<ActionKeyword, ResultType[]> _typesToFilterByActionKeyword = new()
+        {
+            { ActionKeyword.FileSearchActionKeyword, [ResultType.Folder, ResultType.Volume] },
+            { ActionKeyword.FolderSearchActionKeyword, [ResultType.File] },
+        };
+
+
         public SearchManager(Settings settings, PluginInitContext context)
         {
             Context = context;
@@ -48,82 +56,97 @@
         {
             var results = new HashSet<Result>(PathEqualityComparator.Instance);
 
-            // This allows the user to type the below action keywords and see/search the list of quick folder links
-            if (ActionKeywordMatch(query, Settings.ActionKeyword.SearchActionKeyword)
-                || ActionKeywordMatch(query, Settings.ActionKeyword.QuickAccessActionKeyword)
-                || ActionKeywordMatch(query, Settings.ActionKeyword.PathSearchActionKeyword)
-                || ActionKeywordMatch(query, Settings.ActionKeyword.IndexSearchActionKeyword)
-                || ActionKeywordMatch(query, Settings.ActionKeyword.FileContentSearchActionKeyword))
+            var keyword = query.ActionKeyword.Length == 0 ? Query.GlobalPluginWildcardSign : query.ActionKeyword;
+
+            // No action keyword matched - plugin should not handle this query, return empty results.
+            var activeActionKeywords = Settings.GetActiveActionKeywords(keyword);
+            if (activeActionKeywords.Count == 0)
             {
-                if (string.IsNullOrEmpty(query.Search) && ActionKeywordMatch(query, Settings.ActionKeyword.QuickAccessActionKeyword))
-                    return QuickAccess.AccessLinkListAll(query, Settings.QuickAccessLinks);
+                return [.. results];
             }
-            else
+
+            var queryIsEmpty = string.IsNullOrEmpty(query.Search);
+            if (queryIsEmpty && activeActionKeywords.ContainsKey(ActionKeyword.QuickAccessActionKeyword))
             {
-                // No action keyword matched- plugin should not handle this query, return empty results.
-                return new List<Result>();
+                return QuickAccess.AccessLinkListAll(query, Settings.QuickAccessLinks);
             }
 
-            IAsyncEnumerable<SearchResult> searchResults;
+            if (queryIsEmpty)
+            {
+                return [.. results];
+            }
 
-            bool isPathSearch = query.Search.IsLocationPathString()
+            var isPathSearch = query.Search.IsLocationPathString()
                 || EnvironmentVariables.IsEnvironmentVariableSearch(query.Search)
                 || EnvironmentVariables.HasEnvironmentVar(query.Search);
 
+
+            // If no action keyword for path search is specified but the query is a path search, add it.
+            if (!activeActionKeywords.ContainsKey(ActionKeyword.PathSearchActionKeyword) && isPathSearch)
+            {
+                activeActionKeywords.Add(ActionKeyword.PathSearchActionKeyword, keyword);
+            }
+
+            IAsyncEnumerable<SearchResult> searchResults;
+
             string engineName;
 
             switch (isPathSearch)
             {
                 case true
-                    when ActionKeywordMatch(query, Settings.ActionKeyword.PathSearchActionKeyword)
-                         || ActionKeywordMatch(query, Settings.ActionKeyword.SearchActionKeyword):
-
+                    when CanUsePatchSearchByActionKeywords(activeActionKeywords):
                     results.UnionWith(await PathSearchAsync(query, token).ConfigureAwait(false));
-
-                    return results.ToList();
+                    return [.. results];
 
                 case false
-                    when ActionKeywordMatch(query, Settings.ActionKeyword.FileContentSearchActionKeyword):
-
                     // Intentionally require enabling of Everything's content search due to its slowness
+                    when activeActionKeywords.ContainsKey(ActionKeyword.FileContentSearchActionKeyword):
                     if (Settings.ContentIndexProvider is EverythingSearchManager && !Settings.EnableEverythingContentSearch)
                         return EverythingContentSearchResult(query);
 
                     searchResults = Settings.ContentIndexProvider.ContentSearchAsync("", query.Search, token);
                     engineName = Enum.GetName(Settings.ContentSearchEngine);
                     break;
 
-                case false
-                    when ActionKeywordMatch(query, Settings.ActionKeyword.IndexSearchActionKeyword)
-                         || ActionKeywordMatch(query, Settings.ActionKeyword.SearchActionKeyword):
+                case true or false
+                    when activeActionKeywords.ContainsKey(ActionKeyword.QuickAccessActionKeyword):
+                    return QuickAccess.AccessLinkListMatched(query, Settings.QuickAccessLinks);
 
+
+                case false
+                    when CanUseIndexSearchByActionKeywords(activeActionKeywords):
                     searchResults = Settings.IndexProvider.SearchAsync(query.Search, token);
                     engineName = Enum.GetName(Settings.IndexSearchEngine);
                     break;
-
-                case true or false
-                    when ActionKeywordMatch(query, Settings.ActionKeyword.QuickAccessActionKeyword):
-                    return QuickAccess.AccessLinkListMatched(query, Settings.QuickAccessLinks);
-
                 default:
-                    return results.ToList();
-            }
+                    return [.. results];
 
-            // Merge Quick Access Link results for non-path searches.
-            results.UnionWith(QuickAccess.AccessLinkListMatched(query, Settings.QuickAccessLinks));
+            }
 
+            //Merge Quick Access Link results for non-path searches.
+            results.UnionWith(GetQuickAccessResultsFilteredByActionKeyword(query, activeActionKeywords));
             try
             {
                 await foreach (var search in searchResults.WithCancellation(token).ConfigureAwait(false))
-                    if (search.Type == ResultType.File && IsExcludedFile(search)) {
+                {
+                    if (search.Type == ResultType.File && IsExcludedFile(search))
+                    {
                         continue;
-                    } else {
-                        results.Add(ResultManager.CreateResult(query, search));
                     }
+
+                    if (IsResultTypeFilteredByActionKeyword(search.Type, activeActionKeywords))
+                    {
+                        continue;
+                    }
+
+                    results.Add(ResultManager.CreateResult(query, search));
+
+
+                }
             }
             catch (OperationCanceledException)
             {
-                return new List<Result>();
+                return [.. results];
             }
             catch (EngineNotAvailableException)
             {
@@ -137,33 +160,13 @@
             results.RemoveWhere(r => Settings.IndexSearchExcludedSubdirectoryPaths.Any(
                 excludedPath => FilesFolders.PathContains(excludedPath.Path, r.SubTitle, allowEqual: true)));
 
-            return results.ToList();
-        }
-
-        private bool ActionKeywordMatch(Query query, Settings.ActionKeyword allowedActionKeyword)
-        {
-            var keyword = query.ActionKeyword.Length == 0 ? Query.GlobalPluginWildcardSign : query.ActionKeyword;
-
-            return allowedActionKeyword switch
-            {
-                Settings.ActionKeyword.SearchActionKeyword => Settings.SearchActionKeywordEnabled &&
-                                                              keyword == Settings.SearchActionKeyword,
-                Settings.ActionKeyword.PathSearchActionKeyword => Settings.PathSearchKeywordEnabled &&
-                                                                  keyword == Settings.PathSearchActionKeyword,
-                Settings.ActionKeyword.FileContentSearchActionKeyword => Settings.FileContentSearchKeywordEnabled &&
-                                                                         keyword == Settings.FileContentSearchActionKeyword,
-                Settings.ActionKeyword.IndexSearchActionKeyword => Settings.IndexSearchKeywordEnabled &&
-                                                                   keyword == Settings.IndexSearchActionKeyword,
-                Settings.ActionKeyword.QuickAccessActionKeyword => Settings.QuickAccessKeywordEnabled &&
-                                                                   keyword == Settings.QuickAccessActionKeyword,
-                _ => throw new ArgumentOutOfRangeException(nameof(allowedActionKeyword), allowedActionKeyword, "actionKeyword out of range")
-            };
+            return [.. results];
         }
 
         private List<Result> EverythingContentSearchResult(Query query)
         {
-            return new List<Result>()
-            {
+            return
+            [
                 new()
                 {
                     Title = Localize.flowlauncher_plugin_everything_enable_content_search(),
@@ -176,7 +179,7 @@
                         return false;
                     }
                 }
-            };
+            ];
         }
 
         private async Task<List<Result>> PathSearchAsync(Query query, CancellationToken token = default)
@@ -188,7 +191,7 @@
             if (EnvironmentVariables.IsEnvironmentVariableSearch(querySearch))
                 return EnvironmentVariables.GetEnvironmentStringPathSuggestions(querySearch, query, Context);
 
             // Query is a location path with a full environment variable, eg. %appdata%\somefolder\, c:\users\%USERNAME%\downloads
             var needToExpand = EnvironmentVariables.HasEnvironmentVar(querySearch);
             var path = needToExpand ? Environment.ExpandEnvironmentVariables(querySearch) : querySearch;
 
@@ -197,7 +200,7 @@
 
             // Check that actual location exists, otherwise directory search will throw directory not found exception
             if (!FilesFolders.ReturnPreviousDirectoryIfIncompleteString(path).LocationExists())
-                return results.ToList();
+                return [.. results];
 
             var useIndexSearch = Settings.IndexSearchEngine is Settings.IndexSearchEngineOption.WindowsIndex
                                  && UseWindowsIndexForDirectorySearch(path);
@@ -209,7 +212,7 @@
                 : ResultManager.CreateOpenCurrentFolderResult(retrievedDirectoryPath, query.ActionKeyword, useIndexSearch));
 
             if (token.IsCancellationRequested)
-                return new List<Result>();
+                return [.. results];
 
             IAsyncEnumerable<SearchResult> directoryResult;
 
@@ -231,7 +234,7 @@
             }
 
             if (token.IsCancellationRequested)
-                return new List<Result>();
+                return [.. results];
 
             try
             {
@@ -246,14 +249,14 @@
             }
 
 
-            return results.ToList();
+            return [.. results];
         }
 
         public bool IsFileContentSearch(string actionKeyword) => actionKeyword == Settings.FileContentSearchActionKeyword;
 
         public static bool UseIndexSearch(string path)
         {
-            if (Main.Settings.IndexSearchEngine is not Settings.IndexSearchEngineOption.WindowsIndex)
+            if (Main.Settings.IndexSearchEngine is not IndexSearchEngineOption.WindowsIndex)
                 return false;
 
             // Check if the path is using windows index search
@@ -275,10 +278,72 @@
 
         private bool IsExcludedFile(SearchResult result)
         {
-            string[] excludedFileTypes = Settings.ExcludedFileTypes.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
+            string[] excludedFileTypes = Settings.ExcludedFileTypes.Split([','], StringSplitOptions.RemoveEmptyEntries);
             string fileExtension = Path.GetExtension(result.FullPath).TrimStart('.');
 
             return excludedFileTypes.Contains(fileExtension, StringComparer.OrdinalIgnoreCase);
         }
+
+        private List<Result> GetQuickAccessResultsFilteredByActionKeyword(Query query, Dictionary<ActionKeyword, string> actions)
+        {
+            var results = QuickAccess.AccessLinkListMatched(query, Settings.QuickAccessLinks) ?? [];
+            if (results.Count == 0)
+            {
+                return results;
+            }
+
+            return results
+                .Where(r => r.ContextData is SearchResult result
+                       && !IsResultTypeFilteredByActionKeyword(result.Type, actions))
+                .ToList();
+        }
+        private bool IsResultTypeFilteredByActionKeyword(ResultType type, Dictionary<ActionKeyword, string> actions)
+        {
+            foreach (var action in actions.Keys)
+            {
+                if (_typesToFilterByActionKeyword.TryGetValue(action, out var typesToFilter))
+                {
+                    if (typesToFilter.Contains(type))
+                        return true;
+                }
+            }
+
+            return false;
+        }
+
+        private bool CanUseIndexSearchByActionKeywords(Dictionary<ActionKeyword, string> actions)
+        {
+            var keysToUseIndexSearch = new[]
+            {
+                ActionKeyword.FileSearchActionKeyword, ActionKeyword.FolderSearchActionKeyword,
+                ActionKeyword.IndexSearchActionKeyword, ActionKeyword.SearchActionKeyword
+            };
+            foreach (var key in keysToUseIndexSearch)
+            {
+                if (actions.ContainsKey(key))
+                    return true;
+            }
+
+            return false;
+        }
+
+        // Action keywords that supports patch search in results.
+        private bool CanUsePatchSearchByActionKeywords(Dictionary<ActionKeyword, string> actions)
+        {
+            var keysThatSupportPathSearch = new[]
+            {
+                ActionKeyword.PathSearchActionKeyword, ActionKeyword.SearchActionKeyword,
+                ActionKeyword.FolderSearchActionKeyword
+            };
+
+            foreach (var key in keysThatSupportPathSearch)
+            {
+                if (actions.ContainsKey(key))
+                    return true;
+            }
+
+            return false;
+        }
+
     }
 }