more parsers

2 files changed, 65 insertions, 80 deletions

diff --git a/core/src/main/java/org/elasticsearch/search/suggest/completion/CompletionSuggestParser.java b/core/src/main/java/org/elasticsearch/search/suggest/completion/CompletionSuggestParser.java
index 8520698c0e..7a751ad55b 100644
--- a/core/src/main/java/org/elasticsearch/search/suggest/completion/CompletionSuggestParser.java
+++ b/core/src/main/java/org/elasticsearch/search/suggest/completion/CompletionSuggestParser.java
@@ -18,9 +18,9 @@
  */
 package org.elasticsearch.search.suggest.completion;
 
+import org.apache.lucene.analysis.Analyzer;
 import org.elasticsearch.ElasticsearchException;
 import org.elasticsearch.common.HasContextAndHeaders;
-import org.elasticsearch.common.ParseFieldMatcher;
 import org.elasticsearch.common.ParseField;
 import org.elasticsearch.common.bytes.BytesReference;
 import org.elasticsearch.common.unit.Fuzziness;
@@ -28,6 +28,7 @@ import org.elasticsearch.common.xcontent.ObjectParser;
 import org.elasticsearch.common.xcontent.XContentBuilder;
 import org.elasticsearch.common.xcontent.XContentFactory;
 import org.elasticsearch.common.xcontent.XContentParser;
+import org.elasticsearch.index.fielddata.IndexFieldDataService;
 import org.elasticsearch.index.mapper.MappedFieldType;
 import org.elasticsearch.index.mapper.MapperService;
 import org.elasticsearch.index.mapper.core.CompletionFieldMapper;
@@ -40,8 +41,6 @@ import org.elasticsearch.search.suggest.completion.context.ContextMappings;
 import java.io.IOException;
 import java.util.*;
 
-import static org.elasticsearch.search.suggest.SuggestUtils.parseSuggestContext;
-
 /**
  * Parses query options for {@link CompletionSuggester}
  *
@@ -72,6 +71,59 @@ import static org.elasticsearch.search.suggest.SuggestUtils.parseSuggestContext;
  */
 public class CompletionSuggestParser implements SuggestContextParser {
 
+    private static ObjectParser<CompletionSuggestionContext, ContextAndSuggest> TLP_PARSER = new ObjectParser<>("completion", null);
+    private static ObjectParser<CompletionSuggestionBuilder.RegexOptionsBuilder, ContextAndSuggest> REGEXP_PARSER = new ObjectParser<>("regexp", CompletionSuggestionBuilder.RegexOptionsBuilder::new);
+    private static ObjectParser<CompletionSuggestionBuilder.FuzzyOptionsBuilder, ContextAndSuggest> FUZZY_PARSER = new ObjectParser<>("fuzzy", CompletionSuggestionBuilder.FuzzyOptionsBuilder::new);
+    static {
+        FUZZY_PARSER.declareInt(CompletionSuggestionBuilder.FuzzyOptionsBuilder::setFuzzyMinLength, new ParseField("min_length"));
+        FUZZY_PARSER.declareInt(CompletionSuggestionBuilder.FuzzyOptionsBuilder::setMaxDeterminizedStates, new ParseField("max_determinized_states"));
+        FUZZY_PARSER.declareBoolean(CompletionSuggestionBuilder.FuzzyOptionsBuilder::setUnicodeAware, new ParseField("unicode_aware"));
+        FUZZY_PARSER.declareInt(CompletionSuggestionBuilder.FuzzyOptionsBuilder::setFuzzyPrefixLength, new ParseField("prefix_length"));
+        FUZZY_PARSER.declareBoolean(CompletionSuggestionBuilder.FuzzyOptionsBuilder::setTranspositions, new ParseField("transpositions"));
+        FUZZY_PARSER.declareValue((a, b) -> {
+            try {
+                a.setFuzziness(Fuzziness.parse(b).asDistance());
+            } catch (IOException e) {
+                throw new ElasticsearchException(e);
+            }
+        }, new ParseField("fuzziness"));
+        REGEXP_PARSER.declareInt(CompletionSuggestionBuilder.RegexOptionsBuilder::setMaxDeterminizedStates, new ParseField("max_determinized_states"));
+        REGEXP_PARSER.declareStringOrNull(CompletionSuggestionBuilder.RegexOptionsBuilder::setFlags, new ParseField("flags"));
+
+        TLP_PARSER.declareStringArray(CompletionSuggestionContext::setPayloadFields, new ParseField("payload"));
+        TLP_PARSER.declareObjectOrDefault(CompletionSuggestionContext::setFuzzyOptionsBuilder, FUZZY_PARSER, CompletionSuggestionBuilder.FuzzyOptionsBuilder::new, new ParseField("fuzzy"));
+        TLP_PARSER.declareObject(CompletionSuggestionContext::setRegexOptionsBuilder, REGEXP_PARSER, new ParseField("regexp"));
+        TLP_PARSER.declareString(SuggestionSearchContext.SuggestionContext::setField, new ParseField("field"));
+        TLP_PARSER.declareField((p, v, c) -> {
+            String analyzerName = p.text();
+            Analyzer analyzer = c.mapperService.analysisService().analyzer(analyzerName);
+            if (analyzer == null) {
+                throw new IllegalArgumentException("Analyzer [" + analyzerName + "] doesn't exists");
+            }
+            v.setAnalyzer(analyzer);
+        }, new ParseField("analyzer"), ObjectParser.ValueType.STRING);
+        TLP_PARSER.declareString(SuggestionSearchContext.SuggestionContext::setField, new ParseField("analyzer"));
+        TLP_PARSER.declareInt(SuggestionSearchContext.SuggestionContext::setSize, new ParseField("size"));
+        TLP_PARSER.declareInt(SuggestionSearchContext.SuggestionContext::setShardSize, new ParseField("size"));
+        TLP_PARSER.declareField((p, v, c) -> {
+            // Copy the current structure. We will parse, once the mapping is provided
+            XContentBuilder builder = XContentFactory.contentBuilder(p.contentType());
+            builder.copyCurrentStructure(p);
+            BytesReference bytes = builder.bytes();
+            c.contextParser = XContentFactory.xContent(bytes).createParser(bytes);
+            p.skipChildren();
+        }, new ParseField("contexts", "context"), ObjectParser.ValueType.OBJECT); // context is deprecated
+    }
+
+    private static class ContextAndSuggest {
+        XContentParser contextParser;
+        final MapperService mapperService;
+
+        ContextAndSuggest(MapperService mapperService) {
+            this.mapperService = mapperService;
+        }
+    }
+
     private final CompletionSuggester completionSuggester;
 
     public CompletionSuggestParser(CompletionSuggester completionSuggester) {
@@ -79,59 +131,12 @@ public class CompletionSuggestParser implements SuggestContextParser {
     }
 
     @Override
-    public SuggestionSearchContext.SuggestionContext parse(XContentParser parser, MapperService mapperService, HasContextAndHeaders headersContext) throws IOException {
-        XContentParser.Token token;
-        ParseFieldMatcher parseFieldMatcher = mapperService.getIndexSettings().getParseFieldMatcher();
-        String fieldName = null;
+    public SuggestionSearchContext.SuggestionContext parse(XContentParser parser, MapperService mapperService,
+                                                           HasContextAndHeaders headersContext) throws IOException {
         final CompletionSuggestionContext suggestion = new CompletionSuggestionContext(completionSuggester, mapperService, fieldDataService);
-        XContentParser contextParser = null;
-        CompletionSuggestionBuilder.FuzzyOptionsBuilder fuzzyOptions = null;
-        CompletionSuggestionBuilder.RegexOptionsBuilder regexOptions = null;
-        final Set<String> payloadFields = new HashSet<>(1);
-
-        while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
-            if (token == XContentParser.Token.FIELD_NAME) {
-                fieldName = parser.currentName();
-            } else if (token.isValue()) {
-                if (!parseSuggestContext(parser, mapperService, fieldName, suggestion, parseFieldMatcher))  {
-                    if (token == XContentParser.Token.VALUE_BOOLEAN && "fuzzy".equals(fieldName)) {
-                        if (parser.booleanValue()) {
-                            fuzzyOptions = new CompletionSuggestionBuilder.FuzzyOptionsBuilder();
-                        }
-                    } else if (token == XContentParser.Token.VALUE_STRING && "payload".equals(fieldName)) {
-                        payloadFields.add(parser.text());
-                    }
-                }
-            } else if (token == XContentParser.Token.START_OBJECT) {
-                if ("fuzzy".equals(fieldName)) {
-                    fuzzyOptions = FUZZY_PARSER.parse(parser);
-                } else if ("contexts".equals(fieldName) || "context".equals(fieldName)) {
-                    // Copy the current structure. We will parse, once the mapping is provided
-                    XContentBuilder builder = XContentFactory.contentBuilder(parser.contentType());
-                    builder.copyCurrentStructure(parser);
-                    BytesReference bytes = builder.bytes();
-                    contextParser = XContentFactory.xContent(bytes).createParser(bytes);
-                } else if ("regex".equals(fieldName)) {
-                    regexOptions = REGEXP_PARSER.parse(parser);
-                } else {
-                    throw new IllegalArgumentException("suggester [completion] doesn't support field [" + fieldName + "]");
-                }
-            } else if (token == XContentParser.Token.START_ARRAY) {
-                if ("payload".equals(fieldName)) {
-                    while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
-                        if (token == XContentParser.Token.VALUE_STRING) {
-                            payloadFields.add(parser.text());
-                        } else {
-                            throw new IllegalArgumentException("suggester [completion] expected string values in [payload] array");
-                        }
-                    }
-                } else {
-                    throw new IllegalArgumentException("suggester [completion] doesn't support field [" + fieldName + "]");
-                }
-            } else {
-                throw new IllegalArgumentException("suggester [completion] doesn't support field [" + fieldName + "]");
-            }
-        }
+        final ContextAndSuggest contextAndSuggest = new ContextAndSuggest(mapperService);
+        TLP_PARSER.parse(parser, suggestion, contextAndSuggest);
+        final XContentParser contextParser = contextAndSuggest.contextParser;
         MappedFieldType mappedFieldType = mapperService.smartNameFieldType(suggestion.getField());
         if (mappedFieldType == null) {
             throw new ElasticsearchException("Field [" + suggestion.getField() + "] is not a completion suggest field");
@@ -158,34 +163,13 @@ public class CompletionSuggestParser implements SuggestContextParser {
                 contextParser.close();
             }
             suggestion.setFieldType(type);
-            suggestion.setFuzzyOptionsBuilder(fuzzyOptions);
-            suggestion.setRegexOptionsBuilder(regexOptions);
             suggestion.setQueryContexts(queryContexts);
-            suggestion.setPayloadFields(payloadFields);
             return suggestion;
         } else {
             throw new IllegalArgumentException("Field [" + suggestion.getField() + "] is not a completion suggest field");
         }
     }
 
-    private static ObjectParser<CompletionSuggestionBuilder.RegexOptionsBuilder, Void> REGEXP_PARSER = new ObjectParser<>("regexp", CompletionSuggestionBuilder.RegexOptionsBuilder::new);
-    private static ObjectParser<CompletionSuggestionBuilder.FuzzyOptionsBuilder, Void> FUZZY_PARSER = new ObjectParser<>("fuzzy", CompletionSuggestionBuilder.FuzzyOptionsBuilder::new);
 
-    static {
-        FUZZY_PARSER.declareInt(CompletionSuggestionBuilder.FuzzyOptionsBuilder::setFuzzyMinLength, new ParseField("min_length"));
-        FUZZY_PARSER.declareInt(CompletionSuggestionBuilder.FuzzyOptionsBuilder::setMaxDeterminizedStates, new ParseField("max_determinized_states"));
-        FUZZY_PARSER.declareBoolean(CompletionSuggestionBuilder.FuzzyOptionsBuilder::setUnicodeAware, new ParseField("unicode_aware"));
-        FUZZY_PARSER.declareInt(CompletionSuggestionBuilder.FuzzyOptionsBuilder::setFuzzyPrefixLength, new ParseField("prefix_length"));
-        FUZZY_PARSER.declareBoolean(CompletionSuggestionBuilder.FuzzyOptionsBuilder::setTranspositions, new ParseField("transpositions"));
-        FUZZY_PARSER.declareValue((a, b) -> {
-            try {
-                a.setFuzzyPrefixLength(Fuzziness.parse(b).asDistance());
-            } catch (IOException e) {
-                throw new ElasticsearchException(e);
-            }
-        }, new ParseField("fuzziness"));
 
-        REGEXP_PARSER.declareInt(CompletionSuggestionBuilder.RegexOptionsBuilder::setMaxDeterminizedStates, new ParseField("max_determinized_states"));
-        REGEXP_PARSER.declareStringOrNull(CompletionSuggestionBuilder.RegexOptionsBuilder::setFlags, new ParseField("flags"));
-    }
 }
diff --git a/core/src/main/java/org/elasticsearch/search/suggest/completion/CompletionSuggestionContext.java b/core/src/main/java/org/elasticsearch/search/suggest/completion/CompletionSuggestionContext.java
index 9f3e992d9d..eab62a063a 100644
--- a/core/src/main/java/org/elasticsearch/search/suggest/completion/CompletionSuggestionContext.java
+++ b/core/src/main/java/org/elasticsearch/search/suggest/completion/CompletionSuggestionContext.java
@@ -28,10 +28,7 @@ import org.elasticsearch.search.suggest.SuggestionSearchContext;
 import org.elasticsearch.search.suggest.completion.context.ContextMapping;
 import org.elasticsearch.search.suggest.completion.context.ContextMappings;
 
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 
 /**
  *
@@ -85,6 +82,10 @@ public class CompletionSuggestionContext extends SuggestionSearchContext.Suggest
         this.payloadFields = fields;
     }
 
+    void setPayloadFields(List<String> fields) {
+        setPayloadFields(new HashSet<String>(fields));
+    }
+
     Set<String> getPayloadFields() {
         return payloadFields;
     }