Introduce ParseException.

Author: mp911de

src/main/java/org/springframework/data/spel/DefaultValueExpressionParser.java

@@ -18,6 +18,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import org.springframework.expression.ParseException;
 import org.springframework.expression.ParserContext;
 import org.springframework.util.Assert;
 import org.springframework.util.SystemPropertyUtils;
@@ -68,48 +69,50 @@ && findPlaceholderEndIndex(expressionString, expressionIndex) != expressionStrin
 		return parseComposite(expressionString, placerholderIndex, expressionIndex);
 	}
 
-	private CompositeValueExpression parseComposite(String expression, int placerholderIndex, int expressionIndex) {
+	private CompositeValueExpression parseComposite(String expressionString, int placerholderIndex, int expressionIndex) {
 
 		List<ValueExpression> expressions = new ArrayList<>(PLACEHOLDER_PREFIX_LENGTH);
 		int startIndex = getStartIndex(placerholderIndex, expressionIndex);
 
 		if (startIndex != 0) {
-			expressions.add(new LiteralValueExpression(expression.substring(0, startIndex)));
+			expressions.add(new LiteralValueExpression(expressionString.substring(0, startIndex)));
 		}
 
 		while (startIndex != -1) {
 
-			int endIndex = findPlaceholderEndIndex(expression, startIndex);
-			if (endIndex != -1) {
+			int endIndex = findPlaceholderEndIndex(expressionString, startIndex);
 
-				int afterClosingParenthesisIndex = endIndex + 1;
-				String part = expression.substring(startIndex, afterClosingParenthesisIndex);
+			if (endIndex == -1) {
+				throw new ParseException(expressionString, startIndex,
+						"No ending suffix '}' for expression starting at character %d: %s".formatted(startIndex,
+								expressionString.substring(startIndex)));
+			}
 
-				if (part.startsWith(PLACEHOLDER_PREFIX)) {
-					expressions.add(createPlaceholder(part));
-				} else {
-					expressions.add(createExpression(part));
-				}
+			int afterClosingParenthesisIndex = endIndex + 1;
+			String part = expressionString.substring(startIndex, afterClosingParenthesisIndex);
+
+			if (part.startsWith(PLACEHOLDER_PREFIX)) {
+				expressions.add(createPlaceholder(part));
+			} else {
+				expressions.add(createExpression(part));
+			}
 
-				placerholderIndex = expression.indexOf(PLACEHOLDER_PREFIX, endIndex);
-				expressionIndex = expression.indexOf(EXPRESSION_PREFIX, endIndex);
+			placerholderIndex = expressionString.indexOf(PLACEHOLDER_PREFIX, endIndex);
+			expressionIndex = expressionString.indexOf(EXPRESSION_PREFIX, endIndex);
 
-				startIndex = getStartIndex(placerholderIndex, expressionIndex);
+			startIndex = getStartIndex(placerholderIndex, expressionIndex);
 
-				if (startIndex == -1) {
-					// no next expression but we're capturing everything after the expression as literal.
-					expressions.add(new LiteralValueExpression(expression.substring(afterClosingParenthesisIndex)));
-				} else {
-					// capture literal after the expression ends and before the next starts.
-					expressions.add(new LiteralValueExpression(expression.substring(afterClosingParenthesisIndex, startIndex)));
-				}
+			if (startIndex == -1) {
+				// no next expression but we're capturing everything after the expression as literal.
+				expressions.add(new LiteralValueExpression(expressionString.substring(afterClosingParenthesisIndex)));
 			} else {
-				expressions.add(new LiteralValueExpression(expression.substring(startIndex)));
-				startIndex = -1;
+				// capture literal after the expression ends and before the next starts.
+				expressions
+						.add(new LiteralValueExpression(expressionString.substring(afterClosingParenthesisIndex, startIndex)));
 			}
 		}
 
-		return new CompositeValueExpression(expression, expressions);
+		return new CompositeValueExpression(expressionString, expressions);
 	}
 
 	private static int getStartIndex(int placerholderIndex, int expressionIndex) {

src/test/java/org/springframework/data/spel/ValueEvaluationUnitTests.java

@@ -71,7 +71,6 @@ void shouldParseAndEvaluateExpressions() {
 		assertThat(eval("${env.key.one}")).isEqualTo("value");
 		assertThat(eval("${env.key.two}")).isEqualTo("42");
 		assertThat(eval("${env.key.one")).isEqualTo("${env.key.one");
-		assertThat(eval("#{'foo'}-${env.key.one")).isEqualTo("foo-${env.key.one");
 		assertThat(eval("#{'foo'}-")).isEqualTo("foo-");
 		assertThat(eval("#{'fo\"o'}-")).isEqualTo("fo\"o-");
 		assertThat(eval("#{\"foo\"}-")).isEqualTo("foo-");
@@ -99,16 +98,26 @@ void shouldParseLiteral() {
 	@Test // GH-2369
 	void shouldParseCompoundExpression() {
 
-		assertThat(eval("#{'foo'}-${key.one")).isEqualTo("foo-${key.one");
 		assertThat(eval("#{'foo'}-")).isEqualTo("foo-");
 		assertThat(eval("#{'fo\"o'}-")).isEqualTo("fo\"o-");
 		assertThat(eval("#{\"foo\"}-")).isEqualTo("foo-");
 		assertThat(eval("#{\"fo'o\"}-")).isEqualTo("fo'o-");
 		assertThat(eval("${env.key.one}-")).isEqualTo("value-");
 		assertThat(eval("${env.key.one}-and-some-#{'foo'}-#{#contextVar}")).isEqualTo("value-and-some-foo-contextVal");
+	}
+
+	@Test // GH-2369
+	void shouldRaiseParseException() {
+
+		assertThatExceptionOfType(ParseException.class).isThrownBy(() -> eval("#{'foo'}-${key.one")).withMessageContaining(
+				"Expression [#{'foo'}-${key.one] @9: No ending suffix '}' for expression starting at character 9: ${key.one");
+
+		assertThatExceptionOfType(ParseException.class).isThrownBy(() -> eval("#{'foo'}-${env.key.one"));
+		assertThatExceptionOfType(ParseException.class).isThrownBy(() -> eval("#{'foo'"));
 
 		assertThatExceptionOfType(ParseException.class).isThrownBy(() -> eval("#{#foo - ${numeric.key}}"))
 				.withMessageContaining("[#foo - ${numeric.key}]");
+
 	}
 
 	@Test // GH-2369