Improve separator support in PathContainer

To make the switching of separators complete, it is also important to
know whether the decoding of path segment values and the parsing of
path param should be done as those are applied transparently.

This commit replaces the recently added separator argument to
PathContainer.parsePath with an Options type with two predefined
constants. One for HTTP URLs with automatic decoding and parsing of
path params, and another for "." separated message routes without
decoding except for encoded sequences of the separator itself.

See spring-projectsgh-23310

Author: rstoyanchev

spring-web/src/main/java/org/springframework/http/server/DefaultPathContainer.java

@@ -20,7 +20,9 @@
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 
 import org.springframework.lang.Nullable;
@@ -38,11 +40,16 @@
  */
 final class DefaultPathContainer implements PathContainer {
 
-	private static final MultiValueMap<String, String> EMPTY_MAP = new LinkedMultiValueMap<>();
+	private static final MultiValueMap<String, String> EMPTY_PARAMS = new LinkedMultiValueMap<>();
 
 	private static final PathContainer EMPTY_PATH = new DefaultPathContainer("", Collections.emptyList());
 
-	private static final PathContainer.Separator SEPARATOR = () -> "/";
+	private static final Map<Character, DefaultSeparator> SEPARATORS = new HashMap<>(2);
+
+	static {
+		SEPARATORS.put('/', new DefaultSeparator('/', "%2F"));
+		SEPARATORS.put('.', new DefaultSeparator('.', "%2E"));
+	}
 
 
 	private final String path;
@@ -72,10 +79,10 @@ public boolean equals(@Nullable Object other) {
 		if (this == other) {
 			return true;
 		}
-		if (other == null || getClass() != other.getClass()) {
+		if (!(other instanceof PathContainer)) {
 			return false;
 		}
-		return this.path.equals(((DefaultPathContainer) other).path);
+		return value().equals(((PathContainer) other).value());
 	}
 
 	@Override
@@ -89,18 +96,19 @@ public String toString() {
 	}
 
 
-	static PathContainer createFromUrlPath(String path, String separator) {
+	static PathContainer createFromUrlPath(String path, Options options) {
 		if (path.equals("")) {
 			return EMPTY_PATH;
 		}
-		if (separator.length() == 0) {
-			throw new IllegalArgumentException("separator should not be empty");
+		char separator = options.separator();
+		DefaultSeparator separatorElement = SEPARATORS.get(separator);
+		if (separatorElement == null) {
+			throw new IllegalArgumentException("Unexpected separator: '" + separator + "'");
 		}
-		Separator separatorElement = separator.equals(SEPARATOR.value()) ? SEPARATOR : () -> separator;
 		List<Element> elements = new ArrayList<>();
 		int begin;
-		if (path.length() > 0 && path.startsWith(separator)) {
-			begin = separator.length();
+		if (path.length() > 0 && path.charAt(0) == separator) {
+			begin = 1;
 			elements.add(separatorElement);
 		}
 		else {
@@ -110,23 +118,25 @@ static PathContainer createFromUrlPath(String path, String separator) {
 			int end = path.indexOf(separator, begin);
 			String segment = (end != -1 ? path.substring(begin, end) : path.substring(begin));
 			if (!segment.equals("")) {
-				elements.add(parsePathSegment(segment));
+				elements.add(options.shouldDecodeAndParseSegments() ?
+						decodeAndParsePathSegment(segment) :
+						new DefaultPathSegment(segment, separatorElement));
 			}
 			if (end == -1) {
 				break;
 			}
 			elements.add(separatorElement);
-			begin = end + separator.length();
+			begin = end + 1;
 		}
 		return new DefaultPathContainer(path, elements);
 	}
 
-	private static PathSegment parsePathSegment(String segment) {
+	private static PathSegment decodeAndParsePathSegment(String segment) {
 		Charset charset = StandardCharsets.UTF_8;
 		int index = segment.indexOf(';');
 		if (index == -1) {
 			String valueToMatch = StringUtils.uriDecode(segment, charset);
-			return new DefaultPathSegment(segment, valueToMatch, EMPTY_MAP);
+			return new DefaultPathSegment(segment, valueToMatch, EMPTY_PARAMS);
 		}
 		else {
 			String valueToMatch = StringUtils.uriDecode(segment.substring(0, index), charset);
@@ -192,6 +202,30 @@ static PathContainer subPath(PathContainer container, int fromIndex, int toIndex
 	}
 
 
+	private static class DefaultSeparator implements Separator {
+
+		private final String separator;
+
+		private final String encodedSequence;
+
+
+		DefaultSeparator(char separator, String encodedSequence) {
+			this.separator = String.valueOf(separator);
+			this.encodedSequence = encodedSequence;
+		}
+
+
+		@Override
+		public String value() {
+			return this.separator;
+		}
+
+		public String encodedSequence() {
+			return this.encodedSequence;
+		}
+	}
+
+
 	private static class DefaultPathSegment implements PathSegment {
 
 		private final String value;
@@ -202,14 +236,29 @@ private static class DefaultPathSegment implements PathSegment {
 
 		private final MultiValueMap<String, String> parameters;
 
-		public DefaultPathSegment(String value, String valueToMatch, MultiValueMap<String, String> params) {
-			Assert.isTrue(!value.contains("/"), () -> "Invalid path segment value: " + value);
+
+		/**
+		 * Constructor for decoded and parsed segments.
+		 */
+		DefaultPathSegment(String value, String valueToMatch, MultiValueMap<String, String> params) {
 			this.value = value;
 			this.valueToMatch = valueToMatch;
 			this.valueToMatchAsChars = valueToMatch.toCharArray();
 			this.parameters = CollectionUtils.unmodifiableMultiValueMap(params);
 		}
 
+		/**
+		 * Constructor for segments without decoding and parsing.
+		 */
+		DefaultPathSegment(String value, DefaultSeparator separator) {
+			this.value = value;
+			this.valueToMatch = value.contains(separator.encodedSequence()) ?
+					value.replaceAll(separator.encodedSequence(), separator.value()) : value;
+			this.valueToMatchAsChars = this.valueToMatch.toCharArray();
+			this.parameters = EMPTY_PARAMS;
+		}
+
+
 		@Override
 		public String value() {
 			return this.value;
@@ -235,10 +284,10 @@ public boolean equals(@Nullable Object other) {
 			if (this == other) {
 				return true;
 			}
-			if (other == null || getClass() != other.getClass()) {
+			if (!(other instanceof PathSegment)) {
 				return false;
 			}
-			return this.value.equals(((DefaultPathSegment) other).value);
+			return value().equals(((PathSegment) other).value());
 		}
 
 		@Override

spring-web/src/main/java/org/springframework/http/server/PathContainer.java

@@ -72,19 +72,19 @@ default PathContainer subPath(int startIndex, int endIndex) {
 	 * @return the parsed path
 	 */
 	static PathContainer parsePath(String path) {
-		return DefaultPathContainer.createFromUrlPath(path, "/");
+		return DefaultPathContainer.createFromUrlPath(path, Options.HTTP_PATH);
 	}
 
 	/**
 	 * Parse the path value into a sequence of {@link Separator Separator} and
 	 * {@link PathSegment PathSegment} elements.
 	 * @param path the encoded, raw path value to parse
-	 * @param separator the decoded separator for parsing patterns
+	 * @param options to customize parsing
 	 * @return the parsed path
 	 * @since 5.2
 	 */
-	static PathContainer parsePath(String path, String separator) {
-		return DefaultPathContainer.createFromUrlPath(path, separator);
+	static PathContainer parsePath(String path, Options options) {
+		return DefaultPathContainer.createFromUrlPath(path, options);
 	}
 
 
@@ -128,4 +128,58 @@ interface PathSegment extends Element {
 		MultiValueMap<String, String> parameters();
 	}
 
+
+	/**
+	 * Options to customize parsing based on the type of input path.
+	 * @since 5.2
+	 */
+	class Options {
+
+		/**
+		 * Options for HTTP URL paths:
+		 * <p>Separator '/' with URL decoding and parsing of path params.
+		 */
+		public final static Options HTTP_PATH = Options.create('/', true);
+
+		/**
+		 * Options for a message route:
+		 * <p>Separator '.' without URL decoding nor parsing of params. Escape
+		 * sequences for the separator char in segment values are still decoded.
+		 */
+		public final static Options MESSAGE_ROUTE = Options.create('.', false);
+
+
+		private final char separator;
+
+		private final boolean decodeAndParseSegments;
+
+
+		private Options(char separator, boolean decodeAndParseSegments) {
+			this.separator = separator;
+			this.decodeAndParseSegments = decodeAndParseSegments;
+		}
+
+
+		public char separator() {
+			return this.separator;
+		}
+
+		public boolean shouldDecodeAndParseSegments() {
+			return this.decodeAndParseSegments;
+		}
+
+
+		/**
+		 * Create an {@link Options} instance with the given settings.
+		 * @param separator the separator for parsing the path into segments;
+		 * currently this must be slash or dot.
+		 * @param decodeAndParseSegments whether to URL decode path segment
+		 * values and parse path parameters. If set to false, only escape
+		 * sequences for the separator char are decoded.
+		 */
+		public static Options create(char separator, boolean decodeAndParseSegments) {
+			return new Options(separator, decodeAndParseSegments);
+		}
+	}
+
 }

spring-web/src/main/java/org/springframework/web/util/pattern/InternalPathPatternParser.java

@@ -105,16 +105,17 @@ public PathPattern parse(String pathPattern) throws PatternParseException {
 
 		while (this.pos < this.pathPatternLength) {
 			char ch = this.pathPatternData[this.pos];
-			if (ch == this.parser.getSeparator()) {
+			char separator = this.parser.getPathOptions().separator();
+			if (ch == separator) {
 				if (this.pathElementStart != -1) {
 					pushPathElement(createPathElement());
 				}
 				if (peekDoubleWildcard()) {
-					pushPathElement(new WildcardTheRestPathElement(this.pos, this.parser.getSeparator()));
+					pushPathElement(new WildcardTheRestPathElement(this.pos, separator));
 					this.pos += 2;
 				}
 				else {
-					pushPathElement(new SeparatorPathElement(this.pos, this.parser.getSeparator()));
+					pushPathElement(new SeparatorPathElement(this.pos, separator));
 				}
 			}
 			else {
@@ -221,7 +222,7 @@ else if (ch == '}' && !previousBackslash) {
 				}
 				curlyBracketDepth--;
 			}
-			if (ch == this.parser.getSeparator() && !previousBackslash) {
+			if (ch == this.parser.getPathOptions().separator() && !previousBackslash) {
 				throw new PatternParseException(this.pos, this.pathPatternData,
 						PatternMessage.MISSING_CLOSE_CAPTURE);
 			}
@@ -309,20 +310,21 @@ private PathElement createPathElement() {
 		}
 
 		PathElement newPE = null;
+		char separator = this.parser.getPathOptions().separator();
 
 		if (this.variableCaptureCount > 0) {
 			if (this.variableCaptureCount == 1 && this.pathElementStart == this.variableCaptureStart &&
 					this.pathPatternData[this.pos - 1] == '}') {
 				if (this.isCaptureTheRestVariable) {
 					// It is {*....}
 					newPE = new CaptureTheRestPathElement(
-							this.pathElementStart, getPathElementText(), this.parser.getSeparator());
+							this.pathElementStart, getPathElementText(), separator);
 				}
 				else {
 					// It is a full capture of this element (possibly with constraint), for example: /foo/{abc}/
 					try {
 						newPE = new CaptureVariablePathElement(this.pathElementStart, getPathElementText(),
-								this.parser.isCaseSensitive(), this.parser.getSeparator());
+								this.parser.isCaseSensitive(), separator);
 					}
 					catch (PatternSyntaxException pse) {
 						throw new PatternParseException(pse,
@@ -340,7 +342,7 @@ private PathElement createPathElement() {
 				}
 				RegexPathElement newRegexSection = new RegexPathElement(this.pathElementStart,
 						getPathElementText(), this.parser.isCaseSensitive(),
-						this.pathPatternData, this.parser.getSeparator());
+						this.pathPatternData, separator);
 				for (String variableName : newRegexSection.getVariableNames()) {
 					recordCapturedVariable(this.pathElementStart, variableName);
 				}
@@ -350,20 +352,20 @@ private PathElement createPathElement() {
 		else {
 			if (this.wildcard) {
 				if (this.pos - 1 == this.pathElementStart) {
-					newPE = new WildcardPathElement(this.pathElementStart, this.parser.getSeparator());
+					newPE = new WildcardPathElement(this.pathElementStart, separator);
 				}
 				else {
 					newPE = new RegexPathElement(this.pathElementStart, getPathElementText(),
-							this.parser.isCaseSensitive(), this.pathPatternData, this.parser.getSeparator());
+							this.parser.isCaseSensitive(), this.pathPatternData, separator);
 				}
 			}
 			else if (this.singleCharWildcardCount != 0) {
 				newPE = new SingleCharWildcardedPathElement(this.pathElementStart, getPathElementText(),
-						this.singleCharWildcardCount, this.parser.isCaseSensitive(), this.parser.getSeparator());
+						this.singleCharWildcardCount, this.parser.isCaseSensitive(), separator);
 			}
 			else {
 				newPE = new LiteralPathElement(this.pathElementStart, getPathElementText(),
-						this.parser.isCaseSensitive(), this.parser.getSeparator());
+						this.parser.isCaseSensitive(), separator);
 			}
 		}