On untagged queries use query for crate names.

src/library/basetrackcache.cpp

@@ -42,7 +42,8 @@ BaseTrackCache::BaseTrackCache(TrackCollection* pTrackCollection,
                     << "grouping"
                     << "comment"
                     << "title"
-                    << "genre";
+                    << "genre"
+                    << "crate";
 
     m_pKeyNotationCP = new ControlProxy("[Library]", "key_notation", this);
     // Convert all the search column names to their field indexes because we use

src/library/searchqueryparser.cpp

@@ -29,6 +29,7 @@ SearchQueryParser::SearchQueryParser(TrackCollection* pTrackCollection)
                      << "dateadded"
                      << "datetime_added"
                      << "date_added";
+    m_ignoredColumns << "crate";
 
     m_fieldToSqlColumns["artist"] << "artist" << "album_artist";
     m_fieldToSqlColumns["album_artist"] << "album_artist";
@@ -109,6 +110,16 @@ QString SearchQueryParser::getTextArgument(QString argument,
 void SearchQueryParser::parseTokens(QStringList tokens,
                                     QStringList searchColumns,
                                     AndNode* pQuery) const {
+    // we need to create a filtered columns list that are handled differently
+    QStringList(queryColumns);
+    for (const auto& column: searchColumns) {
+        if (m_ignoredColumns.contains(column)) {
+            continue;
+        }
+        queryColumns << column;
+    }
+
+
     while (tokens.size() > 0) {
         QString token = tokens.takeFirst().trimmed();
         if (token.length() == 0) {
@@ -180,14 +191,20 @@ void SearchQueryParser::parseTokens(QStringList tokens,
                 // For untagged strings we search the track fields as well
                 // as the crate names the track is in. This allows the user
                 // to use crates like tags
-                std::unique_ptr<OrNode> gNode = std::make_unique<OrNode>();
+                qDebug() << searchColumns;
+                if (searchColumns.contains("crate")) {
+                    std::unique_ptr<OrNode> gNode = std::make_unique<OrNode>();
 
-                gNode->addNode(std::make_unique<CrateFilterNode>(
-                               &m_pTrackCollection->crates(), token));
-                gNode->addNode(std::make_unique<TextFilterNode>(
-                                m_pTrackCollection->database(), searchColumns, token));
+                    gNode->addNode(std::make_unique<CrateFilterNode>(
+                                    &m_pTrackCollection->crates(), token));
+                    gNode->addNode(std::make_unique<TextFilterNode>(
+                                    m_pTrackCollection->database(), queryColumns, token));
 
-                pNode = std::move(gNode);
+                    pNode = std::move(gNode);
+                } else {
+                    pNode = std::make_unique<TextFilterNode>(
+                             m_pTrackCollection->database(), queryColumns, token);
+                }
             }
         }
         if (pNode) {

src/library/searchqueryparser.h

@@ -34,6 +34,7 @@ class SearchQueryParser {
     QStringList m_textFilters;
     QStringList m_numericFilters;
     QStringList m_specialFilters;
+    QStringList m_ignoredColumns;
     QStringList m_allFilters;
     QHash<QString, QStringList> m_fieldToSqlColumns;
 

src/test/searchqueryparsertest.cpp

@@ -709,6 +709,53 @@ TEST_F(SearchQueryParserTest, CrateFilter) {
                  qPrintable(pQuery->toSql()));
 }
 
+TEST_F(SearchQueryParserTest, ShortCrateFilter) {
+    // User's search term
+    QString crateName = "somecrate";
+    QString searchTerm = "ecrat";
+    QStringList searchColumns;
+    searchColumns << "crate"
+                  << "artist"
+                  << "comment";
+
+    // Parse the user query
+    auto pQuery(m_parser.parseQuery(QString("%1").arg(searchTerm),
+                                    searchColumns, ""));
+
+    // locations for test tracks
+    const QString kTrackALocationTest(QDir::currentPath() %
+                  "/src/test/id3-test-data/cover-test-jpg.mp3");
+    const QString kTrackBLocationTest(QDir::currentPath() %
+                  "/src/test/id3-test-data/cover-test-png.mp3");
+    const QString kTrackCLocationTest(QDir::currentPath() %
+                  "/src/test/id3-test-data/artist.mp3");
+
+    // Create new crate and add it to the collection
+    Crate testCrate;
+    testCrate.setName(searchTerm);
+    CrateId testCrateId;
+    collection()->insertCrate(testCrate, &testCrateId);
+
+    // Add the track in the collection
+    TrackId trackAId = addTrackToCollection(kTrackALocationTest);
+    TrackPointer pTrackA(Track::newDummy(kTrackALocationTest, trackAId));
+    TrackId trackBId = addTrackToCollection(kTrackBLocationTest);
+    TrackPointer pTrackB(Track::newDummy(kTrackBLocationTest, trackBId));
+    TrackId trackCId = addTrackToCollection(kTrackCLocationTest);
+    TrackPointer pTrackC(Track::newDummy(kTrackCLocationTest, trackCId));
+    pTrackC->setComment("garbage somecrate garbage");
+
+    // Add track A to the newly created crate
+    QList<TrackId> trackIds;
+    trackIds << trackAId;
+    collection()->addCrateTracks(testCrateId, trackIds);
+
+    EXPECT_TRUE(pQuery->match(pTrackA));
+    EXPECT_FALSE(pQuery->match(pTrackB));
+    EXPECT_TRUE(pQuery->match(pTrackC));
+}
+
+
 TEST_F(SearchQueryParserTest, CrateFilterEmpty) {
     // Empty should match everything
     auto pQuery(m_parser.parseQuery(QString("crate: "), QStringList(), ""));