util: Remove unused and broken scopeMatch()

Remove scopeMatch() from util.cpp - not only is it no longer needed,
superseded by ExpressionMatch, the scopeMatch behavior broke previous
Quassel functionality.

Details: Channel names can begin with "!", and scopeMatch() does not
support escaping "!" in the beginning of rules.  Escaping support
needs to be added.. but ExpressionMatch can now handle this.  Let us
keep the ugly parser loops confined to one place...

diff --git a/src/common/util.cpp b/src/common/util.cpp
index d7e83d8..914c9a4 100644 (file)
--- a/src/common/util.cpp
+++ b/src/common/util.cpp
@@ -282,89 +282,6 @@ QString formatCurrentDateTimeInString(const QString &formatStr)
 }
 
 
 }
 
 

-bool scopeMatch(const QString &string, const QString &scopeRule, const bool &isRegEx,
-                const bool &isCaseSensitive)
-{
-    // When isRegEx is false:
-    // A match happens when the string does NOT match ANY inverted rules and matches AT LEAST one
-    // normal rule, unless no normal rules exist (implicit wildcard match).  This gives inverted
-    // rules higher priority regardless of ordering.
-    //
-    // When isRegEx is true:
-    // A match happens when the normal regular expression matches.  If prefixed with '!', the match
-    // happens UNLESS the following regular expression matches.
-
-    // TODO: After switching to Qt 5, use of this should be split into two parts, one part that
-    // would generate compiled QRegularExpressions for match/inverted match, regenerating it on any
-    // rule changes, and another part that would check each message against these compiled rules.
-
-    // Cache case sensitivity
-    Qt::CaseSensitivity ruleExactCase = (isCaseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive);
-
-    if (isRegEx) {
-        // Regular expression tests
-        // -------
-        // Check if this is an inverted rule (starts with '!')
-        if (scopeRule.startsWith("!")) {
-            // Take the reminder of the string
-            QRegExp ruleRx(scopeRule.mid(1), ruleExactCase);
-            // Matching an inverted rule: matched (true) implies rule failure (false)
-            return !ruleRx.exactMatch(string);
-        } else {
-            QRegExp ruleRx(scopeRule, ruleExactCase);
-            // Matching a normal rule: matched (true) implies rule success (true)
-            return ruleRx.exactMatch(string);
-        }
-    } else {
-        // Wildcard expression tests
-        // -------
-        // Keep track if any matches are found
-        bool matches = false;
-        // Keep track if normal rules and inverted rules are found, allowing for implicit wildcard
-        bool normalRuleFound = false, invertedRuleFound = false;
-
-        // Split each scope rule by separator, ignoring empty parts
-        foreach(QString rule, scopeRule.split(";", QString::SkipEmptyParts)) {
-            // Trim whitespace from the start/end of the rule
-            rule = rule.trimmed();
-            // Ignore empty rules
-            if (rule.isEmpty())
-                continue;
-
-            // Check if this is an inverted rule (starts with '!')
-            if (rule.startsWith("!")) {
-                // Inverted rule found
-                invertedRuleFound = true;
-
-                // Take the reminder of the string
-                QRegExp ruleRx(rule.mid(1), ruleExactCase);
-                ruleRx.setPatternSyntax(QRegExp::Wildcard);
-                if (ruleRx.exactMatch(string)) {
-                    // Matches an inverted rule, full rule cannot match
-                    return false;
-                }
-            } else {
-                // Normal rule found
-                normalRuleFound = true;
-
-                QRegExp ruleRx(rule, ruleExactCase);
-                ruleRx.setPatternSyntax(QRegExp::Wildcard);
-                if (ruleRx.exactMatch(string)) {
-                    // Matches a normal rule, full rule might match
-                    matches = true;
-                    // Continue checking in case other inverted rules negate this
-                }
-            }
-        }
-        // No inverted rules matched, okay to match normally
-        // Return true if...
-        // ...we found a normal match
-        // ...implicit wildcard: we had inverted rules (that didn't match) and no normal rules
-        return matches || (invertedRuleFound && !normalRuleFound);
-    }
-}
-
-

 QString tryFormatUnixEpoch(const QString &possibleEpochDate, Qt::DateFormat dateFormat, bool useUTC)
 {
     // Does the string resemble a Unix epoch?  Parse as 64-bit time
 QString tryFormatUnixEpoch(const QString &possibleEpochDate, Qt::DateFormat dateFormat, bool useUTC)
 {
     // Does the string resemble a Unix epoch?  Parse as 64-bit time

diff --git a/src/common/util.h b/src/common/util.h
index 514c564..0db903e 100644 (file)
--- a/src/common/util.h
+++ b/src/common/util.h
@@ -80,28 +80,6 @@ QByteArray prettyDigest(const QByteArray &digest);
  */
 QString formatCurrentDateTimeInString(const QString &formatStr);
 
  */
 QString formatCurrentDateTimeInString(const QString &formatStr);
 

-/** Check if a scope rule matches a string
- *
- * When isRegEx is false:
- * Checks that the string does NOT match ANY inverted rules (prefixed by '!'), then checks that
- * it matches AT LEAST one normal (non-inverted) rule.
- *
- * If only inverted rules are specified, it'll match so long as the string does not match any
- * inverted rules (implicit wildcard).
- *
- * When isRegEx is true:
- * Checks that the string matches the entire scopeRule as a regular expression.  If scopeRule starts
- * with a '!', check that the string does NOT match the regular expression.
- *
- * @param string           String to test, e.g. network/channel name
- * @param scopeRule        ';'-separated list of wildcard expressions, prefix of '!' inverts subrule
- * @param isRegEx          If true, treat entire scope rule as regular expression, not wildcards
- * @param isCaseSensitive  If true, treat as case-sensitive, else case-insensitive
- * @return True if matches, otherwise false
- */
-bool scopeMatch(const QString &string, const QString &scopeRule,
-                const bool &isRegEx = false, const bool &isCaseSensitive = false);
-

 /**
  * Try to localize a given date/time in seconds from Unix epoch, pass through string if invalid
  *
 /**
  * Try to localize a given date/time in seconds from Unix epoch, pass through string if invalid
  *