extends SpanQuery {
+
+ protected final Q query;
+ private SpanMultiTermQueryWrapper.SpanRewriteMethod rewriteMethod;
+ long docCount;
+
+ @SuppressWarnings({"rawtypes", "unchecked"})
+ public BoostedSpanMultiTermQueryWrapper(Q query, long docCount) {
+ this.query = Objects.requireNonNull(query);
+ this.rewriteMethod = selectRewriteMethod(query, docCount);
+ this.docCount = docCount;
+ }
+
+ private static SpanMultiTermQueryWrapper.SpanRewriteMethod selectRewriteMethod(MultiTermQuery query, long docCount) {
+ MultiTermQuery.RewriteMethod method = query.getRewriteMethod();
+ if (method instanceof TopTermsRewrite) {
+ final int pqsize = ((TopTermsRewrite) method).getSize();
+ return new BoostedTopTermsSpanBooleanQueryRewrite(pqsize, docCount);
+ } else {
+ return SpanMultiTermQueryWrapper.SCORING_SPAN_QUERY_REWRITE;
+ }
+ }
+
+
+ /**
+ * Expert: returns the rewriteMethod
+ */
+ public final SpanMultiTermQueryWrapper.SpanRewriteMethod getRewriteMethod() {
+ return rewriteMethod;
+ }
+
+ /**
+ * Expert: sets the rewrite method. This only makes sense
+ * to be a span rewrite method.
+ */
+ public final void setRewriteMethod(SpanMultiTermQueryWrapper.SpanRewriteMethod rewriteMethod) {
+ this.rewriteMethod = rewriteMethod;
+ }
+
+ @Override
+ public String getField() {
+ return query.getField();
+ }
+
+ @Override
+ public SpanWeight createWeight(IndexSearcher searcher, ScoreMode scoreMode, float boost) throws IOException {
+ throw new IllegalArgumentException("Rewrite first!");
+ }
+
+ /**
+ * Returns the wrapped query
+ */
+ public Query getWrappedQuery() {
+ return query;
+ }
+
+
+ @Override
+ public String toString(String field) {
+ StringBuilder builder = new StringBuilder();
+ builder.append("NewSpanMultiTermQueryWrapper(");
+ // NOTE: query.toString must be placed in a temp local to avoid compile errors on Java 8u20
+ // see https://bugs.openjdk.java.net/browse/JDK-8056984?page=com.atlassian.streams.streams-jira-plugin:activity-stream-issue-tab
+ String queryStr = query.toString(field);
+ builder.append(queryStr);
+ builder.append(")");
+ return builder.toString();
+ }
+
+ @Override
+ public Query rewrite(IndexReader reader) throws IOException {
+ return rewriteMethod.rewrite(reader, query);
+ }
+
+ @Override
+ public void visit(QueryVisitor visitor) {
+ if (visitor.acceptField(query.getField())) {
+ query.visit(visitor.getSubVisitor(BooleanClause.Occur.MUST, this));
+ }
+ }
+
+ @Override
+ public int hashCode() {
+ return classHash() * 31 + query.hashCode();
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ return query != null && sameClassAs(other) && other != null &&
+ query.equals(((BoostedSpanMultiTermQueryWrapper) other).query);
+ }
+
+
+ /**
+ * A rewrite method that first translates each term into a SpanTermQuery in a
+ * {@link BooleanClause.Occur#SHOULD} clause in a BooleanQuery, and keeps the
+ * scores as computed by the query.
+ *
+ *
+ * This rewrite method only uses the top scoring terms so it will not overflow
+ * the boolean max clause count.
+ *
+ * @see #setRewriteMethod
+ */
+ public static final class BoostedTopTermsSpanBooleanQueryRewrite extends SpanMultiTermQueryWrapper.SpanRewriteMethod {
+ private final TopTermsRewrite> delegate;
+ private int docCount;
+
+ /**
+ * Create a TopTermsSpanBooleanQueryRewrite for
+ * at most size terms.
+ */
+ public BoostedTopTermsSpanBooleanQueryRewrite(int size, long docCount) {
+ delegate = new BoostedTopTermsRewrite<>(size, docCount) {
+
+ @Override
+ protected int getMaxSize() {
+ return Integer.MAX_VALUE;
+ }
+
+ @Override
+ protected List getTopLevelBuilder() {
+ return new ArrayList<>();
+ }
+
+ @Override
+ protected Query build(List queries) {
+ return new BoostedSpanOrQuery(queries.toArray(new SpanQuery[0]));
+ }
+
+ @Override
+ protected void addClause(List topLevel, Term term, int docFreq, float boost, TermStates states) {
+ final BoostSpanTermQuery boostQuery = new BoostSpanTermQuery(term, states, boost);
+ topLevel.add(boostQuery);
+ }
+
+ private float leveralPopularity(int docFreq) {
+ return 1f - (0.3f * (float) docCount / (docFreq + docCount));
+ }
+
+ };
+ }
+
+ /**
+ * return the maximum priority queue size
+ */
+ public int getSize() {
+ return delegate.getSize();
+ }
+
+ @Override
+ public SpanQuery rewrite(IndexReader reader, MultiTermQuery query) throws IOException {
+ return (SpanQuery) delegate.rewrite(reader, query);
+ }
+
+ @Override
+ public int hashCode() {
+ return 31 * delegate.hashCode();
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) return true;
+ if (obj == null) return false;
+ if (getClass() != obj.getClass()) return false;
+ final BoostedTopTermsSpanBooleanQueryRewrite other = (BoostedTopTermsSpanBooleanQueryRewrite) obj;
+ return delegate.equals(other.delegate);
+ }
+ }
+}
+
diff --git a/src/main/java/org/apache/solr/spelling/suggest/AutocompleteSolrSuggester.java b/src/main/java/org/apache/solr/spelling/suggest/AutocompleteSolrSuggester.java
new file mode 100644
index 0000000..b570408
--- /dev/null
+++ b/src/main/java/org/apache/solr/spelling/suggest/AutocompleteSolrSuggester.java
@@ -0,0 +1,239 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.solr.spelling.suggest;
+
+import org.apache.lucene.search.spell.Dictionary;
+import org.apache.lucene.search.suggest.Lookup;
+import org.apache.lucene.search.suggest.Lookup.LookupResult;
+import org.apache.lucene.store.AlreadyClosedException;
+import org.apache.lucene.util.IOUtils;
+import org.apache.solr.common.util.NamedList;
+import org.apache.solr.core.CloseHook;
+import org.apache.solr.core.SolrCore;
+import org.apache.solr.search.SolrIndexSearcher;
+import org.apache.solr.suggest.analyzing.AutocompleteSuggester;
+import org.apache.solr.update.SolrCoreState;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.Closeable;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.lang.invoke.MethodHandles;
+import java.util.List;
+
+import static org.apache.solr.common.params.CommonParams.NAME;
+
+/**
+ * Responsible for loading the lookup and dictionary Implementations specified by
+ * the SolrConfig.
+ * Interacts (query/build/reload) with Lucene Suggesters through {@link Lookup} and
+ * {@link Dictionary}
+ */
+public class AutocompleteSolrSuggester extends SolrSuggester {
+ private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
+
+ private String sourceLocation;
+ private File storeDir;
+ private Dictionary dictionary;
+ private Lookup lookup;
+ private String lookupImpl;
+ private String dictionaryImpl;
+ private String name;
+
+ private LookupFactory factory;
+ private DictionaryFactory dictionaryFactory;
+
+ /**
+ * Uses the config and the core to initialize the underlying
+ * Lucene suggester
+ */
+ @SuppressWarnings({"unchecked"})
+ @Override
+ public String init(NamedList config, SolrCore core) {
+ super.init(config, core);
+
+ log.info("init: {}", config);
+
+ // read the config
+ name = config.get(NAME) != null ? (String) config.get(NAME)
+ : DEFAULT_DICT_NAME;
+ sourceLocation = (String) config.get(LOCATION);
+ lookupImpl = (String) config.get(LOOKUP_IMPL);
+ dictionaryImpl = (String) config.get(DICTIONARY_IMPL);
+ String store = (String) config.get(STORE_DIR);
+
+ if (lookupImpl == null) {
+ lookupImpl = LookupFactory.DEFAULT_FILE_BASED_DICT;
+ log.info("No {} parameter was provided falling back to {}", LOOKUP_IMPL, lookupImpl);
+ }
+
+ // initialize appropriate lookup instance
+ factory = core.getResourceLoader().newInstance(lookupImpl, LookupFactory.class);
+ lookup = factory.create(config, core);
+
+ if (lookup != null && lookup instanceof Closeable) {
+ core.addCloseHook(new CloseHook() {
+ @Override
+ public void preClose(SolrCore core) {
+ try {
+ ((Closeable) lookup).close();
+ } catch (IOException e) {
+ log.warn("Could not close the suggester lookup.", e);
+ }
+ }
+
+ @Override
+ public void postClose(SolrCore core) {
+ throw new UnsupportedOperationException();
+ }
+ });
+ }
+
+ // if store directory is provided make it or load up the lookup with its content
+ if (store != null && !store.isEmpty()) {
+ storeDir = new File(store);
+ if (!storeDir.isAbsolute()) {
+ storeDir = new File(core.getDataDir() + File.separator + storeDir);
+ }
+ if (!storeDir.exists()) {
+ storeDir.mkdirs();
+ } else if (getStoreFile().exists()) {
+ if (log.isDebugEnabled()) {
+ log.debug("attempt reload of the stored lookup from file {}", getStoreFile());
+ }
+ try {
+ lookup.load(new FileInputStream(getStoreFile()));
+ } catch (IOException e) {
+ log.warn("Loading stored lookup data failed, possibly not cached yet");
+ }
+ }
+ }
+
+ // dictionary configuration
+ if (dictionaryImpl == null) {
+ dictionaryImpl = (sourceLocation == null) ? DictionaryFactory.DEFAULT_INDEX_BASED_DICT :
+ DictionaryFactory.DEFAULT_FILE_BASED_DICT;
+ log.info("No {} parameter was provided falling back to {}", DICTIONARY_IMPL, dictionaryImpl);
+ }
+
+ dictionaryFactory = core.getResourceLoader().newInstance(dictionaryImpl, DictionaryFactory.class);
+ dictionaryFactory.setParams(config);
+ log.info("Dictionary loaded with params: {}", config);
+
+ return name;
+ }
+
+ /**
+ * Build the underlying Lucene Suggester
+ */
+ @Override
+ public void build(SolrCore core, SolrIndexSearcher searcher) throws IOException {
+ super.build(core, searcher);
+
+ log.info("AutocompleteSolrSuggester.build({})", name);
+
+ dictionary = dictionaryFactory.create(core, searcher);
+ try {
+ lookup.build(dictionary);
+ } catch (AlreadyClosedException e) {
+ RuntimeException e2 = new SolrCoreState.CoreIsClosedException
+ ("Suggester build has been interrupted by a core reload or shutdown.");
+ e2.initCause(e);
+ throw e2;
+ }
+ if (storeDir != null) {
+ File target = getStoreFile();
+ if (!lookup.store(new FileOutputStream(target))) {
+ log.error("Store Lookup build failed");
+ } else {
+ if (log.isInfoEnabled()) {
+ log.info("Stored suggest data to: {}", target.getAbsolutePath());
+ }
+ }
+ }
+ }
+
+ /**
+ * Reloads the underlying Lucene Suggester
+ */
+ @Override
+ public void reload(SolrCore core, SolrIndexSearcher searcher) throws IOException {
+ super.reload(core, searcher);
+
+ log.info("AutocompleteSolrSuggester.reload({})", name);
+ if (dictionary == null && storeDir != null) {
+ File lookupFile = getStoreFile();
+ if (lookupFile.exists()) {
+ // this may be a firstSearcher event, try loading it
+ FileInputStream is = new FileInputStream(lookupFile);
+ try {
+ if (lookup.load(is)) {
+ return; // loaded ok
+ }
+ } finally {
+ IOUtils.closeWhileHandlingException(is);
+ }
+ } else {
+ log.info("lookup file doesn't exist");
+ }
+ }
+ }
+
+ /**
+ * @return the file where this suggester is stored.
+ * null if no storeDir was configured
+ */
+ @Override
+ public File getStoreFile() {
+ if (storeDir == null) {
+ return null;
+ }
+ return new File(storeDir, factory.storeFileName());
+ }
+
+ /**
+ * Returns suggestions based on the {@link SuggesterOptions} passed
+ */
+ public SuggesterResult getSuggestions(LocalSuggesterOptions options) throws IOException {
+ if (log.isDebugEnabled()) {
+ log.debug("getSuggestions: {}", options.token);
+ }
+ if (lookup == null) {
+ log.info("Lookup is null - invoke suggest.build first");
+ return EMPTY_RESULT;
+ }
+
+ SuggesterResult res = new SuggesterResult();
+ List suggestions;
+ if (options.contextFilterQuery == null) {
+ if (lookup instanceof AutocompleteSuggester) {
+ suggestions = ((AutocompleteSuggester) lookup).lookup(options, false);
+ } else {
+ suggestions = lookup.lookup(options.token, false, options.count);
+ }
+ res.add(getName(), options.token.toString(), suggestions);
+ return res;
+ } else {
+ return super.getSuggestions(options);
+ }
+
+ }
+
+}
diff --git a/src/main/java/org/apache/solr/spelling/suggest/CdiscountSuggesterOptionsUtils.java b/src/main/java/org/apache/solr/spelling/suggest/CdiscountSuggesterOptionsUtils.java
new file mode 100644
index 0000000..8549dea
--- /dev/null
+++ b/src/main/java/org/apache/solr/spelling/suggest/CdiscountSuggesterOptionsUtils.java
@@ -0,0 +1,19 @@
+package org.apache.solr.spelling.suggest;
+
+public class CdiscountSuggesterOptionsUtils {
+
+ public static final String SEPARATOR = "_";
+
+ private CdiscountSuggesterOptionsUtils() {
+ // Nothing to do
+ }
+
+ public static String keyCache(String suggesterName, SuggesterOptions options) {
+ return suggesterName
+ + SEPARATOR + options.token
+ + SEPARATOR + options.contextFilterQuery
+ + SEPARATOR + options.count
+ + SEPARATOR + options.allTermsRequired
+ + SEPARATOR + options.highlight;
+ }
+}
diff --git a/src/main/java/org/apache/solr/spelling/suggest/LocalSuggesterOptions.java b/src/main/java/org/apache/solr/spelling/suggest/LocalSuggesterOptions.java
new file mode 100644
index 0000000..cc5ecda
--- /dev/null
+++ b/src/main/java/org/apache/solr/spelling/suggest/LocalSuggesterOptions.java
@@ -0,0 +1,48 @@
+package org.apache.solr.spelling.suggest;
+
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.util.CharsRef;
+
+public class LocalSuggesterOptions extends SuggesterOptions{
+
+ boolean firstContextOnly;
+ IndexSearcher searcher;
+
+ public LocalSuggesterOptions(SuggesterOptions opts) {
+ super(opts.token, opts.count, opts.contextFilterQuery, opts.allTermsRequired, opts.highlight);
+ }
+
+ public LocalSuggesterOptions(IndexSearcher searcher, CharsRef token, int count, String contextFilterQuery, boolean allTermsRequired, boolean highlight, boolean firstContextOnly) {
+ super(token, count, contextFilterQuery, allTermsRequired, highlight);
+ this.searcher = searcher;
+ this.firstContextOnly = firstContextOnly;
+ }
+
+ public CharsRef getToken() {
+ return super.token;
+ }
+
+ public int getCount() {
+ return super.count;
+ }
+
+ public String getContextFilterQuery() {
+ return super.contextFilterQuery;
+ }
+
+ public boolean isAllTermsRequired() {
+ return super.allTermsRequired;
+ }
+
+ public boolean isHighlight() {
+ return super.highlight;
+ }
+
+ public boolean isFirstContextOnly() {
+ return firstContextOnly;
+ }
+
+ public IndexSearcher getSearcher() {
+ return searcher;
+ }
+}
diff --git a/src/main/java/org/apache/solr/spelling/suggest/fst/AutocompleteLookupFactory.java b/src/main/java/org/apache/solr/spelling/suggest/fst/AutocompleteLookupFactory.java
new file mode 100644
index 0000000..a96d337
--- /dev/null
+++ b/src/main/java/org/apache/solr/spelling/suggest/fst/AutocompleteLookupFactory.java
@@ -0,0 +1,141 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.solr.spelling.suggest.fst;
+
+import org.apache.lucene.search.similarities.Similarity;
+import org.apache.lucene.search.suggest.Lookup;
+import org.apache.lucene.search.suggest.analyzing.AnalyzingInfixSuggester;
+import org.apache.lucene.store.FSDirectory;
+import org.apache.solr.common.util.NamedList;
+import org.apache.solr.core.SolrCore;
+import org.apache.solr.suggest.analyzing.AutocompleteSuggester;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.apache.solr.handler.component.AutocompleteComponent.CONFIG_FIRST_CONTEXT_ONLY;
+
+/**
+ * Factory for {@link AutocompleteLookupFactory}
+ *
+ * @lucene.experimental
+ */
+public class AutocompleteLookupFactory extends AnalyzingInfixLookupFactory {
+
+ private static final String FILENAME = "bifsta.bin";
+ public static final String FIELD = "field";
+ public static final String FIELD_PAYLOAD = "payloadField";
+ public static final String FIELD_NGRAM = "ngramField";
+ public static final String FIELD_NGRAM_SECOND = "ngramSecondField";
+ public static final String FIELD_CONCAT_PAYLOAD = "concatPayloadField";
+ public static final String FIELD_CONCAT_NGRAM = "concatNgramField";
+
+ public static final String FIELD_WEIGHT = "weightField";
+ public static final String WEIGHT_COEFF = "weightCoefficient";
+
+ public static final String FIELD_TEXT = "displayField";
+ public static final String FIELD_CONTEXT = "contextField";
+
+ public static final String MAX_NB_WORDS_FOR_POSITION_MATCH = "maxNbWordsForPositionMatch";
+
+ @Override
+ public Lookup create(@SuppressWarnings({"rawtypes"}) NamedList params, SolrCore core) {
+
+ // optional parameters
+ String indexPath = params.get(INDEX_PATH) != null
+ ? params.get(INDEX_PATH).toString() : "index";
+ if (!new File(indexPath).isAbsolute()) {
+ indexPath = core.getDataDir() + File.separator + "index";
+ }
+
+ int minPrefixChars = params.get(MIN_PREFIX_CHARS) != null
+ ? Integer.parseInt(params.get(MIN_PREFIX_CHARS).toString())
+ : AnalyzingInfixSuggester.DEFAULT_MIN_PREFIX_CHARS;
+
+ boolean allTermsRequired = params.get(ALL_TERMS_REQUIRED) != null
+ ? Boolean.getBoolean(params.get(ALL_TERMS_REQUIRED).toString())
+ : AnalyzingInfixSuggester.DEFAULT_ALL_TERMS_REQUIRED;
+
+ boolean highlight = params.get(HIGHLIGHT) != null
+ ? Boolean.getBoolean(params.get(HIGHLIGHT).toString())
+ : AnalyzingInfixSuggester.DEFAULT_HIGHLIGHT;
+
+ Integer nbWordsForPositionMatch = params.get(MAX_NB_WORDS_FOR_POSITION_MATCH) == null
+ ? null
+ : Integer.parseInt(params.get(MAX_NB_WORDS_FOR_POSITION_MATCH).toString());
+
+ boolean firstContextOnly = params.get(CONFIG_FIRST_CONTEXT_ONLY) != null && Boolean.parseBoolean(params.get(CONFIG_FIRST_CONTEXT_ONLY).toString());
+
+ // Fieldnames
+ Map fields = new HashMap<>();
+ buildFields(FIELD, params, fields);
+ buildFields(FIELD_PAYLOAD, params, fields);
+ buildFields(FIELD_NGRAM, params, fields);
+ buildFields(FIELD_NGRAM_SECOND, params, fields);
+ buildFields(FIELD_CONCAT_PAYLOAD, params, fields);
+ buildFields(FIELD_CONCAT_NGRAM, params, fields);
+
+ buildFields(FIELD_WEIGHT, params, fields);
+ buildFields(FIELD_TEXT, params, fields);
+ buildFields(FIELD_CONTEXT, params, fields);
+
+
+ float coeff = params.get(WEIGHT_COEFF) != null
+ ? Float.parseFloat(params.get(WEIGHT_COEFF).toString())
+ : 1f;
+ Similarity configSimilarity = core.getLatestSchema() != null ? core.getLatestSchema().getSimilarity() : null;
+
+ try {
+ return new AutocompleteSuggester(FSDirectory.open(new File(indexPath).toPath()),
+ minPrefixChars, allTermsRequired, highlight, fields, coeff, nbWordsForPositionMatch, configSimilarity, firstContextOnly);
+ } catch (IOException e) {
+ throw new AutocompleteRuntimeException(e);
+ }
+ }
+
+ /**
+ * Find fields name in params
+ *
+ * @param fieldName
+ * @param params
+ * @param fields
+ */
+ private void buildFields(String fieldName, NamedList params, Map fields) {
+ if (fields == null) {
+ fields = new HashMap<>();
+ }
+ String fieldValue = params.get(fieldName) == null ? null : params.get(fieldName);
+
+ if (fieldValue != null) {
+ fields.put(fieldName, fieldValue);
+ }
+ }
+
+ @Override
+ public String storeFileName() {
+ return FILENAME;
+ }
+
+ public static class AutocompleteRuntimeException extends RuntimeException {
+ public AutocompleteRuntimeException(Throwable cause) {
+ super(cause);
+ }
+ }
+
+}
diff --git a/src/main/java/org/apache/solr/suggest/analyzing/AutocompleteQueryBuilder.java b/src/main/java/org/apache/solr/suggest/analyzing/AutocompleteQueryBuilder.java
new file mode 100644
index 0000000..0843b2b
--- /dev/null
+++ b/src/main/java/org/apache/solr/suggest/analyzing/AutocompleteQueryBuilder.java
@@ -0,0 +1,328 @@
+package org.apache.solr.suggest.analyzing;
+
+import org.apache.lucene.index.Term;
+import org.apache.lucene.queries.function.FunctionQuery;
+import org.apache.lucene.queries.function.valuesource.FloatFieldSource;
+import org.apache.lucene.query.PositionSpanQuery;
+import org.apache.lucene.search.BooleanClause;
+import org.apache.lucene.search.BooleanQuery;
+import org.apache.lucene.search.BoostQuery;
+import org.apache.lucene.search.DisjunctionMaxQuery;
+import org.apache.lucene.search.FuzzyQuery;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.TermQuery;
+import org.apache.lucene.search.spans.SpanQuery;
+import org.apache.lucene.search.spans.SpanTermQuery;
+import org.apache.solr.search.span.BoostedSpanMultiTermQueryWrapper;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import static org.apache.solr.spelling.suggest.fst.AutocompleteLookupFactory.*;
+
+public class AutocompleteQueryBuilder {
+
+ private static final int MIN_LENGTH_FOR_MAXEDITS = 6;
+ private static final int MIN_POSITION_FOR_WORDS = 5;
+
+ private static final float[] DEFAULT_COEFF = {0.5f, 0.4f, 0.3f};
+ private static final float[][] ALL_COEFF = {
+ {15f, 10f, 7f, 5f, 4f, 3f, 2f, 1f},
+ {10f, 9f, 8f, 7f, 6f, 5f, 4f, 3f},
+ {5f, 3f, 2f, 1f, 0.5f, 0.25f}};
+
+ private static final float MIN_FIRST_COEFF = 0.1f;
+
+ private final int nbWordsForPositionMatch;
+ private final Map fields;
+ private final float coeff;
+ private final long docCount;
+
+ public AutocompleteQueryBuilder(Integer nbWordsForPositionMatch, Map fields, float coeff, long docCount) {
+ this.nbWordsForPositionMatch = nbWordsForPositionMatch == null ?
+ AutocompleteQueryBuilder.MIN_LENGTH_FOR_MAXEDITS
+ : nbWordsForPositionMatch;
+
+ this.fields = fields;
+ this.coeff = coeff;
+ this.docCount = docCount;
+ }
+
+
+ public BooleanQuery getQuery(QueryInfos queryInfos, BooleanClause.Occur occ) {
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
+
+ int position = 1;
+
+ List list = new ArrayList<>();
+ FieldsAndW field = new FieldsAndW(FIELD, 1f,
+ FIELD_PAYLOAD, 0.8f,
+ FIELD_NGRAM, 0.9f,
+ FIELD_CONCAT_PAYLOAD, 0.8f,
+ FIELD_NGRAM_SECOND, 1.3f);
+
+ position = matchedTokens(query, queryInfos, list, field, position, occ);
+
+ // Prefix Token
+ list = new ArrayList<>();
+ field = new FieldsAndW(
+ FIELD_PAYLOAD, 1f,
+ FIELD_PAYLOAD, 0.8f,
+ FIELD_NGRAM, 1f,
+ FIELD_CONCAT_PAYLOAD, 0.8f,
+ FIELD_NGRAM_SECOND, 0.3f);
+ prefixToken(query, queryInfos, list, field, position, occ);
+
+ // Potential boost
+ if (this.fields.get(FIELD_WEIGHT) != null) {
+ query.add(new BoostQuery(new FunctionQuery(new FloatFieldSource(this.fields.get(FIELD_WEIGHT))), coeff), occ);
+ }
+
+ return query.build();
+ }
+
+ private int matchedTokens(BooleanQuery.Builder query, QueryInfos queryInfos, List list, FieldsAndW field, int position, BooleanClause.Occur occ) {
+ for (String token : queryInfos.getMatchedTokens()) {
+
+ if (queryInfos.getNbWords() <= nbWordsForPositionMatch || position < MIN_POSITION_FOR_WORDS) {
+ buildNormalAndFuzzyList(list, field, token, position);
+ buildNgramList(list, field, token, position);
+ buildCutList(list, field, position, position - 1, queryInfos);
+ buildConcatList(list, field, token, position);
+ } else {
+ buildOtherListWithoutPosition(list, field, token, position - 1, queryInfos);
+ }
+
+ query.add(new DisjunctionMaxQuery(list, 0f), occ);
+ position++;
+ }
+ return position;
+ }
+
+ private void prefixToken(BooleanQuery.Builder query, QueryInfos queryInfos, List list, FieldsAndW field, int position, BooleanClause.Occur occ) {
+ String token = queryInfos.getPrefixToken();
+
+ if (token != null) {
+ String fieldNameNormal = this.fields.get(field.fieldnameNormal) != null
+ ? this.fields.get(field.fieldnameNormal)
+ : FIELD;
+
+
+ String fieldNameNgram = isNgram(field)
+ ? this.fields.get(field.fieldnameNgram)
+ : fieldNameNormal;
+
+ if (queryInfos.getNbWords() <= nbWordsForPositionMatch) {
+ buildPrefix(list, field, fieldNameNormal, fieldNameNgram, token, position);
+ } else {
+ buildPrefixWithoutPosition(list, field, fieldNameNgram, token);
+ }
+
+ query.add(new DisjunctionMaxQuery(list, 0f), occ);
+ }
+ }
+
+ private void buildNormalAndFuzzyList(List list, FieldsAndW field, String token, int position) {
+ String fieldName = this.fields.get(field.fieldnameNormal);
+ if (fieldName != null) {
+ // normal
+ Query q = getPositionSpanQuery(fieldName, false, token, -1, position, field.weightNormal);
+ list.add(q);
+
+ // fuzzy
+ if (token.length() > 2) {
+ Query fuzz = getPositionSpanQuery(fieldName, true, token, 0, position, field.weightFuz);
+ list.add(fuzz);
+ }
+ }
+ }
+
+ private void buildNgramList(List list, FieldsAndW field, String token, int position) {
+ // ngram
+ if (isNgram(field)) {
+ Query ngram = getPositionSpanQuery(this.fields.get(field.fieldnameNgram), false, token, -1, position, field.weightNgram);
+ list.add(ngram);
+
+ } else {
+ // normal
+ String fieldName = this.fields.get(field.fieldnameFuz) != null ? this.fields.get(field.fieldnameFuz) : this.fields.get(field.fieldnameNormal);
+ Query q = getPositionSpanQuery(fieldName, false, token, -1, position, field.weightNormal);
+ list.add(q);
+ }
+ }
+
+ private void buildCutList(List list, FieldsAndW field, int position, int row, QueryInfos queryInfos) {
+ if (isNgram(field)) {
+ // Cut Word
+ String cuttedToken = row >= queryInfos.getMatchedTokensConcat().size() ? null : queryInfos.getMatchedTokensConcat().get(row);
+ String fieldNameCut = isNgram(field) ? this.fields.get(field.fieldnameNgram) : this.fields.get(field.fieldnameNormal);
+ if (cuttedToken != null) {
+ Query cut = getPositionSpanQuery(fieldNameCut, false, cuttedToken, -1, position, field.weightNgramSecond);
+ list.add(cut);
+ }
+ }
+ }
+
+ private void buildConcatList(List list, FieldsAndW field, String token, int position) {
+ // concat
+ if (isConcat(field)) {
+ Query concat = getPositionSpanQuery(this.fields.get(field.fieldnameConcat), false, token, -1, position, field.weightConcat);
+ list.add(concat);
+ }
+
+ if (isNgramSecond(field)) {
+ Query concat = new TermQuery(new Term(this.fields.get(field.fieldnameNgramSecond), token));
+ list.add(new BoostQuery(concat, field.weightConcat));
+ }
+ }
+
+ private void buildOtherListWithoutPosition(List list, FieldsAndW field, String token, int row, QueryInfos queryInfos) {
+ String fieldNormal = this.fields.get(field.fieldnameNormal);
+
+
+ if (fieldNormal != null) {
+ // Normal
+ Query q = new TermQuery(new Term(fieldNormal, token));
+ list.add(new BoostQuery(q, field.weightNormal));
+
+ // Fuzzy
+ if (token.length() > 4) {
+ Query fuzz = new FuzzyQuery(new Term(fieldNormal, token),
+ token.length() > MIN_LENGTH_FOR_MAXEDITS ? 2 : 1, 1);
+ list.add(new BoostQuery(fuzz, field.weightFuz));
+ }
+ }
+
+ // Ngram
+ if (isNgram(field)) {
+ Query ngram = new TermQuery(new Term(this.fields.get(field.fieldnameNgram), token));
+ list.add(new BoostQuery(ngram, field.weightNgram));
+ }
+
+ // concat
+ if (isConcat(field)) {
+ Query concat = new TermQuery(new Term(this.fields.get(field.fieldnameConcat), token));
+ list.add(new BoostQuery(concat, field.weightConcat));
+ }
+
+ // Cut Word
+ String cuttedToken = row >= queryInfos.getMatchedTokensConcat().size() ? null : queryInfos.getMatchedTokensConcat().get(row);
+ if (cuttedToken != null && fieldNormal != null) {
+ Query cut = new TermQuery(new Term(fieldNormal, cuttedToken));
+ list.add(new BoostQuery(cut, field.weightNgramSecond));
+ }
+ }
+
+ private void buildPrefix(List list, FieldsAndW field, String fieldNameNormal, String fieldNameNgram, String token, int position) {
+ // normal
+ Query normal = getPositionSpanQuery(fieldNameNormal, false, token, -1, position, field.weightNormal);
+ list.add(normal);
+
+ // ngram
+ Query ngram = getPositionSpanQuery(fieldNameNgram, false, token, -1, position, field.weightNgram);
+ list.add(ngram);
+
+ // fuzzy Ngram
+ if (token.length() > 1) {
+ Query fuzz = getPositionSpanQuery(fieldNameNgram, true, token, 1, position, field.weightFuz);
+ list.add(fuzz);
+ }
+
+ if (token.length() > 2) {
+ Query fuzz2 = getPositionSpanQuery(fieldNameNormal, true, token, 0, position, field.weightFuz);
+ list.add(fuzz2);
+ }
+ // Second Ngram
+ if (isNgramSecond(field)) {
+ Query secondNgram = getPositionSpanQuery(this.fields.get(field.fieldnameNgramSecond), false, token, -1, position > 1 ? position - 1 : position, field.weightNgramSecond);
+ list.add(secondNgram);
+ }
+
+ // concat
+ if (token.length() > 3 && isConcat(field)) {
+ Query concat = new TermQuery(new Term(this.fields.get(field.fieldnameConcat), token));
+ list.add(new BoostQuery(concat, field.weightConcat));
+ }
+ }
+
+ private void buildPrefixWithoutPosition(List list, FieldsAndW field, String fieldName, String token) {
+ Query ngram = new TermQuery(new Term(fieldName, token));
+ list.add(new BoostQuery(ngram, field.weightNgram));
+
+ // Second Ngram
+ if (isNgramSecond(field)) {
+ Query secondNgram = new TermQuery(new Term(this.fields.get(field.fieldnameNgramSecond), token));
+ list.add(new BoostQuery(secondNgram, field.weightNgramSecond));
+ }
+
+ if (token.length() > 2) {
+ Query fuzz = new FuzzyQuery(new Term(fieldName, token),
+ token.length() > MIN_LENGTH_FOR_MAXEDITS ? 2 : 1, 1);
+ list.add(new BoostQuery(fuzz, field.weightFuz));
+ }
+ // concat
+ if (isConcat(field)) {
+ Query concat = new TermQuery(new Term(this.fields.get(field.fieldnameConcat), token));
+ list.add(new BoostQuery(concat, field.weightConcat));
+ }
+ }
+
+ private Query getPositionSpanQuery(String fieldName, boolean fuzzyMode, String text, Integer prefixLength, int position, float boost) {
+ SpanQuery span;
+
+ if (fuzzyMode) {
+ int maxEdits = text.length() > MIN_LENGTH_FOR_MAXEDITS ? 2 : 1;
+ FuzzyQuery fuzzyQuery = new FuzzyQuery(new Term(fieldName, text), maxEdits, prefixLength, 25, true);
+ span = new BoostedSpanMultiTermQueryWrapper<>(fuzzyQuery, docCount);
+ } else {
+ span = new SpanTermQuery(new Term(fieldName, text));
+ }
+ return new PositionSpanQuery(span, false, position, true,
+ ALL_COEFF, DEFAULT_COEFF, MIN_FIRST_COEFF, boost);
+ }
+
+
+ public static class FieldsAndW {
+ public String fieldnameNormal;
+ public float weightNormal;
+ public String fieldnameFuz;
+ public float weightFuz;
+ public String fieldnameNgram;
+ public float weightNgram;
+ public String fieldnameNgramSecond;
+ public float weightNgramSecond;
+ public String fieldnameConcat;
+ public float weightConcat;
+
+ private FieldsAndW(String fieldnameNormal, float weightNormal,
+ String fieldnameFuz, float weightFuz,
+ String fieldnameNgram, float weightNgram,
+ String fieldnameConcat, float weightConcat,
+ String fieldnameNgramSecond, float weightNgramSecond
+ ) {
+ this.fieldnameNormal = fieldnameNormal;
+ this.weightNormal = weightNormal;
+ this.fieldnameFuz = fieldnameFuz;
+ this.weightFuz = weightFuz;
+ this.fieldnameNgram = fieldnameNgram;
+ this.weightNgram = weightNgram;
+ this.fieldnameConcat = fieldnameConcat;
+ this.weightConcat = weightConcat;
+ this.fieldnameNgramSecond = fieldnameNgramSecond;
+ this.weightNgramSecond = weightNgramSecond;
+ }
+ }
+
+ private boolean isNgram(FieldsAndW field) {
+ return field.fieldnameNgram != null && this.fields.get(field.fieldnameNgram) != null;
+ }
+
+ private boolean isConcat(FieldsAndW field) {
+ return field.fieldnameConcat != null && this.fields.get(field.fieldnameConcat) != null;
+ }
+
+ private boolean isNgramSecond(FieldsAndW field) {
+ return field.fieldnameNgramSecond != null && this.fields.get(field.fieldnameNgramSecond) != null;
+ }
+}
diff --git a/src/main/java/org/apache/solr/suggest/analyzing/AutocompleteSuggester.java b/src/main/java/org/apache/solr/suggest/analyzing/AutocompleteSuggester.java
new file mode 100644
index 0000000..cee71e7
--- /dev/null
+++ b/src/main/java/org/apache/solr/suggest/analyzing/AutocompleteSuggester.java
@@ -0,0 +1,476 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.solr.suggest.analyzing;
+
+import org.apache.lucene.analysis.Analyzer;
+import org.apache.lucene.analysis.NormalAnalyzer;
+import org.apache.lucene.analysis.TokenStream;
+import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
+import org.apache.lucene.analysis.tokenattributes.OffsetAttribute;
+import org.apache.lucene.index.BinaryDocValues;
+import org.apache.lucene.index.DirectoryReader;
+import org.apache.lucene.index.FilterLeafReader;
+import org.apache.lucene.index.LeafReader;
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.index.ReaderUtil;
+import org.apache.lucene.index.SegmentReader;
+import org.apache.lucene.search.BooleanClause.Occur;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.ScoreDoc;
+import org.apache.lucene.search.SearcherManager;
+import org.apache.lucene.search.TopDocs;
+import org.apache.lucene.search.TopScoreDocCollector;
+import org.apache.lucene.search.similarities.Similarity;
+import org.apache.lucene.search.suggest.InputIterator;
+import org.apache.lucene.search.suggest.Lookup;
+import org.apache.lucene.store.DataInput;
+import org.apache.lucene.store.DataOutput;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.util.Accountable;
+import org.apache.lucene.util.Accountables;
+import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.util.RamUsageEstimator;
+import org.apache.solr.spelling.suggest.LocalSuggesterOptions;
+import org.apache.solr.spelling.suggest.fst.AutocompleteLookupFactory;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static org.apache.solr.spelling.suggest.fst.AutocompleteLookupFactory.FIELD_CONTEXT;
+import static org.apache.solr.spelling.suggest.fst.AutocompleteLookupFactory.FIELD_TEXT;
+
+/**
+ * Analyzes the input text and then suggests matches based
+ * on prefix matches to any tokens in the indexed text.
+ * This also highlights the tokens that match.
+ *
+ * This suggester supports payloads. Matches are sorted only
+ * by the suggest weight; it would be nice to support
+ * blended score + weight sort in the future. This means
+ * this suggester best applies when there is a strong
+ * a-priori ranking of all the suggestions.
+ *
+ *
This suggester supports contexts, including arbitrary binary
+ * terms.
+ */
+
+public class AutocompleteSuggester extends Lookup implements Closeable {
+
+
+ protected final Analyzer queryAnalyzer = new NormalAnalyzer();
+
+ private final Directory dir;
+
+ private final boolean allTermsRequired;
+ private final boolean highlight;
+
+ private final Map fields;
+ private final float coeff;
+ private final Integer nbWordsForPositionMatch;
+ private final boolean onlyFirstContext;
+
+ public SearcherManager searcherMgr;
+ protected final Object searcherMgrLock = new Object();
+
+ private Similarity similarity;
+
+ private long docCount;
+
+ /**
+ * Create a new instance, loading from a previously built
+ * AnalyzingInfixSuggester directory, if it exists. This directory must be
+ * private to the infix suggester (i.e., not an external
+ * Lucene index). Note that {@link #close}
+ * will also close the provided directory.
+ *
+ * @param minPrefixChars Minimum number of leading characters
+ * before PrefixQuery is used (default 4).
+ * Prefixes shorter than this are indexed as character
+ * ngrams (increasing index size but making lookups
+ * faster).
+ * @param allTermsRequired All terms in the suggest query must be matched.
+ * @param highlight Highlight suggest query in suggestions.
+ */
+ public AutocompleteSuggester(Directory dir, int minPrefixChars,
+ boolean allTermsRequired, boolean highlight, Map fields,
+ float coeff, Integer nbWordsForPositionMatch, Similarity similarity, boolean onlyFirstContext) throws IOException {
+
+ if (minPrefixChars < 0) {
+ throw new IllegalArgumentException("minPrefixChars must be >= 0; got: " + minPrefixChars);
+ }
+
+ this.dir = dir;
+ this.allTermsRequired = allTermsRequired;
+ this.highlight = highlight;
+ this.fields = fields;
+ this.coeff = coeff;
+ this.nbWordsForPositionMatch = nbWordsForPositionMatch;
+ this.similarity = similarity;
+ this.onlyFirstContext = onlyFirstContext;
+
+ if (DirectoryReader.indexExists(dir)) {
+ searcherMgr = new SearcherManager(dir, null);
+ }
+ }
+
+ @Override
+ public void build(InputIterator iter) throws IOException {
+ // Nothing to do
+ }
+
+ private void ensureOpen() throws IOException {
+ synchronized (searcherMgrLock) {
+ if (DirectoryReader.indexExists(dir)) {
+ SearcherManager oldSearcherMgr = searcherMgr;
+ searcherMgr = new SearcherManager(dir, null);
+ if (oldSearcherMgr != null) {
+ oldSearcherMgr.close();
+ }
+ }
+ }
+ }
+
+
+ @Override
+ public List lookup(CharSequence key, Set contexts, boolean onlyMorePopular, int num) throws IOException {
+ return lookup2(key, num, allTermsRequired, highlight);
+ }
+
+ /**
+ * Lookup, with context but without booleans. Context booleans default to SHOULD,
+ * so each suggestion must have at least one of the contexts.
+ */
+ public List lookup2(CharSequence key, int num, boolean allTermsRequired, boolean doHighlight) throws IOException {
+ return lookup(null, key, num, allTermsRequired, doHighlight, this.onlyFirstContext);
+ }
+
+ public List lookup(LocalSuggesterOptions options, boolean b) throws IOException {
+ return lookup(options.getSearcher(), options.getToken(), options.getCount(), allTermsRequired, options.isHighlight(), options.isFirstContextOnly());
+ }
+
+ /**
+ * This is an advanced method providing the capability to send down to the suggester any
+ * arbitrary lucene query to be used to filter the result of the suggester
+ */
+ public List lookup(IndexSearcher searcher, CharSequence key, int num, boolean allTermsRequired, boolean doHighlight, boolean firstContextOnly) throws IOException {
+
+ SearcherManager mgr = null;
+ if (searcher == null) {
+ ensureOpen();
+
+ synchronized (searcherMgrLock) {
+ mgr = searcherMgr; // acquire & release on same SearcherManager, via local reference
+ searcher = mgr.acquire();
+ }
+ }
+
+ QueryInfos queryInfos = QueryInfos.parse(key, queryAnalyzer);
+
+ final Occur occur;
+ if (allTermsRequired) {
+ occur = Occur.MUST;
+ } else {
+ occur = Occur.SHOULD;
+ }
+
+ if (similarity != null) {
+ searcher.setSimilarity(similarity);
+ }
+ TopScoreDocCollector c = TopScoreDocCollector.create(num, 1);
+
+ if (docCount == 0) {
+ docCount = searcher.collectionStatistics("id").docCount() / 1000;
+ }
+
+ try {
+ AutocompleteQueryBuilder builder = new AutocompleteQueryBuilder(nbWordsForPositionMatch, fields, coeff, docCount);
+ Query q = builder.getQuery(queryInfos, occur);
+ searcher.search(q, c);
+ TopDocs hits = c.topDocs();
+
+ return createResults(searcher, hits, doHighlight, queryInfos.getMatchedTokens(), queryInfos.getPrefixToken(), firstContextOnly);
+ } finally {
+ if (mgr != null) {
+ mgr.release(searcher);
+ }
+ }
+ }
+
+ /**
+ * Create the results based on the search hits.
+ * Can be overridden by subclass to add particular behavior (e.g. weight transformation).
+ * Note that there is no prefix token (the {@code prefixToken} argument will
+ * be null) whenever the final token in the incoming request was in fact finished
+ * (had trailing characters, such as white-space).
+ *
+ * @throws IOException If there are problems reading fields from the underlying Lucene index.
+ */
+
+ protected List createResults(IndexSearcher searcher, TopDocs hits,
+ boolean doHighlight, Set matchedTokens, String prefixToken,
+ boolean firstContextOnly)
+ throws IOException {
+
+ List results = new ArrayList<>();
+ ScoreDoc fd;
+ BytesRef text;
+ BytesRef contexts = null;
+
+ List leaves = searcher.getIndexReader().leaves();
+ LeafReaderContext readerContext = null;
+ int segment = -1;
+
+ for (int i = 0; i < hits.scoreDocs.length; i++) {
+ fd = hits.scoreDocs[i];
+
+ int seq = ReaderUtil.subIndex(fd.doc, leaves);
+ if (seq != segment) {
+ segment = seq;
+ readerContext = leaves.get(segment);
+ }
+
+ text = getText(readerContext, fd.doc, fields.get(FIELD_TEXT));
+
+ if (!firstContextOnly || i == 0) {
+ contexts = getText(readerContext, fd.doc, fields.get(FIELD_CONTEXT));
+ }
+
+ float sc = hits.scoreDocs[i].score;
+ long score = (long) (sc * 1000000);
+
+ LookupResult result;
+ String t = text.utf8ToString();
+ if (doHighlight) {
+ result = new LookupResult(t, highlight(t, matchedTokens, prefixToken), score, null, contexts == null ? null : Set.of(contexts));
+ } else {
+ result = new LookupResult(t, score, null, contexts == null ? null : Set.of(contexts));
+ }
+ results.add(result);
+ }
+
+ return results;
+ }
+
+ BytesRef getText(LeafReaderContext readerContext, int docId, String fieldName) throws IOException {
+ if (fields.get(FIELD_TEXT) != null) {
+ BinaryDocValues textDV = readerContext.reader().getSortedDocValues(fieldName);
+ if (textDV != null) {
+ textDV.advance(docId - readerContext.docBase);
+ return textDV.binaryValue();
+ }
+ }
+ return null;
+ }
+
+
+ /**
+ * Override this method to customize the Object
+ * representing a single highlighted suggestions; the
+ * result is set on each {@link
+ * LookupResult#highlightKey} member.
+ */
+ protected Object highlight(String text, Set matchedTokens, String prefixToken) throws IOException {
+ try (TokenStream ts = queryAnalyzer.tokenStream("text", new StringReader(text))) {
+ CharTermAttribute termAtt = ts.addAttribute(CharTermAttribute.class);
+ OffsetAttribute offsetAtt = ts.addAttribute(OffsetAttribute.class);
+ ts.reset();
+ StringBuilder sb = new StringBuilder();
+ int upto = 0;
+ while (ts.incrementToken()) {
+ String token = termAtt.toString();
+ int startOffset = offsetAtt.startOffset();
+ int endOffset = offsetAtt.endOffset();
+ if (upto < startOffset) {
+ addNonMatch(sb, text.substring(upto, startOffset));
+ upto = startOffset;
+ } else if (upto > startOffset) {
+ continue;
+ }
+
+ if (matchedTokens.contains(token)) {
+ // Token matches.
+ addWholeMatch(sb, text.substring(startOffset, endOffset), token);
+ upto = endOffset;
+ } else if (prefixToken != null && token.startsWith(prefixToken)) {
+ addPrefixMatch(sb, text.substring(startOffset, endOffset), token, prefixToken);
+ upto = endOffset;
+ }
+ }
+ ts.end();
+ int endOffset = offsetAtt.endOffset();
+ if (upto < endOffset) {
+ addNonMatch(sb, text.substring(upto));
+ }
+ return sb.toString();
+ }
+ }
+
+ /**
+ * Called while highlighting a single result, to append a
+ * non-matching chunk of text from the suggestion to the
+ * provided fragments list.
+ *
+ * @param sb The {@code StringBuilder} to append to
+ * @param text The text chunk to add
+ */
+ protected void addNonMatch(StringBuilder sb, String text) {
+ sb.append(text);
+ }
+
+ /**
+ * Called while highlighting a single result, to append
+ * the whole matched token to the provided fragments list.
+ *
+ * @param sb The {@code StringBuilder} to append to
+ * @param surface The surface form (original) text
+ * @param analyzed The analyzed token corresponding to the surface form text
+ */
+ protected void addWholeMatch(StringBuilder sb, String surface, String analyzed) {
+ sb.append("[");
+ sb.append(surface);
+ sb.append("]");
+ }
+
+ /**
+ * Called while highlighting a single result, to append a
+ * matched prefix token, to the provided fragments list.
+ *
+ * @param sb The {@code StringBuilder} to append to
+ * @param surface The fragment of the surface form
+ * (indexed during {@link #build}, corresponding to
+ * this match
+ * @param analyzed The analyzed token that matched
+ * @param prefixToken The prefix of the token that matched
+ */
+ protected void addPrefixMatch(StringBuilder sb, String surface, String analyzed, String prefixToken) {
+ // TODO: apps can try to invert their analysis logic
+ // here, e.g. downcase the two before checking prefix:
+ if (prefixToken.length() >= surface.length()) {
+ addWholeMatch(sb, surface, analyzed);
+ return;
+ }
+ sb.append("[");
+ sb.append(surface.substring(0, prefixToken.length()));
+ sb.append("]");
+ sb.append(surface.substring(prefixToken.length()));
+ }
+
+ @Override
+ public boolean store(DataOutput in) throws IOException {
+ return false;
+ }
+
+ @Override
+ public boolean load(DataInput out) throws IOException {
+ return false;
+ }
+
+ @Override
+ public void close() throws IOException {
+ if (searcherMgr != null) {
+ searcherMgr.close();
+ searcherMgr = null;
+ }
+ if (dir != null) {
+ dir.close();
+ }
+ }
+
+ @Override
+ public long ramBytesUsed() {
+ long mem = RamUsageEstimator.shallowSizeOf(this);
+ try {
+ if (searcherMgr != null) {
+ SearcherManager mgr;
+ IndexSearcher searcher;
+ synchronized (searcherMgrLock) {
+ mgr = searcherMgr; // acquire & release on same SearcherManager, via local reference
+ searcher = mgr.acquire();
+ }
+ try {
+ for (LeafReaderContext context : searcher.getIndexReader().leaves()) {
+ LeafReader reader = FilterLeafReader.unwrap(context.reader());
+ if (reader instanceof SegmentReader) {
+ mem += ((SegmentReader) context.reader()).ramBytesUsed();
+ }
+ }
+ } finally {
+ mgr.release(searcher);
+ }
+ }
+ return mem;
+ } catch (IOException ioe) {
+ throw new AutocompleteLookupFactory.AutocompleteRuntimeException(ioe);
+ }
+ }
+
+ @Override
+ public Collection getChildResources() {
+ List resources = new ArrayList<>();
+ try {
+ if (searcherMgr != null) {
+ SearcherManager mgr;
+ IndexSearcher searcher;
+ synchronized (searcherMgrLock) {
+ mgr = searcherMgr; // acquire & release on same SearcherManager, via local reference
+ searcher = mgr.acquire();
+ }
+ try {
+ for (LeafReaderContext context : searcher.getIndexReader().leaves()) {
+ LeafReader reader = FilterLeafReader.unwrap(context.reader());
+ if (reader instanceof SegmentReader) {
+ resources.add(Accountables.namedAccountable("segment", (SegmentReader) reader));
+ }
+ }
+ } finally {
+ mgr.release(searcher);
+ }
+ }
+ return Collections.unmodifiableList(resources);
+ } catch (IOException ioe) {
+ throw new AutocompleteLookupFactory.AutocompleteRuntimeException(ioe);
+ }
+ }
+
+ @Override
+ public long getCount() throws IOException {
+ if (searcherMgr == null) {
+ return 0;
+ }
+ SearcherManager mgr;
+ IndexSearcher searcher;
+ synchronized (searcherMgrLock) {
+ mgr = searcherMgr; // acquire & release on same SearcherManager, via local reference
+ searcher = mgr.acquire();
+ }
+ try {
+ return searcher.getIndexReader().numDocs();
+ } finally {
+ mgr.release(searcher);
+ }
+ }
+
+
+}
diff --git a/src/main/java/org/apache/solr/suggest/analyzing/QueryInfos.java b/src/main/java/org/apache/solr/suggest/analyzing/QueryInfos.java
new file mode 100644
index 0000000..3f92293
--- /dev/null
+++ b/src/main/java/org/apache/solr/suggest/analyzing/QueryInfos.java
@@ -0,0 +1,138 @@
+package org.apache.solr.suggest.analyzing;
+
+import org.apache.lucene.analysis.Analyzer;
+import org.apache.lucene.analysis.TokenStream;
+import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
+import org.apache.lucene.analysis.tokenattributes.OffsetAttribute;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.lang.invoke.MethodHandles;
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+
+public class QueryInfos {
+
+ private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
+
+ public String prefixToken;
+ public Set matchedTokens = new LinkedHashSet<>();
+ public List matchedTokensConcat = new ArrayList<>();
+
+ public int nbLetters;
+ public int nbWords;
+ public boolean lastWordFinished;
+
+ private QueryInfos() {
+ }
+
+ public static QueryInfos parse(CharSequence text, Analyzer analyzer) {
+ QueryInfos queryInfos = new QueryInfos();
+
+ queryInfos.setLastWordFinished(text.charAt(text.length() - 1) == ' ');
+
+ try (TokenStream ts = analyzer.tokenStream("", new StringReader(text.toString()))) {
+ ts.reset();
+
+ final CharTermAttribute termAtt = ts.addAttribute(CharTermAttribute.class);
+ final OffsetAttribute offsetAtt = ts.addAttribute(OffsetAttribute.class);
+
+ String lastToken = null;
+ int maxEndOffset = -1;
+ while (ts.incrementToken()) {
+ if (lastToken != null) {
+ queryInfos.addMatchedTokens(lastToken);
+ queryInfos.addNbLetters(lastToken.length());
+ queryInfos.addOneWord();
+ }
+ lastToken = termAtt.toString();
+ if (lastToken != null) {
+ maxEndOffset = Math.max(maxEndOffset, offsetAtt.endOffset());
+ }
+ }
+ ts.end();
+
+ if (lastToken != null) {
+ if (maxEndOffset == offsetAtt.endOffset()) {
+ queryInfos.setPrefixToken(lastToken);
+ } else {
+ queryInfos.addMatchedTokens(lastToken);
+ }
+ queryInfos.addNbLetters(lastToken.length());
+ queryInfos.addOneWord();
+ }
+ } catch (NullPointerException | IOException e) {
+ log.warn("failed to parse : {} ", text);
+ }
+
+ buildConcat(queryInfos);
+
+ return queryInfos;
+ }
+
+ private static void buildConcat(QueryInfos queryInfos) {
+ String lastWord = null;
+ for (String w : queryInfos.getMatchedTokens()) {
+ if(lastWord != null) {
+ queryInfos.addMatchedTokensConcat(lastWord+ w);
+ }
+ lastWord = w;
+ }
+
+ if(queryInfos.getPrefixToken() != null && queryInfos.getPrefixToken().trim().length() > 0) {
+ queryInfos.addMatchedTokensConcat(lastWord+ queryInfos.getPrefixToken());
+ }
+ }
+
+ public String getPrefixToken() {
+ return prefixToken;
+ }
+
+ public void setPrefixToken(String prefixToken) {
+ this.prefixToken = prefixToken;
+ }
+
+ public Set getMatchedTokens() {
+ return matchedTokens;
+ }
+
+ public void addMatchedTokens(String matchedToken) {
+ this.matchedTokens.add(matchedToken);
+ }
+
+ public List getMatchedTokensConcat() {
+ return matchedTokensConcat;
+ }
+
+ public void addMatchedTokensConcat(String m) {
+ this.matchedTokensConcat.add(m);
+ }
+
+ public int getNbLetters() {
+ return nbLetters;
+ }
+
+ public void addNbLetters(int nbLetter) {
+ this.nbLetters += nbLetter;
+ }
+
+ public int getNbWords() {
+ return nbWords;
+ }
+
+ public void addOneWord() {
+ this.nbWords += 1;
+ }
+
+ public boolean isLastWordFinished() {
+ return lastWordFinished;
+ }
+
+ public void setLastWordFinished(boolean lastWordFinished) {
+ this.lastWordFinished = lastWordFinished;
+ }
+}
diff --git a/src/main/java/org/apache/solr/update/processor/WordConcatFieldUpdateProcessorFactory.java b/src/main/java/org/apache/solr/update/processor/WordConcatFieldUpdateProcessorFactory.java
new file mode 100644
index 0000000..048b0df
--- /dev/null
+++ b/src/main/java/org/apache/solr/update/processor/WordConcatFieldUpdateProcessorFactory.java
@@ -0,0 +1,56 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.solr.update.processor;
+
+import org.apache.lucene.analysis.CustomAnalyzer;
+import org.apache.lucene.analysis.WordsParser;
+import org.apache.solr.core.SolrCore;
+import org.apache.solr.request.SolrQueryRequest;
+import org.apache.solr.response.SolrQueryResponse;
+
+import static org.apache.solr.update.processor.FieldValueMutatingUpdateProcessor.valueMutator;
+
+/**
+ *
+ */
+public final class WordConcatFieldUpdateProcessorFactory extends FieldMutatingUpdateProcessorFactory {
+
+ @Override
+ public FieldMutatingUpdateProcessor.FieldNameSelector
+ getDefaultSelector(final SolrCore core) {
+ return FieldMutatingUpdateProcessor.SELECT_ALL_FIELDS;
+ }
+
+ @Override
+ public UpdateRequestProcessor getInstance(SolrQueryRequest req,
+ SolrQueryResponse rsp,
+ UpdateRequestProcessor next) {
+ return valueMutator(getSelector(), next, src -> {
+ if (src instanceof CharSequence) {
+ CharSequence s = (CharSequence) src;
+ return WordsParser.recomposeText(
+ WordsParser.concatWords(
+ WordsParser.decomposeText(new CustomAnalyzer(), "", s.toString()),
+ 2, true, true),
+ " ", true);
+ }
+
+ return src;
+ });
+ }
+}
+
diff --git a/src/test/java/org/apache/lucene/analysis/CDelimitedPayloadTokenFilterFactoryTest.java b/src/test/java/org/apache/lucene/analysis/CDelimitedPayloadTokenFilterFactoryTest.java
new file mode 100644
index 0000000..e4f3262
--- /dev/null
+++ b/src/test/java/org/apache/lucene/analysis/CDelimitedPayloadTokenFilterFactoryTest.java
@@ -0,0 +1,91 @@
+package org.apache.lucene.analysis;
+
+import org.apache.lucene.analysis.payloads.FloatEncoder;
+import org.apache.lucene.analysis.payloads.IdentityEncoder;
+import org.apache.lucene.analysis.payloads.IntegerEncoder;
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+public class CDelimitedPayloadTokenFilterFactoryTest {
+
+ @Test
+ public void testEncoder() {
+ Map args = new HashMap<>();
+ args.put(CDelimitedPayloadTokenFilterFactory.DELIMITER_ATTR, "?");
+
+ CDelimitedPayloadTokenFilterFactory factory = new CDelimitedPayloadTokenFilterFactory(args);
+
+ boolean foundError = false;
+ try {
+ factory.inform(null);
+ } catch (IllegalArgumentException e) {
+ foundError = true;
+ }
+ assertTrue(foundError);
+
+ // Float
+ args.put(CDelimitedPayloadTokenFilterFactory.ENCODER_ATTR, "float");
+ factory = new CDelimitedPayloadTokenFilterFactory(args);
+ factory.inform(null);
+
+ assertNotNull(factory.getEncoder());
+ assertTrue(factory.getEncoder() instanceof FloatEncoder);
+
+ // Integer
+ args.put(CDelimitedPayloadTokenFilterFactory.ENCODER_ATTR, "integer");
+ factory = new CDelimitedPayloadTokenFilterFactory(args);
+ factory.inform(null);
+
+ assertNotNull(factory.getEncoder());
+ assertTrue(factory.getEncoder() instanceof IntegerEncoder);
+
+ // Identity
+ args.put(CDelimitedPayloadTokenFilterFactory.ENCODER_ATTR, "identity");
+ factory = new CDelimitedPayloadTokenFilterFactory(args);
+ factory.inform(null);
+
+ assertNotNull(factory.getEncoder());
+ assertTrue(factory.getEncoder() instanceof IdentityEncoder);
+ }
+
+
+ @Test
+ public void testDelimiter() {
+ Map args = new HashMap<>();
+ args.put(CDelimitedPayloadTokenFilterFactory.DELIMITER_ATTR, null);
+ args.put(CDelimitedPayloadTokenFilterFactory.ENCODER_ATTR, "integer");
+
+ CDelimitedPayloadTokenFilterFactory factory = new CDelimitedPayloadTokenFilterFactory(args);
+
+ boolean foundNoError = true;
+ try {
+ factory.inform(null);
+ } catch (IllegalArgumentException e) {
+ foundNoError = false;
+ }
+ assertTrue(foundNoError);
+
+
+ // bad delimiter
+ args.put(CDelimitedPayloadTokenFilterFactory.DELIMITER_ATTR, "xx");
+ args.put(CDelimitedPayloadTokenFilterFactory.ENCODER_ATTR, "integer");
+
+
+ boolean foundError = false;
+ try {
+ factory = new CDelimitedPayloadTokenFilterFactory(args);
+ // factory.inform(null);
+ } catch (IllegalArgumentException e) {
+ foundError = true;
+ }
+ assertTrue(foundError);
+
+
+
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/org/apache/lucene/analysis/NgramAnalyzerTest.java b/src/test/java/org/apache/lucene/analysis/NgramAnalyzerTest.java
new file mode 100644
index 0000000..8ac88f0
--- /dev/null
+++ b/src/test/java/org/apache/lucene/analysis/NgramAnalyzerTest.java
@@ -0,0 +1,36 @@
+package org.apache.lucene.analysis;
+
+import org.junit.Test;
+
+import java.util.stream.Collectors;
+
+import static org.junit.Assert.assertEquals;
+
+public class NgramAnalyzerTest {
+
+ @Test
+ public void test1() {
+ Analyzer analyzer = new NgramPositionAnalyzer();
+ WordsParser.Data data = WordsParser.parse("Ceci est un test.. !", analyzer);
+
+ assertEquals("c|ce|cec|ceci|e|ec|eci|c|ci|i|e|es|est|s|st|t|u|un|n|t|te|tes|test|e|es|est|s|st|t", String.join("|", data.words));
+ assertEquals("1|0|0|0|0|0|0|0|0|0|1|0|0|0|0|0|1|0|0|1|0|0|0|0|0|0|0|0|0",
+ data.positions.stream().map(x -> "" + x).collect(Collectors.joining("|")));
+
+ assertEquals("1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|2.0|2.0|2.0|2.0|2.0|2.0|3.0|3.0|3.0|4.0|4.0|4.0|4.0|4.0|4.0|4.0|4.0|4.0|4.0",
+ data.payloads.stream().map(x -> "" + x).collect(Collectors.joining("|")));
+ }
+
+ @Test
+ public void test2() {
+ Analyzer analyzer = new NgramPositionAnalyzer();
+ WordsParser.Data data = WordsParser.parse("thermomix", analyzer);
+
+ assertEquals("t|th|the|ther|therm|thermo|thermom|thermomi|thermomix|h|he|her|herm|hermo|hermom|hermomi|hermomix|e|er|erm|ermo|ermom|ermomi|ermomix|r|rm|rmo|rmom|rmomi|rmomix|m|mo|mom|momi|momix|o|om|omi|omix|m|mi|mix|i|ix|x", String.join("|", data.words));
+ assertEquals("1|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0",
+ data.positions.stream().map(x -> "" + x).collect(Collectors.joining("|")));
+
+ assertEquals("1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0|1.0",
+ data.payloads.stream().map(x -> "" + x).collect(Collectors.joining("|")));
+ }
+}
diff --git a/src/test/java/org/apache/lucene/analysis/NormalAnalyzerTest.java b/src/test/java/org/apache/lucene/analysis/NormalAnalyzerTest.java
new file mode 100644
index 0000000..0366f00
--- /dev/null
+++ b/src/test/java/org/apache/lucene/analysis/NormalAnalyzerTest.java
@@ -0,0 +1,36 @@
+package org.apache.lucene.analysis;
+
+import org.junit.Test;
+
+import java.util.stream.Collectors;
+
+import static org.junit.Assert.assertEquals;
+
+public class NormalAnalyzerTest {
+
+ @Test
+ public void test1() {
+ Analyzer analyzer = new NormalAnalyzer();
+ WordsParser.Data data = WordsParser.parse("Ceci est un test.. !", analyzer);
+
+ assertEquals("ceci|est|un|test", String.join("|", data.words));
+ assertEquals("1|1|1|1",
+ data.positions.stream().map(x -> "" + x).collect(Collectors.joining("|")));
+
+ assertEquals("",
+ data.payloads.stream().map(x -> "" + x).collect(Collectors.joining("|")));
+ }
+
+ @Test
+ public void test2() {
+ Analyzer analyzer = new PositionAnalyzer();
+ WordsParser.Data data = WordsParser.parse("Ceci est un test.. !", analyzer);
+
+ assertEquals("ceci|est|un|test", String.join("|", data.words));
+ assertEquals("1|1|1|1",
+ data.positions.stream().map(x -> "" + x).collect(Collectors.joining("|")));
+
+ assertEquals("1.0|2.0|3.0|4.0",
+ data.payloads.stream().map(x -> "" + x).collect(Collectors.joining("|")));
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/org/apache/lucene/analysis/TestPositionspanQuery.java b/src/test/java/org/apache/lucene/analysis/TestPositionspanQuery.java
new file mode 100644
index 0000000..8cc6ca9
--- /dev/null
+++ b/src/test/java/org/apache/lucene/analysis/TestPositionspanQuery.java
@@ -0,0 +1,273 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.lucene.analysis;
+
+import org.apache.lucene.analysis.tokenattributes.PayloadAttribute;
+import org.apache.lucene.document.Document;
+import org.apache.lucene.document.Field;
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.index.RandomIndexWriter;
+import org.apache.lucene.index.Term;
+import org.apache.lucene.query.PositionSpanQuery;
+import org.apache.lucene.search.BooleanClause;
+import org.apache.lucene.search.BooleanQuery;
+import org.apache.lucene.search.CheckHits;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.QueryUtils;
+import org.apache.lucene.search.ScoreDoc;
+import org.apache.lucene.search.ScoreMode;
+import org.apache.lucene.search.TopDocs;
+import org.apache.lucene.search.similarities.ClassicSimilarity;
+import org.apache.lucene.search.similarities.Similarity;
+import org.apache.lucene.search.spans.SpanQuery;
+import org.apache.lucene.search.spans.SpanTermQuery;
+import org.apache.lucene.search.spans.SpanWeight;
+import org.apache.lucene.search.spans.Spans;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.util.English;
+import org.apache.lucene.util.LuceneTestCase;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+
+import java.io.IOException;
+
+
+/**
+ *
+ **/
+public class TestPositionspanQuery extends LuceneTestCase {
+ private static IndexSearcher searcher;
+ private static IndexReader reader;
+ private static Similarity similarity = new BoostingSimilarity();
+ private static final byte[] payloadField = new byte[]{1};
+ private static final byte[] payloadMultiField1 = new byte[]{2};
+ private static final byte[] payloadMultiField2 = new byte[]{4};
+ protected static Directory directory;
+
+ public static final String NO_PAYLOAD_FIELD = "noPayloadField";
+ public static final String MULTI_FIELD = "multiField";
+ public static final String FIELD = "field";
+
+ public static final float[] FIRST_COEFF = {3f, 2f, 1f};
+ public static final float[] SECOND_COEFF = {2f, 1.5f, 1f, 0.5f};
+ public static final float[] THIRD_COEFF = {1f, 0.5f, 0.4f, 0.3f};
+ public static final float[] DEFAULT_COEFF = {0.5f, 0.4f, 0.3f};
+ public static final float MIN_FIRST_COEFF = 0.2f;
+ public static final float[][] ALL_COEFF = {FIRST_COEFF, SECOND_COEFF, THIRD_COEFF};
+
+
+ private static class PayloadAnalyzer extends Analyzer {
+
+ private PayloadAnalyzer() {
+ super(PER_FIELD_REUSE_STRATEGY);
+ }
+
+ @Override
+ public TokenStreamComponents createComponents(String fieldName) {
+ Tokenizer result = new MockTokenizer(MockTokenizer.SIMPLE, true);
+ return new TokenStreamComponents(result, new PayloadFilter(result, fieldName));
+ }
+ }
+
+ private static class PayloadFilter extends TokenFilter {
+ private final String fieldName;
+ private int numSeen = 0;
+
+ private final PayloadAttribute payloadAtt;
+
+ public PayloadFilter(TokenStream input, String fieldName) {
+ super(input);
+ this.fieldName = fieldName;
+ payloadAtt = addAttribute(PayloadAttribute.class);
+ }
+
+ @Override
+ public boolean incrementToken() throws IOException {
+ boolean hasNext = input.incrementToken();
+ if (hasNext) {
+ if (fieldName.equals("field")) {
+ payloadAtt.setPayload(new BytesRef(payloadField));
+ } else if (fieldName.equals("multiField")) {
+ if (numSeen % 2 == 0) {
+ payloadAtt.setPayload(new BytesRef(payloadMultiField1));
+ } else {
+ payloadAtt.setPayload(new BytesRef(payloadMultiField2));
+ }
+ numSeen++;
+ }
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ @Override
+ public void reset() throws IOException {
+ super.reset();
+ this.numSeen = 0;
+ }
+ }
+
+ @BeforeClass
+ public static void beforeClass() throws Exception {
+ directory = newDirectory();
+ RandomIndexWriter writer = new RandomIndexWriter(random(), directory,
+ newIndexWriterConfig(new PayloadAnalyzer())
+ .setSimilarity(similarity).setMergePolicy(newLogMergePolicy()));
+ //writer.infoStream = System.out;
+ for (int i = 0; i < 1000; i++) {
+ Document doc = new Document();
+ Field noPayloadField = newTextField(NO_PAYLOAD_FIELD, English.intToEnglish(i), Field.Store.YES);
+ //noPayloadField.setBoost(0);
+ doc.add(noPayloadField);
+ doc.add(newTextField("field", English.intToEnglish(i), Field.Store.YES));
+ doc.add(newTextField("multiField", English.intToEnglish(i) + " " + English.intToEnglish(i), Field.Store.YES));
+ writer.addDocument(doc);
+ }
+ writer.forceMerge(1);
+ reader = writer.getReader();
+ writer.close();
+
+ searcher = newSearcher(getOnlyLeafReader(reader));
+ searcher.setSimilarity(similarity);
+ }
+
+ @AfterClass
+ public static void afterClass() throws Exception {
+ searcher = null;
+ reader.close();
+ reader = null;
+ directory.close();
+ directory = null;
+ }
+
+ public void test() throws IOException {
+ SpanQuery query = new PositionSpanQuery(new SpanTermQuery(new Term("field", "seventy")),
+ 0, true,
+ ALL_COEFF, DEFAULT_COEFF, MIN_FIRST_COEFF, 1f);
+
+ TopDocs hits = searcher.search(query, 100);
+ assertNotNull("hits is null and it shouldn't be", hits);
+ assertEquals("hits Size: " + hits.totalHits.value + " is not: " + 100, 100, hits.totalHits.value);
+
+ //they should all have the exact same score, because they all contain seventy once, and we set
+ //all the other similarity factors to be 1
+
+ for (int i = 0; i < hits.scoreDocs.length; i++) {
+ ScoreDoc doc = hits.scoreDocs[i];
+ assertEquals(0.2f, doc.score, 0f);
+ }
+
+ }
+
+ public void testQuery() {
+ SpanQuery boostingFuncTermQuery = new PositionSpanQuery(new SpanTermQuery(new Term(MULTI_FIELD, "seventy")),
+ 0, true,
+ ALL_COEFF, DEFAULT_COEFF, MIN_FIRST_COEFF, 1f);
+ QueryUtils.check(boostingFuncTermQuery);
+
+ SpanTermQuery spanTermQuery = new SpanTermQuery(new Term(MULTI_FIELD, "seventy"));
+
+ assertEquals(boostingFuncTermQuery.equals(spanTermQuery), spanTermQuery.equals(boostingFuncTermQuery));
+
+ }
+
+ public void testMultipleMatchesPerDoc() throws Exception {
+ SpanQuery query = new PositionSpanQuery(new SpanTermQuery(new Term(MULTI_FIELD, "seventy")),
+ 0, true,
+ ALL_COEFF, DEFAULT_COEFF, MIN_FIRST_COEFF, 1f);
+ TopDocs hits = searcher.search(query, 100);
+ assertNotNull("hits is null and it shouldn't be", hits);
+ assertEquals("hits Size: " + hits.totalHits.value + " is not: " + 100, 100, hits.totalHits.value);
+
+ //they should all have the exact same score, because they all contain seventy once, and we set
+ //all the other similarity factors to be 1
+
+ //System.out.println("Hash: " + seventyHash + " Twice Hash: " + 2*seventyHash);
+ //there should be exactly 10 items that score a 4, all the rest should score a 2
+ //The 10 items are: 70 + i*100 where i in [0-9]
+ for (int i = 0; i < hits.scoreDocs.length; i++) {
+ ScoreDoc doc = hits.scoreDocs[i];
+ assertEquals(doc.score + " does not equal: " + 0.2, 0.2, doc.score, 0.0001);
+ }
+ // CheckHits.checkExplanations(query, "field", searcher, true);
+ Spans spans = query.createWeight(searcher, ScoreMode.COMPLETE_NO_SCORES, 1f).getSpans(searcher.getIndexReader().leaves().get(0), SpanWeight.Postings.POSITIONS);
+ assertNotNull("spans is null and it shouldn't be", spans);
+ //should be two matches per document
+ int count = 0;
+ //100 hits times 2 matches per hit, we should have 200 in count
+ while (spans.nextDoc() != Spans.NO_MORE_DOCS) {
+ while (spans.nextStartPosition() != Spans.NO_MORE_POSITIONS) {
+ count++;
+ }
+ }
+ assertEquals(count + " does not equal: " + 200, 200, count);
+ }
+
+ public void testNoMatch() throws Exception {
+ SpanQuery query = new PositionSpanQuery(new SpanTermQuery(new Term(FIELD, "junk")),
+ 0, true,
+ ALL_COEFF, DEFAULT_COEFF, MIN_FIRST_COEFF, 1f);
+ TopDocs hits = searcher.search(query, 100);
+ assertNotNull("hits is null and it shouldn't be", hits);
+ assertEquals("hits Size: " + hits.totalHits.value + " is not: " + 0, 0, hits.totalHits.value);
+
+ }
+
+ public void testNoPayload() throws Exception {
+ SpanQuery q1 = new PositionSpanQuery(new SpanTermQuery(new Term(NO_PAYLOAD_FIELD, "zero")),
+ 0, true,
+ ALL_COEFF, DEFAULT_COEFF, MIN_FIRST_COEFF, 1f);
+ SpanQuery q2 = new PositionSpanQuery(new SpanTermQuery(new Term(NO_PAYLOAD_FIELD, "foo")),
+ 0, true,
+ ALL_COEFF, DEFAULT_COEFF, MIN_FIRST_COEFF, 1f);
+ BooleanClause c1 = new BooleanClause(q1, BooleanClause.Occur.MUST);
+ BooleanClause c2 = new BooleanClause(q2, BooleanClause.Occur.MUST_NOT);
+ BooleanQuery.Builder query = new BooleanQuery.Builder();
+ query.add(c1);
+ query.add(c2);
+ TopDocs hits = searcher.search(query.build(), 100);
+ assertNotNull("hits is null and it shouldn't be", hits);
+ assertEquals("hits Size: " + hits.totalHits.value + " is not: " + 1, 1, hits.totalHits.value);
+ int[] results = new int[1];
+ results[0] = 0;//hits.scoreDocs[0].doc;
+ CheckHits.checkHitCollector(random(), query.build(), NO_PAYLOAD_FIELD, searcher, results);
+ }
+
+ static class BoostingSimilarity extends ClassicSimilarity {
+
+ //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ //Make everything else 1 so we see the effect of the payload
+ //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ @Override
+ public float lengthNorm(int length) {
+ return 1;
+ }
+
+ @Override
+ public float idf(long docFreq, long docCount) {
+ return 1;
+ }
+
+ @Override
+ public float tf(float freq) {
+ return freq == 0 ? 0 : 1;
+ }
+ }
+
+}
diff --git a/src/test/java/org/apache/lucene/queries/payloads/TestPayloadCheckQuery.java b/src/test/java/org/apache/lucene/queries/payloads/TestPayloadCheckQuery.java
new file mode 100644
index 0000000..c5c2994
--- /dev/null
+++ b/src/test/java/org/apache/lucene/queries/payloads/TestPayloadCheckQuery.java
@@ -0,0 +1,232 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.lucene.queries.payloads;
+
+import org.apache.lucene.analysis.Analyzer;
+import org.apache.lucene.analysis.MockTokenizer;
+import org.apache.lucene.analysis.SimplePayloadFilter;
+import org.apache.lucene.analysis.Tokenizer;
+import org.apache.lucene.document.Document;
+import org.apache.lucene.document.Field;
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.index.RandomIndexWriter;
+import org.apache.lucene.index.Term;
+import org.apache.lucene.search.CheckHits;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.WildcardQuery;
+import org.apache.lucene.search.spans.SpanNearQuery;
+import org.apache.lucene.search.spans.SpanPositionRangeQuery;
+import org.apache.lucene.search.spans.SpanQuery;
+import org.apache.lucene.search.spans.SpanTermQuery;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.util.English;
+import org.apache.lucene.util.LuceneTestCase;
+import org.apache.lucene.util.TestUtil;
+import org.apache.solr.search.span.BoostedSpanMultiTermQueryWrapper;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/** basic test of payload-spans */
+public class TestPayloadCheckQuery extends LuceneTestCase {
+ private static IndexSearcher searcher;
+ private static IndexReader reader;
+ private static Directory directory;
+
+ @BeforeClass
+ public static void beforeClass() throws Exception {
+ Analyzer simplePayloadAnalyzer = new Analyzer() {
+ @Override
+ public TokenStreamComponents createComponents(String fieldName) {
+ Tokenizer tokenizer = new MockTokenizer(MockTokenizer.SIMPLE, true);
+ return new TokenStreamComponents(tokenizer, new SimplePayloadFilter(tokenizer));
+ }
+ };
+
+ directory = newDirectory();
+ RandomIndexWriter writer = new RandomIndexWriter(random(), directory,
+ newIndexWriterConfig(simplePayloadAnalyzer)
+ .setMaxBufferedDocs(TestUtil.nextInt(random(), 100, 1000)).setMergePolicy(newLogMergePolicy()));
+ //writer.infoStream = System.out;
+ for (int i = 0; i < 2000; i++) {
+ Document doc = new Document();
+ doc.add(newTextField("field", English.intToEnglish(i), Field.Store.YES));
+ writer.addDocument(doc);
+ }
+ reader = writer.getReader();
+ searcher = newSearcher(reader);
+ writer.close();
+ }
+
+ @AfterClass
+ public static void afterClass() throws Exception {
+ reader.close();
+ directory.close();
+ searcher = null;
+ reader = null;
+ directory = null;
+ }
+
+ private void checkHits(Query query, int[] results) throws IOException {
+ CheckHits.checkHits(random(), query, "field", searcher, results);
+ }
+
+ public void testSpanPayloadCheck() throws Exception {
+ SpanQuery term1 = new SpanTermQuery(new Term("field", "five"));
+ BytesRef pay = new BytesRef("pos: " + 5);
+ SpanQuery query = new SpanPayloadCheckQuery(term1, Collections.singletonList(pay));
+ checkHits(query, new int[]
+ {1125, 1135, 1145, 1155, 1165, 1175, 1185, 1195, 1225, 1235, 1245, 1255, 1265, 1275, 1285, 1295, 1325, 1335, 1345, 1355, 1365, 1375, 1385, 1395, 1425, 1435, 1445, 1455, 1465, 1475, 1485, 1495, 1525, 1535, 1545, 1555, 1565, 1575, 1585, 1595, 1625, 1635, 1645, 1655, 1665, 1675, 1685, 1695, 1725, 1735, 1745, 1755, 1765, 1775, 1785, 1795, 1825, 1835, 1845, 1855, 1865, 1875, 1885, 1895, 1925, 1935, 1945, 1955, 1965, 1975, 1985, 1995});
+ assertTrue(searcher.explain(query, 1125).getValue().doubleValue() > 0.0f);
+
+ SpanTermQuery term2 = new SpanTermQuery(new Term("field", "hundred"));
+ SpanNearQuery snq;
+ SpanQuery[] clauses;
+ List list;
+ BytesRef pay2;
+ clauses = new SpanQuery[2];
+ clauses[0] = term1;
+ clauses[1] = term2;
+ snq = new SpanNearQuery(clauses, 0, true);
+ pay = new BytesRef("pos: " + 0);
+ pay2 = new BytesRef("pos: " + 1);
+ list = new ArrayList<>();
+ list.add(pay);
+ list.add(pay2);
+ query = new SpanPayloadCheckQuery(snq, list);
+ checkHits(query, new int[]
+ {500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560, 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576, 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597, 598, 599});
+ clauses = new SpanQuery[3];
+ clauses[0] = term1;
+ clauses[1] = term2;
+ clauses[2] = new SpanTermQuery(new Term("field", "five"));
+ snq = new SpanNearQuery(clauses, 0, true);
+ pay = new BytesRef("pos: " + 0);
+ pay2 = new BytesRef("pos: " + 1);
+ BytesRef pay3 = new BytesRef("pos: " + 2);
+ list = new ArrayList<>();
+ list.add(pay);
+ list.add(pay2);
+ list.add(pay3);
+ query = new SpanPayloadCheckQuery(snq, list);
+ checkHits(query, new int[]
+ {505});
+ }
+
+ public void testUnorderedPayloadChecks() throws Exception {
+
+ SpanTermQuery term5 = new SpanTermQuery(new Term("field", "five"));
+ SpanTermQuery term100 = new SpanTermQuery(new Term("field", "hundred"));
+ SpanTermQuery term4 = new SpanTermQuery(new Term("field", "four"));
+ SpanNearQuery nearQuery = new SpanNearQuery(new SpanQuery[]{term5, term100, term4}, 0, false);
+
+ List payloads = new ArrayList<>();
+ payloads.add(new BytesRef("pos: " + 2));
+ payloads.add(new BytesRef("pos: " + 1));
+ payloads.add(new BytesRef("pos: " + 0));
+
+ SpanPayloadCheckQuery payloadQuery = new SpanPayloadCheckQuery(nearQuery, payloads);
+ checkHits(payloadQuery, new int[]{ 405 });
+
+ payloads.clear();
+ payloads.add(new BytesRef("pos: " + 0));
+ payloads.add(new BytesRef("pos: " + 1));
+ payloads.add(new BytesRef("pos: " + 2));
+
+ payloadQuery = new SpanPayloadCheckQuery(nearQuery, payloads);
+ checkHits(payloadQuery, new int[]{ 504 });
+
+ }
+
+ public void testComplexSpanChecks() throws Exception {
+ SpanTermQuery one = new SpanTermQuery(new Term("field", "one"));
+ SpanTermQuery thous = new SpanTermQuery(new Term("field", "thousand"));
+ //should be one position in between
+ SpanTermQuery hundred = new SpanTermQuery(new Term("field", "hundred"));
+ SpanTermQuery three = new SpanTermQuery(new Term("field", "three"));
+
+ SpanNearQuery oneThous = new SpanNearQuery(new SpanQuery[]{one, thous}, 0, true);
+ SpanNearQuery hundredThree = new SpanNearQuery(new SpanQuery[]{hundred, three}, 0, true);
+ SpanNearQuery oneThousHunThree = new SpanNearQuery(new SpanQuery[]{oneThous, hundredThree}, 1, true);
+ SpanQuery query;
+ //this one's too small
+ query = new SpanPositionRangeQuery(oneThousHunThree, 1, 2);
+ checkHits(query, new int[]{});
+ //this one's just right
+ query = new SpanPositionRangeQuery(oneThousHunThree, 0, 6);
+ checkHits(query, new int[]{1103, 1203,1303,1403,1503,1603,1703,1803,1903});
+
+ List payloads = new ArrayList<>();
+ BytesRef pay = new BytesRef(("pos: " + 0).getBytes(StandardCharsets.UTF_8));
+ BytesRef pay2 = new BytesRef(("pos: " + 1).getBytes(StandardCharsets.UTF_8));
+ BytesRef pay3 = new BytesRef(("pos: " + 3).getBytes(StandardCharsets.UTF_8));
+ BytesRef pay4 = new BytesRef(("pos: " + 4).getBytes(StandardCharsets.UTF_8));
+ payloads.add(pay);
+ payloads.add(pay2);
+ payloads.add(pay3);
+ payloads.add(pay4);
+ query = new SpanPayloadCheckQuery(oneThousHunThree, payloads);
+ checkHits(query, new int[]{1103, 1203,1303,1403,1503,1603,1703,1803,1903});
+ }
+
+ public void testEquality() {
+ SpanQuery sq1 = new SpanTermQuery(new Term("field", "one"));
+ SpanQuery sq2 = new SpanTermQuery(new Term("field", "two"));
+ BytesRef payload1 = new BytesRef("pay1");
+ BytesRef payload2 = new BytesRef("pay2");
+ SpanQuery query1 = new SpanPayloadCheckQuery(sq1, Collections.singletonList(payload1));
+ SpanQuery query2 = new SpanPayloadCheckQuery(sq2, Collections.singletonList(payload1));
+ SpanQuery query3 = new SpanPayloadCheckQuery(sq1, Collections.singletonList(payload2));
+ SpanQuery query4 = new SpanPayloadCheckQuery(sq2, Collections.singletonList(payload2));
+ SpanQuery query5 = new SpanPayloadCheckQuery(sq1, Collections.singletonList(payload1));
+
+ assertEquals(query1, query5);
+ assertFalse(query1.equals(query2));
+ assertFalse(query1.equals(query3));
+ assertFalse(query1.equals(query4));
+ assertFalse(query2.equals(query3));
+ assertFalse(query2.equals(query4));
+ assertFalse(query3.equals(query4));
+ }
+
+ public void testRewrite() throws IOException {
+ BoostedSpanMultiTermQueryWrapper fiv = new BoostedSpanMultiTermQueryWrapper<>(new WildcardQuery(new Term("field", "fiv*")),10);
+ BoostedSpanMultiTermQueryWrapper hund = new BoostedSpanMultiTermQueryWrapper<>(new WildcardQuery(new Term("field", "hund*")),10);
+ BoostedSpanMultiTermQueryWrapper twent = new BoostedSpanMultiTermQueryWrapper<>(new WildcardQuery(new Term("field", "twent*")),10);
+ BoostedSpanMultiTermQueryWrapper nin = new BoostedSpanMultiTermQueryWrapper<>(new WildcardQuery(new Term("field", "nin*")),10);
+
+ SpanNearQuery sq = new SpanNearQuery(new SpanQuery[] {fiv, hund, twent, nin}, 0, true);
+
+ List payloads = new ArrayList<>();
+ payloads.add(new BytesRef("pos: 0"));
+ payloads.add(new BytesRef("pos: 1"));
+ payloads.add(new BytesRef("pos: 2"));
+ payloads.add(new BytesRef("pos: 3"));
+
+ SpanPayloadCheckQuery query = new SpanPayloadCheckQuery(sq, payloads);
+
+ // if query wasn't rewritten properly, the query would have failed with "Rewrite first!"
+ checkHits(query, new int[]{529});
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/org/apache/lucene/queries/payloads/TestPayloadScoreQuery.java b/src/test/java/org/apache/lucene/queries/payloads/TestPayloadScoreQuery.java
new file mode 100644
index 0000000..5be5304
--- /dev/null
+++ b/src/test/java/org/apache/lucene/queries/payloads/TestPayloadScoreQuery.java
@@ -0,0 +1,262 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.lucene.queries.payloads;
+
+import org.apache.lucene.analysis.Analyzer;
+import org.apache.lucene.analysis.MockTokenizer;
+import org.apache.lucene.analysis.TokenFilter;
+import org.apache.lucene.analysis.TokenStream;
+import org.apache.lucene.analysis.Tokenizer;
+import org.apache.lucene.analysis.tokenattributes.PayloadAttribute;
+import org.apache.lucene.document.Document;
+import org.apache.lucene.document.Field;
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.index.NoMergePolicy;
+import org.apache.lucene.index.RandomIndexWriter;
+import org.apache.lucene.index.Term;
+import org.apache.lucene.search.CollectionStatistics;
+import org.apache.lucene.search.Explanation;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.QueryUtils;
+import org.apache.lucene.search.TermStatistics;
+import org.apache.lucene.search.TopDocs;
+import org.apache.lucene.search.WildcardQuery;
+import org.apache.lucene.search.similarities.ClassicSimilarity;
+import org.apache.lucene.search.spans.BoostSpanTermQuery;
+import org.apache.lucene.search.spans.BoostedSpanOrQuery;
+import org.apache.lucene.search.spans.SpanMultiTermQueryWrapper;
+import org.apache.lucene.search.spans.SpanNearQuery;
+import org.apache.lucene.search.spans.SpanQuery;
+import org.apache.lucene.search.spans.SpanTermQuery;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.util.English;
+import org.apache.lucene.util.LuceneTestCase;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.IOException;
+
+public class TestPayloadScoreQuery extends LuceneTestCase {
+
+ private static void checkQuery(SpanQuery query, PayloadFunction function, int[] expectedDocs, float[] expectedScores) throws IOException {
+ checkQuery(query, function, true, expectedDocs, expectedScores);
+ }
+
+ private static void checkQuery(SpanQuery query, PayloadFunction function, boolean includeSpanScore, int[] expectedDocs, float[] expectedScores) throws IOException {
+
+ assertTrue("Expected docs and scores arrays must be the same length!", expectedDocs.length == expectedScores.length);
+
+ PayloadScoreQuery psq = new PayloadScoreQuery(query, function, PayloadDecoder.FLOAT_DECODER, includeSpanScore);
+ TopDocs hits = searcher.search(psq, expectedDocs.length);
+
+ for (int i = 0; i < hits.scoreDocs.length; i++) {
+ if (i > expectedDocs.length - 1)
+ fail("Unexpected hit in document " + hits.scoreDocs[i].doc);
+ if (hits.scoreDocs[i].doc != expectedDocs[i])
+ fail("Unexpected hit in document " + hits.scoreDocs[i].doc);
+ assertEquals("Bad score in document " + expectedDocs[i], expectedScores[i], hits.scoreDocs[i].score, 0.000001);
+ }
+
+ if (hits.scoreDocs.length > expectedDocs.length)
+ fail("Unexpected hit in document " + hits.scoreDocs[expectedDocs.length]);
+
+ QueryUtils.check(random(), psq, searcher);
+ }
+
+ @Test
+ public void testTermQuery() throws IOException {
+
+ SpanTermQuery q = new SpanTermQuery(new Term("field", "eighteen"));
+ for (PayloadFunction fn
+ : new PayloadFunction[]{new AveragePayloadFunction(), new MaxPayloadFunction(), new MinPayloadFunction()}) {
+ checkQuery(q, fn, new int[]{118, 218, 18},
+ new float[]{4.0f, 4.0f, 2.0f});
+ }
+
+ }
+
+ @Test
+ public void testOrQuery() throws IOException {
+
+ BoostedSpanOrQuery q = new BoostedSpanOrQuery(new BoostSpanTermQuery(new Term("field", "eighteen"), null, 1f),
+ new BoostSpanTermQuery(new Term("field", "nineteen"), null, 1f));
+ for (PayloadFunction fn
+ : new PayloadFunction[]{new AveragePayloadFunction(), new MaxPayloadFunction(), new MinPayloadFunction()}) {
+ checkQuery(q, fn, new int[]{118, 119, 218, 219, 18, 19},
+ new float[]{4.0f, 4.0f, 4.0f, 4.0f, 2.0f, 2.0f});
+ }
+
+ }
+
+ @Test
+ public void testNearQuery() throws IOException {
+
+ // 2 4
+ // twenty two
+ // 2 4 4 4
+ // one hundred twenty two
+
+ SpanNearQuery q = new SpanNearQuery(new SpanQuery[]{
+ new SpanTermQuery(new Term("field", "twenty")),
+ new SpanTermQuery(new Term("field", "two"))
+ }, 0, true);
+
+ checkQuery(q, new MaxPayloadFunction(), new int[]{22, 122, 222}, new float[]{4.0f, 4.0f, 4.0f});
+ checkQuery(q, new MinPayloadFunction(), new int[]{122, 222, 22}, new float[]{4.0f, 4.0f, 2.0f});
+ checkQuery(q, new AveragePayloadFunction(), new int[]{122, 222, 22}, new float[]{4.0f, 4.0f, 3.0f});
+
+ }
+
+
+ @Test
+ public void testEquality() {
+ SpanQuery sq1 = new SpanTermQuery(new Term("field", "one"));
+ SpanQuery sq2 = new SpanTermQuery(new Term("field", "two"));
+ PayloadFunction minFunc = new MinPayloadFunction();
+ PayloadFunction maxFunc = new MaxPayloadFunction();
+ PayloadScoreQuery query1 = new PayloadScoreQuery(sq1, minFunc, PayloadDecoder.FLOAT_DECODER, true);
+ PayloadScoreQuery query2 = new PayloadScoreQuery(sq2, minFunc, PayloadDecoder.FLOAT_DECODER, true);
+ PayloadScoreQuery query3 = new PayloadScoreQuery(sq2, maxFunc, PayloadDecoder.FLOAT_DECODER, true);
+ PayloadScoreQuery query4 = new PayloadScoreQuery(sq2, maxFunc, PayloadDecoder.FLOAT_DECODER, false);
+ PayloadScoreQuery query5 = new PayloadScoreQuery(sq1, minFunc, PayloadDecoder.FLOAT_DECODER);
+
+ assertEquals(query1, query5);
+ assertFalse(query1.equals(query2));
+ assertFalse(query1.equals(query3));
+ assertFalse(query1.equals(query4));
+ assertFalse(query2.equals(query3));
+ assertFalse(query2.equals(query4));
+ assertFalse(query3.equals(query4));
+ }
+
+ public void testRewrite() throws IOException {
+ SpanMultiTermQueryWrapper xyz = new SpanMultiTermQueryWrapper<>(new WildcardQuery(new Term("field", "xyz*")));
+ PayloadScoreQuery psq = new PayloadScoreQuery(xyz, new AveragePayloadFunction(), PayloadDecoder.FLOAT_DECODER, false);
+
+ // if query wasn't rewritten properly, the query would have failed with "Rewrite first!"
+ searcher.search(psq, 1);
+ }
+
+
+ private static IndexSearcher searcher;
+ private static IndexReader reader;
+ private static Directory directory;
+ private static JustScorePayloadSimilarity similarity = new JustScorePayloadSimilarity();
+ private static byte[] payload2 = new byte[]{2};
+ private static byte[] payload4 = new byte[]{4};
+
+ private static class PayloadAnalyzer extends Analyzer {
+ @Override
+ public TokenStreamComponents createComponents(String fieldName) {
+ Tokenizer result = new MockTokenizer(MockTokenizer.SIMPLE, true);
+ return new TokenStreamComponents(result, new PayloadFilter(result));
+ }
+ }
+
+ private static class PayloadFilter extends TokenFilter {
+
+ private int numSeen = 0;
+ private final PayloadAttribute payAtt;
+
+ public PayloadFilter(TokenStream input) {
+ super(input);
+ payAtt = addAttribute(PayloadAttribute.class);
+ }
+
+ @Override
+ public boolean incrementToken() throws IOException {
+ boolean result = false;
+ if (input.incrementToken()) {
+ if (numSeen % 4 == 0) {
+ payAtt.setPayload(new BytesRef(payload2));
+ } else {
+ payAtt.setPayload(new BytesRef(payload4));
+ }
+ numSeen++;
+ result = true;
+ }
+ return result;
+ }
+
+ @Override
+ public void reset() throws IOException {
+ super.reset();
+ this.numSeen = 0;
+ }
+ }
+
+ @BeforeClass
+ public static void beforeClass() throws Exception {
+ directory = newDirectory();
+ RandomIndexWriter writer = new RandomIndexWriter(random(), directory,
+ newIndexWriterConfig(new PayloadAnalyzer())
+ .setMergePolicy(NoMergePolicy.INSTANCE));
+ //writer.infoStream = System.out;
+ for (int i = 0; i < 300; i++) {
+ Document doc = new Document();
+ doc.add(newTextField("field", English.intToEnglish(i), Field.Store.YES));
+ String txt = English.intToEnglish(i) + ' ' + English.intToEnglish(i + 1);
+ doc.add(newTextField("field2", txt, Field.Store.YES));
+ writer.addDocument(doc);
+ }
+ reader = writer.getReader();
+ writer.close();
+
+ searcher = newSearcher(reader);
+ searcher.setSimilarity(new JustScorePayloadSimilarity());
+ }
+
+ @AfterClass
+ public static void afterClass() throws Exception {
+ searcher = null;
+ reader.close();
+ reader = null;
+ directory.close();
+ directory = null;
+ }
+
+ static class JustScorePayloadSimilarity extends ClassicSimilarity {
+
+ //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ //Make everything else 1 so we see the effect of the payload
+ //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ @Override
+ public float lengthNorm(int length) {
+ return 1;
+ }
+
+ @Override
+ public float tf(float freq) {
+ return 1.0f;
+ }
+
+ // idf used for phrase queries
+ @Override
+ public Explanation idfExplain(CollectionStatistics collectionStats, TermStatistics[] termStats) {
+ return Explanation.match(1.0f, "Inexplicable");
+ }
+
+ @Override
+ public Explanation idfExplain(CollectionStatistics collectionStats, TermStatistics termStats) {
+ return Explanation.match(1.0f, "Inexplicable");
+ }
+
+ }
+
+}
diff --git a/src/test/java/org/apache/solr/suggest/analysis/AutocompleteSuggesterConcatTest.java b/src/test/java/org/apache/solr/suggest/analysis/AutocompleteSuggesterConcatTest.java
new file mode 100644
index 0000000..c5183f6
--- /dev/null
+++ b/src/test/java/org/apache/solr/suggest/analysis/AutocompleteSuggesterConcatTest.java
@@ -0,0 +1,213 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.solr.suggest.analysis;
+
+import org.apache.solr.SolrTestCaseJ4;
+import org.apache.solr.common.SolrException;
+import org.apache.solr.common.params.ModifiableSolrParams;
+import org.apache.solr.request.SolrQueryRequest;
+import org.apache.solr.util.BaseTestHarness;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.xml.xpath.XPathExpressionException;
+import java.lang.invoke.MethodHandles;
+
+public class AutocompleteSuggesterConcatTest extends SolrTestCaseJ4 {
+ private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
+ public static final String HANDLER = "/autocomplete";
+
+ @BeforeClass
+ public static void beforeClass() throws Exception {
+ System.setProperty("enable.update.log", "false");
+ System.setProperty("solr.directoryFactory", "solr.StandardDirectoryFactory");
+ initCore("solrconfig2.xml", "schema.xml");
+ }
+
+ @Override
+ @Before
+ public void setUp() throws Exception {
+ super.setUp();
+ clearIndex();
+ index();
+ assertU(commit());
+ assertU(optimize());
+ }
+
+ public static void index() {
+ assertU(adoc("id", "1", "search", "apple iphone", "weight", "100"));
+ assertU(adoc("id", "2", "search", "apple iphone 11", "weight", "200"));
+ assertU(adoc("id", "3", "search", "apple iphone 12", "weight", "300"));
+ assertU(adoc("id", "4", "search", "apple iphone 13", "weight", "100"));
+ assertU(adoc("id", "5", "search", "apple ipad", "weight", "500"));
+ assertU(adoc("id", "6", "search", "thermomix", "weight", "100"));
+ assertU(adoc("id", "7", "search", "thermo mix", "weight", "500"));
+ assertU(adoc("id", "8", "search", "red bike", "weight", "100"));
+ assertU(adoc("id", "9", "search", "bike red", "weight", "600"));
+
+ }
+
+ @Test
+ public void testBasic() {
+ SolrQueryRequest request = req("q", "apple");
+
+ String tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='5']";
+
+ String test1 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[1]/str[@name='searchHighlight' and text()='[apple] ipad']";
+ String test2 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[2]/str[@name='searchHighlight' and text()='[apple] iphone 12']";
+ String test3 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[3]/str[@name='searchHighlight' and text()='[apple] iphone 11']";
+ String test4 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[4]/str[@name='searchHighlight' and text()='[apple] iphone']";
+ String test5 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[5]/str[@name='searchHighlight' and text()='[apple] iphone 13']";
+
+ assertQ("", HANDLER, request, tests, test1, test2, test3, test4, test5);
+ }
+
+ @Test
+ public void testEmpty() {
+ SolrQueryRequest request = req("q", "applefzefzefzfz");
+
+ String tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='0']";
+
+ assertQ("", HANDLER, request, tests);
+ }
+
+ @Test
+ public void testAC1() {
+ SolrQueryRequest request = req("q", "apple i");
+
+ String tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='5']";
+
+ String test2 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[1]/str[@name='searchHighlight' and text()='[apple] [i]pad']";
+ String test3 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[2]/str[@name='searchHighlight' and text()='[apple] [i]phone 12']";
+ String test4 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[3]/str[@name='searchHighlight' and text()='[apple] [i]phone 11']";
+ String test5 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[4]/str[@name='searchHighlight' and text()='[apple] [i]phone']";
+ String test1 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[5]/str[@name='searchHighlight' and text()='[apple] [i]phone 13']";
+
+
+ assertQ("", HANDLER, request, tests, test2, test3, test4, test5, test1);
+ }
+
+ @Test
+ public void testAC2() {
+ SolrQueryRequest request = req("q", "apple iph");
+
+ String tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='5']";
+
+ String test2 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[1]/str[@name='searchHighlight' and text()='[apple] [iph]one 12']";
+ String test3 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[2]/str[@name='searchHighlight' and text()='[apple] [iph]one 11']";
+ String test4 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[3]/str[@name='searchHighlight' and text()='[apple] [iph]one']";
+ String test5 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[4]/str[@name='searchHighlight' and text()='[apple] [iph]one 13']";
+ String test1 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[5]/str[@name='searchHighlight' and text()='[apple] ipad']";
+
+
+ assertQ("", HANDLER, request, tests, test2, test3, test4, test5);
+ }
+
+ @Test
+ public void testAC3() {
+ SolrQueryRequest request = req("q", "appleip");
+
+ String tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='5']";
+
+ String test1 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[1]/str[@name='searchHighlight' and text()='apple ipad']";
+ String test2 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[2]/str[@name='searchHighlight' and text()='apple iphone 12']";
+ String test3 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[3]/str[@name='searchHighlight' and text()='apple iphone 11']";
+ String test4 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[4]/str[@name='searchHighlight' and text()='apple iphone']";
+ String test5 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[5]/str[@name='searchHighlight' and text()='apple iphone 13']";
+
+ assertQ("", HANDLER, request, tests, test1, test2, test3, test4, test5);
+ }
+
+ @Test
+ public void testConcat() {
+ SolrQueryRequest request = req("q", "thermo");
+ String tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='2']";
+ String test1 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[1]/str[@name='searchHighlight' and text()='[thermo] mix']";
+ String test2 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[2]/str[@name='searchHighlight' and text()='[thermo]mix']";
+
+ assertQ("", HANDLER, request, tests, test1, test2);
+
+
+ request = req("q", "thermom");
+ tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='2']";
+ test1 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[1]/str[@name='searchHighlight' and text()='[thermom]ix']";
+ test2 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[2]/str[@name='searchHighlight' and text()='thermo mix']";
+
+ assertQ("", HANDLER, request, tests, test1, test2);
+ }
+
+ @Test
+ public void testFuzzy() {
+ SolrQueryRequest request = req("q", "therom");
+ String tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='2']";
+
+ assertQ("", HANDLER, request, tests);
+
+ request = req("q", "apple ipda");
+ tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='1']";
+
+ assertQ("", HANDLER, request, tests);
+ }
+
+ @Test
+ public void testFuzzy2() {
+ SolrQueryRequest request = req("q", "apple ipda");
+ String tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='1']";
+
+ assertQ("", HANDLER, request, tests);
+ }
+
+
+ private static void assertQ(String message, String handler, SolrQueryRequest req, String... tests) {
+ try {
+ if (null == message) {
+ String var10000 = "";
+ } else {
+ (new StringBuilder()).append(message).append(" ").toString();
+ }
+
+ ModifiableSolrParams xmlWriterTypeParams = new ModifiableSolrParams(req.getParams());
+ xmlWriterTypeParams.set("wt", new String[]{"xml"});
+ xmlWriterTypeParams.set("indent", new String[]{xmlWriterTypeParams.get("indent", "off")});
+ req.setParams(xmlWriterTypeParams);
+ String response = h.query(handler, req);
+ if (req.getParams().getBool("facet", false)) {
+ String[] allTests = new String[tests.length + 1];
+ System.arraycopy(tests, 0, allTests, 1, tests.length);
+ allTests[0] = "*[count(//lst[@name='facet_counts']/*[@name='exception'])=0]";
+ tests = allTests;
+ }
+
+ String results = BaseTestHarness.validateXPath(response, tests);
+ if (null != results) {
+ String msg = "REQUEST FAILED: xpath=" + results + "\n\txml response was: " + response + "\n\trequest was:" + req.getParamString();
+ log.error(msg);
+ throw new RuntimeException(msg);
+ }
+ } catch (XPathExpressionException var8) {
+ throw new RuntimeException("XPath is invalid", var8);
+ } catch (Exception var9) {
+ SolrException.log(log, "REQUEST FAILED: " + req.getParamString(), var9);
+ throw new RuntimeException("Exception during query", var9);
+ }
+ }
+
+
+}
diff --git a/src/test/java/org/apache/solr/suggest/analysis/AutocompleteSuggesterNgramTest.java b/src/test/java/org/apache/solr/suggest/analysis/AutocompleteSuggesterNgramTest.java
new file mode 100644
index 0000000..4e86360
--- /dev/null
+++ b/src/test/java/org/apache/solr/suggest/analysis/AutocompleteSuggesterNgramTest.java
@@ -0,0 +1,207 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.solr.suggest.analysis;
+
+import org.apache.solr.SolrTestCaseJ4;
+import org.apache.solr.common.SolrException;
+import org.apache.solr.common.params.ModifiableSolrParams;
+import org.apache.solr.request.SolrQueryRequest;
+import org.apache.solr.util.BaseTestHarness;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.xml.xpath.XPathExpressionException;
+import java.lang.invoke.MethodHandles;
+
+public class AutocompleteSuggesterNgramTest extends SolrTestCaseJ4 {
+ private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
+ public static final String HANDLER = "/autocomplete";
+
+ @BeforeClass
+ public static void beforeClass() throws Exception {
+ System.setProperty("enable.update.log", "false");
+ System.setProperty("solr.directoryFactory", "solr.StandardDirectoryFactory");
+ initCore("solrconfig3.xml", "schema.xml");
+ }
+
+ @After
+ public void afterClass() throws Exception {
+ super.tearDown();
+ }
+
+ @Override
+ @Before
+ public void setUp() throws Exception {
+ super.setUp();
+ clearIndex();
+ index();
+ assertU(commit());
+ assertU(optimize());
+ }
+
+ public static void index() {
+ assertU(adoc("id", "1", "search", "apple iphone", "weight", "100"));
+ assertU(adoc("id", "2", "search", "apple iphone 11", "weight", "200"));
+ assertU(adoc("id", "3", "search", "apple iphone 12", "weight", "300"));
+ assertU(adoc("id", "4", "search", "apple iphone 13", "weight", "100"));
+ assertU(adoc("id", "5", "search", "apple ipad", "weight", "500"));
+ assertU(adoc("id", "6", "search", "thermomix", "weight", "100"));
+ assertU(adoc("id", "7", "search", "thermo mix", "weight", "500"));
+ assertU(adoc("id", "8", "search", "red bike", "weight", "100"));
+ assertU(adoc("id", "9", "search", "bike red", "weight", "600"));
+
+ }
+
+ @Test
+ public void testBasic() {
+ SolrQueryRequest request = req("q", "apple");
+
+ String tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='5']";
+
+ String test1 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[1]/str[@name='searchHighlight' and text()='[apple] ipad']";
+ String test2 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[2]/str[@name='searchHighlight' and text()='[apple] iphone 12']";
+ String test3 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[3]/str[@name='searchHighlight' and text()='[apple] iphone 11']";
+ String test4 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[4]/str[@name='searchHighlight' and text()='[apple] iphone']";
+ String test5 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[5]/str[@name='searchHighlight' and text()='[apple] iphone 13']";
+
+ assertQ("", HANDLER, request, tests, test1, test2, test3, test4, test5);
+ }
+
+ @Test
+ public void testEmpty() {
+ SolrQueryRequest request = req("q", "applefzefzefzfz");
+
+ String tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='0']";
+
+ assertQ("", HANDLER, request, tests);
+ }
+
+ @Test
+ public void testAC1() {
+ SolrQueryRequest request = req("q", "apple i");
+
+ String tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='0']";
+
+ assertQ("", HANDLER, request, tests);
+ }
+
+ @Test
+ public void testAC2() {
+ SolrQueryRequest request = req("q", "apple iph");
+
+ String tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='0']";
+
+
+ assertQ("", HANDLER, request, tests);
+ }
+
+ @Test
+ public void testAC3() {
+ SolrQueryRequest request = req("q", "appleip");
+
+ String tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='5']";
+
+ String test1 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[1]/str[@name='searchHighlight' and text()='apple ipad']";
+ String test2 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[2]/str[@name='searchHighlight' and text()='apple iphone 12']";
+ String test3 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[3]/str[@name='searchHighlight' and text()='apple iphone 11']";
+ String test4 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[4]/str[@name='searchHighlight' and text()='apple iphone']";
+ String test5 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[5]/str[@name='searchHighlight' and text()='apple iphone 13']";
+
+ assertQ("", HANDLER, request, tests, test1, test2, test3, test4, test5);
+ }
+
+ @Test
+ public void testConcat() {
+ SolrQueryRequest request = req("q", "thermo");
+ String tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='1']";
+ String test1 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[1]/str[@name='searchHighlight' and text()='[thermo] mix']";
+// String test2 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[2]/str[@name='searchHighlight' and text()='[thermomix']";
+
+ assertQ("", HANDLER, request, tests, test1);
+
+
+ request = req("q", "thermom");
+ tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='2']";
+ test1 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[1]/str[@name='searchHighlight' and text()='thermo mix']";
+ String test2 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[2]/str[@name='searchHighlight' and text()='[thermom]ix']";
+
+ assertQ("", HANDLER, request, tests, test1, test2);
+ }
+
+ @Test
+ public void testFuzzy() {
+ SolrQueryRequest request = req("q", "therom");
+ String tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='1']";
+ String test1 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[1]/str[@name='searchHighlight' and text()='thermo mix']";
+
+ assertQ("", HANDLER, request, tests, test1);
+
+ request = req("q", "apple ipda");
+ tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='1']";
+ test1 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[1]/str[@name='searchHighlight' and text()='[apple] ipad']";
+
+ assertQ("", HANDLER, request, tests, test1);
+ }
+
+ @Test
+ public void testLengthCache() {
+ SolrQueryRequest request = req("q", "th");
+ String tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='0']";
+ assertQ("", HANDLER, request, tests );
+
+ }
+
+ private static void assertQ(String message, String handler, SolrQueryRequest req, String... tests) {
+ try {
+ if (null == message) {
+ String var10000 = "";
+ } else {
+ (new StringBuilder()).append(message).append(" ").toString();
+ }
+
+ ModifiableSolrParams xmlWriterTypeParams = new ModifiableSolrParams(req.getParams());
+ xmlWriterTypeParams.set("wt", new String[]{"xml"});
+ xmlWriterTypeParams.set("indent", new String[]{xmlWriterTypeParams.get("indent", "off")});
+ req.setParams(xmlWriterTypeParams);
+ String response = h.query(handler, req);
+ if (req.getParams().getBool("facet", false)) {
+ String[] allTests = new String[tests.length + 1];
+ System.arraycopy(tests, 0, allTests, 1, tests.length);
+ allTests[0] = "*[count(//lst[@name='facet_counts']/*[@name='exception'])=0]";
+ tests = allTests;
+ }
+
+ String results = BaseTestHarness.validateXPath(response, tests);
+ if (null != results) {
+ String msg = "REQUEST FAILED: xpath=" + results + "\n\txml response was: " + response + "\n\trequest was:" + req.getParamString();
+ log.error(msg);
+ throw new RuntimeException(msg);
+ }
+ } catch (XPathExpressionException var8) {
+ throw new RuntimeException("XPath is invalid", var8);
+ } catch (Exception var9) {
+ SolrException.log(log, "REQUEST FAILED: " + req.getParamString(), var9);
+ throw new RuntimeException("Exception during query", var9);
+ }
+ }
+
+
+}
diff --git a/src/test/java/org/apache/solr/suggest/analysis/AutocompleteSuggesterTest.java b/src/test/java/org/apache/solr/suggest/analysis/AutocompleteSuggesterTest.java
new file mode 100644
index 0000000..ccdb675
--- /dev/null
+++ b/src/test/java/org/apache/solr/suggest/analysis/AutocompleteSuggesterTest.java
@@ -0,0 +1,207 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.solr.suggest.analysis;
+
+import org.apache.solr.SolrTestCaseJ4;
+import org.apache.solr.common.SolrException;
+import org.apache.solr.common.params.ModifiableSolrParams;
+import org.apache.solr.request.SolrQueryRequest;
+import org.apache.solr.util.BaseTestHarness;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.xml.xpath.XPathExpressionException;
+import java.lang.invoke.MethodHandles;
+
+public class AutocompleteSuggesterTest extends SolrTestCaseJ4 {
+ private static final Logger log = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
+ public static final String HANDLER = "/autocomplete";
+
+ @BeforeClass
+ public static void beforeClass() throws Exception {
+ System.setProperty("enable.update.log", "false");
+ System.setProperty("solr.directoryFactory", "solr.StandardDirectoryFactory");
+ initCore("solrconfig.xml", "schema.xml");
+ }
+
+ @Override
+ @Before
+ public void setUp() throws Exception {
+ super.setUp();
+ clearIndex();
+ index();
+ assertU(commit());
+ assertU(optimize());
+ }
+
+ public static void index() {
+ assertU(adoc("id", "1", "search", "apple iphone", "weight", "100"));
+ assertU(adoc("id", "2", "search", "apple iphone 11", "weight", "200"));
+ assertU(adoc("id", "3", "search", "apple iphone 12", "weight", "300"));
+ assertU(adoc("id", "4", "search", "apple iphone 13", "weight", "100"));
+ assertU(adoc("id", "5", "search", "apple ipad", "weight", "500"));
+ assertU(adoc("id", "6", "search", "thermomix", "weight", "100"));
+ assertU(adoc("id", "7", "search", "thermo mix", "weight", "500"));
+ assertU(adoc("id", "8", "search", "red bike", "weight", "100"));
+ assertU(adoc("id", "9", "search", "bike red", "weight", "600"));
+
+ }
+
+ @Test
+ public void testBasic() {
+ SolrQueryRequest request = req("q", "apple");
+
+ String tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='5']";
+
+ String test1 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[1]/str[@name='searchHighlight' and text()='[apple] ipad']";
+ String test2 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[2]/str[@name='searchHighlight' and text()='[apple] iphone 12']";
+ String test3 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[3]/str[@name='searchHighlight' and text()='[apple] iphone 11']";
+ String test4 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[4]/str[@name='searchHighlight' and text()='[apple] iphone']";
+ String test5 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[5]/str[@name='searchHighlight' and text()='[apple] iphone 13']";
+
+ assertQ("", HANDLER, request, tests, test1, test2, test3, test4, test5);
+ }
+
+ @Test
+ public void testEmpty() {
+ SolrQueryRequest request = req("q", "applefzefzefzfz");
+
+ String tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='0']";
+
+ assertQ("", HANDLER, request, tests);
+ }
+
+ @Test
+ public void testAC1() {
+ SolrQueryRequest request = req("q", "apple i");
+
+ String tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='5']";
+
+ String test2 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[1]/str[@name='searchHighlight' and text()='[apple] [i]pad']";
+ String test3 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[2]/str[@name='searchHighlight' and text()='[apple] [i]phone 12']";
+ String test4 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[3]/str[@name='searchHighlight' and text()='[apple] [i]phone 11']";
+ String test5 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[4]/str[@name='searchHighlight' and text()='[apple] [i]phone']";
+ String test1 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[5]/str[@name='searchHighlight' and text()='[apple] [i]phone 13']";
+
+
+ assertQ("", HANDLER, request, tests, test2, test3, test4, test5, test1);
+ }
+
+ @Test
+ public void testAC2() {
+ SolrQueryRequest request = req("q", "apple iph");
+
+ String tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='5']";
+
+ String test2 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[1]/str[@name='searchHighlight' and text()='[apple] [iph]one 12']";
+ String test3 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[2]/str[@name='searchHighlight' and text()='[apple] [iph]one 11']";
+ String test4 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[3]/str[@name='searchHighlight' and text()='[apple] [iph]one']";
+ String test5 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[4]/str[@name='searchHighlight' and text()='[apple] [iph]one 13']";
+ String test1 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[5]/str[@name='searchHighlight' and text()='[apple] ipad']";
+
+ assertQ("", HANDLER, request, tests, test2, test3, test4, test5, test1);
+ }
+
+ @Test
+ public void testAC3() {
+ SolrQueryRequest request = req("q", "appleip");
+
+ String tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='5']";
+
+ String test1 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[1]/str[@name='searchHighlight' and text()='apple ipad']";
+ String test2 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[2]/str[@name='searchHighlight' and text()='apple iphone 12']";
+ String test3 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[3]/str[@name='searchHighlight' and text()='apple iphone 11']";
+ String test4 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[4]/str[@name='searchHighlight' and text()='apple iphone']";
+ String test5 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[5]/str[@name='searchHighlight' and text()='apple iphone 13']";
+
+ assertQ("", HANDLER, request, tests, test1, test2, test3, test4, test5);
+ }
+
+ @Test
+ public void testConcat() {
+ SolrQueryRequest request = req("q", "thermo");
+ String tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='2']";
+ String test1 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[1]/str[@name='searchHighlight' and text()='[thermo] mix']";
+ String test2 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[2]/str[@name='searchHighlight' and text()='[thermo]mix']";
+
+ assertQ("", HANDLER, request, tests, test1, test2);
+
+
+ request = req("q", "thermom");
+ tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='2']";
+ test1 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[1]/str[@name='searchHighlight' and text()='[thermom]ix']";
+ test2 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[2]/str[@name='searchHighlight' and text()='thermo mix']";
+
+ assertQ("", HANDLER, request, tests, test1, test2);
+ }
+
+ @Test
+ public void testFuzzy() {
+ SolrQueryRequest request = req("q", "therom");
+ String tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='2']";
+ String test1 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[1]/str[@name='searchHighlight' and text()='thermo mix']";
+ String test2 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[2]/str[@name='searchHighlight' and text()='thermomix']";
+
+ assertQ("", HANDLER, request, tests, test1, test2);
+
+ request = req("q", "apple ipda");
+ tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='1']";
+ test1 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[1]/str[@name='searchHighlight' and text()='[apple] ipad']";
+
+ assertQ("", HANDLER, request, tests, test1);
+ }
+
+
+ private static void assertQ(String message, String handler, SolrQueryRequest req, String... tests) {
+ try {
+ if (null == message) {
+ String var10000 = "";
+ } else {
+ (new StringBuilder()).append(message).append(" ").toString();
+ }
+
+ ModifiableSolrParams xmlWriterTypeParams = new ModifiableSolrParams(req.getParams());
+ xmlWriterTypeParams.set("wt", new String[]{"xml"});
+ xmlWriterTypeParams.set("indent", new String[]{xmlWriterTypeParams.get("indent", "off")});
+ req.setParams(xmlWriterTypeParams);
+ String response = h.query(handler, req);
+ if (req.getParams().getBool("facet", false)) {
+ String[] allTests = new String[tests.length + 1];
+ System.arraycopy(tests, 0, allTests, 1, tests.length);
+ allTests[0] = "*[count(//lst[@name='facet_counts']/*[@name='exception'])=0]";
+ tests = allTests;
+ }
+
+ String results = BaseTestHarness.validateXPath(response, tests);
+ if (null != results) {
+ String msg = "REQUEST FAILED: xpath=" + results + "\n\txml response was: " + response + "\n\trequest was:" + req.getParamString();
+ log.error(msg);
+ throw new RuntimeException(msg);
+ }
+ } catch (XPathExpressionException var8) {
+ throw new RuntimeException("XPath is invalid", var8);
+ } catch (Exception var9) {
+ SolrException.log(log, "REQUEST FAILED: " + req.getParamString(), var9);
+ throw new RuntimeException("Exception during query", var9);
+ }
+ }
+
+
+}
diff --git a/src/test/java/org/apache/solr/suggest/analysis/TestLevenshtein.java b/src/test/java/org/apache/solr/suggest/analysis/TestLevenshtein.java
new file mode 100644
index 0000000..4a83ff6
--- /dev/null
+++ b/src/test/java/org/apache/solr/suggest/analysis/TestLevenshtein.java
@@ -0,0 +1,17 @@
+package org.apache.solr.suggest.analysis;
+
+import org.apache.lucene.query.DamerauLevenshteinAlgorithm;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class TestLevenshtein {
+
+
+ @Test
+ public void test() {
+ DamerauLevenshteinAlgorithm algo = new DamerauLevenshteinAlgorithm(1,1,1,2);
+ assertEquals(1,algo.execute("marrio", "mario"));
+ assertEquals(1,algo.execute("marrio", "matrio"));
+ }
+}
diff --git a/src/test/java/org/apache/solr/suggest/analysis/XPathTest.java b/src/test/java/org/apache/solr/suggest/analysis/XPathTest.java
new file mode 100644
index 0000000..3ef91ea
--- /dev/null
+++ b/src/test/java/org/apache/solr/suggest/analysis/XPathTest.java
@@ -0,0 +1,58 @@
+package org.apache.solr.suggest.analysis;
+
+import org.apache.solr.util.BaseTestHarness;
+import org.junit.Test;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.xml.sax.SAXException;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathConstants;
+import javax.xml.xpath.XPathExpressionException;
+import javax.xml.xpath.XPathFactory;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+
+public class XPathTest {
+
+
+ @Test
+ public void test() throws XPathExpressionException, SAXException {
+ String response = "" +
+ "0253applexml5apple ipad515apple iphone 12509apple iphone 11505apple iphone503apple iphone 13503" +
+ "";
+ String tests = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/int[@name='numFound' and text()='5']";
+
+ String test1 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[1]/str[@name='search' and text()='apple ipad']";
+ String test2 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[2]/str[@name='search' and text()='apple iphone 12']";
+ String test3 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[3]/str[@name='search' and text()='apple iphone 11']";
+ String test4 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[4]/str[@name='search' and text()='apple iphone']";
+ String test5 = "//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']//*[5]/str[@name='search' and text()='apple iphone 13']";
+
+ assertNull(BaseTestHarness.validateXPath(response, tests, test1, test2, test3, test4, test5));
+ }
+
+ @Test
+ public void test2() throws ParserConfigurationException, IOException, SAXException, XPathExpressionException {
+ String response = "" +
+ "0253applexml5apple ipad515 apple iphone 12 509 apple iphone 11505 apple iphone503 apple iphone 13503" +
+ "";
+
+ DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+ DocumentBuilder db = dbf.newDocumentBuilder();
+ Document document = db.parse(new ByteArrayInputStream(response.getBytes(StandardCharsets.UTF_8)));// same xml comments as above.
+
+ XPathFactory xpf = XPathFactory.newInstance();
+ XPath xpath = xpf.newXPath();
+ Element userElement = (Element) xpath.evaluate("//response/lst[@name='suggest']/lst[@name='default']/lst[@name='response']/arr[@name='hits']/*[1]/str[@name='search' and text()='apple ipad']", document,
+ XPathConstants.NODE);
+ assertNotNull(userElement);
+ }
+}
diff --git a/src/test/resources/solr.xml b/src/test/resources/solr.xml
new file mode 100644
index 0000000..79db206
--- /dev/null
+++ b/src/test/resources/solr.xml
@@ -0,0 +1,58 @@
+
+
+
+
+
+
+
+
+ ${shareSchema:false}
+ ${configSetBaseDir:configsets}
+ ${coreRootDirectory:.}
+ ${solr.allowPaths:}
+
+
+ ${urlScheme:}
+ ${socketTimeout:15000}
+ ${connTimeout:15000}
+ ${solr.tests.shardsWhitelist:}
+
+
+
+ 4
+
+
+
+
+ 127.0.0.1
+ ${hostPort:8983}
+ ${hostContext:solr}
+ ${solr.zkclienttimeout:60000}
+ ${genericCoreNodeNames:true}
+ ${leaderVoteWait:15000}
+ ${leaderConflictResolveWait:45000}
+ ${distribUpdateConnTimeout:5000}
+ ${distribUpdateSoTimeout:30000}
+ ${autoReplicaFailoverWaitAfterExpiration:10000}
+ ${autoReplicaFailoverWorkLoopDelay:10000}
+ ${autoReplicaFailoverBadNodeExpiration:60000}
+
+
+
diff --git a/src/test/resources/solr/collection1/currency.xml b/src/test/resources/solr/collection1/currency.xml
new file mode 100644
index 0000000..6a12b32
--- /dev/null
+++ b/src/test/resources/solr/collection1/currency.xml
@@ -0,0 +1,37 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/test/resources/solr/collection1/enumsConfig.xml b/src/test/resources/solr/collection1/enumsConfig.xml
new file mode 100644
index 0000000..9bfbfc3
--- /dev/null
+++ b/src/test/resources/solr/collection1/enumsConfig.xml
@@ -0,0 +1,52 @@
+
+
+
+
+
+
+
+ Not Available
+ Low
+ Medium
+ High
+
+ x4
+ x5
+ x6
+ x7
+ x8
+ x9
+ x10
+ Critical
+
+ x12
+ x13
+ x14
+ x15
+ x16
+ x17
+ x18
+
+
+
diff --git a/src/test/resources/solr/collection1/lang/contractions_fr.txt b/src/test/resources/solr/collection1/lang/contractions_fr.txt
new file mode 100644
index 0000000..e69de29
diff --git a/src/test/resources/solr/collection1/mapping-ISOLatin1Accent.txt b/src/test/resources/solr/collection1/mapping-ISOLatin1Accent.txt
new file mode 100644
index 0000000..ede7742
--- /dev/null
+++ b/src/test/resources/solr/collection1/mapping-ISOLatin1Accent.txt
@@ -0,0 +1,246 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Syntax:
+# "source" => "target"
+# "source".length() > 0 (source cannot be empty.)
+# "target".length() >= 0 (target can be empty.)
+
+# example:
+# "À" => "A"
+# "\u00C0" => "A"
+# "\u00C0" => "\u0041"
+# "ß" => "ss"
+# "\t" => " "
+# "\n" => ""
+
+# À => A
+"\u00C0" => "A"
+
+# Á => A
+"\u00C1" => "A"
+
+# Â => A
+"\u00C2" => "A"
+
+# Ã => A
+"\u00C3" => "A"
+
+# Ä => A
+"\u00C4" => "A"
+
+# Å => A
+"\u00C5" => "A"
+
+# Æ => AE
+"\u00C6" => "AE"
+
+# Ç => C
+"\u00C7" => "C"
+
+# È => E
+"\u00C8" => "E"
+
+# É => E
+"\u00C9" => "E"
+
+# Ê => E
+"\u00CA" => "E"
+
+# Ë => E
+"\u00CB" => "E"
+
+# Ì => I
+"\u00CC" => "I"
+
+# Í => I
+"\u00CD" => "I"
+
+# Î => I
+"\u00CE" => "I"
+
+# Ï => I
+"\u00CF" => "I"
+
+# IJ => IJ
+"\u0132" => "IJ"
+
+# Ð => D
+"\u00D0" => "D"
+
+# Ñ => N
+"\u00D1" => "N"
+
+# Ò => O
+"\u00D2" => "O"
+
+# Ó => O
+"\u00D3" => "O"
+
+# Ô => O
+"\u00D4" => "O"
+
+# Õ => O
+"\u00D5" => "O"
+
+# Ö => O
+"\u00D6" => "O"
+
+# Ø => O
+"\u00D8" => "O"
+
+# Π=> OE
+"\u0152" => "OE"
+
+# Þ
+"\u00DE" => "TH"
+
+# Ù => U
+"\u00D9" => "U"
+
+# Ú => U
+"\u00DA" => "U"
+
+# Û => U
+"\u00DB" => "U"
+
+# Ü => U
+"\u00DC" => "U"
+
+# Ý => Y
+"\u00DD" => "Y"
+
+# Ÿ => Y
+"\u0178" => "Y"
+
+# à => a
+"\u00E0" => "a"
+
+# á => a
+"\u00E1" => "a"
+
+# â => a
+"\u00E2" => "a"
+
+# ã => a
+"\u00E3" => "a"
+
+# ä => a
+"\u00E4" => "a"
+
+# å => a
+"\u00E5" => "a"
+
+# æ => ae
+"\u00E6" => "ae"
+
+# ç => c
+"\u00E7" => "c"
+
+# è => e
+"\u00E8" => "e"
+
+# é => e
+"\u00E9" => "e"
+
+# ê => e
+"\u00EA" => "e"
+
+# ë => e
+"\u00EB" => "e"
+
+# ì => i
+"\u00EC" => "i"
+
+# í => i
+"\u00ED" => "i"
+
+# î => i
+"\u00EE" => "i"
+
+# ï => i
+"\u00EF" => "i"
+
+# ij => ij
+"\u0133" => "ij"
+
+# ð => d
+"\u00F0" => "d"
+
+# ñ => n
+"\u00F1" => "n"
+
+# ò => o
+"\u00F2" => "o"
+
+# ó => o
+"\u00F3" => "o"
+
+# ô => o
+"\u00F4" => "o"
+
+# õ => o
+"\u00F5" => "o"
+
+# ö => o
+"\u00F6" => "o"
+
+# ø => o
+"\u00F8" => "o"
+
+# œ => oe
+"\u0153" => "oe"
+
+# ß => ss
+"\u00DF" => "ss"
+
+# þ => th
+"\u00FE" => "th"
+
+# ù => u
+"\u00F9" => "u"
+
+# ú => u
+"\u00FA" => "u"
+
+# û => u
+"\u00FB" => "u"
+
+# ü => u
+"\u00FC" => "u"
+
+# ý => y
+"\u00FD" => "y"
+
+# ÿ => y
+"\u00FF" => "y"
+
+# ff => ff
+"\uFB00" => "ff"
+
+# fi => fi
+"\uFB01" => "fi"
+
+# fl => fl
+"\uFB02" => "fl"
+
+# ffi => ffi
+"\uFB03" => "ffi"
+
+# ffl => ffl
+"\uFB04" => "ffl"
+
+# ſt => ft
+"\uFB05" => "ft"
+
+# st => st
+"\uFB06" => "st"
diff --git a/src/test/resources/solr/collection1/old_synonyms.txt b/src/test/resources/solr/collection1/old_synonyms.txt
new file mode 100644
index 0000000..a7624f0
--- /dev/null
+++ b/src/test/resources/solr/collection1/old_synonyms.txt
@@ -0,0 +1,22 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+a => aa
+b => b1 b2
+c => c1,c2
+a\=>a => b\=>b
+a\,a => b\,b
+foo,bar,baz
+
+Television,TV,Televisions
diff --git a/src/test/resources/solr/collection1/open-exchange-rates.json b/src/test/resources/solr/collection1/open-exchange-rates.json
new file mode 100644
index 0000000..6b40ac4
--- /dev/null
+++ b/src/test/resources/solr/collection1/open-exchange-rates.json
@@ -0,0 +1,18 @@
+{
+ "disclaimer": "This data is not real, it was synthetically created to match currency.xml. It is modeled after the data format available from openexchangerates.org. See https://openexchangerates.org/documentation for details
+
+
+ IMPORTANT NOTE: In order for tests to work, this data must be kept in sync with ./currency.xml",
+
+
+ "license": "http://www.apache.org/licenses/LICENSE-2.0",
+ "timestamp": 1332070464,
+ "base": "USD",
+ "rates": {
+ "USD": 1,
+ "JPY": 81.29,
+ "EUR": 2.5,
+ "GBP": 0.5,
+ "MXN": 2.0
+ }
+}
diff --git a/src/test/resources/solr/collection1/protwords.txt b/src/test/resources/solr/collection1/protwords.txt
new file mode 100644
index 0000000..ab7e3e2
--- /dev/null
+++ b/src/test/resources/solr/collection1/protwords.txt
@@ -0,0 +1,23 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#use a protected word file to avoid stemming two
+#unrelated words to the same base word.
+#to test, we will use words that would normally obviously be stemmed.
+cats
+ridding
+c#
+c++
+.net
diff --git a/src/test/resources/solr/collection1/schema.xml b/src/test/resources/solr/collection1/schema.xml
new file mode 100644
index 0000000..5b0a3be
--- /dev/null
+++ b/src/test/resources/solr/collection1/schema.xml
@@ -0,0 +1,97 @@
+
+
+
+
+
+
+
+ id
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/test/resources/solr/collection1/solrconfig.snippet.randomindexconfig.xml b/src/test/resources/solr/collection1/solrconfig.snippet.randomindexconfig.xml
new file mode 100644
index 0000000..de5c714
--- /dev/null
+++ b/src/test/resources/solr/collection1/solrconfig.snippet.randomindexconfig.xml
@@ -0,0 +1,51 @@
+
+
+
+
+
+
+
+
+ ${useCompoundFile:false}
+
+ ${solr.tests.maxBufferedDocs}
+ ${solr.tests.ramBufferSizeMB}
+ ${solr.tests.maxCommitMergeWaitTime:-1}
+ ${solr.tests.ramPerThreadHardLimitMB}
+
+
+
+ 1000
+ 10000
+
+
+ ${solr.tests.lockType:single}
+
+ ${solr.tests.infostream:false}
+
+
diff --git a/src/test/resources/solr/collection1/solrconfig.xml b/src/test/resources/solr/collection1/solrconfig.xml
new file mode 100644
index 0000000..b61af65
--- /dev/null
+++ b/src/test/resources/solr/collection1/solrconfig.xml
@@ -0,0 +1,158 @@
+
+
+
+
+ 8.8.0
+
+ ${solr.data.dir:}
+
+
+
+ 1000000
+ 2000000
+ 3000000
+ 4000000
+ ${solr.hdfs.home:}
+ ${solr.hdfs.blockcache.enabled:true}
+ ${solr.hdfs.blockcache.global:true}
+ ${solr.hdfs.blockcache.write.enabled:false}
+ ${solr.hdfs.blockcache.blocksperbank:10}
+ ${solr.hdfs.blockcache.slab.count:1}
+
+
+
+
+
+
+
+ ${solr.lock.type:native}
+
+
+
+
+ ${solr.autoCommit.maxTime:-1}
+ 1
+
+
+
+ ${solr.ulog.dir:}
+
+
+ ${solr.commitwithin.softcommit:true}
+
+
+
+
+
+ search
+ search_payload
+
+
+ search
+ search_ngram
+
+
+ search
+ search_payload_concat
+
+
+ search
+ search_ngram_concat
+
+
+ search
+ search_text
+
+
+ search_payload_concat
+ search_ngram_concat
+
+
+
+
+
+
+
+
+ ${solr.max.booleanClauses:1024}
+
+
+
+
+
+
+
+
+
+ true
+ 30
+ 200
+ true
+
+
+
+
+
+
+
+
+
+ explicit
+ 10
+ id,word,friends
+ json
+ edismax
+ word
+ word
+ 100%
+ 5
+
+
+
+
+
+
+ explicit
+ 0
+ true
+ 7
+
+
+ autocomplete
+
+
+
+
+
+ default
+ AutocompleteLookupFactory
+ AutocompleteSuggester
+ DocumentDictionaryFactory
+ search
+ search_payload
+ search_ngram
+ search_payload_concat
+ search_ngram_concat
+ categories
+
+ search_text
+
+ true
+ weight
+ 0.00003
+ text_fr
+ 1
+ true
+
+ autocompleteCache
+ 2
+
+
+
+
+
+
diff --git a/src/test/resources/solr/collection1/solrconfig2.xml b/src/test/resources/solr/collection1/solrconfig2.xml
new file mode 100644
index 0000000..4f1bbf7
--- /dev/null
+++ b/src/test/resources/solr/collection1/solrconfig2.xml
@@ -0,0 +1,156 @@
+
+
+
+
+ 8.8.0
+
+ ${solr.data.dir:}
+
+
+
+ 1000000
+ 2000000
+ 3000000
+ 4000000
+ ${solr.hdfs.home:}
+ ${solr.hdfs.blockcache.enabled:true}
+ ${solr.hdfs.blockcache.global:true}
+ ${solr.hdfs.blockcache.write.enabled:false}
+ ${solr.hdfs.blockcache.blocksperbank:10}
+ ${solr.hdfs.blockcache.slab.count:1}
+
+
+
+
+
+
+
+ ${solr.lock.type:native}
+
+
+
+
+ ${solr.autoCommit.maxTime:-1}
+ 1
+
+
+
+ ${solr.ulog.dir:}
+
+
+ ${solr.commitwithin.softcommit:true}
+
+
+
+
+
+ search
+ search_payload
+
+
+ search
+ search_ngram
+
+
+ search
+ search_payload_concat
+
+
+ search
+ search_ngram_concat
+
+
+ search
+ search_text
+
+
+ search_payload_concat
+ search_ngram_concat
+
+
+
+
+
+
+
+
+ ${solr.max.booleanClauses:1024}
+
+
+
+
+
+
+
+
+
+ true
+ 30
+ 200
+ true
+
+
+
+
+
+
+
+
+
+ explicit
+ 10
+ id,word,friends
+ json
+ edismax
+ word
+ word
+ 100%
+ 5
+
+
+
+
+
+
+ explicit
+ 0
+ true
+ 7
+
+
+ autocomplete
+
+
+
+
+
+ default
+ AutocompleteLookupFactory
+ AutocompleteSuggester
+ DocumentDictionaryFactory
+ search
+
+ search_ngram
+
+ search_ngram_concat
+ search_text
+ categories
+ true
+ weight
+ 0.00003
+ text_fr
+ 1
+ true
+
+ autocompleteCache
+ 2
+
+
+
+
+
+
diff --git a/src/test/resources/solr/collection1/solrconfig3.xml b/src/test/resources/solr/collection1/solrconfig3.xml
new file mode 100644
index 0000000..54c2f1a
--- /dev/null
+++ b/src/test/resources/solr/collection1/solrconfig3.xml
@@ -0,0 +1,157 @@
+
+
+
+
+ 8.8.0
+
+ ${solr.data.dir:}
+
+
+
+ 1000000
+ 2000000
+ 3000000
+ 4000000
+ ${solr.hdfs.home:}
+ ${solr.hdfs.blockcache.enabled:true}
+ ${solr.hdfs.blockcache.global:true}
+ ${solr.hdfs.blockcache.write.enabled:false}
+ ${solr.hdfs.blockcache.blocksperbank:10}
+ ${solr.hdfs.blockcache.slab.count:1}
+
+
+
+
+
+
+
+ ${solr.lock.type:native}
+
+
+
+
+ ${solr.autoCommit.maxTime:-1}
+ 1
+
+
+
+ ${solr.ulog.dir:}
+
+
+ ${solr.commitwithin.softcommit:true}
+
+
+
+
+
+ search
+ search_payload
+
+
+ search
+ search_ngram
+
+
+ search
+ search_payload_concat
+
+
+ search
+ search_ngram_concat
+
+
+ search
+ search_text
+
+
+ search_payload_concat
+ search_ngram_concat
+
+
+
+
+
+
+
+
+ ${solr.max.booleanClauses:1024}
+
+
+
+
+
+
+
+
+
+ true
+ 30
+ 200
+ true
+
+
+
+
+
+
+
+
+
+ explicit
+ 10
+ id,word,friends
+ json
+ edismax
+ word
+ word
+ 100%
+ 5
+
+
+
+
+
+
+ explicit
+ 0
+ true
+ 7
+
+
+ autocomplete
+
+
+
+
+
+ default
+ AutocompleteLookupFactory
+ AutocompleteSuggester
+ DocumentDictionaryFactory
+ search
+ search_payload
+
+ search_payload_concat
+
+
+ search_text
+ categories
+ true
+ weight
+ 0.00003
+ text_fr
+ 1
+ true
+
+ autocompleteCache
+ 2
+
+
+
+
+
+
diff --git a/src/test/resources/solr/collection1/stopwords.txt b/src/test/resources/solr/collection1/stopwords.txt
new file mode 100644
index 0000000..a18de89
--- /dev/null
+++ b/src/test/resources/solr/collection1/stopwords.txt
@@ -0,0 +1,57 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#-----------------------------------------------------------------------
+# a couple of test stopwords to test that the words are really being
+# configured from this file:
+stopworda
+stopwordb
+
+#Standard english stop words taken from Lucene's StopAnalyzer
+a
+an
+are
+as
+at
+be
+but
+by
+for
+if
+in
+into
+is
+it
+no
+not
+of
+on
+or
+s
+such
+t
+that
+the
+their
+then
+there
+these
+they
+this
+to
+was
+will
+with
+
diff --git a/src/test/resources/solr/collection1/synonyms.txt b/src/test/resources/solr/collection1/synonyms.txt
new file mode 100644
index 0000000..d7feb34
--- /dev/null
+++ b/src/test/resources/solr/collection1/synonyms.txt
@@ -0,0 +1,54 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#-----------------------------------------------------------------------
+#some test synonym mappings unlikely to appear in real input text
+aaa => aaaa
+bbb => bbbb1 bbbb2
+ccc => cccc1,cccc2
+a\=>a => b\=>b
+a\,a => b\,b
+fooaaa,baraaa,bazaaa
+
+# Some synonym groups specific to this example
+GB,gib,gigabyte,gigabytes
+MB,mib,megabyte,megabytes
+Television, Televisions, TV, TVs
+#notice we use "gib" instead of "GiB" so any WordDelimiterGraphFilter coming
+#after us won't split it into two words.
+
+# Synonym mappings can be used for spelling correction too
+pixima => pixma
+
+# multiword synonyms
+wi fi => wifi
+crow blackbird, grackle
+
+# Synonyms used in semantic expansion
+tabby => tabby, cat, feline, animal
+persian => persian, cat, feline, animal
+
+jeans, denim pants
+
+# Boosted Synonyms
+tiger, tigre|0.9
+lynx => lince|0.8, lynx_canadensis|0.9
+
+leopard, big cat|0.8, bagheera|0.9, panthera pardus|0.85
+lion => panthera leo|0.9, simba leo|0.8, kimba|0.75
+
+panthera pardus, leopard|0.6
+panthera tigris => tiger|0.99
+
+snow leopard, panthera uncia|0.9, big cat|0.8, white_leopard|0.6
+panthera onca => jaguar|0.95, big cat|0.85, black panther|0.65
+panthera blytheae, oldest|0.5 ancient|0.9 panthera
\ No newline at end of file
diff --git a/src/webapp/autocomplete.html b/src/webapp/autocomplete.html
new file mode 100644
index 0000000..79d1115
--- /dev/null
+++ b/src/webapp/autocomplete.html
@@ -0,0 +1,26 @@
+
+
+
+
+
+
+
+Solr autocomplete
+
+
+
+
+
+
+
+
Configuration de Firefox
+
Dans le menu "about:config", modifier la variable 'security.csp.enable' à false
+
+
+
+
+
\ No newline at end of file
diff --git a/src/webapp/css/jquery-ui.css b/src/webapp/css/jquery-ui.css
new file mode 100644
index 0000000..42e9b50
--- /dev/null
+++ b/src/webapp/css/jquery-ui.css
@@ -0,0 +1,1314 @@
+/*! jQuery UI - v1.13.1 - 2022-01-20
+* http://jqueryui.com
+* Includes: core.css, accordion.css, autocomplete.css, menu.css, button.css, controlgroup.css, checkboxradio.css, datepicker.css, dialog.css, draggable.css, resizable.css, progressbar.css, selectable.css, selectmenu.css, slider.css, sortable.css, spinner.css, tabs.css, tooltip.css, theme.css
+* To view and modify this theme, visit http://jqueryui.com/themeroller/?ffDefault=Trebuchet%20MS%2CTahoma%2CVerdana%2CArial%2Csans-serif&fwDefault=bold&fsDefault=1.1em&cornerRadius=4px&bgColorHeader=f6a828&bgTextureHeader=gloss_wave&bgImgOpacityHeader=35&borderColorHeader=e78f08&fcHeader=ffffff&iconColorHeader=ffffff&bgColorContent=eeeeee&bgTextureContent=highlight_soft&bgImgOpacityContent=100&borderColorContent=dddddd&fcContent=333333&iconColorContent=222222&bgColorDefault=f6f6f6&bgTextureDefault=glass&bgImgOpacityDefault=100&borderColorDefault=cccccc&fcDefault=1c94c4&iconColorDefault=ef8c08&bgColorHover=fdf5ce&bgTextureHover=glass&bgImgOpacityHover=100&borderColorHover=fbcb09&fcHover=c77405&iconColorHover=ef8c08&bgColorActive=ffffff&bgTextureActive=glass&bgImgOpacityActive=65&borderColorActive=fbd850&fcActive=eb8f00&iconColorActive=ef8c08&bgColorHighlight=ffe45c&bgTextureHighlight=highlight_soft&bgImgOpacityHighlight=75&borderColorHighlight=fed22f&fcHighlight=363636&iconColorHighlight=228ef1&bgColorError=b81900&bgTextureError=diagonals_thick&bgImgOpacityError=18&borderColorError=cd0a0a&fcError=ffffff&iconColorError=ffd27a&bgColorOverlay=666666&bgTextureOverlay=diagonals_thick&bgImgOpacityOverlay=20&opacityOverlay=50&bgColorShadow=000000&bgTextureShadow=flat&bgImgOpacityShadow=10&opacityShadow=20&thicknessShadow=5px&offsetTopShadow=-5px&offsetLeftShadow=-5px&cornerRadiusShadow=5px
+* Copyright jQuery Foundation and other contributors; Licensed MIT */
+
+/* Layout helpers
+----------------------------------*/
+.ui-helper-hidden {
+ display: none;
+}
+.ui-helper-hidden-accessible {
+ border: 0;
+ clip: rect(0 0 0 0);
+ height: 1px;
+ margin: -1px;
+ overflow: hidden;
+ padding: 0;
+ position: absolute;
+ width: 1px;
+}
+.ui-helper-reset {
+ margin: 0;
+ padding: 0;
+ border: 0;
+ outline: 0;
+ line-height: 1.3;
+ text-decoration: none;
+ font-size: 100%;
+ list-style: none;
+}
+.ui-helper-clearfix:before,
+.ui-helper-clearfix:after {
+ content: "";
+ display: table;
+ border-collapse: collapse;
+}
+.ui-helper-clearfix:after {
+ clear: both;
+}
+.ui-helper-zfix {
+ width: 100%;
+ height: 100%;
+ top: 0;
+ left: 0;
+ position: absolute;
+ opacity: 0;
+ -ms-filter: "alpha(opacity=0)"; /* support: IE8 */
+}
+
+.ui-front {
+ z-index: 100;
+}
+
+
+/* Interaction Cues
+----------------------------------*/
+.ui-state-disabled {
+ cursor: default !important;
+ pointer-events: none;
+}
+
+
+/* Icons
+----------------------------------*/
+.ui-icon {
+ display: inline-block;
+ vertical-align: middle;
+ margin-top: -.25em;
+ position: relative;
+ text-indent: -99999px;
+ overflow: hidden;
+ background-repeat: no-repeat;
+}
+
+.ui-widget-icon-block {
+ left: 50%;
+ margin-left: -8px;
+ display: block;
+}
+
+/* Misc visuals
+----------------------------------*/
+
+/* Overlays */
+.ui-widget-overlay {
+ position: fixed;
+ top: 0;
+ left: 0;
+ width: 100%;
+ height: 100%;
+}
+.ui-accordion .ui-accordion-header {
+ display: block;
+ cursor: pointer;
+ position: relative;
+ margin: 2px 0 0 0;
+ padding: .5em .5em .5em .7em;
+ font-size: 100%;
+}
+.ui-accordion .ui-accordion-content {
+ padding: 1em 2.2em;
+ border-top: 0;
+ overflow: auto;
+}
+.ui-autocomplete {
+ position: absolute;
+ top: 0;
+ left: 0;
+ cursor: default;
+}
+.ui-menu {
+ list-style: none;
+ padding: 0;
+ margin: 0;
+ display: block;
+ outline: 0;
+}
+.ui-menu .ui-menu {
+ position: absolute;
+}
+.ui-menu .ui-menu-item {
+ margin: 0;
+ cursor: pointer;
+ /* support: IE10, see #8844 */
+ list-style-image: url("data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7");
+}
+.ui-menu .ui-menu-item-wrapper {
+ position: relative;
+ padding: 3px 1em 3px .4em;
+}
+.ui-menu .ui-menu-divider {
+ margin: 5px 0;
+ height: 0;
+ font-size: 0;
+ line-height: 0;
+ border-width: 1px 0 0 0;
+}
+.ui-menu .ui-state-focus,
+.ui-menu .ui-state-active {
+ margin: -1px;
+}
+
+/* icon support */
+.ui-menu-icons {
+ position: relative;
+}
+.ui-menu-icons .ui-menu-item-wrapper {
+ padding-left: 2em;
+}
+
+/* left-aligned */
+.ui-menu .ui-icon {
+ position: absolute;
+ top: 0;
+ bottom: 0;
+ left: .2em;
+ margin: auto 0;
+}
+
+/* right-aligned */
+.ui-menu .ui-menu-icon {
+ left: auto;
+ right: 0;
+}
+.ui-button {
+ padding: .4em 1em;
+ display: inline-block;
+ position: relative;
+ line-height: normal;
+ margin-right: .1em;
+ cursor: pointer;
+ vertical-align: middle;
+ text-align: center;
+ -webkit-user-select: none;
+ -moz-user-select: none;
+ -ms-user-select: none;
+ user-select: none;
+
+ /* Support: IE <= 11 */
+ overflow: visible;
+}
+
+.ui-button,
+.ui-button:link,
+.ui-button:visited,
+.ui-button:hover,
+.ui-button:active {
+ text-decoration: none;
+}
+
+/* to make room for the icon, a width needs to be set here */
+.ui-button-icon-only {
+ width: 2em;
+ box-sizing: border-box;
+ text-indent: -9999px;
+ white-space: nowrap;
+}
+
+/* no icon support for input elements */
+input.ui-button.ui-button-icon-only {
+ text-indent: 0;
+}
+
+/* button icon element(s) */
+.ui-button-icon-only .ui-icon {
+ position: absolute;
+ top: 50%;
+ left: 50%;
+ margin-top: -8px;
+ margin-left: -8px;
+}
+
+.ui-button.ui-icon-notext .ui-icon {
+ padding: 0;
+ width: 2.1em;
+ height: 2.1em;
+ text-indent: -9999px;
+ white-space: nowrap;
+
+}
+
+input.ui-button.ui-icon-notext .ui-icon {
+ width: auto;
+ height: auto;
+ text-indent: 0;
+ white-space: normal;
+ padding: .4em 1em;
+}
+
+/* workarounds */
+/* Support: Firefox 5 - 40 */
+input.ui-button::-moz-focus-inner,
+button.ui-button::-moz-focus-inner {
+ border: 0;
+ padding: 0;
+}
+.ui-controlgroup {
+ vertical-align: middle;
+ display: inline-block;
+}
+.ui-controlgroup > .ui-controlgroup-item {
+ float: left;
+ margin-left: 0;
+ margin-right: 0;
+}
+.ui-controlgroup > .ui-controlgroup-item:focus,
+.ui-controlgroup > .ui-controlgroup-item.ui-visual-focus {
+ z-index: 9999;
+}
+.ui-controlgroup-vertical > .ui-controlgroup-item {
+ display: block;
+ float: none;
+ width: 100%;
+ margin-top: 0;
+ margin-bottom: 0;
+ text-align: left;
+}
+.ui-controlgroup-vertical .ui-controlgroup-item {
+ box-sizing: border-box;
+}
+.ui-controlgroup .ui-controlgroup-label {
+ padding: .4em 1em;
+}
+.ui-controlgroup .ui-controlgroup-label span {
+ font-size: 80%;
+}
+.ui-controlgroup-horizontal .ui-controlgroup-label + .ui-controlgroup-item {
+ border-left: none;
+}
+.ui-controlgroup-vertical .ui-controlgroup-label + .ui-controlgroup-item {
+ border-top: none;
+}
+.ui-controlgroup-horizontal .ui-controlgroup-label.ui-widget-content {
+ border-right: none;
+}
+.ui-controlgroup-vertical .ui-controlgroup-label.ui-widget-content {
+ border-bottom: none;
+}
+
+/* Spinner specific style fixes */
+.ui-controlgroup-vertical .ui-spinner-input {
+
+ /* Support: IE8 only, Android < 4.4 only */
+ width: 75%;
+ width: calc( 100% - 2.4em );
+}
+.ui-controlgroup-vertical .ui-spinner .ui-spinner-up {
+ border-top-style: solid;
+}
+
+.ui-checkboxradio-label .ui-icon-background {
+ box-shadow: inset 1px 1px 1px #ccc;
+ border-radius: .12em;
+ border: none;
+}
+.ui-checkboxradio-radio-label .ui-icon-background {
+ width: 16px;
+ height: 16px;
+ border-radius: 1em;
+ overflow: visible;
+ border: none;
+}
+.ui-checkboxradio-radio-label.ui-checkboxradio-checked .ui-icon,
+.ui-checkboxradio-radio-label.ui-checkboxradio-checked:hover .ui-icon {
+ background-image: none;
+ width: 8px;
+ height: 8px;
+ border-width: 4px;
+ border-style: solid;
+}
+.ui-checkboxradio-disabled {
+ pointer-events: none;
+}
+.ui-datepicker {
+ width: 17em;
+ padding: .2em .2em 0;
+ display: none;
+}
+.ui-datepicker .ui-datepicker-header {
+ position: relative;
+ padding: .2em 0;
+}
+.ui-datepicker .ui-datepicker-prev,
+.ui-datepicker .ui-datepicker-next {
+ position: absolute;
+ top: 2px;
+ width: 1.8em;
+ height: 1.8em;
+}
+.ui-datepicker .ui-datepicker-prev-hover,
+.ui-datepicker .ui-datepicker-next-hover {
+ top: 1px;
+}
+.ui-datepicker .ui-datepicker-prev {
+ left: 2px;
+}
+.ui-datepicker .ui-datepicker-next {
+ right: 2px;
+}
+.ui-datepicker .ui-datepicker-prev-hover {
+ left: 1px;
+}
+.ui-datepicker .ui-datepicker-next-hover {
+ right: 1px;
+}
+.ui-datepicker .ui-datepicker-prev span,
+.ui-datepicker .ui-datepicker-next span {
+ display: block;
+ position: absolute;
+ left: 50%;
+ margin-left: -8px;
+ top: 50%;
+ margin-top: -8px;
+}
+.ui-datepicker .ui-datepicker-title {
+ margin: 0 2.3em;
+ line-height: 1.8em;
+ text-align: center;
+}
+.ui-datepicker .ui-datepicker-title select {
+ font-size: 1em;
+ margin: 1px 0;
+}
+.ui-datepicker select.ui-datepicker-month,
+.ui-datepicker select.ui-datepicker-year {
+ width: 45%;
+}
+.ui-datepicker table {
+ width: 100%;
+ font-size: .9em;
+ border-collapse: collapse;
+ margin: 0 0 .4em;
+}
+.ui-datepicker th {
+ padding: .7em .3em;
+ text-align: center;
+ font-weight: bold;
+ border: 0;
+}
+.ui-datepicker td {
+ border: 0;
+ padding: 1px;
+}
+.ui-datepicker td span,
+.ui-datepicker td a {
+ display: block;
+ padding: .2em;
+ text-align: right;
+ text-decoration: none;
+}
+.ui-datepicker .ui-datepicker-buttonpane {
+ background-image: none;
+ margin: .7em 0 0 0;
+ padding: 0 .2em;
+ border-left: 0;
+ border-right: 0;
+ border-bottom: 0;
+}
+.ui-datepicker .ui-datepicker-buttonpane button {
+ float: right;
+ margin: .5em .2em .4em;
+ cursor: pointer;
+ padding: .2em .6em .3em .6em;
+ width: auto;
+ overflow: visible;
+}
+.ui-datepicker .ui-datepicker-buttonpane button.ui-datepicker-current {
+ float: left;
+}
+
+/* with multiple calendars */
+.ui-datepicker.ui-datepicker-multi {
+ width: auto;
+}
+.ui-datepicker-multi .ui-datepicker-group {
+ float: left;
+}
+.ui-datepicker-multi .ui-datepicker-group table {
+ width: 95%;
+ margin: 0 auto .4em;
+}
+.ui-datepicker-multi-2 .ui-datepicker-group {
+ width: 50%;
+}
+.ui-datepicker-multi-3 .ui-datepicker-group {
+ width: 33.3%;
+}
+.ui-datepicker-multi-4 .ui-datepicker-group {
+ width: 25%;
+}
+.ui-datepicker-multi .ui-datepicker-group-last .ui-datepicker-header,
+.ui-datepicker-multi .ui-datepicker-group-middle .ui-datepicker-header {
+ border-left-width: 0;
+}
+.ui-datepicker-multi .ui-datepicker-buttonpane {
+ clear: left;
+}
+.ui-datepicker-row-break {
+ clear: both;
+ width: 100%;
+ font-size: 0;
+}
+
+/* RTL support */
+.ui-datepicker-rtl {
+ direction: rtl;
+}
+.ui-datepicker-rtl .ui-datepicker-prev {
+ right: 2px;
+ left: auto;
+}
+.ui-datepicker-rtl .ui-datepicker-next {
+ left: 2px;
+ right: auto;
+}
+.ui-datepicker-rtl .ui-datepicker-prev:hover {
+ right: 1px;
+ left: auto;
+}
+.ui-datepicker-rtl .ui-datepicker-next:hover {
+ left: 1px;
+ right: auto;
+}
+.ui-datepicker-rtl .ui-datepicker-buttonpane {
+ clear: right;
+}
+.ui-datepicker-rtl .ui-datepicker-buttonpane button {
+ float: left;
+}
+.ui-datepicker-rtl .ui-datepicker-buttonpane button.ui-datepicker-current,
+.ui-datepicker-rtl .ui-datepicker-group {
+ float: right;
+}
+.ui-datepicker-rtl .ui-datepicker-group-last .ui-datepicker-header,
+.ui-datepicker-rtl .ui-datepicker-group-middle .ui-datepicker-header {
+ border-right-width: 0;
+ border-left-width: 1px;
+}
+
+/* Icons */
+.ui-datepicker .ui-icon {
+ display: block;
+ text-indent: -99999px;
+ overflow: hidden;
+ background-repeat: no-repeat;
+ left: .5em;
+ top: .3em;
+}
+.ui-dialog {
+ position: absolute;
+ top: 0;
+ left: 0;
+ padding: .2em;
+ outline: 0;
+}
+.ui-dialog .ui-dialog-titlebar {
+ padding: .4em 1em;
+ position: relative;
+}
+.ui-dialog .ui-dialog-title {
+ float: left;
+ margin: .1em 0;
+ white-space: nowrap;
+ width: 90%;
+ overflow: hidden;
+ text-overflow: ellipsis;
+}
+.ui-dialog .ui-dialog-titlebar-close {
+ position: absolute;
+ right: .3em;
+ top: 50%;
+ width: 20px;
+ margin: -10px 0 0 0;
+ padding: 1px;
+ height: 20px;
+}
+.ui-dialog .ui-dialog-content {
+ position: relative;
+ border: 0;
+ padding: .5em 1em;
+ background: none;
+ overflow: auto;
+}
+.ui-dialog .ui-dialog-buttonpane {
+ text-align: left;
+ border-width: 1px 0 0 0;
+ background-image: none;
+ margin-top: .5em;
+ padding: .3em 1em .5em .4em;
+}
+.ui-dialog .ui-dialog-buttonpane .ui-dialog-buttonset {
+ float: right;
+}
+.ui-dialog .ui-dialog-buttonpane button {
+ margin: .5em .4em .5em 0;
+ cursor: pointer;
+}
+.ui-dialog .ui-resizable-n {
+ height: 2px;
+ top: 0;
+}
+.ui-dialog .ui-resizable-e {
+ width: 2px;
+ right: 0;
+}
+.ui-dialog .ui-resizable-s {
+ height: 2px;
+ bottom: 0;
+}
+.ui-dialog .ui-resizable-w {
+ width: 2px;
+ left: 0;
+}
+.ui-dialog .ui-resizable-se,
+.ui-dialog .ui-resizable-sw,
+.ui-dialog .ui-resizable-ne,
+.ui-dialog .ui-resizable-nw {
+ width: 7px;
+ height: 7px;
+}
+.ui-dialog .ui-resizable-se {
+ right: 0;
+ bottom: 0;
+}
+.ui-dialog .ui-resizable-sw {
+ left: 0;
+ bottom: 0;
+}
+.ui-dialog .ui-resizable-ne {
+ right: 0;
+ top: 0;
+}
+.ui-dialog .ui-resizable-nw {
+ left: 0;
+ top: 0;
+}
+.ui-draggable .ui-dialog-titlebar {
+ cursor: move;
+}
+.ui-draggable-handle {
+ -ms-touch-action: none;
+ touch-action: none;
+}
+.ui-resizable {
+ position: relative;
+}
+.ui-resizable-handle {
+ position: absolute;
+ font-size: 0.1px;
+ display: block;
+ -ms-touch-action: none;
+ touch-action: none;
+}
+.ui-resizable-disabled .ui-resizable-handle,
+.ui-resizable-autohide .ui-resizable-handle {
+ display: none;
+}
+.ui-resizable-n {
+ cursor: n-resize;
+ height: 7px;
+ width: 100%;
+ top: -5px;
+ left: 0;
+}
+.ui-resizable-s {
+ cursor: s-resize;
+ height: 7px;
+ width: 100%;
+ bottom: -5px;
+ left: 0;
+}
+.ui-resizable-e {
+ cursor: e-resize;
+ width: 7px;
+ right: -5px;
+ top: 0;
+ height: 100%;
+}
+.ui-resizable-w {
+ cursor: w-resize;
+ width: 7px;
+ left: -5px;
+ top: 0;
+ height: 100%;
+}
+.ui-resizable-se {
+ cursor: se-resize;
+ width: 12px;
+ height: 12px;
+ right: 1px;
+ bottom: 1px;
+}
+.ui-resizable-sw {
+ cursor: sw-resize;
+ width: 9px;
+ height: 9px;
+ left: -5px;
+ bottom: -5px;
+}
+.ui-resizable-nw {
+ cursor: nw-resize;
+ width: 9px;
+ height: 9px;
+ left: -5px;
+ top: -5px;
+}
+.ui-resizable-ne {
+ cursor: ne-resize;
+ width: 9px;
+ height: 9px;
+ right: -5px;
+ top: -5px;
+}
+.ui-progressbar {
+ height: 2em;
+ text-align: left;
+ overflow: hidden;
+}
+.ui-progressbar .ui-progressbar-value {
+ margin: -1px;
+ height: 100%;
+}
+.ui-progressbar .ui-progressbar-overlay {
+ background: url("data:image/gif;base64,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");
+ height: 100%;
+ -ms-filter: "alpha(opacity=25)"; /* support: IE8 */
+ opacity: 0.25;
+}
+.ui-progressbar-indeterminate .ui-progressbar-value {
+ background-image: none;
+}
+.ui-selectable {
+ -ms-touch-action: none;
+ touch-action: none;
+}
+.ui-selectable-helper {
+ position: absolute;
+ z-index: 100;
+ border: 1px dotted black;
+}
+.ui-selectmenu-menu {
+ padding: 0;
+ margin: 0;
+ position: absolute;
+ top: 0;
+ left: 0;
+ display: none;
+}
+.ui-selectmenu-menu .ui-menu {
+ overflow: auto;
+ overflow-x: hidden;
+ padding-bottom: 1px;
+}
+.ui-selectmenu-menu .ui-menu .ui-selectmenu-optgroup {
+ font-size: 1em;
+ font-weight: bold;
+ line-height: 1.5;
+ padding: 2px 0.4em;
+ margin: 0.5em 0 0 0;
+ height: auto;
+ border: 0;
+}
+.ui-selectmenu-open {
+ display: block;
+}
+.ui-selectmenu-text {
+ display: block;
+ margin-right: 20px;
+ overflow: hidden;
+ text-overflow: ellipsis;
+}
+.ui-selectmenu-button.ui-button {
+ text-align: left;
+ white-space: nowrap;
+ width: 14em;
+}
+.ui-selectmenu-icon.ui-icon {
+ float: right;
+ margin-top: 0;
+}
+.ui-slider {
+ position: relative;
+ text-align: left;
+}
+.ui-slider .ui-slider-handle {
+ position: absolute;
+ z-index: 2;
+ width: 1.2em;
+ height: 1.2em;
+ cursor: pointer;
+ -ms-touch-action: none;
+ touch-action: none;
+}
+.ui-slider .ui-slider-range {
+ position: absolute;
+ z-index: 1;
+ font-size: .7em;
+ display: block;
+ border: 0;
+ background-position: 0 0;
+}
+
+/* support: IE8 - See #6727 */
+.ui-slider.ui-state-disabled .ui-slider-handle,
+.ui-slider.ui-state-disabled .ui-slider-range {
+ filter: inherit;
+}
+
+.ui-slider-horizontal {
+ height: .8em;
+}
+.ui-slider-horizontal .ui-slider-handle {
+ top: -.3em;
+ margin-left: -.6em;
+}
+.ui-slider-horizontal .ui-slider-range {
+ top: 0;
+ height: 100%;
+}
+.ui-slider-horizontal .ui-slider-range-min {
+ left: 0;
+}
+.ui-slider-horizontal .ui-slider-range-max {
+ right: 0;
+}
+
+.ui-slider-vertical {
+ width: .8em;
+ height: 100px;
+}
+.ui-slider-vertical .ui-slider-handle {
+ left: -.3em;
+ margin-left: 0;
+ margin-bottom: -.6em;
+}
+.ui-slider-vertical .ui-slider-range {
+ left: 0;
+ width: 100%;
+}
+.ui-slider-vertical .ui-slider-range-min {
+ bottom: 0;
+}
+.ui-slider-vertical .ui-slider-range-max {
+ top: 0;
+}
+.ui-sortable-handle {
+ -ms-touch-action: none;
+ touch-action: none;
+}
+.ui-spinner {
+ position: relative;
+ display: inline-block;
+ overflow: hidden;
+ padding: 0;
+ vertical-align: middle;
+}
+.ui-spinner-input {
+ border: none;
+ background: none;
+ color: inherit;
+ padding: .222em 0;
+ margin: .2em 0;
+ vertical-align: middle;
+ margin-left: .4em;
+ margin-right: 2em;
+}
+.ui-spinner-button {
+ width: 1.6em;
+ height: 50%;
+ font-size: .5em;
+ padding: 0;
+ margin: 0;
+ text-align: center;
+ position: absolute;
+ cursor: default;
+ display: block;
+ overflow: hidden;
+ right: 0;
+}
+/* more specificity required here to override default borders */
+.ui-spinner a.ui-spinner-button {
+ border-top-style: none;
+ border-bottom-style: none;
+ border-right-style: none;
+}
+.ui-spinner-up {
+ top: 0;
+}
+.ui-spinner-down {
+ bottom: 0;
+}
+.ui-tabs {
+ position: relative;/* position: relative prevents IE scroll bug (element with position: relative inside container with overflow: auto appear as "fixed") */
+ padding: .2em;
+}
+.ui-tabs .ui-tabs-nav {
+ margin: 0;
+ padding: .2em .2em 0;
+}
+.ui-tabs .ui-tabs-nav li {
+ list-style: none;
+ float: left;
+ position: relative;
+ top: 0;
+ margin: 1px .2em 0 0;
+ border-bottom-width: 0;
+ padding: 0;
+ white-space: nowrap;
+}
+.ui-tabs .ui-tabs-nav .ui-tabs-anchor {
+ float: left;
+ padding: .5em 1em;
+ text-decoration: none;
+}
+.ui-tabs .ui-tabs-nav li.ui-tabs-active {
+ margin-bottom: -1px;
+ padding-bottom: 1px;
+}
+.ui-tabs .ui-tabs-nav li.ui-tabs-active .ui-tabs-anchor,
+.ui-tabs .ui-tabs-nav li.ui-state-disabled .ui-tabs-anchor,
+.ui-tabs .ui-tabs-nav li.ui-tabs-loading .ui-tabs-anchor {
+ cursor: text;
+}
+.ui-tabs-collapsible .ui-tabs-nav li.ui-tabs-active .ui-tabs-anchor {
+ cursor: pointer;
+}
+.ui-tabs .ui-tabs-panel {
+ display: block;
+ border-width: 0;
+ padding: 1em 1.4em;
+ background: none;
+}
+.ui-tooltip {
+ padding: 8px;
+ position: absolute;
+ z-index: 9999;
+ max-width: 300px;
+}
+body .ui-tooltip {
+ border-width: 2px;
+}
+/* Component containers
+----------------------------------*/
+.ui-widget {
+ font-family: Trebuchet MS,Tahoma,Verdana,Arial,sans-serif;
+ font-size: 1.1em;
+}
+.ui-widget .ui-widget {
+ font-size: 1em;
+}
+.ui-widget input,
+.ui-widget select,
+.ui-widget textarea,
+.ui-widget button {
+ font-family: Trebuchet MS,Tahoma,Verdana,Arial,sans-serif;
+ font-size: 1em;
+}
+.ui-widget.ui-widget-content {
+ border: 1px solid #cccccc;
+}
+.ui-widget-content {
+ border: 1px solid #dddddd;
+ background: #eeeeee url("images/ui-bg_highlight-soft_100_eeeeee_1x100.png") 50% top repeat-x;
+ color: #333333;
+}
+.ui-widget-content a {
+ color: #333333;
+}
+.ui-widget-header {
+ border: 1px solid #e78f08;
+ background: #f6a828 url("images/ui-bg_gloss-wave_35_f6a828_500x100.png") 50% 50% repeat-x;
+ color: #ffffff;
+ font-weight: bold;
+}
+.ui-widget-header a {
+ color: #ffffff;
+}
+
+/* Interaction states
+----------------------------------*/
+.ui-state-default,
+.ui-widget-content .ui-state-default,
+.ui-widget-header .ui-state-default,
+.ui-button,
+
+/* We use html here because we need a greater specificity to make sure disabled
+works properly when clicked or hovered */
+html .ui-button.ui-state-disabled:hover,
+html .ui-button.ui-state-disabled:active {
+ border: 1px solid #cccccc;
+ background: #f6f6f6 url("images/ui-bg_glass_100_f6f6f6_1x400.png") 50% 50% repeat-x;
+ font-weight: bold;
+ color: #1c94c4;
+}
+.ui-state-default a,
+.ui-state-default a:link,
+.ui-state-default a:visited,
+a.ui-button,
+a:link.ui-button,
+a:visited.ui-button,
+.ui-button {
+ color: #1c94c4;
+ text-decoration: none;
+}
+.ui-state-hover,
+.ui-widget-content .ui-state-hover,
+.ui-widget-header .ui-state-hover,
+.ui-state-focus,
+.ui-widget-content .ui-state-focus,
+.ui-widget-header .ui-state-focus,
+.ui-button:hover,
+.ui-button:focus {
+ border: 1px solid #fbcb09;
+ background: #fdf5ce url("images/ui-bg_glass_100_fdf5ce_1x400.png") 50% 50% repeat-x;
+ font-weight: bold;
+ color: #c77405;
+}
+.ui-state-hover a,
+.ui-state-hover a:hover,
+.ui-state-hover a:link,
+.ui-state-hover a:visited,
+.ui-state-focus a,
+.ui-state-focus a:hover,
+.ui-state-focus a:link,
+.ui-state-focus a:visited,
+a.ui-button:hover,
+a.ui-button:focus {
+ color: #c77405;
+ text-decoration: none;
+}
+
+.ui-visual-focus {
+ box-shadow: 0 0 3px 1px rgb(94, 158, 214);
+}
+.ui-state-active,
+.ui-widget-content .ui-state-active,
+.ui-widget-header .ui-state-active,
+a.ui-button:active,
+.ui-button:active,
+.ui-button.ui-state-active:hover {
+ border: 1px solid #fbd850;
+ background: #ffffff url("images/ui-bg_glass_65_ffffff_1x400.png") 50% 50% repeat-x;
+ font-weight: bold;
+ color: #eb8f00;
+}
+.ui-icon-background,
+.ui-state-active .ui-icon-background {
+ border: #fbd850;
+ background-color: #eb8f00;
+}
+.ui-state-active a,
+.ui-state-active a:link,
+.ui-state-active a:visited {
+ color: #eb8f00;
+ text-decoration: none;
+}
+
+/* Interaction Cues
+----------------------------------*/
+.ui-state-highlight,
+.ui-widget-content .ui-state-highlight,
+.ui-widget-header .ui-state-highlight {
+ border: 1px solid #fed22f;
+ background: #ffe45c url("images/ui-bg_highlight-soft_75_ffe45c_1x100.png") 50% top repeat-x;
+ color: #363636;
+}
+.ui-state-checked {
+ border: 1px solid #fed22f;
+ background: #ffe45c;
+}
+.ui-state-highlight a,
+.ui-widget-content .ui-state-highlight a,
+.ui-widget-header .ui-state-highlight a {
+ color: #363636;
+}
+.ui-state-error,
+.ui-widget-content .ui-state-error,
+.ui-widget-header .ui-state-error {
+ border: 1px solid #cd0a0a;
+ background: #b81900 url("images/ui-bg_diagonals-thick_18_b81900_40x40.png") 50% 50% repeat;
+ color: #ffffff;
+}
+.ui-state-error a,
+.ui-widget-content .ui-state-error a,
+.ui-widget-header .ui-state-error a {
+ color: #ffffff;
+}
+.ui-state-error-text,
+.ui-widget-content .ui-state-error-text,
+.ui-widget-header .ui-state-error-text {
+ color: #ffffff;
+}
+.ui-priority-primary,
+.ui-widget-content .ui-priority-primary,
+.ui-widget-header .ui-priority-primary {
+ font-weight: bold;
+}
+.ui-priority-secondary,
+.ui-widget-content .ui-priority-secondary,
+.ui-widget-header .ui-priority-secondary {
+ opacity: .7;
+ -ms-filter: "alpha(opacity=70)"; /* support: IE8 */
+ font-weight: normal;
+}
+.ui-state-disabled,
+.ui-widget-content .ui-state-disabled,
+.ui-widget-header .ui-state-disabled {
+ opacity: .35;
+ -ms-filter: "alpha(opacity=35)"; /* support: IE8 */
+ background-image: none;
+}
+.ui-state-disabled .ui-icon {
+ -ms-filter: "alpha(opacity=35)"; /* support: IE8 - See #6059 */
+}
+
+/* Icons
+----------------------------------*/
+
+/* states and images */
+.ui-icon {
+ width: 16px;
+ height: 16px;
+}
+.ui-icon,
+.ui-widget-content .ui-icon {
+ background-image: url("images/ui-icons_222222_256x240.png");
+}
+.ui-widget-header .ui-icon {
+ background-image: url("images/ui-icons_ffffff_256x240.png");
+}
+.ui-state-hover .ui-icon,
+.ui-state-focus .ui-icon,
+.ui-button:hover .ui-icon,
+.ui-button:focus .ui-icon {
+ background-image: url("images/ui-icons_ef8c08_256x240.png");
+}
+.ui-state-active .ui-icon,
+.ui-button:active .ui-icon {
+ background-image: url("images/ui-icons_ef8c08_256x240.png");
+}
+.ui-state-highlight .ui-icon,
+.ui-button .ui-state-highlight.ui-icon {
+ background-image: url("images/ui-icons_228ef1_256x240.png");
+}
+.ui-state-error .ui-icon,
+.ui-state-error-text .ui-icon {
+ background-image: url("images/ui-icons_ffd27a_256x240.png");
+}
+.ui-button .ui-icon {
+ background-image: url("images/ui-icons_ef8c08_256x240.png");
+}
+
+/* positioning */
+/* Three classes needed to override `.ui-button:hover .ui-icon` */
+.ui-icon-blank.ui-icon-blank.ui-icon-blank {
+ background-image: none;
+}
+.ui-icon-caret-1-n { background-position: 0 0; }
+.ui-icon-caret-1-ne { background-position: -16px 0; }
+.ui-icon-caret-1-e { background-position: -32px 0; }
+.ui-icon-caret-1-se { background-position: -48px 0; }
+.ui-icon-caret-1-s { background-position: -65px 0; }
+.ui-icon-caret-1-sw { background-position: -80px 0; }
+.ui-icon-caret-1-w { background-position: -96px 0; }
+.ui-icon-caret-1-nw { background-position: -112px 0; }
+.ui-icon-caret-2-n-s { background-position: -128px 0; }
+.ui-icon-caret-2-e-w { background-position: -144px 0; }
+.ui-icon-triangle-1-n { background-position: 0 -16px; }
+.ui-icon-triangle-1-ne { background-position: -16px -16px; }
+.ui-icon-triangle-1-e { background-position: -32px -16px; }
+.ui-icon-triangle-1-se { background-position: -48px -16px; }
+.ui-icon-triangle-1-s { background-position: -65px -16px; }
+.ui-icon-triangle-1-sw { background-position: -80px -16px; }
+.ui-icon-triangle-1-w { background-position: -96px -16px; }
+.ui-icon-triangle-1-nw { background-position: -112px -16px; }
+.ui-icon-triangle-2-n-s { background-position: -128px -16px; }
+.ui-icon-triangle-2-e-w { background-position: -144px -16px; }
+.ui-icon-arrow-1-n { background-position: 0 -32px; }
+.ui-icon-arrow-1-ne { background-position: -16px -32px; }
+.ui-icon-arrow-1-e { background-position: -32px -32px; }
+.ui-icon-arrow-1-se { background-position: -48px -32px; }
+.ui-icon-arrow-1-s { background-position: -65px -32px; }
+.ui-icon-arrow-1-sw { background-position: -80px -32px; }
+.ui-icon-arrow-1-w { background-position: -96px -32px; }
+.ui-icon-arrow-1-nw { background-position: -112px -32px; }
+.ui-icon-arrow-2-n-s { background-position: -128px -32px; }
+.ui-icon-arrow-2-ne-sw { background-position: -144px -32px; }
+.ui-icon-arrow-2-e-w { background-position: -160px -32px; }
+.ui-icon-arrow-2-se-nw { background-position: -176px -32px; }
+.ui-icon-arrowstop-1-n { background-position: -192px -32px; }
+.ui-icon-arrowstop-1-e { background-position: -208px -32px; }
+.ui-icon-arrowstop-1-s { background-position: -224px -32px; }
+.ui-icon-arrowstop-1-w { background-position: -240px -32px; }
+.ui-icon-arrowthick-1-n { background-position: 1px -48px; }
+.ui-icon-arrowthick-1-ne { background-position: -16px -48px; }
+.ui-icon-arrowthick-1-e { background-position: -32px -48px; }
+.ui-icon-arrowthick-1-se { background-position: -48px -48px; }
+.ui-icon-arrowthick-1-s { background-position: -64px -48px; }
+.ui-icon-arrowthick-1-sw { background-position: -80px -48px; }
+.ui-icon-arrowthick-1-w { background-position: -96px -48px; }
+.ui-icon-arrowthick-1-nw { background-position: -112px -48px; }
+.ui-icon-arrowthick-2-n-s { background-position: -128px -48px; }
+.ui-icon-arrowthick-2-ne-sw { background-position: -144px -48px; }
+.ui-icon-arrowthick-2-e-w { background-position: -160px -48px; }
+.ui-icon-arrowthick-2-se-nw { background-position: -176px -48px; }
+.ui-icon-arrowthickstop-1-n { background-position: -192px -48px; }
+.ui-icon-arrowthickstop-1-e { background-position: -208px -48px; }
+.ui-icon-arrowthickstop-1-s { background-position: -224px -48px; }
+.ui-icon-arrowthickstop-1-w { background-position: -240px -48px; }
+.ui-icon-arrowreturnthick-1-w { background-position: 0 -64px; }
+.ui-icon-arrowreturnthick-1-n { background-position: -16px -64px; }
+.ui-icon-arrowreturnthick-1-e { background-position: -32px -64px; }
+.ui-icon-arrowreturnthick-1-s { background-position: -48px -64px; }
+.ui-icon-arrowreturn-1-w { background-position: -64px -64px; }
+.ui-icon-arrowreturn-1-n { background-position: -80px -64px; }
+.ui-icon-arrowreturn-1-e { background-position: -96px -64px; }
+.ui-icon-arrowreturn-1-s { background-position: -112px -64px; }
+.ui-icon-arrowrefresh-1-w { background-position: -128px -64px; }
+.ui-icon-arrowrefresh-1-n { background-position: -144px -64px; }
+.ui-icon-arrowrefresh-1-e { background-position: -160px -64px; }
+.ui-icon-arrowrefresh-1-s { background-position: -176px -64px; }
+.ui-icon-arrow-4 { background-position: 0 -80px; }
+.ui-icon-arrow-4-diag { background-position: -16px -80px; }
+.ui-icon-extlink { background-position: -32px -80px; }
+.ui-icon-newwin { background-position: -48px -80px; }
+.ui-icon-refresh { background-position: -64px -80px; }
+.ui-icon-shuffle { background-position: -80px -80px; }
+.ui-icon-transfer-e-w { background-position: -96px -80px; }
+.ui-icon-transferthick-e-w { background-position: -112px -80px; }
+.ui-icon-folder-collapsed { background-position: 0 -96px; }
+.ui-icon-folder-open { background-position: -16px -96px; }
+.ui-icon-document { background-position: -32px -96px; }
+.ui-icon-document-b { background-position: -48px -96px; }
+.ui-icon-note { background-position: -64px -96px; }
+.ui-icon-mail-closed { background-position: -80px -96px; }
+.ui-icon-mail-open { background-position: -96px -96px; }
+.ui-icon-suitcase { background-position: -112px -96px; }
+.ui-icon-comment { background-position: -128px -96px; }
+.ui-icon-person { background-position: -144px -96px; }
+.ui-icon-print { background-position: -160px -96px; }
+.ui-icon-trash { background-position: -176px -96px; }
+.ui-icon-locked { background-position: -192px -96px; }
+.ui-icon-unlocked { background-position: -208px -96px; }
+.ui-icon-bookmark { background-position: -224px -96px; }
+.ui-icon-tag { background-position: -240px -96px; }
+.ui-icon-home { background-position: 0 -112px; }
+.ui-icon-flag { background-position: -16px -112px; }
+.ui-icon-calendar { background-position: -32px -112px; }
+.ui-icon-cart { background-position: -48px -112px; }
+.ui-icon-pencil { background-position: -64px -112px; }
+.ui-icon-clock { background-position: -80px -112px; }
+.ui-icon-disk { background-position: -96px -112px; }
+.ui-icon-calculator { background-position: -112px -112px; }
+.ui-icon-zoomin { background-position: -128px -112px; }
+.ui-icon-zoomout { background-position: -144px -112px; }
+.ui-icon-search { background-position: -160px -112px; }
+.ui-icon-wrench { background-position: -176px -112px; }
+.ui-icon-gear { background-position: -192px -112px; }
+.ui-icon-heart { background-position: -208px -112px; }
+.ui-icon-star { background-position: -224px -112px; }
+.ui-icon-link { background-position: -240px -112px; }
+.ui-icon-cancel { background-position: 0 -128px; }
+.ui-icon-plus { background-position: -16px -128px; }
+.ui-icon-plusthick { background-position: -32px -128px; }
+.ui-icon-minus { background-position: -48px -128px; }
+.ui-icon-minusthick { background-position: -64px -128px; }
+.ui-icon-close { background-position: -80px -128px; }
+.ui-icon-closethick { background-position: -96px -128px; }
+.ui-icon-key { background-position: -112px -128px; }
+.ui-icon-lightbulb { background-position: -128px -128px; }
+.ui-icon-scissors { background-position: -144px -128px; }
+.ui-icon-clipboard { background-position: -160px -128px; }
+.ui-icon-copy { background-position: -176px -128px; }
+.ui-icon-contact { background-position: -192px -128px; }
+.ui-icon-image { background-position: -208px -128px; }
+.ui-icon-video { background-position: -224px -128px; }
+.ui-icon-script { background-position: -240px -128px; }
+.ui-icon-alert { background-position: 0 -144px; }
+.ui-icon-info { background-position: -16px -144px; }
+.ui-icon-notice { background-position: -32px -144px; }
+.ui-icon-help { background-position: -48px -144px; }
+.ui-icon-check { background-position: -64px -144px; }
+.ui-icon-bullet { background-position: -80px -144px; }
+.ui-icon-radio-on { background-position: -96px -144px; }
+.ui-icon-radio-off { background-position: -112px -144px; }
+.ui-icon-pin-w { background-position: -128px -144px; }
+.ui-icon-pin-s { background-position: -144px -144px; }
+.ui-icon-play { background-position: 0 -160px; }
+.ui-icon-pause { background-position: -16px -160px; }
+.ui-icon-seek-next { background-position: -32px -160px; }
+.ui-icon-seek-prev { background-position: -48px -160px; }
+.ui-icon-seek-end { background-position: -64px -160px; }
+.ui-icon-seek-start { background-position: -80px -160px; }
+/* ui-icon-seek-first is deprecated, use ui-icon-seek-start instead */
+.ui-icon-seek-first { background-position: -80px -160px; }
+.ui-icon-stop { background-position: -96px -160px; }
+.ui-icon-eject { background-position: -112px -160px; }
+.ui-icon-volume-off { background-position: -128px -160px; }
+.ui-icon-volume-on { background-position: -144px -160px; }
+.ui-icon-power { background-position: 0 -176px; }
+.ui-icon-signal-diag { background-position: -16px -176px; }
+.ui-icon-signal { background-position: -32px -176px; }
+.ui-icon-battery-0 { background-position: -48px -176px; }
+.ui-icon-battery-1 { background-position: -64px -176px; }
+.ui-icon-battery-2 { background-position: -80px -176px; }
+.ui-icon-battery-3 { background-position: -96px -176px; }
+.ui-icon-circle-plus { background-position: 0 -192px; }
+.ui-icon-circle-minus { background-position: -16px -192px; }
+.ui-icon-circle-close { background-position: -32px -192px; }
+.ui-icon-circle-triangle-e { background-position: -48px -192px; }
+.ui-icon-circle-triangle-s { background-position: -64px -192px; }
+.ui-icon-circle-triangle-w { background-position: -80px -192px; }
+.ui-icon-circle-triangle-n { background-position: -96px -192px; }
+.ui-icon-circle-arrow-e { background-position: -112px -192px; }
+.ui-icon-circle-arrow-s { background-position: -128px -192px; }
+.ui-icon-circle-arrow-w { background-position: -144px -192px; }
+.ui-icon-circle-arrow-n { background-position: -160px -192px; }
+.ui-icon-circle-zoomin { background-position: -176px -192px; }
+.ui-icon-circle-zoomout { background-position: -192px -192px; }
+.ui-icon-circle-check { background-position: -208px -192px; }
+.ui-icon-circlesmall-plus { background-position: 0 -208px; }
+.ui-icon-circlesmall-minus { background-position: -16px -208px; }
+.ui-icon-circlesmall-close { background-position: -32px -208px; }
+.ui-icon-squaresmall-plus { background-position: -48px -208px; }
+.ui-icon-squaresmall-minus { background-position: -64px -208px; }
+.ui-icon-squaresmall-close { background-position: -80px -208px; }
+.ui-icon-grip-dotted-vertical { background-position: 0 -224px; }
+.ui-icon-grip-dotted-horizontal { background-position: -16px -224px; }
+.ui-icon-grip-solid-vertical { background-position: -32px -224px; }
+.ui-icon-grip-solid-horizontal { background-position: -48px -224px; }
+.ui-icon-gripsmall-diagonal-se { background-position: -64px -224px; }
+.ui-icon-grip-diagonal-se { background-position: -80px -224px; }
+
+
+/* Misc visuals
+----------------------------------*/
+
+/* Corner radius */
+.ui-corner-all,
+.ui-corner-top,
+.ui-corner-left,
+.ui-corner-tl {
+ border-top-left-radius: 4px;
+}
+.ui-corner-all,
+.ui-corner-top,
+.ui-corner-right,
+.ui-corner-tr {
+ border-top-right-radius: 4px;
+}
+.ui-corner-all,
+.ui-corner-bottom,
+.ui-corner-left,
+.ui-corner-bl {
+ border-bottom-left-radius: 4px;
+}
+.ui-corner-all,
+.ui-corner-bottom,
+.ui-corner-right,
+.ui-corner-br {
+ border-bottom-right-radius: 4px;
+}
+
+/* Overlays */
+.ui-widget-overlay {
+ background: #666666 url("images/ui-bg_diagonals-thick_20_666666_40x40.png") 50% 50% repeat;
+ opacity: .5;
+ -ms-filter: Alpha(Opacity=50); /* support: IE8 */
+}
+.ui-widget-shadow {
+ -webkit-box-shadow: -5px -5px 5px #000000;
+ box-shadow: -5px -5px 5px #000000;
+}
diff --git a/src/webapp/js/ac.js b/src/webapp/js/ac.js
new file mode 100644
index 0000000..771e61b
--- /dev/null
+++ b/src/webapp/js/ac.js
@@ -0,0 +1,21 @@
+$(function() {
+ var URL_PREFIX = "http://localhost:8984/solr/autocomplete/autocomplete?suggest.dictionary=perso&q=";
+ var URL_SUFFIX = "&wt=json";
+ $("#searchBox").autocomplete({
+ source : function(request, response) {
+ var URL = URL_PREFIX + encodeURIComponent($("#searchBox").val()) + URL_SUFFIX;
+ $.ajax({
+ url : URL,
+ success : function(data) {
+ var docs = JSON.stringify(data.suggest.perso.response.hits);
+ var jsonData = JSON.parse(docs);
+ console.debug(jsonData);
+ response($.map(jsonData, function(value, key) { return { label : value.search } }));
+ },
+ dataType : 'jsonp',
+ jsonp : 'json.wrf'
+ });
+ },
+ minLength : 1
+ })
+ });
\ No newline at end of file
diff --git a/src/webapp/js/jquery-3.6.0.js b/src/webapp/js/jquery-3.6.0.js
new file mode 100644
index 0000000..fc6c299
--- /dev/null
+++ b/src/webapp/js/jquery-3.6.0.js
@@ -0,0 +1,10881 @@
+/*!
+ * jQuery JavaScript Library v3.6.0
+ * https://jquery.com/
+ *
+ * Includes Sizzle.js
+ * https://sizzlejs.com/
+ *
+ * Copyright OpenJS Foundation and other contributors
+ * Released under the MIT license
+ * https://jquery.org/license
+ *
+ * Date: 2021-03-02T17:08Z
+ */
+( function( global, factory ) {
+
+ "use strict";
+
+ if ( typeof module === "object" && typeof module.exports === "object" ) {
+
+ // For CommonJS and CommonJS-like environments where a proper `window`
+ // is present, execute the factory and get jQuery.
+ // For environments that do not have a `window` with a `document`
+ // (such as Node.js), expose a factory as module.exports.
+ // This accentuates the need for the creation of a real `window`.
+ // e.g. var jQuery = require("jquery")(window);
+ // See ticket #14549 for more info.
+ module.exports = global.document ?
+ factory( global, true ) :
+ function( w ) {
+ if ( !w.document ) {
+ throw new Error( "jQuery requires a window with a document" );
+ }
+ return factory( w );
+ };
+ } else {
+ factory( global );
+ }
+
+// Pass this if window is not defined yet
+} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
+
+// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
+// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
+// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
+// enough that all such attempts are guarded in a try block.
+"use strict";
+
+var arr = [];
+
+var getProto = Object.getPrototypeOf;
+
+var slice = arr.slice;
+
+var flat = arr.flat ? function( array ) {
+ return arr.flat.call( array );
+} : function( array ) {
+ return arr.concat.apply( [], array );
+};
+
+
+var push = arr.push;
+
+var indexOf = arr.indexOf;
+
+var class2type = {};
+
+var toString = class2type.toString;
+
+var hasOwn = class2type.hasOwnProperty;
+
+var fnToString = hasOwn.toString;
+
+var ObjectFunctionString = fnToString.call( Object );
+
+var support = {};
+
+var isFunction = function isFunction( obj ) {
+
+ // Support: Chrome <=57, Firefox <=52
+ // In some browsers, typeof returns "function" for HTML