RequestPath improvements

Static parse methods on PathSegmentContainer and PathSegment plus:

isEmpty() on PathSegmentContainer and PathSegment
isAbsolute() and hasTrailingSlash() on PathSegmentContainer
char[] alternative for valueDecoded() on PathSegment

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

@@ -28,6 +28,7 @@ import org.springframework.util.MultiValueMap;
 import org.springframework.util.StringUtils;
 
 /**
+ * Default implementation of {@link RequestPath}.
  *
  * @author Rossen Stoyanchev
  * @since 5.0
@@ -58,13 +59,13 @@ class DefaultRequestPath implements RequestPath {
 		this.pathWithinApplication = initPathWithinApplication(this.fullPath, this.contextPath);
 	}
 
-	DefaultRequestPath(RequestPath requestPath, String contextPath, Charset charset) {
+	DefaultRequestPath(RequestPath requestPath, String contextPath) {
 		this.fullPath = new DefaultPathSegmentContainer(requestPath.value(), requestPath.pathSegments());
 		this.contextPath = initContextPath(this.fullPath, contextPath);
 		this.pathWithinApplication = initPathWithinApplication(this.fullPath, this.contextPath);
 	}
 
-	private static PathSegmentContainer parsePath(String path, Charset charset) {
+	static PathSegmentContainer parsePath(String path, Charset charset) {
 		path = StringUtils.hasText(path) ? path : "";
 		if ("".equals(path)) {
 			return EMPTY_PATH;
@@ -73,8 +74,8 @@ class DefaultRequestPath implements RequestPath {
 			return ROOT_PATH;
 		}
 		List<PathSegment> result = new ArrayList<>();
-		int begin = 1;
-		while (true) {
+		int begin = (path.charAt(0) == '/' ? 1 : 0);
+		while (begin < path.length()) {
 			int end = path.indexOf('/', begin);
 			String segment = (end != -1 ? path.substring(begin, end) : path.substring(begin));
 			result.add(parsePathSegment(segment, charset));
@@ -82,22 +83,18 @@ class DefaultRequestPath implements RequestPath {
 				break;
 			}
 			begin = end + 1;
-			if (begin == path.length()) {
-				// trailing slash
-				result.add(EMPTY_PATH_SEGMENT);
-				break;
-			}
 		}
 		return new DefaultPathSegmentContainer(path, result);
 	}
 
-	private static PathSegment parsePathSegment(String input, Charset charset) {
+	static PathSegment parsePathSegment(String input, Charset charset) {
 		if ("".equals(input)) {
 			return EMPTY_PATH_SEGMENT;
 		}
 		int index = input.indexOf(';');
 		if (index == -1) {
-			return new DefaultPathSegment(input, StringUtils.uriDecode(input, charset), "", EMPTY_MAP);
+			String inputDecoded = StringUtils.uriDecode(input, charset);
+			return new DefaultPathSegment(input, inputDecoded, "", EMPTY_MAP);
 		}
 		String value = input.substring(0, index);
 		String valueDecoded = StringUtils.uriDecode(value, charset);
@@ -180,16 +177,37 @@ class DefaultRequestPath implements RequestPath {
 	}
 
 
+	// PathSegmentContainer methods..
+
+
+	@Override
+	public boolean isEmpty() {
+		return this.contextPath.isEmpty() && this.pathWithinApplication.isEmpty();
+	}
+
 	@Override
 	public String value() {
 		return this.fullPath.value();
 	}
 
+	@Override
+	public boolean isAbsolute() {
+		return !this.contextPath.isEmpty() && this.contextPath.isAbsolute() || this.pathWithinApplication.isAbsolute();
+	}
+
 	@Override
 	public List<PathSegment> pathSegments() {
 		return this.fullPath.pathSegments();
 	}
 
+	@Override
+	public boolean hasTrailingSlash() {
+		return this.pathWithinApplication.hasTrailingSlash();
+	}
+
+
+	// RequestPath methods..
+
 	@Override
 	public PathSegmentContainer contextPath() {
 		return this.contextPath;
@@ -205,12 +223,22 @@ class DefaultRequestPath implements RequestPath {
 
 		private final String path;
 
+		private final boolean empty;
+
+		private final boolean absolute;
+
 		private final List<PathSegment> pathSegments;
 
+		private final boolean trailingSlash;
+
 
-		DefaultPathSegmentContainer(String path, List<PathSegment> pathSegments) {
+
+		DefaultPathSegmentContainer(String path, List<PathSegment> segments) {
 			this.path = path;
-			this.pathSegments = Collections.unmodifiableList(pathSegments);
+			this.absolute = path.startsWith("/");
+			this.pathSegments = Collections.unmodifiableList(segments);
+			this.trailingSlash = path.endsWith("/") && path.length() > 1;
+			this.empty = !this.absolute && !this.trailingSlash && segments.stream().allMatch(PathSegment::isEmpty);
 		}
 
 
@@ -219,11 +247,26 @@ class DefaultRequestPath implements RequestPath {
 			return this.path;
 		}
 
+		@Override
+		public boolean isEmpty() {
+			return this.empty;
+		}
+
+		@Override
+		public boolean isAbsolute() {
+			return this.absolute;
+		}
+
 		@Override
 		public List<PathSegment> pathSegments() {
 			return this.pathSegments;
 		}
 
+		@Override
+		public boolean hasTrailingSlash() {
+			return this.trailingSlash;
+		}
+
 
 		@Override
 		public boolean equals(Object other) {
@@ -254,6 +297,10 @@ class DefaultRequestPath implements RequestPath {
 
 		private final String valueDecoded;
 
+		private final char[] valueCharsDecoded;
+
+		private final boolean empty;
+
 		private final String semicolonContent;
 
 		private final MultiValueMap<String, String> parameters;
@@ -262,8 +309,12 @@ class DefaultRequestPath implements RequestPath {
 		DefaultPathSegment(String value, String valueDecoded, String semicolonContent,
 				MultiValueMap<String, String> params) {
 
+			Assert.isTrue(!value.contains("/"), "Invalid path segment value: " + value);
+
 			this.value = value;
 			this.valueDecoded = valueDecoded;
+			this.valueCharsDecoded = valueDecoded.toCharArray();
+			this.empty = !StringUtils.hasText(this.valueDecoded);
 			this.semicolonContent = semicolonContent;
 			this.parameters = CollectionUtils.unmodifiableMultiValueMap(params);
 		}
@@ -279,6 +330,16 @@ class DefaultRequestPath implements RequestPath {
 			return this.valueDecoded;
 		}
 
+		@Override
+		public char[] valueCharsDecoded() {
+			return this.valueCharsDecoded;
+		}
+
+		@Override
+		public boolean isEmpty() {
+			return this.empty;
+		}
+
 		@Override
 		public String semicolonContent() {
 			return this.semicolonContent;

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

@@ -107,7 +107,7 @@ class DefaultServerHttpRequestBuilder implements ServerHttpRequest.Builder {
 			return null;
 		}
 		else if (uriToUse == null) {
-			return new DefaultRequestPath(this.delegate.getPath(), this.contextPath, StandardCharsets.UTF_8);
+			return new DefaultRequestPath(this.delegate.getPath(), this.contextPath);
 		}
 		else {
 			return new DefaultRequestPath(uriToUse, this.contextPath, StandardCharsets.UTF_8);

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

@@ -15,6 +15,8 @@
  */
 package org.springframework.http.server.reactive;
 
+import java.nio.charset.Charset;
+
 import org.springframework.util.MultiValueMap;
 
 /**
@@ -32,10 +34,21 @@ public interface PathSegment {
 	String value();
 
 	/**
-	 * The path {@link #value()} decoded.
+	 * Return the path {@link #value()} decoded.
 	 */
 	String valueDecoded();
 
+	/**
+	 * Return the same as {@link #valueDecoded()} but as a {@code char[]}.
+	 */
+	char[] valueCharsDecoded();
+
+	/**
+	 * Whether the path value (encoded or decoded) is empty meaning that it has
+	 * {@link Character#isWhitespace whitespace} characters or none.
+	 */
+	boolean isEmpty();
+
 	/**
 	 * Return the portion of the path segment after and including the first
 	 * ";" (semicolon) representing path parameters. The actual parsed
@@ -48,4 +61,15 @@ public interface PathSegment {
 	 */
 	MultiValueMap<String, String> parameters();
 
+
+	/**
+	 * Parse the given path segment value.
+	 * @param path the value to parse
+	 * @param encoding the charset to use for the decoded value
+	 * @return the parsed path segment
+	 */
+	static PathSegment parse(String path, Charset encoding) {
+		return DefaultRequestPath.parsePathSegment(path, encoding);
+	}
+
 }

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

@@ -15,13 +15,18 @@
  */
 package org.springframework.http.server.reactive;
 
+import java.nio.charset.Charset;
 import java.util.List;
 
 /**
  * Container for 0..N path segments.
  *
+ * <p>Typically consumed via {@link ServerHttpRequest#getPath()} but can also
+ * be created by parsing a path value via {@link #parse(String, Charset)}.
+ *
  * @author Rossen Stoyanchev
  * @since 5.0
+ * @see RequestPath
  */
 public interface PathSegmentContainer {
 
@@ -30,9 +35,36 @@ public interface PathSegmentContainer {
 	 */
 	String value();
 
+	/**
+	 * Whether the path (encoded or decoded) is empty meaning that it has
+	 * {@link Character#isWhitespace whitespace} characters or none.
+	 */
+	boolean isEmpty();
+
+	/**
+	 * Whether the path {@link #value()} starts with "/".
+	 */
+	boolean isAbsolute();
+
 	/**
 	 * The list of path segments contained.
 	 */
 	List<PathSegment> pathSegments();
 
+	/**
+	 * Whether the path {@link #value()} ends with "/".
+	 */
+	boolean hasTrailingSlash();
+
+
+	/**
+	 * Parse the given path value into a {@link PathSegmentContainer}.
+	 * @param path the value to parse
+	 * @param encoding the charset to use for decoded path segment values
+	 * @return the parsed path
+	 */
+	static PathSegmentContainer parse(String path, Charset encoding) {
+		return DefaultRequestPath.parsePath(path, encoding);
+	}
+
 }

spring-web/src/test/java/org/springframework/http/server/reactive/DefaultRequestPathTests.java

@@ -16,7 +16,6 @@
 package org.springframework.http.server.reactive;
 
 import java.net.URI;
-import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
@@ -27,6 +26,7 @@ import org.junit.Test;
 import org.springframework.util.LinkedMultiValueMap;
 import org.springframework.util.MultiValueMap;
 
+import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.junit.Assert.assertEquals;
 
 /**
@@ -38,97 +38,118 @@ public class DefaultRequestPathTests {
 	@Test
 	public void pathSegment() throws Exception {
 		// basic
-		testPathSegment("cars", "", "cars", "cars", new LinkedMultiValueMap<>());
+		testPathSegment("cars", "", "cars", "cars", false, new LinkedMultiValueMap<>());
 
 		// empty
-		testPathSegment("", "", "", "", new LinkedMultiValueMap<>());
+		testPathSegment("", "", "", "", true, new LinkedMultiValueMap<>());
 
 		// spaces
-		testPathSegment("%20", "", "%20", " ", new LinkedMultiValueMap<>());
-		testPathSegment("%20a%20", "", "%20a%20", " a ", new LinkedMultiValueMap<>());
+		testPathSegment("%20%20", "", "%20%20", "  ", true, new LinkedMultiValueMap<>());
+		testPathSegment("%20a%20", "", "%20a%20", " a ", false, new LinkedMultiValueMap<>());
 	}
 
 	@Test
-	public void pathSegmentWithParams() throws Exception {
+	public void pathSegmentParams() throws Exception {
 		// basic
 		LinkedMultiValueMap<String, String> params = new LinkedMultiValueMap<>();
 		params.add("colors", "red");
 		params.add("colors", "blue");
 		params.add("colors", "green");
 		params.add("year", "2012");
-		testPathSegment("cars", ";colors=red,blue,green;year=2012", "cars", "cars", params);
+		testPathSegment("cars", ";colors=red,blue,green;year=2012", "cars", "cars", false, params);
 
 		// trailing semicolon
 		params = new LinkedMultiValueMap<>();
 		params.add("p", "1");
-		testPathSegment("path", ";p=1;", "path", "path", params);
+		testPathSegment("path", ";p=1;", "path", "path", false, params);
 
 		// params with spaces
 		params = new LinkedMultiValueMap<>();
 		params.add("param name", "param value");
-		testPathSegment("path", ";param%20name=param%20value;%20", "path", "path", params);
+		testPathSegment("path", ";param%20name=param%20value;%20", "path", "path", false, params);
 
 		// empty params
 		params = new LinkedMultiValueMap<>();
 		params.add("p", "1");
-		testPathSegment("path", ";;;%20;%20;p=1;%20", "path", "path", params);
+		testPathSegment("path", ";;;%20;%20;p=1;%20", "path", "path", false, params);
+	}
+
+	private void testPathSegment(String pathSegment, String semicolonContent,
+			String value, String valueDecoded, boolean empty, MultiValueMap<String, String> params) {
+
+		PathSegment segment = PathSegment.parse(pathSegment + semicolonContent, UTF_8);
+
+		assertEquals("value: '" + pathSegment + "'", value, segment.value());
+		assertEquals("valueDecoded: '" + pathSegment + "'", valueDecoded, segment.valueDecoded());
+		assertEquals("isEmpty: '" + pathSegment + "'", empty, segment.isEmpty());
+		assertEquals("semicolonContent: '" + pathSegment + "'", semicolonContent, segment.semicolonContent());
+		assertEquals("params: '" + pathSegment + "'", params, segment.parameters());
 	}
 
 	@Test
 	public void path() throws Exception {
 		// basic
-		testPath("/a/b/c", "/a/b/c", Arrays.asList("a", "b", "c"));
+		testPath("/a/b/c", "/a/b/c", false, true, Arrays.asList("a", "b", "c"), false);
 
 		// root path
-		testPath("/%20", "/%20", Collections.singletonList("%20"));
-		testPath("",   "", Collections.emptyList());
-		testPath("%20", "", Collections.emptyList());
+		testPath("/", "/", false, true, Collections.singletonList(""), false);
+
+		// empty path
+		testPath("",   "", true, false, Collections.emptyList(), false);
+		testPath("%20%20",   "%20%20", true, false, Collections.singletonList("%20%20"), false);
 
 		// trailing slash
-		testPath("/a/b/", "/a/b/", Arrays.asList("a", "b", ""));
-		testPath("/a/b//", "/a/b//", Arrays.asList("a", "b", "", ""));
+		testPath("/a/b/", "/a/b/", false, true, Arrays.asList("a", "b"), true);
+		testPath("/a/b//", "/a/b//", false, true, Arrays.asList("a", "b", ""), true);
 
-		// extra slashes ande spaces
-		testPath("//%20/%20", "//%20/%20", Arrays.asList("", "%20", "%20"));
+		// extra slashes and spaces
+		testPath("/%20", "/%20", false, true, Collections.singletonList("%20"), false);
+		testPath("//%20/%20", "//%20/%20", false, true, Arrays.asList("", "%20", "%20"), false);
 	}
 
-	@Test
-	public void contextPath() throws Exception {
-		URI uri = URI.create("http://localhost:8080/app/a/b/c");
-		RequestPath path = new DefaultRequestPath(uri, "/app", StandardCharsets.UTF_8);
+	private void testPath(String input, String value, boolean empty, boolean absolute,
+			List<String> segments, boolean trailingSlash) {
 
-		PathSegmentContainer contextPath = path.contextPath();
-		assertEquals("/app", contextPath.value());
-		assertEquals(Collections.singletonList("app"), pathSegmentValues(contextPath));
+		PathSegmentContainer path = PathSegmentContainer.parse(input, UTF_8);
 
-		PathSegmentContainer pathWithinApplication = path.pathWithinApplication();
-		assertEquals("/a/b/c", pathWithinApplication.value());
-		assertEquals(Arrays.asList("a", "b", "c"), pathSegmentValues(pathWithinApplication));
+		List<String> segmentValues = path.pathSegments().stream().map(PathSegment::value)
+				.collect(Collectors.toList());
+
+		assertEquals("value: '" + input + "'", value, path.value());
+		assertEquals("empty: '" + input + "'", empty, path.isEmpty());
+		assertEquals("isAbsolute: '" + input + "'", absolute, path.isAbsolute());
+		assertEquals("pathSegments: " + input, segments, segmentValues);
+		assertEquals("hasTrailingSlash: '" + input + "'", trailingSlash, path.hasTrailingSlash());
 	}
 
+	@Test
+	public void requestPath() throws Exception {
+		// basic
+		testRequestPath("/app/a/b/c", "/app", "/a/b/c", false, true, false);
 
-	private void testPathSegment(String pathSegment, String semicolonContent,
-			String value, String valueDecoded, MultiValueMap<String, String> parameters) {
+		// no context path
+		testRequestPath("/a/b/c", "", "/a/b/c", false, true, false);
 
-		URI uri = URI.create("http://localhost:8080/" + pathSegment + semicolonContent);
-		PathSegment segment = new DefaultRequestPath(uri, "", StandardCharsets.UTF_8).pathSegments().get(0);
+		// empty path
+		testRequestPath("", "", "", true, false, false);
+		testRequestPath("", "/", "", true, false, false);
 
-		assertEquals(value, segment.value());
-		assertEquals(valueDecoded, segment.valueDecoded());
-		assertEquals(semicolonContent, segment.semicolonContent());
-		assertEquals(parameters, segment.parameters());
+		// trailing slash
+		testRequestPath("/app/a/", "/app", "/a/", false, true, true);
+		testRequestPath("/app/a//", "/app", "/a//", false, true, true);
 	}
 
-	private void testPath(String input, String value, List<String> segments) {
-		URI uri = URI.create("http://localhost:8080" + input);
-		RequestPath path = new DefaultRequestPath(uri, "", StandardCharsets.UTF_8);
+	private void testRequestPath(String fullPath, String contextPath, String pathWithinApplication,
+			boolean empty, boolean absolute, boolean trailingSlash) {
 
-		assertEquals(value, path.value());
-		assertEquals(segments, pathSegmentValues(path));
-	}
+		URI uri = URI.create("http://localhost:8080" + fullPath);
+		RequestPath requestPath = new DefaultRequestPath(uri, contextPath, UTF_8);
 
-	private static List<String> pathSegmentValues(PathSegmentContainer path) {
-		return path.pathSegments().stream().map(PathSegment::value).collect(Collectors.toList());
+		assertEquals(empty, requestPath.isEmpty());
+		assertEquals(absolute, requestPath.isAbsolute());
+		assertEquals(trailingSlash, requestPath.hasTrailingSlash());
+		assertEquals(contextPath.equals("/") ? "" : contextPath, requestPath.contextPath().value());
+		assertEquals(pathWithinApplication, requestPath.pathWithinApplication().value());
 	}
 
 }