DATACMNS-1258 - Added infrastructure for SpEL handling in queries.

The goal is to extract the parts of query parsing that are generic into commons in order to avoid slightly different behavior in modules. 

Extracted the QuotationMap from Spring Data JPA as well as the part of the parser that deals with extracting SpEL expressions.
Added the SpelEvaluator for evaluating the SpEL expressions.

Added enough configurability to satisfy the needs of Neo4j and JPA.
Mainly to support the different formats for bind parameter :name vs {name}.

Author: schauder

src/main/java/org/springframework/data/repository/query/parser/QuotationMap.java

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed 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.springframework.data.repository.query.parser;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.springframework.data.domain.Range;
+import org.springframework.lang.Nullable;
+
+/**
+ * Value object to analyze a String to determine the parts of the String that are quoted and offers an API to query that
+ * information.
+ *
+ * @author Jens Schauder
+ * @since 2.0.3
+ */
+public class QuotationMap {
+
+	private static final Set<Character> QUOTING_CHARACTERS = new HashSet<>(Arrays.asList('"', '\''));
+
+	private final List<Range<Integer>> quotedRanges = new ArrayList<>();
+
+	public QuotationMap(@Nullable String query) {
+
+		if (query == null) {
+			return;
+		}
+
+		Character inQuotation = null;
+		int start = 0;
+
+		for (int i = 0; i < query.length(); i++) {
+
+			char currentChar = query.charAt(i);
+
+			if (QUOTING_CHARACTERS.contains(currentChar)) {
+
+				if (inQuotation == null) {
+
+					inQuotation = currentChar;
+					start = i;
+
+				} else if (currentChar == inQuotation) {
+
+					inQuotation = null;
+					quotedRanges.add(Range.of(Range.Bound.inclusive(start), Range.Bound.inclusive(i)));
+				}
+			}
+		}
+
+		if (inQuotation != null) {
+			throw new IllegalArgumentException(
+					String.format("The string <%s> starts a quoted range at %d, but never ends it.", query, start));
+		}
+	}
+
+	/**
+	 * Checks if a given index is within a quoted range.
+	 *
+	 * @param index to check if it is part of a quoted range.
+	 * @return whether the query contains a quoted range at {@literal index}.
+	 */
+	public boolean isQuoted(int index) {
+		return quotedRanges.stream().anyMatch(r -> r.contains(index));
+	}
+}

src/main/java/org/springframework/data/repository/query/parser/SpelEvaluator.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed 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.springframework.data.repository.query.parser;
+
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.springframework.data.repository.query.EvaluationContextProvider;
+import org.springframework.data.repository.query.Parameters;
+import org.springframework.expression.EvaluationContext;
+import org.springframework.expression.spel.standard.SpelExpressionParser;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+
+/**
+ * Evaluates SpEL expressions as extracted by the SpelExtractor based on parameter information from a method and
+ * parameter values from a method call.
+ *
+ * @author Jens Schauder
+ * @author Gerrit Meier
+ */
+@RequiredArgsConstructor
+public class SpelEvaluator {
+
+	private final static SpelExpressionParser PARSER = new SpelExpressionParser();
+
+	@NonNull private final EvaluationContextProvider evaluationContextProvider;
+	@NonNull private final Parameters<?, ?> parameters;
+
+	/**
+	 * A map from parameter name to SpEL expression as returned by {@link SpelQueryContext.SpelExtractor#parameterNameToSpelMap()}.
+	 */
+	@NonNull private final Map<String, String> parameterNameToSpelMap;
+
+	/**
+	 * Evaluate all the SpEL expressions in {@link #parameterNameToSpelMap} based on values provided as an argument.
+	 *
+	 * @param values Parameter values. Must not be {@literal null}.
+	 * @return a map from parameter name to evaluated value. Guaranteed to be not {@literal null}.
+	 */
+	public Map<String, Object> evaluate(Object[] values) {
+
+		Assert.notNull(values, "Values must not be null.");
+
+		HashMap<String, Object> spelExpressionResults = new HashMap<>();
+		EvaluationContext evaluationContext = evaluationContextProvider.getEvaluationContext(parameters, values);
+		for (Map.Entry<String, String> parameterNameToSpel : parameterNameToSpelMap.entrySet()) {
+
+			Object spElValue = getSpElValue(evaluationContext, parameterNameToSpel.getValue());
+			spelExpressionResults.put(parameterNameToSpel.getKey(), spElValue);
+		}
+
+		return spelExpressionResults;
+	}
+
+	@Nullable
+	private Object getSpElValue(EvaluationContext evaluationContext, String expression) {
+		return PARSER.parseExpression(expression).getValue(evaluationContext, Object.class);
+	}
+}

src/main/java/org/springframework/data/repository/query/parser/SpelQueryContext.java

@@ -0,0 +1,161 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed 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.springframework.data.repository.query.parser;
+
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.BiFunction;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.springframework.util.Assert;
+
+/**
+ * Source of {@link SpelExtractor} encapsulating configuration often common for all queries.
+ *
+ * @author Jens Schauder
+ * @author Gerrit Meier
+ */
+@RequiredArgsConstructor
+public class SpelQueryContext {
+
+	private final static String SPEL_PATTERN_STRING = "([:?])#\\{([^}]+)}";
+	private final static Pattern SPEL_PATTERN = Pattern.compile(SPEL_PATTERN_STRING);
+
+	/**
+	 * A function from the index of a SpEL expression in a query and the actual SpEL expression to the parameter name to
+	 * be used in place of the SpEL expression. A typical implementation is expected to look like
+	 * <code>(index, spel) -> "__some_placeholder_" + index</code>
+	 */
+	@NonNull private final BiFunction<Integer, String, String> parameterNameSource;
+
+	/**
+	 * A function from a prefix used to demarcate a SpEL expression in a query and a parameter name as returned from
+	 * {@link #parameterNameSource} to a {@literal String} to be used as a replacement of the SpEL in the query. The
+	 * returned value should normally be interpretable as a bind parameter by the underlying persistence mechanism. A
+	 * typical implementation is expected to look like <code>(prefix, name) -> prefix + name</code> or
+	 * <code>(prefix, name) -> "{" + name + "}"</code>
+	 */
+	@NonNull private final BiFunction<String, String, String> replacementSource;
+
+	/**
+	 * Parses the query for SpEL expressions using the pattern
+	 * 
+	 * <pre>
+	 * &lt;prefix&gt;#{&lt;spel&gt;}
+	 * </pre>
+	 * 
+	 * with prefix being the character ':' or '?'. Parsing honors quoted {@literal String}s enclosed in single or double
+	 * quotation marks.
+	 *
+	 * @param query a query containing SpEL expressions in the format described above. Must not be {@literal null}.
+	 * @return A {@link SpelExtractor} which makes the query with SpEL expressions replaced by bind parameters and a map
+	 *         from bind parameter to SpEL expression available. Guaranteed to be not {@literal null}.
+	 */
+	public SpelExtractor parse(String query) {
+		return new SpelExtractor(query);
+	}
+
+	/**
+	 * Parses a query string, identifies the contained SpEL expressions, replaces them with bind parameters and offers a
+	 * {@link Map} from those bind parameters to the spel expression.
+	 * <p>
+	 * The parser detects quoted parts of the query string and does not detect SpEL expressions inside such quoted parts
+	 * of the query.
+	 *
+	 * @author Jens Schauder
+	 */
+	public class SpelExtractor {
+
+		private static final int PREFIX_GROUP_INDEX = 1;
+		private static final int EXPRESSION_GROUP_INDEX = 2;
+
+		private final String query;
+		private final Map<String, String> expressions;
+
+		/**
+		 * Creates a SpelExtractor from a query String.
+		 * 
+		 * @param query Must not be {@literal null}.
+		 */
+		private SpelExtractor(String query) {
+
+			Assert.notNull(query, "Query must not be null");
+
+			HashMap<String, String> expressions = new HashMap<>();
+
+			Matcher matcher = SPEL_PATTERN.matcher(query);
+
+			StringBuilder resultQuery = new StringBuilder();
+
+			QuotationMap quotedAreas = new QuotationMap(query);
+
+			int expressionCounter = 0;
+			int matchedUntil = 0;
+
+			while (matcher.find()) {
+
+				if (quotedAreas.isQuoted(matcher.start())) {
+
+					resultQuery.append(query.substring(matchedUntil, matcher.end()));
+
+				} else {
+
+					String spelExpression = matcher.group(EXPRESSION_GROUP_INDEX);
+					String prefix = matcher.group(PREFIX_GROUP_INDEX);
+
+					String parameterName = parameterNameSource.apply(expressionCounter, spelExpression);
+					String replacement = replacementSource.apply(prefix, parameterName);
+
+					resultQuery.append(query.substring(matchedUntil, matcher.start()));
+					resultQuery.append(replacement);
+
+					expressions.put(parameterName, spelExpression);
+					expressionCounter++;
+				}
+
+				matchedUntil = matcher.end();
+			}
+
+			resultQuery.append(query.substring(matchedUntil));
+
+			this.expressions = Collections.unmodifiableMap(expressions);
+			this.query = resultQuery.toString();
+		}
+
+		/**
+		 * The query with all the SpEL expressions replaced with bind parameters.
+		 *
+		 * @return Guaranteed to be not {@literal null}.
+		 */
+		public String query() {
+			return query;
+		}
+
+		/**
+		 * A {@literal Map} from parameter name to SpEL expression.
+		 * 
+		 * @return Guaranteed to be not {@literal null}.
+		 */
+		public Map<String, String> parameterNameToSpelMap() {
+			return expressions;
+		}
+	}
+}