core: fzy finder singleton

Author: CMurtagh-LGTM

src/core/CMakeLists.txt

@@ -39,6 +39,7 @@ qt_add_library(quickshell-core STATIC
 	scriptmodel.cpp
 	colorquantizer.cpp
 	toolsupport.cpp
+	fzy.cpp
 )
 
 qt_add_qml_module(quickshell-core

src/core/fzy.cpp

@@ -0,0 +1,215 @@
+#include "fzy.h"
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <limits>
+
+#include <qlist.h>
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qstring.h>
+#include <qstringview.h>
+#include <qtypes.h>
+#include <qvariant.h>
+#include <span>
+
+namespace {
+constexpr qsizetype MATCH_MAX_LEN = 1024;
+
+constexpr double SCORE_MAX = std::numeric_limits<double>::infinity();
+constexpr double SCORE_MIN = -std::numeric_limits<double>::infinity();
+
+constexpr double SCORE_GAP_LEADING = -0.005;
+constexpr double SCORE_GAP_TRAILING = -0.005;
+constexpr double SCORE_GAP_INNER = -0.01;
+constexpr double SCORE_MATCH_CONSECUTIVE = 1.0;
+constexpr double SCORE_MATCH_SLASH = 0.9;
+constexpr double SCORE_MATCH_WORD = 0.8;
+constexpr double SCORE_MATCH_CAPITAL = 0.7;
+constexpr double SCORE_MATCH_DOT = 0.6;
+
+struct ScoredResult {
+	double score {};
+	QString str;
+	QObject* obj = nullptr;
+};
+
+bool hasMatch(QStringView needle, QStringView haystack) {
+	qsizetype index = 0;
+	for (auto needleChar: needle) {
+		index = haystack.indexOf(needleChar, index, Qt::CaseInsensitive);
+		if (index == -1) {
+			return false;
+		}
+		index++;
+	}
+	return true;
+}
+
+struct MatchStruct {
+	QString lowerNeedle;
+	QString lowerHaystack;
+
+	std::array<double, MATCH_MAX_LEN> matchBonus {};
+};
+
+double getBonus(QChar ch, QChar lastCh) {
+	if (!lastCh.isLetterOrNumber()) {
+		return 0.0;
+	}
+	switch (ch.unicode()) {
+	case '/': return SCORE_MATCH_SLASH;
+	case '-':
+	case '_':
+	case ' ': return SCORE_MATCH_WORD;
+	case '.': return SCORE_MATCH_DOT;
+	case 'a':
+	case 'b':
+	case 'c':
+	case 'd':
+	case 'e':
+	case 'f':
+	case 'g':
+	case 'h':
+	case 'i':
+	case 'j':
+	case 'k':
+	case 'l':
+	case 'm':
+	case 'n':
+	case 'o':
+	case 'p':
+	case 'q':
+	case 'r':
+	case 's':
+	case 't':
+	case 'u':
+	case 'v':
+	case 'w':
+	case 'x':
+	case 'y':
+	case 'z': return lastCh.isUpper() ? SCORE_MATCH_CAPITAL : 0.0;
+	default: return 0.0;
+	}
+}
+
+void precomputeBonus(QStringView haystack, std::span<double> matchBonus) {
+	/* Which positions are beginning of words */
+	QChar lastCh = '/';
+	for (qsizetype index = 0; index < haystack.size(); index++) {
+		const QChar ch = haystack[index];
+		matchBonus[index] = getBonus(lastCh, ch);
+		lastCh = ch;
+	}
+}
+
+MatchStruct setupMatchStruct(QStringView needle, QStringView haystack) {
+	MatchStruct match {};
+
+	for (const auto nch: needle) {
+		match.lowerNeedle.push_back(nch.toLower());
+	}
+	for (const auto hch: haystack) {
+		match.lowerHaystack.push_back(hch.toLower());
+	}
+
+	precomputeBonus(haystack, match.matchBonus);
+
+	return match;
+}
+
+void matchRow(
+    const MatchStruct& match,
+    qsizetype row,
+    std::span<double> currD,
+    std::span<double> currM,
+    std::span<const double> lastD,
+    std::span<const double> lastM
+) {
+	const qsizetype needleLen = match.lowerNeedle.size();
+	const qsizetype haystackLen = match.lowerHaystack.size();
+
+	const QStringView lowerNeedle = match.lowerNeedle;
+	const QStringView lowerHaystack = match.lowerHaystack;
+	const std::span<const double> matchBonus = match.matchBonus;
+
+	double prevScore = SCORE_MIN;
+	const double gapScore = row == needleLen - 1 ? SCORE_GAP_TRAILING : SCORE_GAP_INNER;
+
+	/* These will not be used with this value, but not all compilers see it */
+	double prevM = SCORE_MIN;
+	double prevD = SCORE_MIN;
+
+	for (qsizetype index = 0; index < haystackLen; index++) {
+		if (lowerNeedle[row] == lowerHaystack[index]) {
+			double score = SCORE_MIN;
+			if (!row) {
+				score = (static_cast<double>(index) * SCORE_GAP_LEADING) + matchBonus[index];
+			} else if (index) { /* row > 0 && index > 0*/
+				score = fmax(
+				    prevM + matchBonus[index],
+
+				    /* consecutive match, doesn't stack with match_bonus */
+				    prevD + SCORE_MATCH_CONSECUTIVE
+				);
+			}
+			prevD = lastD[index];
+			prevM = lastM[index];
+			currD[index] = score;
+			currM[index] = prevScore = fmax(score, prevScore + gapScore);
+		} else {
+			prevD = lastD[index];
+			prevM = lastM[index];
+			currD[index] = SCORE_MIN;
+			currM[index] = prevScore = prevScore + gapScore;
+		}
+	}
+}
+
+double match(QStringView needle, QStringView haystack) {
+	if (needle.empty()) return SCORE_MIN;
+
+	if (haystack.size() > MATCH_MAX_LEN || needle.size() > haystack.size()) {
+		return SCORE_MIN;
+	} else if (haystack.size() == needle.size()) {
+		return SCORE_MAX;
+	}
+
+	const MatchStruct match = setupMatchStruct(needle, haystack);
+
+	/*
+	 * D Stores the best score for this position ending with a match.
+	 * M Stores the best possible score at this position.
+	 */
+	std::array<double, MATCH_MAX_LEN> d {};
+	std::array<double, MATCH_MAX_LEN> m {};
+
+	for (qsizetype index = 0; index < needle.size(); index++) {
+		matchRow(match, index, d, m, d, m);
+	}
+
+	return m[haystack.size() - 1];
+}
+
+} // namespace
+
+namespace qs {
+
+QList<QObject*>
+FzyFinder::filter(const QString& needle, const QList<QObject*>& haystacks, const QString& name) {
+	QList<ScoredResult> list;
+	for (auto* haystack: haystacks) {
+		const auto h = haystack->property(name.toUtf8()).toString();
+		if (hasMatch(needle, h)) {
+			list.emplace_back(match(needle, h), h, haystack);
+		}
+	}
+	std::ranges::stable_sort(list, std::ranges::greater(), &ScoredResult::score);
+	auto out = QList<QObject*>(list.size());
+	std::ranges::transform(list, out.begin(), [](const ScoredResult& result) -> QObject* {
+		return result.obj;
+	});
+	return out;
+}
+
+} // namespace qs

src/core/fzy.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <qlist.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qstring.h>
+
+namespace qs {
+
+///! A fzy finder.
+/// A fzy finder.
+///
+/// You can use this singleton to filter desktop entries like below.
+///
+/// ```qml
+/// model: ScriptModel {
+///   values: FzyFinder.filter(search.text, @@DesktopEntries.applications.values, "name");
+/// }
+/// ```
+class FzyFinder : public QObject {
+	Q_OBJECT;
+	QML_SINGLETON;
+	QML_ELEMENT;
+
+public:
+	explicit FzyFinder(QObject* parent = nullptr): QObject(parent) {}
+
+	/// Filters the list haystacks that don't contain the needle.
+	/// `needle` is the query to search with.
+	/// `haystacks` is what will be searched.
+	/// `name` is a property of each object in `haystacks` if `haystacks[n].name` is not a `string` then it will be treated as an empty string.
+	/// The returned list is the objects that contain the query in fzy score order.
+	Q_INVOKABLE [[nodiscard]] static QList<QObject*> filter(const QString& needle, const QList<QObject*>& haystacks, const QString& name);
+};
+
+}

src/core/module.md

@@ -30,5 +30,6 @@ headers = [
 	"clock.hpp",
 	"scriptmodel.hpp",
 	"colorquantizer.hpp",
+	"fzy.hpp",
 ]
 -----