#include #include #include #include #include #include #include #include #include "qssquery.h" const QVector &QSSQuery::getTokens() const { return tokens; } const QVector &QSSQuery::getSortConditions() const { return sortConditions; } QueryType QSSQuery::getQueryType() { return static_cast(tokensMask & COMBINED); } void QSSQuery::addSortCondition(SortCondition sc) { this->sortConditions.append(sc); } bool QSSQuery::checkParanthesis(QString expression) { QStack open; QStack close; bool inQuotes = false; for(QChar &c : expression) { if(!inQuotes) { if(c == '(') { open.push(c); } if(c == ')') { close.push(c); } } if(c == '"') { inQuotes = ! inQuotes; } } if(open.size() != close.size()) { return false; } while(!open.empty() && !close.empty()) { QChar o = open.pop(); QChar c = close.pop(); if(o != '(' && c != ')' ) { return false; } } return true; } std::optional fromString(QString fieldString) { if(fieldString == "path" || fieldString == "file.path") { return FILE_PATH; } else if(fieldString == "mtime" || fieldString == "file.mtime") { return FILE_MTIME; } else if(fieldString == "size" || fieldString == "file.size") { return FILE_SIZE; } else if(fieldString == "content.text") { return CONTENT_TEXT; } else if(fieldString == "content.page" || fieldString == "page") { return CONTENT_TEXT_PAGE; } return { }; } //sort:(mtime desc, page asc) QVector createSortConditions(QString sortExpression) { QVector result; QStringList splitted_inner = sortExpression.split(","); for(int i = 0; i < splitted_inner.length(); i++) { QStringList splitted = splitted_inner[i].split(" "); if(splitted.length() < 1 || splitted.length() > 2) { throw QSSGeneralException("sort specifier must have format [field] (asc|desc)"); } QString field = splitted[0]; auto queryField = fromString(field); if(!queryField) { throw QSSGeneralException("Unknown sort field supplied"); } SortOrder order; if(splitted.length() == 2) { QString orderstr = splitted[1]; if(orderstr.compare("asc", Qt::CaseInsensitive) == 0) { order = ASC; } else if(orderstr.compare("desc", Qt::CaseInsensitive) == 0) { order = DESC; } else { throw QSSGeneralException("Unknown order specifier: " + order); } } else { order = ASC; } SortCondition condition; condition.field = queryField.value(); condition.order = order; result.append(condition); } return result; } void QSSQuery::addToken(Token t) { tokens.append(t); tokensMask |= t.type; } /* Builds the query from the supplied expression * * AND is the default boolean operator, when the user does not provide any * thus, "Downloads zip" becomes essentailly "path.contains:(Downloads) AND path.contains:(zip)" * * TODO: It's a bit ugly still*/ QSSQuery QSSQuery::build(QString expression) { if(!checkParanthesis(expression)) { throw QSSGeneralException("Invalid paranthesis"); } QSSQuery result; //TODO: merge lonewords QRegularExpression rx("((?(\\.|\\w)+):(?\\((?[^\\)]+)\\)|([\\w,])+)|(?AND|OR)|(?!)|(?\\(|\\))|(?\\w+))"); QRegularExpressionMatchIterator i = rx.globalMatch(expression); auto previousWasBool = [&result]{ return ! result.tokens.empty() && ( (result.tokens.last().type & BOOL) == BOOL); }; auto previousWas = [&result](TokenType t) { return ! result.tokens.empty() && ( result.tokens.last().type == t); }; while(i.hasNext()) { QRegularExpressionMatch m = i.next(); QString boolean = m.captured("boolean"); QString negation = m.captured("negation"); QString filtername = m.captured("filtername"); QString bracket = m.captured("bracket"); QString loneword = m.captured("loneword"); if(boolean != "") { if(previousWasBool()) { throw QSSGeneralException("Can't have two booleans following each other"); } if(previousWas(NEGATION)) { throw QSSGeneralException("Can't have a negation preceeding a boolean"); } if(boolean == "AND") { result.addToken(Token(BOOL_AND)); } else if(boolean == "OR") { result.addToken(Token(BOOL_OR)); } } if(negation != "") { if(previousWas(NEGATION)) { throw QSSGeneralException("Can't have two negations following each other"); } if(!previousWasBool()) { result.addToken(Token(BOOL_AND)); //Implicit and, our default operation } result.addToken(Token(NEGATION)); } if(!result.tokens.isEmpty() && !previousWasBool() && !previousWas(NEGATION) && !previousWas(BRACKET_OPEN) && bracket != ")") { //the current token isn't a negation, isn't a boolean. Thus, implicit AND is required result.addToken(Token(BOOL_AND)); } if(bracket != "") { if(bracket == "(") { result.addToken(Token(BRACKET_OPEN)); } else { result.addToken(Token(BRACKET_CLOSE)); } } if(loneword != "") { result.addToken(Token(FILTER_PATH_CONTAINS, loneword)); } if(filtername != "") { TokenType tokenType; QString value = m.captured("innerargs"); if(value == "") { value = m.captured("args"); } if(filtername == "path.contains") { tokenType = FILTER_PATH_CONTAINS; } else if(filtername == "path.starts") { tokenType = FILTER_PATH_STARTS; } else if(filtername == "path.ends") { tokenType = FILTER_PATH_ENDS; } else if(filtername == "file.size" || filtername == "size") { tokenType = FILTER_PATH_SIZE; } else if(filtername == "c" || filtername == "contains") { tokenType = FILTER_CONTENT_CONTAINS; } else if(filtername == "page" || filtername == "content.page") { tokenType = FILTER_CONTENT_PAGE; } else if(filtername == "sort") //TODO: given this is not really a "filter", this feels slightly misplaced here { if(!result.sortConditions.empty()) { throw QSSGeneralException("Two sort statements are illegal"); } //TODO: hack, since we are not a "filter", we must remove a preceeding (implicit) boolean if(result.tokens.last().type & BOOL == BOOL) { result.tokens.pop_back(); } result.sortConditions = createSortConditions(value); continue; } else { throw QSSGeneralException("Unknown filter provided!"); } result.addToken(Token(tokenType, value)); } } bool contentsearch = result.getTokensMask() & FILTER_CONTENT == FILTER_CONTENT; bool sortsForContent = std::any_of(result.sortConditions.begin(), result.sortConditions.end(), [](SortCondition c){ return c.field == CONTENT_TEXT; }); if(!contentsearch && sortsForContent) { throw QSSGeneralException("We cannot sort by text if we don't search for it"); } return result; }