Implement type checking/validation for filters

CHANGELOG.md

@@ -16,6 +16,7 @@
 - Minor: Added support for HTTP and Socks5 proxies through environment variables. (#4321)
 - Minor: Added crashpad to capture crashes on Windows locally. See PR for build/crash analysis instructions. (#4351)
 - Minor: Github releases now include flatpakref files for nightly builds
+- Minor: Added better filter validation and error messages. (#4364)
 - Bugfix: Fixed User Card moderation actions not working after Twitch IRC chat command deprecation. (#4378)
 - Bugfix: Fixed User Card broadcaster actions (mod, unmod, vip, unvip) not working after Twitch IRC chat command deprecation. (#4387)
 - Bugfix: Fixed crash that would occur when performing certain actions after removing all tabs. (#4271)

src/CMakeLists.txt

@@ -74,12 +74,26 @@ set(SOURCE_FILES
         controllers/filters/FilterRecord.hpp
         controllers/filters/FilterSet.cpp
         controllers/filters/FilterSet.hpp
-        controllers/filters/parser/FilterParser.cpp
-        controllers/filters/parser/FilterParser.hpp
-        controllers/filters/parser/Tokenizer.cpp
-        controllers/filters/parser/Tokenizer.hpp
-        controllers/filters/parser/Types.cpp
-        controllers/filters/parser/Types.hpp
+        controllers/filters/lang/expressions/Expression.cpp
+        controllers/filters/lang/expressions/Expression.hpp
+        controllers/filters/lang/expressions/BinaryOperation.cpp
+        controllers/filters/lang/expressions/BinaryOperation.hpp
+        controllers/filters/lang/expressions/ListExpression.cpp
+        controllers/filters/lang/expressions/ListExpression.hpp
+        controllers/filters/lang/expressions/RegexExpression.cpp
+        controllers/filters/lang/expressions/RegexExpression.hpp
+        controllers/filters/lang/expressions/UnaryOperation.hpp
+        controllers/filters/lang/expressions/UnaryOperation.cpp
+        controllers/filters/lang/expressions/ValueExpression.cpp
+        controllers/filters/lang/expressions/ValueExpression.hpp
+        controllers/filters/lang/Filter.cpp
+        controllers/filters/lang/Filter.hpp
+        controllers/filters/lang/FilterParser.cpp
+        controllers/filters/lang/FilterParser.hpp
+        controllers/filters/lang/Tokenizer.cpp
+        controllers/filters/lang/Tokenizer.hpp
+        controllers/filters/lang/Types.cpp
+        controllers/filters/lang/Types.hpp
 
         controllers/highlights/BadgeHighlightModel.cpp
         controllers/highlights/BadgeHighlightModel.hpp

src/controllers/filters/FilterRecord.cpp

@@ -1,22 +1,37 @@
-#include "controllers/filters/FilterRecord.hpp"
+#include "FilterRecord.hpp"
+
+#include "controllers/filters/lang/Filter.hpp"
 
 namespace chatterino {
 
 FilterRecord::FilterRecord(const QString &name, const QString &filter)
-    : name_(name)
-    , filter_(filter)
-    , id_(QUuid::createUuid())
-    , parser_(std::make_unique<filterparser::FilterParser>(filter))
+    : FilterRecord(name, filter, QUuid::createUuid())
 {
 }
 
 FilterRecord::FilterRecord(const QString &name, const QString &filter,
                            const QUuid &id)
     : name_(name)
-    , filter_(filter)
+    , filterText_(filter)
     , id_(id)
-    , parser_(std::make_unique<filterparser::FilterParser>(filter))
 {
+    using namespace filters;
+    auto result = Filter::fromString(filter);
+    if (std::holds_alternative<Filter>(result))
+    {
+        this->filter_ =
+            std::make_unique<Filter>(std::move(std::get<Filter>(result)));
+
+        if (this->filter_->returnType() != Type::Bool)
+        {
+            // Only accept Bool results
+            this->filter_ = nullptr;
+        }
+    }
+    else
+    {
+        this->filter_ = nullptr;
+    }
 }
 
 const QString &FilterRecord::getName() const
@@ -26,7 +41,7 @@ const QString &FilterRecord::getName() const
 
 const QString &FilterRecord::getFilter() const
 {
-    return this->filter_;
+    return this->filterText_;
 }
 
 const QUuid &FilterRecord::getId() const
@@ -36,12 +51,13 @@ const QUuid &FilterRecord::getId() const
 
 bool FilterRecord::valid() const
 {
-    return this->parser_->valid();
+    return this->filter_ != nullptr;
 }
 
-bool FilterRecord::filter(const filterparser::ContextMap &context) const
+bool FilterRecord::filter(const filters::ContextMap &context) const
 {
-    return this->parser_->execute(context);
+    assert(this->valid());
+    return this->filter_->execute(context).toBool();
 }
 
 bool FilterRecord::operator==(const FilterRecord &other) const

src/controllers/filters/FilterRecord.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "controllers/filters/parser/FilterParser.hpp"
+#include "controllers/filters/lang/Filter.hpp"
 #include "util/RapidjsonHelpers.hpp"
 #include "util/RapidJsonSerializeQString.hpp"
 
@@ -28,16 +28,16 @@ class FilterRecord
 
     bool valid() const;
 
-    bool filter(const filterparser::ContextMap &context) const;
+    bool filter(const filters::ContextMap &context) const;
 
     bool operator==(const FilterRecord &other) const;
 
 private:
     QString name_;
-    QString filter_;
+    QString filterText_;
     QUuid id_;
 
-    std::unique_ptr<filterparser::FilterParser> parser_;
+    std::unique_ptr<filters::Filter> filter_;
 };
 
 using FilterRecordPtr = std::shared_ptr<FilterRecord>;

src/controllers/filters/FilterSet.cpp

@@ -38,8 +38,7 @@ bool FilterSet::filter(const MessagePtr &m, ChannelPtr channel) const
     if (this->filters_.size() == 0)
         return true;
 
-    filterparser::ContextMap context =
-        filterparser::buildContextMap(m, channel.get());
+    filters::ContextMap context = filters::buildContextMap(m, channel.get());
     for (const auto &f : this->filters_.values())
     {
         if (!f->valid() || !f->filter(context))

src/controllers/filters/lang/Filter.cpp

@@ -0,0 +1,155 @@
+#include "Filter.hpp"
+
+#include "Application.hpp"
+#include "common/Channel.hpp"
+#include "controllers/filters/lang/FilterParser.hpp"
+#include "messages/Message.hpp"
+#include "providers/twitch/TwitchBadge.hpp"
+#include "providers/twitch/TwitchChannel.hpp"
+#include "providers/twitch/TwitchIrcServer.hpp"
+
+namespace chatterino::filters {
+
+ContextMap buildContextMap(const MessagePtr &m, chatterino::Channel *channel)
+{
+    auto watchingChannel = chatterino::getApp()->twitch->watchingChannel.get();
+
+    /* Known Identifiers
+     *
+     * author.badges
+     * author.color
+     * author.name
+     * author.no_color
+     * author.subbed
+     * author.sub_length
+     *
+     * channel.name
+     * channel.watching
+     *
+     * flags.highlighted
+     * flags.points_redeemed
+     * flags.sub_message
+     * flags.system_message
+     * flags.reward_message
+     * flags.first_message
+     * flags.elevated_message
+     * flags.cheer_message
+     * flags.whisper
+     * flags.reply
+     * flags.automod
+     *
+     * message.content
+     * message.length
+     *
+     */
+
+    using MessageFlag = chatterino::MessageFlag;
+
+    QStringList badges;
+    badges.reserve(m->badges.size());
+    for (const auto &e : m->badges)
+    {
+        badges << e.key_;
+    }
+
+    bool watching = !watchingChannel->getName().isEmpty() &&
+                    watchingChannel->getName().compare(
+                        m->channelName, Qt::CaseInsensitive) == 0;
+
+    bool subscribed = false;
+    int subLength = 0;
+    for (const auto &subBadge : {"subscriber", "founder"})
+    {
+        if (!badges.contains(subBadge))
+        {
+            continue;
+        }
+        subscribed = true;
+        if (m->badgeInfos.find(subBadge) != m->badgeInfos.end())
+        {
+            subLength = m->badgeInfos.at(subBadge).toInt();
+        }
+    }
+    ContextMap vars = {
+        {"author.badges", std::move(badges)},
+        {"author.color", m->usernameColor},
+        {"author.name", m->displayName},
+        {"author.no_color", !m->usernameColor.isValid()},
+        {"author.subbed", subscribed},
+        {"author.sub_length", subLength},
+
+        {"channel.name", m->channelName},
+        {"channel.watching", watching},
+
+        {"flags.highlighted", m->flags.has(MessageFlag::Highlighted)},
+        {"flags.points_redeemed", m->flags.has(MessageFlag::RedeemedHighlight)},
+        {"flags.sub_message", m->flags.has(MessageFlag::Subscription)},
+        {"flags.system_message", m->flags.has(MessageFlag::System)},
+        {"flags.reward_message",
+         m->flags.has(MessageFlag::RedeemedChannelPointReward)},
+        {"flags.first_message", m->flags.has(MessageFlag::FirstMessage)},
+        {"flags.elevated_message", m->flags.has(MessageFlag::ElevatedMessage)},
+        {"flags.cheer_message", m->flags.has(MessageFlag::CheerMessage)},
+        {"flags.whisper", m->flags.has(MessageFlag::Whisper)},
+        {"flags.reply", m->flags.has(MessageFlag::ReplyMessage)},
+        {"flags.automod", m->flags.has(MessageFlag::AutoMod)},
+
+        {"message.content", m->messageText},
+        {"message.length", m->messageText.length()},
+    };
+    {
+        using namespace chatterino;
+        auto *tc = dynamic_cast<TwitchChannel *>(channel);
+        if (channel && !channel->isEmpty() && tc)
+        {
+            vars["channel.live"] = tc->isLive();
+        }
+        else
+        {
+            vars["channel.live"] = false;
+        }
+    }
+    return vars;
+}
+
+FilterResult Filter::fromString(const QString &str)
+{
+    FilterParser parser(str);
+
+    if (parser.valid())
+    {
+        auto exp = parser.release();
+        auto typ = parser.returnType();
+        return Filter(std::move(exp), typ);
+    }
+
+    return FilterError{parser.errors().join("\n")};
+}
+
+Filter::Filter(ExpressionPtr expression, Type returnType)
+    : expression_(std::move(expression))
+    , returnType_(returnType)
+{
+}
+
+Type Filter::returnType() const
+{
+    return this->returnType_;
+}
+
+QVariant Filter::execute(const ContextMap &context) const
+{
+    return this->expression_->execute(context);
+}
+
+QString Filter::filterString() const
+{
+    return this->expression_->filterString();
+}
+
+QString Filter::debugString() const
+{
+    return this->expression_->debug();
+}
+
+}  // namespace chatterino::filters

src/controllers/filters/lang/Filter.hpp

@@ -0,0 +1,48 @@
+#pragma once
+
+#include "controllers/filters/lang/expressions/Expression.hpp"
+#include "controllers/filters/lang/Types.hpp"
+
+#include <QString>
+
+#include <memory>
+#include <variant>
+
+namespace chatterino {
+
+class Channel;
+struct Message;
+using MessagePtr = std::shared_ptr<const Message>;
+
+}  // namespace chatterino
+
+namespace chatterino::filters {
+
+ContextMap buildContextMap(const MessagePtr &m, chatterino::Channel *channel);
+
+class Filter;
+struct FilterError {
+    QString message;
+};
+
+using FilterResult = std::variant<Filter, FilterError>;
+
+class Filter
+{
+public:
+    static FilterResult fromString(const QString &str);
+
+    Type returnType() const;
+    QVariant execute(const ContextMap &context) const;
+
+    QString filterString() const;
+    QString debugString() const;
+
+private:
+    Filter(ExpressionPtr expression, Type returnType);
+
+    ExpressionPtr expression_;
+    Type returnType_;
+};
+
+}  // namespace chatterino::filters