(#1340) Add Incremental Prefix Filtering

Author: jibedoubleve

src/Infra/Lanceur.Infra/Services/SearchService.cs

@@ -10,12 +10,12 @@ public sealed class SearchService : ISearchService
 {
     #region Fields
 
-    private Cmdline? _lastQuery;
+    private Cmdline? _previousQuery;
 
     private readonly ILogger<SearchService> _logger;
     private readonly IMacroAliasExpanderService _macroAliasExpanderService;
     private readonly ISearchServiceOrchestrator _orchestrator;
-    private readonly IEnumerable<IStoreService> _storeServices;
+    private readonly IReadOnlyCollection<IStoreService> _storeServices;
 
     #endregion
 
@@ -31,7 +31,7 @@ ISearchServiceOrchestrator orchestrator
         ArgumentNullException.ThrowIfNull(storeServices);
 
         _storeServices = storeServices.ToList();
-        if (!_storeServices.Any())
+        if (_storeServices.Count == 0)
         {
             throw new ArgumentException("There are no store activated for the search service");
         }
@@ -45,46 +45,55 @@ ISearchServiceOrchestrator orchestrator
 
     #region Methods
 
-    private async Task DispatchSearchAsync(IList<QueryResult> destination, Cmdline query, bool doesReturnAllIfEmpty)
+    private bool CanPrune(Cmdline? previousQuery, Cmdline currentQuery)
+    {
+        if (previousQuery is null) { return false; }
+
+        if (previousQuery.IsEmpty()) { return false; }
+
+        return GetAliveStores(currentQuery)
+            .All(store => store.CanPruneResult(previousQuery, currentQuery));
+    }
+
+    private async Task DispatchSearchAsync(IList<QueryResult> destination, Cmdline currentQuery, bool doesReturnAllIfEmpty)
     {
         using var measurement = _logger.WarnIfSlow(this);
-        if (doesReturnAllIfEmpty && query.IsEmpty())
+        if (doesReturnAllIfEmpty && currentQuery.IsEmpty())
         {
             destination.ReplaceWith(
                 await GetAllAsync()
             );
             return;
         }
 
-        if (query.IsEmpty())
+        if (currentQuery.IsEmpty())
         {
             destination.Clear();
             return;
         }
-        
-        if (_lastQuery is not null
-            && !_lastQuery.IsEmpty()
-            && query.ToString().StartsWith(_lastQuery.ToString(), StringComparison.CurrentCultureIgnoreCase))
+
+        if (CanPrune(_previousQuery, currentQuery))
         {
             _logger.LogTrace(
                 "Query {NewQuery} refines {OldQuery}; pruning existing results instead of searching stores",
-                query.Parameters,
-                _lastQuery.Parameters
+                currentQuery.ToString(),
+                _previousQuery?.ToString() ?? "<EMPTY>"
             );
-            PruneResults(destination, query);
+            
+            //CanPrune guarantees the _previousQuery is not null
+            PruneResults(destination, _previousQuery!, currentQuery);
             return;
         }
 
         _logger.LogTrace(
             "Execute a full search for query {Query}",
-            query
+            currentQuery
         );
-        await SearchInStoreAsync(destination, query);
+        await SearchInStoreAsync(destination, currentQuery);
     }
 
     private IEnumerable<QueryResult> FormatForDisplay(QueryResult[] collection)
     {
-        collection ??= [];
         // Upgrade alias to executable macros (if any) 
         var macros = collection.Length != 0
             ? _macroAliasExpanderService.Expand(collection).ToList()
@@ -101,36 +110,43 @@ private IEnumerable<QueryResult> FormatForDisplay(QueryResult[] collection)
             : DisplayQueryResult.NoResultFound;
     }
 
-    private void PruneResults(IList<QueryResult> destination, Cmdline query)
+    private IStoreService[] GetAliveStores(Cmdline query)
+        => _storeServices.Where(service => _orchestrator.IsAlive(service, query))
+                         .ToArray();
+
+    private void PruneResults(IList<QueryResult> destination, Cmdline previousQuery, Cmdline currentQuery)
     {
-        var toDelete = destination.Where(item =>
-            !item.Name.StartsWith(query.Parameters, StringComparison.InvariantCultureIgnoreCase)
-        ).ToArray();
+        var stores = GetAliveStores(currentQuery);
+
+        var idle = stores.FirstOrDefault(s => s.StoreOrchestration.IdleOthers);
+        if (idle is not null)
+        {
+            stores = [idle];
+        }
+
+        var deletedCount = stores.Sum(store => store.PruneResult(destination, previousQuery, currentQuery));
 
         _logger.LogTrace(
-            "Prune {ItemCount} result(s) for {Query}",
-            toDelete.Length,
-            query
+            "Pruned {ItemCount} result(s) for {Query}",
+            deletedCount,
+            currentQuery
         );
-
-        destination.RemoveMultiple(toDelete);
     }
 
     private async Task SearchInStoreAsync(IList<QueryResult> destination, Cmdline query)
     {
         //Get the alive stores
-        var aliveStores = _storeServices.Where(service => _orchestrator.IsAlive(service, query))
-                                        .ToArray();
+        var aliveStores = GetAliveStores(query);
 
-        // I've got a service that stunts all the others, then
+        // I've got a service that idles all the others, then
         // I execute the search for this one only
         var tasks = new List<Task<IEnumerable<QueryResult>>>();
         if (aliveStores.Any(x => x.StoreOrchestration.IdleOthers))
         {
             var store = aliveStores.First(x => x.StoreOrchestration.IdleOthers);
             tasks.Add(Task.Run(() => store.Search(query)));
         }
-        else // No store that stunt all the other stores, execute aggregated search
+        else // No store that idles all the other stores, execute aggregated search
         {
             tasks = aliveStores.Select(store => Task.Run(() => store.Search(query)))
                                .ToList();
@@ -139,7 +155,7 @@ private async Task SearchInStoreAsync(IList<QueryResult> destination, Cmdline qu
         _logger.LogTrace(
             "For the query {Query}, {IdleCount} store(s) IDLE and {ActiveCount} store(s) ALIVE",
             query,
-            _storeServices.Count() - tasks.Count,
+            _storeServices.Count - tasks.Count,
             tasks.Count
         );
 
@@ -155,16 +171,17 @@ private async Task SearchInStoreAsync(IList<QueryResult> destination, Cmdline qu
 
         // If there's an exact match, promote
         // it to the top of the list.
-        var match = orderedResults.FirstOrDefault(r => r.Name == query.Name);
+        var match = orderedResults.FirstOrDefault(r =>
+            r.Name.Equals(query.Name, StringComparison.InvariantCultureIgnoreCase)
+        );
+
         if (match is not null) { orderedResults.Move(match, 0); }
 
-        if (orderedResults.Count == 0)
-        {
-            destination.ReplaceWith(
-                DisplayQueryResult.SingleFromResult("No result found", iconKind: "AlertCircleOutline")
-            );
-        }
-        else { destination.ReplaceWith(orderedResults); }
+        destination.ReplaceWith(
+            orderedResults.Count == 0
+                ? DisplayQueryResult.SingleFromResult("No result found", iconKind: "AlertCircleOutline")
+                : orderedResults
+        );
     }
 
     /// <inheritdoc />
@@ -184,7 +201,7 @@ public async Task<IEnumerable<QueryResult>> GetAllAsync()
     public async Task SearchAsync(IList<QueryResult> destination, Cmdline query, bool doesReturnAllIfEmpty = false)
     {
         await DispatchSearchAsync(destination, query, doesReturnAllIfEmpty);
-        _lastQuery = query;
+        _previousQuery = query;
     }
 
     #endregion

src/Infra/Lanceur.Infra/Stores/AdditionalParametersStore.cs

@@ -1,5 +1,6 @@
+using System.Text.RegularExpressions;
+using Humanizer;
 using Lanceur.Core.Configuration;
-using Lanceur.Core.Configuration.Sections;
 using Lanceur.Core.Configuration.Sections.Application;
 using Lanceur.Core.Constants;
 using Lanceur.Core.Managers;
@@ -12,7 +13,7 @@
 
 namespace Lanceur.Infra.Stores;
 
-[Store]
+[Store("(.*):(.*)")]
 public sealed class AdditionalParametersStore : StoreBase, IStoreService
 {
     #region Fields
@@ -36,28 +37,73 @@ ISection<StoreSection> storeSettings
         _aliasService = aliasService;
         _logger = logger;
         _featureFlags = featureFlags;
+
+        ShortcutRegex = new Lazy<Regex>(() => new Regex(Shortcut, RegexOptions.Compiled, 250.Milliseconds()));
     }
 
     #endregion
 
     #region Properties
 
-    /// <inheritdoc />
-    public bool IsOverridable => false;
+    private Lazy<Regex> ShortcutRegex { get; }
+
+    /// <inheritdoc cref="IStoreService.IsOverridable" />
+    public override bool IsOverridable => false;
 
     /// <inheritdoc />
     public StoreOrchestration StoreOrchestration
         => _featureFlags.IsEnabled(Features.AdditionalParameterAlwaysActive)
             ? StoreOrchestrationFactory.SharedAlwaysActive()
-            : StoreOrchestrationFactory.Shared(".*:.*");
+            : StoreOrchestrationFactory.Shared(Shortcut);
 
     #endregion
 
     #region Methods
 
+    private bool IsRefinementOf(string value, string check)
+        => !IsUnfiltered(check)
+           && check.StartsWith(value, StringComparison.InvariantCultureIgnoreCase);
+
+    private bool IsRefinementOf(QueryResult query, string value)
+        => IsRefinementOf(value, query.Name);
+
+
+    private bool IsUnfiltered(Cmdline previous)
+    {
+        var splits = ShortcutRegex.Value.Match(previous);
+
+        if (!splits.Success) { return false; }
+
+        return splits.Groups[2].Value.Length == 0;
+    }
+
+    private static string SelectProperty(Cmdline cmdline) => cmdline.Name;
+
+    /// <inheritdoc cref="CanPruneResult" />
+    public override bool CanPruneResult(Cmdline previous, Cmdline current)
+    {
+        if (SelectProperty(current).Length == 0) { return false; }
+
+        return OverrideCanPruneResult(
+            previous,
+            current,
+            SelectProperty,
+            IsRefinementOf
+        );
+    }
+
     /// <inheritdoc cref="IStoreService.GetAll" />
     public override IEnumerable<QueryResult> GetAll() => _aliasService.GetAllAliasWithAdditionalParameters();
 
+    public override int PruneResult(IList<QueryResult> destination, Cmdline previous, Cmdline current)
+        => OverridePruneResult(
+            destination,
+            previous,
+            current,
+            SelectProperty,
+            IsRefinementOf
+        );
+
     /// <inheritdoc />
     public IEnumerable<QueryResult> Search(Cmdline cmdline)
     {

src/Infra/Lanceur.Infra/Stores/AliasStore.cs

@@ -1,5 +1,4 @@
 using Lanceur.Core.Configuration;
-using Lanceur.Core.Configuration.Sections;
 using Lanceur.Core.Configuration.Sections.Application;
 using Lanceur.Core.Managers;
 using Lanceur.Core.Models;
@@ -38,8 +37,8 @@ ISection<StoreSection> storeSettings
 
     #region Properties
 
-    /// <inheritdoc />
-    public bool IsOverridable => false;
+    /// <inheritdoc cref="IStoreService.IsOverridable"/>
+    public override bool IsOverridable => false;
 
     /// <inheritdoc />
     public StoreOrchestration StoreOrchestration => StoreOrchestrationFactory.SharedAlwaysActive();

src/Infra/Lanceur.Infra/Stores/BookmarksStore.cs

@@ -1,6 +1,5 @@
 using System.Web.Bookmarks;
 using Lanceur.Core.Configuration;
-using Lanceur.Core.Configuration.Sections;
 using Lanceur.Core.Configuration.Sections.Application;
 using Lanceur.Core.Managers;
 using Lanceur.Core.Models;
@@ -26,41 +25,72 @@ public BookmarksStore(
         IStoreOrchestrationFactory orchestrationFactory,
         IBookmarkRepositoryFactory bookmarkRepositoryFactory,
         ISection<StoreSection> storeSettings
-    ) : base(orchestrationFactory, storeSettings)
-    {
+    ) : base(orchestrationFactory, storeSettings) =>
         _bookmarkRepositoryFactory = bookmarkRepositoryFactory;
-    }
 
     #endregion
 
     #region Properties
 
-    /// <inheritdoc />
-    public bool IsOverridable => true;
+    /// <inheritdoc cref="IStoreService.IsOverridable" />
+    public override bool IsOverridable => true;
 
-    public StoreOrchestration StoreOrchestration => StoreOrchestrationFactory.Exclusive(DefaultShortcut);
+    public StoreOrchestration StoreOrchestration => StoreOrchestrationFactory.Exclusive(Shortcut);
 
     #endregion
 
     #region Methods
 
+    private static bool IsRefinementOf(string value, string check)
+        => check.Contains(value, StringComparison.InvariantCultureIgnoreCase);
+
+    private static bool IsRefinementOf(QueryResult query, string value)
+        => IsRefinementOf(value, query.Name);
+
+    private static string SelectProperty(Cmdline cmdline) => cmdline.Parameters;
+
+    /// <inheritdoc cref="CanPruneResult" />
+    public override bool CanPruneResult(Cmdline previous, Cmdline current)
+    {
+        if (SelectProperty(previous).Length == 0) { return false; }
+
+        return OverrideCanPruneResult(
+            previous,
+            current,
+            SelectProperty,
+            IsRefinementOf
+        );
+    }
+
+    /// <inheritdoc cref="PruneResult" />
+    public override int PruneResult(IList<QueryResult> destination, Cmdline previous, Cmdline current)
+        => OverridePruneResult(
+            destination,
+            previous,
+            current,
+            SelectProperty,
+            IsRefinementOf
+        );
+
     /// <inheritdoc />
     public IEnumerable<QueryResult> Search(Cmdline cmdline)
     {
         var bookmarkSourceBrowser = StoreSettings.Value.BookmarkSourceBrowser;
         var repository = _bookmarkRepositoryFactory.BuildBookmarkRepository(bookmarkSourceBrowser);
 
+        var query = SelectProperty(cmdline);
+
         if (!repository.IsBookmarkSourceAvailable())
         {
             return DisplayQueryResult.SingleFromResult("The bookmark source is not available!");
         }
 
-        if (cmdline.Parameters.IsNullOrWhiteSpace())
+        if (query.IsNullOrWhiteSpace())
         {
             return DisplayQueryResult.SingleFromResult("Enter text to search in your browser's bookmarks...");
         }
 
-        return repository.GetBookmarks(cmdline.Parameters)
+        return repository.GetBookmarks(query)
                          .Select(e => e.ToAliasQueryResult())
                          .ToList();
     }