Feature/enable lucene query parsing

src/main/java/org/jabref/logic/importer/QueryParser.java

@@ -0,0 +1,53 @@
+package org.jabref.logic.importer;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+
+import org.jabref.logic.importer.fetcher.ComplexSearchQuery;
+
+import org.apache.lucene.index.Term;
+import org.apache.lucene.queryparser.flexible.core.QueryNodeException;
+import org.apache.lucene.queryparser.flexible.standard.StandardQueryParser;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.QueryVisitor;
+
+/**
+ * This class converts a query string written in lucene syntax into a complex search query.
+ *
+ * For simplicity this is limited to fielded data and the boolean AND operator.
+ */
+public class QueryParser {
+
+    /**
+     * Converts the given query string into a complex query using lucene.
+     * Note: For unique fields, the alphabetically first instance in the query string is used in the complex query.
+     *
+     * @param queryString The given query string
+     * @return A complex query containing all fields of the query string
+     * @throws QueryNodeException Error during parsing
+     */
+    public Optional<ComplexSearchQuery> convertQueryStringIntoComplexQuery(String queryString) {
+        try {
+            ComplexSearchQuery.ComplexSearchQueryBuilder builder = ComplexSearchQuery.builder();
+
+            StandardQueryParser parser = new StandardQueryParser();
+            Query luceneQuery = parser.parse(queryString, "default");
+            Set<Term> terms = new HashSet<>();
+            // This implementation collects all terms from the leaves of the query tree independent of the internal boolean structure
+            // If further capabilities are required in the future the visitor and ComplexSearchQuery has to be adapted accordingly.
+            QueryVisitor visitor = QueryVisitor.termCollector(terms);
+            luceneQuery.visit(visitor);
+
+            List<Term> sortedTerms = new ArrayList<>(terms);
+            sortedTerms.sort(Comparator.comparing(Term::text));
+            builder.terms(sortedTerms);
+            return Optional.of(builder.build());
+        } catch (QueryNodeException ex) {
+            return Optional.empty();
+        }
+    }
+}

src/main/java/org/jabref/logic/importer/SearchBasedFetcher.java

@@ -1,7 +1,6 @@
 package org.jabref.logic.importer;
 
 import java.util.List;
-import java.util.Optional;
 
 import org.jabref.logic.importer.fetcher.ComplexSearchQuery;
 import org.jabref.model.entry.BibEntry;
@@ -28,7 +27,7 @@ public interface SearchBasedFetcher extends WebFetcher {
      */
     default List<BibEntry> performComplexSearch(ComplexSearchQuery complexSearchQuery) throws FetcherException {
         // Default Implementation behaves like perform search using the default field phrases as query
-        Optional<List<String>> defaultPhrases = complexSearchQuery.getDefaultFieldPhrases();
-        return performSearch(defaultPhrases.map(strings -> String.join(" ", strings)).orElse(""));
+        List<String> defaultPhrases = complexSearchQuery.getDefaultFieldPhrases();
+        return performSearch(String.join(" ", defaultPhrases));
     }
 }

src/main/java/org/jabref/logic/importer/SearchBasedParserFetcher.java

@@ -7,7 +7,6 @@
 import java.net.URL;
 import java.util.Collections;
 import java.util.List;
-import java.util.Optional;
 
 import org.jabref.logic.importer.fetcher.ComplexSearchQuery;
 import org.jabref.model.cleanup.Formatter;
@@ -85,8 +84,8 @@ private List<BibEntry> getBibEntries(URL urlForQuery) throws FetcherException {
 
     default URL getComplexQueryURL(ComplexSearchQuery complexSearchQuery) throws URISyntaxException, MalformedURLException, FetcherException {
         // Default Implementation behaves like getURLForQuery using the default field phrases as query
-        Optional<List<String>> defaultPhrases = complexSearchQuery.getDefaultFieldPhrases();
-        return this.getURLForQuery(defaultPhrases.map(strings -> String.join(" ", strings)).orElse(""));
+        List<String> defaultPhrases = complexSearchQuery.getDefaultFieldPhrases();
+        return this.getURLForQuery(String.join(" ", defaultPhrases));
     }
 
     /**

src/main/java/org/jabref/logic/importer/fetcher/ArXiv.java

@@ -264,12 +264,12 @@ public List<BibEntry> performSearch(String query) throws FetcherException {
     @Override
     public List<BibEntry> performComplexSearch(ComplexSearchQuery complexSearchQuery) throws FetcherException {
         List<String> searchTerms = new ArrayList<>();
-        complexSearchQuery.getAuthors().ifPresent(authors -> authors.forEach(author -> searchTerms.add("au:" + author)));
-        complexSearchQuery.getTitlePhrases().ifPresent(title -> searchTerms.add("ti:" + title));
+        complexSearchQuery.getAuthors().forEach(author -> searchTerms.add("au:" + author));
+        complexSearchQuery.getTitlePhrases().forEach(title -> searchTerms.add("ti:" + title));
         complexSearchQuery.getJournal().ifPresent(journal -> searchTerms.add("jr:" + journal));
         // Since ArXiv API does not support year search, we ignore the year related terms
         complexSearchQuery.getToYear().ifPresent(year -> searchTerms.add(year.toString()));
-        complexSearchQuery.getDefaultFieldPhrases().ifPresent(searchTerms::addAll);
+        searchTerms.addAll(complexSearchQuery.getDefaultFieldPhrases());
         String complexQueryString = String.join(" AND ", searchTerms);
         return performSearch(complexQueryString);
     }

src/main/java/org/jabref/logic/importer/fetcher/ComplexSearchQuery.java

@@ -31,16 +31,32 @@ private ComplexSearchQuery(List<String> defaultField, List<String> authors, List
         this.singleYear = singleYear;
     }
 
-    public Optional<List<String>> getDefaultFieldPhrases() {
-        return Optional.ofNullable(defaultField);
+    public static ComplexSearchQuery fromTerms(Collection<Term> terms) {
+        ComplexSearchQueryBuilder builder = ComplexSearchQuery.builder();
+        terms.forEach(term -> {
+            String termText = term.text();
+            switch (term.field().toLowerCase()) {
+                case "author" -> builder.author(termText);
+                case "title" -> builder.titlePhrase(termText);
+                case "journal" -> builder.journal(termText);
+                case "year" -> builder.singleYear(Integer.valueOf(termText));
+                case "year-range" -> builder.fromYearAndToYear(Integer.valueOf(termText.split("-")[0]), Integer.valueOf(termText.split("-")[1]));
+                case "default" -> builder.defaultFieldPhrase(termText);
+            }
+        });
+        return builder.build();
+    }
+
+    public List<String> getDefaultFieldPhrases() {
+        return defaultField;
     }
 
-    public Optional<List<String>> getAuthors() {
-        return Optional.ofNullable(authors);
+    public List<String> getAuthors() {
+        return authors;
     }
 
-    public Optional<List<String>> getTitlePhrases() {
-        return Optional.ofNullable(titlePhrases);
+    public List<String> getTitlePhrases() {
+        return titlePhrases;
     }
 
     public Optional<Integer> getFromYear() {
@@ -63,10 +79,35 @@ public static ComplexSearchQueryBuilder builder() {
         return new ComplexSearchQueryBuilder();
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+
+        ComplexSearchQuery that = (ComplexSearchQuery) o;
+
+        // Just check for set equality, order does not matter
+        if (!(getDefaultFieldPhrases().containsAll(that.getDefaultFieldPhrases()) && that.getDefaultFieldPhrases().containsAll(getDefaultFieldPhrases())))
+            return false;
+        if (!(getAuthors().containsAll(that.getAuthors()) && that.getAuthors().containsAll(getAuthors())))
+            return false;
+        if (!(getTitlePhrases().containsAll(that.getTitlePhrases()) && that.getTitlePhrases().containsAll(getTitlePhrases())))
+            return false;
+        if (getFromYear().isPresent() ? !getFromYear().equals(that.getFromYear()) : that.getFromYear().isPresent())
+            return false;
+        if (getToYear().isPresent() ? !getToYear().equals(that.getToYear()) : that.getToYear().isPresent())
+            return false;
+        if (getSingleYear().isPresent() ? !getSingleYear().equals(that.getSingleYear()) : that.getSingleYear().isPresent())
+            return false;
+        return getJournal().isPresent() ? getJournal().equals(that.getJournal()) : !that.getJournal().isPresent();
+    }
+
     public static class ComplexSearchQueryBuilder {
-        private List<String> defaultFieldPhrases;
-        private List<String> authors;
-        private List<String> titlePhrases;
+        private List<String> defaultFieldPhrases = new ArrayList<>();
+        private List<String> authors = new ArrayList<>();
+        private List<String> titlePhrases = new ArrayList<>();
         private String journal;
         private Integer fromYear;
         private Integer toYear;
@@ -79,9 +120,6 @@ public ComplexSearchQueryBuilder defaultFieldPhrase(String defaultFieldPhrase) {
             if (Objects.requireNonNull(defaultFieldPhrase).isBlank()) {
                 throw new IllegalArgumentException("Parameter must not be blank");
             }
-            if (Objects.isNull(defaultFieldPhrases)) {
-                this.defaultFieldPhrases = new ArrayList<>();
-            }
             // Strip all quotes before wrapping
             this.defaultFieldPhrases.add(String.format("\"%s\"", defaultFieldPhrase.replace("\"", "")));
             return this;
@@ -94,9 +132,6 @@ public ComplexSearchQueryBuilder author(String author) {
             if (Objects.requireNonNull(author).isBlank()) {
                 throw new IllegalArgumentException("Parameter must not be blank");
             }
-            if (Objects.isNull(authors)) {
-                this.authors = new ArrayList<>();
-            }
             // Strip all quotes before wrapping
             this.authors.add(String.format("\"%s\"", author.replace("\"", "")));
             return this;
@@ -109,9 +144,6 @@ public ComplexSearchQueryBuilder titlePhrase(String titlePhrase) {
             if (Objects.requireNonNull(titlePhrase).isBlank()) {
                 throw new IllegalArgumentException("Parameter must not be blank");
             }
-            if (Objects.isNull(titlePhrases)) {
-                this.titlePhrases = new ArrayList<>();
-            }
             // Strip all quotes before wrapping
             this.titlePhrases.add(String.format("\"%s\"", titlePhrase.replace("\"", "")));
             return this;

src/main/java/org/jabref/logic/importer/fetcher/GoogleScholar.java

@@ -205,9 +205,9 @@ public List<BibEntry> performComplexSearch(ComplexSearchQuery complexSearchQuery
 
     private String constructComplexQueryString(ComplexSearchQuery complexSearchQuery) {
         List<String> searchTerms = new ArrayList<>();
-        complexSearchQuery.getDefaultFieldPhrases().ifPresent(searchTerms::addAll);
-        complexSearchQuery.getAuthors().ifPresent(authors -> authors.forEach(author -> searchTerms.add("author:" + author)));
-        complexSearchQuery.getTitlePhrases().ifPresent(phrases -> searchTerms.add("allintitle:" + String.join(" ", phrases)));
+        searchTerms.addAll(complexSearchQuery.getDefaultFieldPhrases());
+        complexSearchQuery.getAuthors().forEach(author -> searchTerms.add("author:" + author));
+        searchTerms.add("allintitle:" + String.join(" ", complexSearchQuery.getTitlePhrases()));
         complexSearchQuery.getJournal().ifPresent(journal -> searchTerms.add("source:" + journal));
         // API automatically ANDs the terms
         return String.join(" ", searchTerms);

src/main/java/org/jabref/logic/importer/fetcher/IEEE.java

@@ -236,11 +236,15 @@ public Optional<HelpFile> getHelpPage() {
     public URL getComplexQueryURL(ComplexSearchQuery complexSearchQuery) throws URISyntaxException, MalformedURLException {
         URIBuilder uriBuilder = new URIBuilder("https://ieeexploreapi.ieee.org/api/v1/search/articles");
         uriBuilder.addParameter("apikey", API_KEY);
-        complexSearchQuery.getDefaultFieldPhrases().ifPresent(defaultFieldPhrases -> uriBuilder.addParameter("querytext", String.join(" AND ", defaultFieldPhrases)));
-        complexSearchQuery.getAuthors().ifPresent(authors ->
-                uriBuilder.addParameter("author", String.join(" AND ", authors)));
-        complexSearchQuery.getTitlePhrases().ifPresent(articleTitlePhrases ->
-                uriBuilder.addParameter("article_title", String.join(" AND ", articleTitlePhrases)));
+        if (!complexSearchQuery.getDefaultFieldPhrases().isEmpty()) {
+            uriBuilder.addParameter("querytext", String.join(" AND ", complexSearchQuery.getDefaultFieldPhrases()));
+        }
+        if (!complexSearchQuery.getAuthors().isEmpty()) {
+            uriBuilder.addParameter("author", String.join(" AND ", complexSearchQuery.getAuthors()));
+        }
+        if (!complexSearchQuery.getAuthors().isEmpty()) {
+            uriBuilder.addParameter("article_title", String.join(" AND ", complexSearchQuery.getTitlePhrases()));
+        }
         complexSearchQuery.getJournal().ifPresent(journalTitle -> uriBuilder.addParameter("publication_title", journalTitle));
         complexSearchQuery.getFromYear().map(String::valueOf).ifPresent(year -> uriBuilder.addParameter("start_year", year));
         complexSearchQuery.getToYear().map(String::valueOf).ifPresent(year -> uriBuilder.addParameter("end_year", year));

src/main/java/org/jabref/logic/importer/fetcher/SpringerFetcher.java

@@ -171,12 +171,12 @@ public URL getComplexQueryURL(ComplexSearchQuery complexSearchQuery) throws URIS
 
     private String constructComplexQueryString(ComplexSearchQuery complexSearchQuery) {
         List<String> searchTerms = new ArrayList<>();
-        complexSearchQuery.getAuthors().ifPresent(authors -> authors.forEach(author -> searchTerms.add("name:" + author)));
-        complexSearchQuery.getTitlePhrases().ifPresent(titlePhrases -> titlePhrases.forEach(title -> searchTerms.add("title:" + title)));
+        complexSearchQuery.getAuthors().forEach(author -> searchTerms.add("name:" + author));
+        complexSearchQuery.getTitlePhrases().forEach(title -> searchTerms.add("title:" + title));
         complexSearchQuery.getJournal().ifPresent(journal -> searchTerms.add("journal:" + journal));
         // Since Springer API does not support year range search, we ignore formYear and toYear and use "singleYear" only
         complexSearchQuery.getSingleYear().ifPresent(year -> searchTerms.add("year:" + year.toString()));
-        complexSearchQuery.getDefaultFieldPhrases().ifPresent(searchTerms::addAll);
+        searchTerms.addAll(complexSearchQuery.getDefaultFieldPhrases());
         return String.join(" AND ", searchTerms);
     }