finders/desktop: add support for GenericName fuzzy querying (#139)

* finders/desktop: use m_name instead of m_fuzzable for cache entries

Signed-off-by: Sofia Donato Ferreira <flowlnlnln@gmail.com>

* fuzzy: support multiple fuzzables per FinderResult

This allows us to query multiple information about an entry at the same
time, selecting the one with the best match.

Signed-off-by: Sofia Donato Ferreira <flowlnlnln@gmail.com>

* finders/desktop: add support for GenericName fuzzy querying

Signed-off-by: Sofia Donato Ferreira <flowlnlnln@gmail.com>

---------

Signed-off-by: Sofia Donato Ferreira <flowlnlnln@gmail.com>

Author: flowln

src/finders/Fuzzy.cpp

@@ -183,7 +183,12 @@ static void workerFn(std::vector<SScoreData>& scores, const std::vector<SP<IFind
     for (size_t i = start; i < end; ++i) {
         auto& ref = scores[i];
 
-        ref.score = scoreCandidate(query, in[i]->fuzzable(), in[i]->frequency());
+        float bestScore = 0.F;
+        for (auto const& candidate : in[i]->fuzzables()) {
+            auto score = scoreCandidate(query, candidate, in[i]->frequency());
+            bestScore  = std::max(score, bestScore);
+        }
+        ref.score = bestScore;
 
         ref.result = in[i];
         ref.idx    = i;
@@ -255,4 +260,22 @@ std::vector<SP<IFinderResult>> Fuzzy::getNResults(const std::vector<SP<IFinderRe
         workerFn(scores, in, query, 0, in.size());
 
     return getBestResultsStable(scores, results);
-}
+}
+
+std::vector<std::string> Fuzzy::createFuzzableStrings(std::initializer_list<std::string_view> strings, bool toLowercase) {
+    std::vector<std::string> fuzzables{strings.size()};
+
+    for (auto&& sv : strings) {
+        std::string fuzzable;
+        fuzzable.resize(sv.size());
+
+        if (toLowercase)
+            std::ranges::transform(sv, fuzzable.begin(), ::tolower);
+        else
+            fuzzable.assign(sv);
+
+        fuzzables.emplace_back(std::move(fuzzable));
+    }
+
+    return fuzzables;
+}

src/finders/Fuzzy.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <initializer_list>
 #include <string>
 #include <vector>
 
@@ -8,4 +9,5 @@
 
 namespace Fuzzy {
     std::vector<SP<IFinderResult>> getNResults(const std::vector<SP<IFinderResult>>& in, const std::string& query, size_t results);
-};
+    std::vector<std::string>       createFuzzableStrings(std::initializer_list<std::string_view>, bool toLowercase = true);
+};

src/finders/IFinderResult.hpp

@@ -1,18 +1,19 @@
 #pragma once
 
 #include <string>
+#include <vector>
 #include "FinderTypes.hpp"
 
 class IFinderResult {
   public:
     virtual ~IFinderResult() = default;
 
-    virtual eFinderTypes       type()     = 0;
-    virtual void               run()      = 0;
-    virtual const std::string& fuzzable() = 0;
-    virtual const std::string& name()     = 0;
-    virtual uint32_t           frequency();
+    virtual eFinderTypes                    type()      = 0;
+    virtual void                            run()       = 0;
+    virtual const std::vector<std::string>& fuzzables() = 0;
+    virtual const std::string&              name()      = 0;
+    virtual uint32_t                        frequency();
 
   protected:
     IFinderResult() = default;
-};
+};

src/finders/desktop/DesktopFinder.cpp

@@ -37,8 +37,8 @@ class CDesktopEntry : public IFinderResult {
     CDesktopEntry()          = default;
     virtual ~CDesktopEntry() = default;
 
-    virtual const std::string& fuzzable() {
-        return m_fuzzable;
+    virtual const std::vector<std::string>& fuzzables() {
+        return m_fuzzables;
     }
 
     virtual eFinderTypes type() {
@@ -64,8 +64,8 @@ class CDesktopEntry : public IFinderResult {
 
         Debug::log(TRACE, "Running {}", toExec);
 
-        g_desktopFinder->m_entryFrequencyCache->incrementCachedEntry(m_fuzzable);
-        m_frequency = g_desktopFinder->m_entryFrequencyCache->getCachedEntry(m_fuzzable);
+        g_desktopFinder->m_entryFrequencyCache->incrementCachedEntry(m_name);
+        m_frequency = g_desktopFinder->m_entryFrequencyCache->getCachedEntry(m_name);
 
         // replace all funky codes with nothing
         replaceInString(toExec, "%U", "");
@@ -84,10 +84,11 @@ class CDesktopEntry : public IFinderResult {
         proc.runAsync();
     }
 
-    std::string m_name, m_exec, m_icon, m_fuzzable, m_stem;
-    bool        m_terminal = false;
+    std::string              m_name, m_exec, m_icon, m_stem;
+    std::vector<std::string> m_fuzzables;
+    bool                     m_terminal = false;
 
-    uint32_t    m_frequency = 0;
+    uint32_t                 m_frequency = 0;
 };
 
 static std::filesystem::path resolvePath(const std::string& p) {
@@ -242,6 +243,7 @@ void CDesktopFinder::cacheEntry(const std::filesystem::path& path) {
     };
 
     const auto NAME      = extract("Name");
+    const auto GEN_NAME  = extract("GenericName");
     const auto ICON      = extract("Icon");
     const auto EXEC      = extract("Exec");
     const auto NODISPLAY = extract("NoDisplay") == "true";
@@ -259,15 +261,14 @@ void CDesktopFinder::cacheEntry(const std::filesystem::path& path) {
         std::erase_if(m_desktopEntryCache, [&pathStem](const auto& e) { return e->m_stem == pathStem; });
     }
 
-    auto& e       = m_desktopEntryCache.emplace_back(makeShared<CDesktopEntry>());
-    e->m_exec     = EXEC;
-    e->m_icon     = ICON;
-    e->m_name     = NAME;
-    e->m_fuzzable = NAME;
-    e->m_stem     = std::move(pathStem);
-    e->m_terminal = TERMINAL;
-    std::ranges::transform(e->m_fuzzable, e->m_fuzzable.begin(), ::tolower);
-    e->m_frequency = m_entryFrequencyCache->getCachedEntry(e->m_fuzzable);
+    auto& e        = m_desktopEntryCache.emplace_back(makeShared<CDesktopEntry>());
+    e->m_exec      = EXEC;
+    e->m_icon      = ICON;
+    e->m_name      = NAME;
+    e->m_fuzzables = Fuzzy::createFuzzableStrings({NAME, GEN_NAME});
+    e->m_stem      = std::move(pathStem);
+    e->m_terminal  = TERMINAL;
+    e->m_frequency = m_entryFrequencyCache->getCachedEntry(e->m_name);
     m_desktopEntryCacheGeneric.emplace_back(e);
 
     Debug::log(TRACE, "desktop: cached {} with icon {} and exec line of \"{}\"", NAME, ICON, EXEC);

src/finders/font/FontFinder.cpp

@@ -14,8 +14,8 @@ class CFontEntry : public IFinderResult {
     CFontEntry()          = default;
     virtual ~CFontEntry() = default;
 
-    virtual const std::string& fuzzable() {
-        return m_fuzzable;
+    virtual const std::vector<std::string>& fuzzables() {
+        return m_fuzzables;
     }
 
     virtual eFinderTypes type() {
@@ -33,7 +33,8 @@ class CFontEntry : public IFinderResult {
         proc.runAsync();
     }
 
-    std::string m_font, m_fuzzable;
+    std::string              m_font;
+    std::vector<std::string> m_fuzzables;
 };
 
 CFontFinder::CFontFinder() : m_valid(FcInit()) {
@@ -69,10 +70,9 @@ void CFontFinder::refreshFonts() {
             if (!family || !style)
                 continue;
 
-            auto e        = m_entries.emplace_back(makeShared<CFontEntry>());
-            e->m_font     = std::format("{} {}", (char*)family, (char*)style);
-            e->m_fuzzable = e->m_font;
-            std::ranges::transform(e->m_fuzzable, e->m_fuzzable.begin(), ::tolower);
+            auto e         = m_entries.emplace_back(makeShared<CFontEntry>());
+            e->m_font      = std::format("{} {}", (char*)family, (char*)style);
+            e->m_fuzzables = Fuzzy::createFuzzableStrings({e->m_font});
             m_entriesGeneric.emplace_back(std::move(e));
         }
     }

src/finders/ipc/IPCFinder.cpp

@@ -20,8 +20,8 @@ class CIPCEntry : public IFinderResult {
     CIPCEntry()          = default;
     virtual ~CIPCEntry() = default;
 
-    virtual const std::string& fuzzable() {
-        return m_fuzzable;
+    virtual const std::vector<std::string>& fuzzables() {
+        return m_fuzzables;
     }
 
     virtual eFinderTypes type() {
@@ -40,7 +40,8 @@ class CIPCEntry : public IFinderResult {
         Debug::log(TRACE, "Selected {}", m_entry);
     }
 
-    std::string m_entry, m_fuzzable;
+    std::string              m_entry;
+    std::vector<std::string> m_fuzzables;
 };
 
 CIPCFinder::CIPCFinder() = default;
@@ -55,9 +56,8 @@ void CIPCFinder::setData(const std::vector<const char*>& data) {
     for (const auto& s : data) {
         auto e = m_entries.emplace_back(makeShared<CIPCEntry>());
         m_entriesGeneric.emplace_back(e);
-        e->m_entry    = s;
-        e->m_fuzzable = s;
-        std::ranges::transform(e->m_fuzzable, e->m_fuzzable.begin(), ::tolower);
+        e->m_entry     = s;
+        e->m_fuzzables = Fuzzy::createFuzzableStrings({s});
     }
 }
 
@@ -67,9 +67,8 @@ void CIPCFinder::setData(const std::vector<std::string>& data) {
     for (const auto& s : data) {
         auto e = m_entries.emplace_back(makeShared<CIPCEntry>());
         m_entriesGeneric.emplace_back(e);
-        e->m_entry    = s;
-        e->m_fuzzable = s;
-        std::ranges::transform(e->m_fuzzable, e->m_fuzzable.begin(), ::tolower);
+        e->m_entry     = s;
+        e->m_fuzzables = Fuzzy::createFuzzableStrings({s});
     }
 }
 

src/finders/math/MathFinder.cpp

@@ -13,8 +13,8 @@ class CMathEntry : public IFinderResult {
     CMathEntry()          = default;
     virtual ~CMathEntry() = default;
 
-    virtual const std::string& fuzzable() {
-        return m_fuzzable;
+    virtual const std::vector<std::string>& fuzzables() {
+        return m_fuzzables;
     }
 
     virtual eFinderTypes type() {
@@ -32,7 +32,8 @@ class CMathEntry : public IFinderResult {
         proc.runAsync();
     }
 
-    std::string m_expr, m_result, m_fuzzable;
+    std::string              m_expr, m_result;
+    std::vector<std::string> m_fuzzables;
 };
 
 CMathFinder::CMathFinder() = default;

src/finders/unicode/UnicodeFinder.cpp

@@ -17,8 +17,8 @@ class CUnicodeEntry : public IFinderResult {
     CUnicodeEntry()          = default;
     virtual ~CUnicodeEntry() = default;
 
-    virtual const std::string& fuzzable() {
-        return m_fuzzable;
+    virtual const std::vector<std::string>& fuzzables() {
+        return m_fuzzables;
     }
 
     virtual eFinderTypes type() {
@@ -43,9 +43,10 @@ class CUnicodeEntry : public IFinderResult {
         proc.runAsync();
     }
 
-    std::string m_name, m_unicode, m_fuzzable;
+    std::string              m_name, m_unicode;
+    std::vector<std::string> m_fuzzables;
 
-    uint32_t    m_frequency = 0;
+    uint32_t                 m_frequency = 0;
 };
 
 static bool isSurrogate(UChar32 cp) {
@@ -86,11 +87,10 @@ void CUnicodeFinder::init() {
         std::string utf8;
         us.toUTF8String(utf8);
 
-        auto& e       = m_unicodeEntryCache.emplace_back(makeShared<CUnicodeEntry>());
-        e->m_unicode  = utf8;
-        e->m_name     = name;
-        e->m_fuzzable = name;
-        std::ranges::transform(e->m_fuzzable, e->m_fuzzable.begin(), ::tolower);
+        auto& e        = m_unicodeEntryCache.emplace_back(makeShared<CUnicodeEntry>());
+        e->m_unicode   = utf8;
+        e->m_name      = name;
+        e->m_fuzzables = Fuzzy::createFuzzableStrings({name});
         std::ranges::transform(e->m_name, e->m_name.begin(), ::toupper);
         e->m_frequency = g_unicodeFinder->m_entryFrequencyCache->getCachedEntry(e->m_unicode);
         m_unicodeEntryCacheGeneric.emplace_back(e);

src/query/QueryProcessor.hpp

@@ -28,4 +28,4 @@ class CQueryProcessor {
     WP<IFinder>             m_overrideFinder;
 };
 
-inline UP<CQueryProcessor> g_queryProcessor = makeUnique<CQueryProcessor>();
+inline UP<CQueryProcessor> g_queryProcessor = makeUnique<CQueryProcessor>();