Cleanup code and search widget display

* Make search widget larger
* Move regex converter into Tools namespace
* Use QSharedPointer for search terms

Author: droidmonkey

src/core/EntrySearcher.cpp

@@ -19,9 +19,12 @@
 #include "EntrySearcher.h"
 
 #include "core/Group.h"
+#include "core/Tools.h"
 
-EntrySearcher::EntrySearcher(bool caseSensitive) :
-    m_caseSensitive(caseSensitive)
+EntrySearcher::EntrySearcher(bool caseSensitive)
+    : m_caseSensitive(caseSensitive)
+    , m_termParser(R"re(([-*+]+)?(?:(\w*):)?(?:(?=")"((?:[^"\\]|\\.)*)"|([^ ]*))( |$))re")
+    // Group 1 = modifiers, Group 2 = field, Group 3 = quoted string, Group 4 = unquoted string
 {
 }
 
@@ -60,14 +63,14 @@ void EntrySearcher::setCaseSensitive(bool state)
 
 bool EntrySearcher::searchEntryImpl(const QString& searchString, Entry* entry)
 {
-    auto searchTerms = parseSearchTerms(searchString);
-    bool found;
-
     // Pre-load in case they are needed
     auto attributes = QStringList(entry->attributes()->keys());
     auto attachments = QStringList(entry->attachments()->keys());
 
-    for (SearchTerm* term : searchTerms) {
+    bool found;
+    auto searchTerms = parseSearchTerms(searchString);
+
+    for (const auto& term : searchTerms) {
         switch (term->field) {
         case Field::Title:
             found = term->regex.match(entry->resolvePlaceholder(entry->title())).hasMatch();
@@ -106,18 +109,14 @@ bool EntrySearcher::searchEntryImpl(const QString& searchString, Entry* entry)
     return true;
 }
 
-QList<EntrySearcher::SearchTerm*> EntrySearcher::parseSearchTerms(const QString& searchString)
+QList<QSharedPointer<EntrySearcher::SearchTerm> > EntrySearcher::parseSearchTerms(const QString& searchString)
 {
-    auto terms = QList<SearchTerm*>();
-    // Group 1 = modifiers, Group 2 = field, Group 3 = quoted string, Group 4 = unquoted string
-    auto termParser = QRegularExpression(R"re(([-*+]+)?(?:(\w*):)?(?:(?=")"((?:[^"\\]|\\.)*)"|([^ ]*))( |$))re");
-    // Escape common regex symbols except for *, ?, and |
-    auto regexEscape = QRegularExpression(R"re(([-[\]{}()+.,\\\/^$#]))re");
+    auto terms = QList<QSharedPointer<SearchTerm> >();
 
-    auto results = termParser.globalMatch(searchString);
+    auto results = m_termParser.globalMatch(searchString);
     while (results.hasNext()) {
         auto result = results.next();
-        auto term = new SearchTerm();
+        QSharedPointer<SearchTerm> term(new SearchTerm());
 
         // Quoted string group
         term->word = result.captured(3);
@@ -129,32 +128,16 @@ QList<EntrySearcher::SearchTerm*> EntrySearcher::parseSearchTerms(const QString&
 
         // If still empty, ignore this match
         if (term->word.isEmpty()) {
-            delete term;
             continue;
         }
 
-        QString regex = term->word;
-
-        // Wildcard support (*, ?, |)
-        if (!result.captured(1).contains("*")) {
-            regex.replace(regexEscape, "\\\\1");
-            regex.replace("**", "*");
-            regex.replace("*", ".*");
-            regex.replace("?", ".");
-        }
-
-        term->regex = QRegularExpression(regex);
-        if (!m_caseSensitive) {
-            term->regex.setPatternOptions(QRegularExpression::CaseInsensitiveOption);
-        }
+        auto mods = result.captured(1);
 
-        // Exact modifier
-        if (result.captured(1).contains("+")) {
-            term->regex.setPattern("^" + term->regex.pattern() + "$");
-        }
+        // Convert term to regex
+        term->regex = Tools::convertToRegex(term->word, !mods.contains("*"), mods.contains("+"), m_caseSensitive);
 
         // Exclude modifier
-        term->exclude = result.captured(1).contains("-");
+        term->exclude = mods.contains("-");
 
         // Determine the field to search
         QString field = result.captured(2);

src/core/EntrySearcher.h

@@ -28,7 +28,7 @@ class Entry;
 class EntrySearcher
 {
 public:
-    EntrySearcher(bool caseSensitive = false);
+    explicit EntrySearcher(bool caseSensitive = false);
 
     QList<Entry*> search(const QString& searchString, const Group* group);
     QList<Entry*> searchEntries(const QString& searchString, const QList<Entry*>& entries);
@@ -57,9 +57,10 @@ class EntrySearcher
         bool exclude;
     };
 
-    QList<SearchTerm*> parseSearchTerms(const QString& searchString);
+    QList<QSharedPointer<SearchTerm> > parseSearchTerms(const QString& searchString);
 
     bool m_caseSensitive;
+    QRegularExpression m_termParser;
 
     friend class TestEntrySearcher;
 };

src/core/Tools.cpp

@@ -24,6 +24,7 @@
 #include <QIODevice>
 #include <QLocale>
 #include <QStringList>
+#include <QRegularExpression>
 
 #include <QElapsedTimer>
 
@@ -357,4 +358,32 @@ bool createWindowsDACL()
     return bSuccess;
 }
 
+// Escape common regex symbols except for *, ?, and |
+auto regexEscape = QRegularExpression(R"re(([-[\]{}()+.,\\\/^$#]))re");
+
+QRegularExpression convertToRegex(const QString& string, bool useWildcards, bool exactMatch, bool caseSensitive)
+{
+    QString pattern = string;
+
+    // Wildcard support (*, ?, |)
+    if (useWildcards) {
+        pattern.replace(regexEscape, "\\\\1");
+        pattern.replace("**", "*");
+        pattern.replace("*", ".*");
+        pattern.replace("?", ".");
+    }
+
+    // Exact modifier
+    if (exactMatch) {
+        pattern = "^" + pattern + "$";
+    }
+
+    auto regex = QRegularExpression(pattern);
+    if (!caseSensitive) {
+        regex.setPatternOptions(QRegularExpression::CaseInsensitiveOption);
+    }
+
+    return regex;
+}
+
 } // namespace Tools

src/core/Tools.h

@@ -28,6 +28,7 @@
 #include <algorithm>
 
 class QIODevice;
+class QRegularExpression;
 
 namespace Tools {
 
@@ -43,6 +44,8 @@ void wait(int ms);
 void disableCoreDumps();
 void setupSearchPaths();
 bool createWindowsDACL();
+QRegularExpression convertToRegex(const QString& string, bool useWildcards = false, bool exactMatch = false,
+                                  bool caseSensitive = false);
 
 template <typename RandomAccessIterator, typename T>
 RandomAccessIterator binaryFind(RandomAccessIterator begin, RandomAccessIterator end, const T& value)

src/gui/SearchWidget.ui

@@ -34,6 +34,9 @@
      <property name="orientation">
       <enum>Qt::Horizontal</enum>
      </property>
+     <property name="sizeType">
+      <enum>QSizePolicy::Minimum</enum>
+     </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>40</width>
@@ -44,6 +47,18 @@
    </item>
    <item>
     <widget class="QLineEdit" name="searchEdit">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="minimumSize">
+      <size>
+       <width>0</width>
+       <height>0</height>
+      </size>
+     </property>
      <property name="styleSheet">
       <string notr="true">padding:3px</string>
      </property>

tests/TestEntrySearcher.cpp

@@ -161,8 +161,6 @@ void TestEntrySearcher::testSearchTermParser()
     QCOMPARE(terms[4]->field, EntrySearcher::All);
     QCOMPARE(terms[4]->word, QString("noquote"));
 
-    qDeleteAll(terms);
-
     // Test wildcard and regex search terms
     terms = m_entrySearcher.parseSearchTerms("+url:*.google.com *user:\\d+\\w{2}");
 
@@ -173,6 +171,4 @@ void TestEntrySearcher::testSearchTermParser()
 
     QCOMPARE(terms[1]->field, EntrySearcher::Username);
     QCOMPARE(terms[1]->regex.pattern(), QString("\\d+\\w{2}"));
-
-    qDeleteAll(terms);
 }