Add a new completion API for experimental plugins feature.

docs/chatterino.d.ts

@@ -19,4 +19,21 @@ declare module c2 {
   ): boolean;
   function send_msg(channel: String, text: String): boolean;
   function system_msg(channel: String, text: String): boolean;
+
+  class CompletionList {
+      values: String[];
+      hide_others: boolean;
+  }
+
+  enum EventType {
+      RegisterCompletions = "RegisterCompletions",
+  }
+
+  type CbFuncCompletionsRequested = (query: string, full_text_content: string,
+                                     cursor_position: number, is_first_word: boolean) => CompletionList;
+  type CbFunc<T> = T extends EventType.RegisterCompletions ? CbFuncCompletionsRequested
+                   : never;
+
+
+  function register_callback<T>(type: T, func: CbFunc<T>): void;
 }

src/controllers/completion/TabCompletionModel.cpp

@@ -1,5 +1,6 @@
 #include "controllers/completion/TabCompletionModel.hpp"
 
+#include "Application.hpp"
 #include "common/Channel.hpp"
 #include "controllers/completion/sources/CommandSource.hpp"
 #include "controllers/completion/sources/EmoteSource.hpp"
@@ -9,6 +10,9 @@
 #include "controllers/completion/strategies/ClassicUserStrategy.hpp"
 #include "controllers/completion/strategies/CommandStrategy.hpp"
 #include "controllers/completion/strategies/SmartEmoteStrategy.hpp"
+#include "controllers/plugins/LuaUtilities.hpp"
+#include "controllers/plugins/Plugin.hpp"
+#include "controllers/plugins/PluginController.hpp"
 #include "singletons/Settings.hpp"
 
 namespace chatterino {
@@ -19,7 +23,9 @@ TabCompletionModel::TabCompletionModel(Channel &channel, QObject *parent)
 {
 }
 
-void TabCompletionModel::updateResults(const QString &query, bool isFirstWord)
+void TabCompletionModel::updateResults(const QString &query,
+                                       const QString &fullTextContent,
+                                       int cursorPosition, bool isFirstWord)
 {
     this->updateSourceFromQuery(query);
 
@@ -29,6 +35,17 @@ void TabCompletionModel::updateResults(const QString &query, bool isFirstWord)
 
         // Copy results to this model
         QStringList results;
+#ifdef CHATTERINO_HAVE_PLUGINS
+        // Try plugins first
+        bool done{};
+        std::tie(done, results) = getApp()->plugins->updateCustomCompletions(
+            query, fullTextContent, cursorPosition, isFirstWord);
+        if (done)
+        {
+            this->setStringList(results);
+            return;
+        }
+#endif
         this->source_->addToStringList(results, 0, isFirstWord);
         this->setStringList(results);
     }

src/controllers/completion/TabCompletionModel.hpp

@@ -26,8 +26,12 @@ class TabCompletionModel : public QStringListModel
 
     /// @brief Updates the model based on the completion query
     /// @param query Completion query
+    /// @param fullTextContent Full text of the input, used by plugins for contextual completion
+    /// @param cursorPosition Number of characters behind the cursor from the
+    /// beginning of fullTextContent, also used by plugins
     /// @param isFirstWord Whether the completion is the first word in the input
-    void updateResults(const QString &query, bool isFirstWord = false);
+    void updateResults(const QString &query, const QString &fullTextContent,
+                       int cursorPosition, bool isFirstWord = false);
 
 private:
     enum class SourceKind {

src/controllers/plugins/LuaAPI.cpp

@@ -82,6 +82,8 @@ int c2_register_command(lua_State *L)
                       "\"pointer\"");
         return 0;
     }
+    // args already taken
+    BalanceKepper _(L, 1);
 
     auto callbackSavedName = QString("c2commandcb-%1").arg(name);
     lua_setfield(L, LUA_REGISTRYINDEX, callbackSavedName.toStdString().c_str());
@@ -94,6 +96,39 @@ int c2_register_command(lua_State *L)
     return 1;
 }
 
+int c2_register_callback(lua_State *L)
+{
+    auto *pl = getApp()->plugins->getPluginByStatePtr(L);
+    if (pl == nullptr)
+    {
+        luaL_error(L, "internal error: no plugin");
+        return 0;
+    }
+    EventType evtType{};
+    if (!lua::peek(L, &evtType, 1))
+    {
+        luaL_error(L, "cannot get event name (1st arg of register_callback, "
+                      "expected a string)");
+        return 0;
+    }
+    if (lua_isnoneornil(L, 2))
+    {
+        luaL_error(L, "missing argument for register_callback: function "
+                      "\"pointer\"");
+        return 0;
+    }
+    // args already taken
+    BalanceKepper _(L);
+
+    auto callbackSavedName = QString("c2cb-%1").arg(
+        magic_enum::enum_name<EventType>(evtType).data());
+    lua_setfield(L, LUA_REGISTRYINDEX, callbackSavedName.toStdString().c_str());
+
+    lua_pop(L, 2);
+
+    return 0;
+}
+
 int c2_send_msg(lua_State *L)
 {
     QString text;
@@ -119,6 +154,8 @@ int c2_send_msg(lua_State *L)
         lua::push(L, false);
         return 1;
     }
+    // args already taken
+    BalanceKepper _(L, 1);
 
     const auto chn = getApp()->twitch->getChannelOrEmpty(channel);
     if (chn->isEmpty())
@@ -167,6 +204,9 @@ int c2_system_msg(lua_State *L)
         lua::push(L, false);
         return 1;
     }
+    // args already taken
+    BalanceKepper _(L, 1);
+
     const auto chn = getApp()->twitch->getChannelOrEmpty(channel);
     if (chn->isEmpty())
     {
@@ -199,6 +239,7 @@ int c2_log(lua_State *L)
         luaL_error(L, "Invalid log level, use one from c2.LogLevel.");
         return 0;
     }
+    BalanceKepper _(L, 1);
     QDebug stream = qdebugStreamForLogLevel(lvl);
     logHelper(L, pl, stream, logc);
     return 0;

src/controllers/plugins/LuaAPI.hpp

@@ -1,14 +1,18 @@
 #pragma once
 
 #ifdef CHATTERINO_HAVE_PLUGINS
+#    include <QString>
+
+#    include <vector>
 
 struct lua_State;
 namespace chatterino::lua::api {
-// names in this namespace reflect what's visible inside Lua and follow the lua naming scheme
+// function names in this namespace reflect what's visible inside Lua and follow the lua naming scheme
 
 // NOLINTBEGIN(readability-identifier-naming)
 // Following functions are exposed in c2 table.
 int c2_register_command(lua_State *L);
+int c2_register_callback(lua_State *L);
 int c2_send_msg(lua_State *L);
 int c2_system_msg(lua_State *L);
 int c2_log(lua_State *L);
@@ -23,6 +27,24 @@ int g_import(lua_State *L);
 // Represents "calls" to qCDebug, qCInfo ...
 enum class LogLevel { Debug, Info, Warning, Critical };
 
+// Exposed as c2.EventType
+// Represents callbacks c2 can do into lua world
+enum class EventType {
+    CompletionRequested,
+};
+
+/**
+ * This is for custom completion, a registered function returns this type
+ * however in Lua array part (value) and object part (hideOthers) are in the same
+ * table.
+ */
+struct CompletionList {
+    std::vector<QString> values{};
+
+    // exposed as hide_others
+    bool hideOthers{};
+};
+
 }  // namespace chatterino::lua::api
 
 #endif

src/controllers/plugins/LuaUtilities.cpp

@@ -4,6 +4,7 @@
 #    include "common/Channel.hpp"
 #    include "common/QLogging.hpp"
 #    include "controllers/commands/CommandContext.hpp"
+#    include "controllers/plugins/LuaAPI.hpp"
 
 #    include <lauxlib.h>
 #    include <lua.h>
@@ -75,6 +76,9 @@ QString humanErrorText(lua_State *L, int errCode)
         case LUA_ERRFILE:
             errName = "(file error)";
             break;
+        case ERROR_BAD_PEEK:
+            errName = "(unable to convert value to c++)";
+            break;
         default:
             errName = "(unknown error type)";
     }
@@ -111,6 +115,7 @@ StackIdx push(lua_State *L, const std::string &str)
 
 StackIdx push(lua_State *L, const CommandContext &ctx)
 {
+    BalanceKepper _(L, 1);
     auto outIdx = pushEmptyTable(L, 2);
 
     push(L, ctx.words);
@@ -127,8 +132,21 @@ StackIdx push(lua_State *L, const bool &b)
     return lua_gettop(L);
 }
 
+bool peek(lua_State *L, bool *out, StackIdx idx)
+{
+    BalanceKepper _(L);
+    if (!lua_isboolean(L, idx))
+    {
+        return false;
+    }
+
+    *out = bool(lua_toboolean(L, idx));
+    return true;
+}
+
 bool peek(lua_State *L, double *out, StackIdx idx)
 {
+    BalanceKepper _(L);
     int ok{0};
     auto v = lua_tonumberx(L, idx, &ok);
     if (ok != 0)
@@ -140,6 +158,7 @@ bool peek(lua_State *L, double *out, StackIdx idx)
 
 bool peek(lua_State *L, QString *out, StackIdx idx)
 {
+    BalanceKepper _(L);
     size_t len{0};
     const char *str = lua_tolstring(L, idx, &len);
     if (str == nullptr)
@@ -156,6 +175,7 @@ bool peek(lua_State *L, QString *out, StackIdx idx)
 
 bool peek(lua_State *L, QByteArray *out, StackIdx idx)
 {
+    BalanceKepper _(L);
     size_t len{0};
     const char *str = lua_tolstring(L, idx, &len);
     if (str == nullptr)
@@ -172,6 +192,7 @@ bool peek(lua_State *L, QByteArray *out, StackIdx idx)
 
 bool peek(lua_State *L, std::string *out, StackIdx idx)
 {
+    BalanceKepper _(L);
     size_t len{0};
     const char *str = lua_tolstring(L, idx, &len);
     if (str == nullptr)
@@ -186,6 +207,23 @@ bool peek(lua_State *L, std::string *out, StackIdx idx)
     return true;
 }
 
+bool peek(lua_State *L, api::CompletionList *out, StackIdx idx)
+{
+    BalanceKepper _(L);
+    int typ = lua_getfield(L, idx, "values");
+    if (typ != LUA_TTABLE)
+    {
+        lua_pop(L, 1);
+        return false;
+    }
+    if (!lua::pop(L, &out->values, -1))
+    {
+        return false;
+    }
+    lua_getfield(L, idx, "hide_others");
+    return lua::pop(L, &out->hideOthers);
+}
+
 QString toString(lua_State *L, StackIdx idx)
 {
     size_t len{};