1 /***************************************************************************
2 * Copyright (C) 2005-2019 by the Quassel Project *
3 * devel@quassel-irc.org *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) version 3. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
19 ***************************************************************************/
23 #include "common-export.h"
29 #include <QStringList>
31 #include "expressionmatch.h"
33 #include "syncableobject.h"
35 class COMMON_EXPORT IgnoreListManager : public SyncableObject
41 inline IgnoreListManager(QObject* parent = nullptr)
42 : SyncableObject(parent)
44 setAllowClientUpdates(true);
46 IgnoreListManager& operator=(const IgnoreListManager& other);
57 UnmatchedStrictness = 0,
70 * Individual ignore list rule
72 class COMMON_EXPORT IgnoreListItem
76 * Construct an empty ignore rule
78 IgnoreListItem() = default;
81 * Construct an ignore rule with the given parameters
83 * CAUTION: For legacy reasons, "contents" doubles as the identifier for the ignore rule.
84 * Duplicate entries are not allowed.
86 * @param type Type of ignore rule
87 * @param contents String representing a message contents expression to match
88 * @param isRegEx True if regular expression, otherwise false
89 * @param strictness Strictness of ignore rule
90 * @param scope What to match scope rule against
91 * @param scopeRule String representing a scope rule expression to match
92 * @param isEnabled True if enabled, otherwise false
95 IgnoreType type, QString contents, bool isRegEx, StrictnessType strictness, ScopeType scope, QString scopeRule, bool isEnabled)
96 : _contents(std::move(contents))
98 , _strictness(strictness)
100 , _scopeRule(std::move(scopeRule))
101 , _isEnabled(isEnabled)
103 // Allow passing empty "contents" as they can happen when editing an ignore rule
105 // Handle CTCP ignores
108 _cacheInvalid = true;
109 // Cache expression matches on construction
111 // This provides immediate feedback on errors when loading the rule. If profiling shows
112 // this as a performance bottleneck, this can be removed in deference to caching on
115 // Inversely, if needed for validity checks, caching can be done on every update below
116 // instead of on first use.
117 determineExpressions();
121 * Gets the type of this ignore rule
123 * @return IgnoreType of the rule
125 inline IgnoreType type() const { return _type; }
127 * Sets the type of this ignore rule
129 * @param type IgnoreType of the rule
131 inline void setType(IgnoreType type)
133 // Handle CTCP ignores
134 if (type == CtcpIgnore) {
135 // This is not performance-intensive; sticking with QRegExp for Qt 4 is fine
136 // Split based on whitespace characters
137 QStringList split(contents().split(QRegExp("\\s+"), QString::SkipEmptyParts));
138 // Match on the first item, handling empty rules/matches
139 if (!split.isEmpty()) {
140 // Take the first item as the sender
141 _cacheCtcpSender = split.takeFirst();
142 // Track the rest as CTCP types to ignore
143 _cacheCtcpTypes = split;
146 // No match found - this can happen if a pure whitespace CTCP ignore rule is
147 // created. Fall back to matching all senders.
149 // RegEx match everything
150 _cacheCtcpSender = ".*";
153 // Wildcard match everything
154 _cacheCtcpSender = "*";
156 // Clear the types (split is already empty)
157 _cacheCtcpTypes = split;
164 * Gets the message contents this rule matches
166 * NOTE: Use IgnoreListItem::contentsMatcher() for performing matches
168 * CAUTION: For legacy reasons, "contents" doubles as the identifier for the ignore rule.
169 * Duplicate entries are not allowed.
171 * @return String representing a phrase or expression to match
173 inline QString contents() const { return _contents; }
175 * Sets the message contents this rule matches
177 * @param contents String representing a phrase or expression to match
179 inline void setContents(const QString& contents)
181 // Allow passing empty "contents" as they can happen when editing an ignore rule
182 _contents = contents;
183 _cacheInvalid = true;
187 * Gets if this is a regular expression rule
189 * @return True if regular expression, otherwise false
191 inline bool isRegEx() const { return _isRegEx; }
193 * Sets if this rule is a regular expression rule
195 * @param isRegEx True if regular expression, otherwise false
197 inline void setIsRegEx(bool isRegEx)
200 _cacheInvalid = true;
204 * Gets the strictness of this ignore rule
206 * @return StrictnessType of the rule
208 inline StrictnessType strictness() const { return _strictness; }
210 * Sets the strictness of this ignore rule
212 * @param strictness StrictnessType of the rule
214 inline void setStrictness(StrictnessType strictness) { _strictness = strictness; }
217 * Gets what to match scope rule against
219 * @return ScopeType of the rule
221 inline ScopeType scope() const { return _scope; }
223 * Sets what to match scope rule against
225 * @param type ScopeType of the rule
227 inline void setScope(ScopeType scope) { _scope = scope; }
230 * Gets the scope rule this rule matches
232 * NOTE: Use IgnoreListItem::scopeRuleMatcher() for performing matches
234 * @return String representing a phrase or expression to match
236 inline QString scopeRule() const { return _scopeRule; }
238 * Sets the scope rule this rule matches
240 * @param scopeRule String representing a phrase or expression to match
242 inline void setScopeRule(const QString& scopeRule)
244 _scopeRule = scopeRule;
245 _cacheInvalid = true;
249 * Gets if this rule is enabled and active
251 * @return True if enabled, otherwise false
253 inline bool isEnabled() const { return _isEnabled; }
255 * Sets if this rule is enabled and active
257 * @param isEnabled True if enabled, otherwise false
259 inline void setIsEnabled(bool isEnabled) { _isEnabled = isEnabled; }
262 * Gets the ignored CTCP types for CTCP ignores
264 * @return List of CTCP types to ignore, or empty for all
266 inline QStringList ctcpTypes() const { return _cacheCtcpTypes; }
269 * Gets the expression matcher for the message contents, caching if needed
271 * @return Expression matcher to compare with message contents
273 inline ExpressionMatch contentsMatcher() const
276 determineExpressions();
278 return _contentsMatch;
282 * Gets the expression matcher for the scope, caching if needed
284 * @return Expression matcher to compare with scope
286 inline ExpressionMatch scopeRuleMatcher() const
289 determineExpressions();
291 return _scopeRuleMatch;
295 * Gets the expression matcher for the message contents, caching if needed
297 * @return Expression matcher to compare with message contents
299 inline ExpressionMatch senderCTCPMatcher() const
302 determineExpressions();
304 return _ctcpSenderMatch;
307 bool operator!=(const IgnoreListItem& other) const;
311 * Update internal cache of expression matching if needed
313 void determineExpressions() const;
315 IgnoreType _type = {};
316 QString _contents = {};
317 bool _isRegEx = false;
318 StrictnessType _strictness = {};
319 ScopeType _scope = {};
320 QString _scopeRule = {};
321 bool _isEnabled = true;
323 QString _cacheCtcpSender = {}; ///< For CTCP rules, precalculate sender
324 QStringList _cacheCtcpTypes = {}; ///< For CTCP rules, precalculate types
326 // These represent internal cache and should be safe to mutate in 'const' functions
327 // See https://stackoverflow.com/questions/3141087/what-is-meant-with-const-at-end-of-function-declaration
328 mutable bool _cacheInvalid = true; ///< If true, match cache needs redone
329 mutable ExpressionMatch _contentsMatch = {}; ///< Expression match cache for message
330 mutable ExpressionMatch _scopeRuleMatch = {}; ///< Expression match cache for scope rule
331 mutable ExpressionMatch _ctcpSenderMatch = {}; ///< Expression match cache for CTCP nick
334 using IgnoreList = QList<IgnoreListItem>;
336 int indexOf(const QString& ignore) const;
337 inline bool contains(const QString& ignore) const { return indexOf(ignore) != -1; }
338 inline bool isEmpty() const { return _ignoreList.isEmpty(); }
339 inline int count() const { return _ignoreList.count(); }
340 inline void removeAt(int index) { _ignoreList.removeAt(index); }
341 inline IgnoreListItem& operator[](int i) { return _ignoreList[i]; }
342 inline const IgnoreListItem& operator[](int i) const { return _ignoreList.at(i); }
343 inline const IgnoreList& ignoreList() const { return _ignoreList; }
345 //! Check if a message matches the IgnoreRule
346 /** This method checks if a message matches the users ignorelist.
347 * \param msg The Message that should be checked
348 * \param network The networkname the message belongs to
349 * \return UnmatchedStrictness, HardStrictness or SoftStrictness representing the match type
351 inline StrictnessType match(const Message& msg, const QString& network = QString())
353 return _match(msg.contents(), msg.sender(), msg.type(), network, msg.bufferInfo().bufferName());
356 bool ctcpMatch(const QString sender, const QString& network, const QString& type = QString());
358 // virtual void addIgnoreListItem(const IgnoreListItem &item);
361 virtual QVariantMap initIgnoreList() const;
362 virtual void initSetIgnoreList(const QVariantMap& ignoreList);
364 //! Request removal of an ignore rule based on the rule itself.
365 /** Use this method if you want to remove a single ignore rule
366 * and get that synced with the core immediately.
367 * \param ignoreRule A valid ignore rule
369 virtual inline void requestRemoveIgnoreListItem(const QString& ignoreRule) { REQUEST(ARG(ignoreRule)) }
370 virtual void removeIgnoreListItem(const QString& ignoreRule);
372 //! Request toggling of "isActive" flag of a given ignore rule.
373 /** Use this method if you want to toggle the "isActive" flag of a single ignore rule
374 * and get that synced with the core immediately.
375 * \param ignoreRule A valid ignore rule
377 virtual inline void requestToggleIgnoreRule(const QString& ignoreRule) { REQUEST(ARG(ignoreRule)) }
378 virtual void toggleIgnoreRule(const QString& ignoreRule);
380 //! Request an IgnoreListItem to be added to the ignore list
381 /** Items added to the list with this method, get immediately synced with the core
382 * \param type The IgnoreType of the new rule
383 * \param ignoreRule The rule itself
384 * \param isRegEx Signals if the rule should be interpreted as a regular expression
385 * \param strictness Th StrictnessType that should be applied
386 * \param scope The ScopeType that should be set
387 * \param scopeRule A string of semi-colon separated network- or channelnames
388 * \param isActive Signals if the rule is enabled or not
390 virtual inline void requestAddIgnoreListItem(
391 int type, const QString& ignoreRule, bool isRegEx, int strictness, int scope, const QString& scopeRule, bool isActive)
393 REQUEST(ARG(type), ARG(ignoreRule), ARG(isRegEx), ARG(strictness), ARG(scope), ARG(scopeRule), ARG(isActive))
396 virtual void addIgnoreListItem(
397 int type, const QString& ignoreRule, bool isRegEx, int strictness, int scope, const QString& scopeRule, bool isActive);
400 void setIgnoreList(const QList<IgnoreListItem>& ignoreList) { _ignoreList = ignoreList; }
402 StrictnessType _match(
403 const QString& msgContents, const QString& msgSender, Message::Type msgType, const QString& network, const QString& bufferName);
406 void ignoreAdded(IgnoreType type,
407 const QString& ignoreRule,
409 StrictnessType strictness,
411 const QVariant& scopeRule,
415 IgnoreList _ignoreList;