Functional DSL incorrect path mapping Fixes #980, #968.

Author: bnasslahsen

springdoc-openapi-common/src/main/java/org/springdoc/core/fn/AbstractRouterFunctionVisitor.java

@@ -21,16 +21,18 @@
 package org.springdoc.core.fn;
 
 import java.util.ArrayList;
-import java.util.Arrays;
+import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 import org.apache.commons.lang3.StringUtils;
 
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpMethod;
+import org.springframework.util.CollectionUtils;
 
 /**
  * The type Abstract router function visitor.
@@ -46,50 +48,63 @@ public class AbstractRouterFunctionVisitor {
 	/**
 	 * The Nested or paths.
 	 */
-	protected List<String> nestedOrPaths = new ArrayList<>();
+	protected List<String> orPaths = new ArrayList<>();
 
 	/**
 	 * The Nested and paths.
 	 */
-	protected List<String> nestedAndPaths = new ArrayList<>();
+	protected Map<Integer, List<String>> nestedPaths = new LinkedHashMap<>();
 
 	/**
-	 * The Nested accept headers.
+	 * The Is or.
 	 */
-	protected List<String> nestedAcceptHeaders = new ArrayList<>();
+	protected boolean isOr;
 
 	/**
-	 * The Nested content type headers.
+	 * The Router function data.
 	 */
-	protected List<String> nestedContentTypeHeaders = new ArrayList<>();
+	protected List<RouterFunctionData> currentRouterFunctionDatas;
 
 	/**
-	 * The Is or.
+	 * The Attributes.
 	 */
-	protected boolean isOr;
+	protected Map<String, Object> attributes = new LinkedHashMap<>();
 
 	/**
-	 * The Is nested.
+	 * The Level.
 	 */
-	protected boolean isNested;
+	private int level;
 
 	/**
-	 * The Router function data.
+	 * The Methods.
 	 */
-	protected RouterFunctionData routerFunctionData;
+	private Set<HttpMethod> methods;
 
 	/**
-	 * The Attributes.
+	 * The Consumes.
 	 */
-	protected Map<String,Object> attributes = new LinkedHashMap<>();
+	private final List<String> consumes = new ArrayList<>();
+
+	/**
+	 * The Produces.
+	 */
+	private final List<String> produces = new ArrayList<>();
+
+	/**
+	 * The Query params.
+	 */
+	private final Map<String, String> queryParams = new LinkedHashMap<>();
 
 	/**
 	 * Method.
 	 *
 	 * @param methods the methods
 	 */
 	public void method(Set<HttpMethod> methods) {
-		routerFunctionData.setMethods(methods);
+		if (CollectionUtils.isEmpty(currentRouterFunctionDatas))
+			this.methods = methods;
+		else
+			currentRouterFunctionDatas.forEach(routerFunctionData -> routerFunctionData.setMethods(methods));
 	}
 
 	/**
@@ -98,12 +113,26 @@ public void method(Set<HttpMethod> methods) {
 	 * @param pattern the pattern
 	 */
 	public void path(String pattern) {
-		if (routerFunctionData != null)
-			routerFunctionData.setPath(pattern);
+		if (currentRouterFunctionDatas != null) {
+			if (!nestedPaths.isEmpty()) {
+				List<String> nestedPathsList = this.nestedPaths.values().stream().flatMap(List::stream).collect(Collectors.toList());
+				if (!orPaths.isEmpty())
+					orPaths.forEach(nestedOrPath -> createRouterFunctionData(String.join(StringUtils.EMPTY, nestedPathsList) + nestedOrPath + pattern));
+				else
+					createRouterFunctionData(String.join(StringUtils.EMPTY, nestedPathsList) + pattern);
+			}
+			else if (!orPaths.isEmpty())
+				orPaths.forEach(nestedOrPath -> createRouterFunctionData(nestedOrPath + pattern));
+			else
+				createRouterFunctionData(pattern);
+		}
 		else if (isOr)
-			nestedOrPaths.add(pattern);
-		else if (isNested)
-			nestedAndPaths.add(pattern);
+			orPaths.add(pattern);
+		else if (this.level > 0) {
+			List<String> paths = CollectionUtils.isEmpty(this.nestedPaths.get(this.level)) ? new ArrayList<>() : this.nestedPaths.get(this.level);
+			paths.add(pattern);
+			this.nestedPaths.put(this.level, paths);
+		}
 	}
 
 	/**
@@ -113,14 +142,12 @@ else if (isNested)
 	 * @param value the value
 	 */
 	public void header(String name, String value) {
-		if (HttpHeaders.ACCEPT.equals(name)) {
-			calculateAccept(value);
-		}
-		else if (HttpHeaders.CONTENT_TYPE.equals(name)) {
-			calculateContentType(value);
-		}
+		if (HttpHeaders.ACCEPT.equals(name))
+			calculateHeader(value, this.produces, name);
+		else if (HttpHeaders.CONTENT_TYPE.equals(name))
+			calculateHeader(value, this.consumes, name);
 		else
-			routerFunctionData.addHeaders(name + "=" + value);
+			currentRouterFunctionDatas.forEach(routerFunctionData -> routerFunctionData.addHeaders(name + "=" + value));
 	}
 
 	/**
@@ -139,7 +166,10 @@ public List<RouterFunctionData> getRouterFunctionDatas() {
 	 * @param value the value
 	 */
 	public void queryParam(String name, String value) {
-		routerFunctionData.addQueryParams(name, value);
+		if (CollectionUtils.isEmpty(currentRouterFunctionDatas))
+			queryParams.put(name, value);
+		else
+			currentRouterFunctionDatas.forEach(routerFunctionData -> routerFunctionData.addQueryParams(name, value));
 	}
 
 	/**
@@ -200,7 +230,7 @@ public void or() {
 	 * End or.
 	 */
 	public void endOr() {
-		// Not yet needed
+		this.isOr = false;
 	}
 
 	/**
@@ -217,96 +247,90 @@ public void endNegate() {
 		// Not yet needed
 	}
 
+	/**
+	 * Attributes.
+	 *
+	 * @param map the map
+	 */
+	public void attributes(Map<String, Object> map) {
+		this.attributes = map;
+	}
+
 	/**
 	 * Compute nested.
 	 */
-	protected void computeNested() {
-		if (!nestedAndPaths.isEmpty()) {
-			String nestedPath = String.join(StringUtils.EMPTY, nestedAndPaths);
-			routerFunctionDatas.forEach(existingRouterFunctionData -> existingRouterFunctionData.setPath(nestedPath + existingRouterFunctionData.getPath()));
-			nestedAndPaths.clear();
-		}
-		if (!nestedOrPaths.isEmpty()) {
-			List<RouterFunctionData> routerFunctionDatasClone = new ArrayList<>();
-			for (RouterFunctionData functionData : routerFunctionDatas) {
-				for (String nestedOrPath : nestedOrPaths) {
-					RouterFunctionData routerFunctionDataClone = new RouterFunctionData(nestedOrPath , functionData);
-					routerFunctionDatasClone.add(routerFunctionDataClone);
-				}
-			}
-			this.routerFunctionDatas = routerFunctionDatasClone;
-			nestedAndPaths.clear();
-		}
-		if (!nestedAcceptHeaders.isEmpty()) {
-			routerFunctionDatas.forEach(existingRouterFunctionData -> existingRouterFunctionData.addProduces(nestedAcceptHeaders));
-			nestedAcceptHeaders.clear();
-		}
-		if (!nestedContentTypeHeaders.isEmpty()) {
-			routerFunctionDatas.forEach(existingRouterFunctionData -> existingRouterFunctionData.addConsumes(nestedContentTypeHeaders));
-			nestedContentTypeHeaders.clear();
-		}
+	protected void commonEndNested() {
+		nestedPaths.remove(this.level);
+		this.level--;
 	}
 
 	/**
-	 * Calculate content type.
-	 *
-	 * @param value the value
+	 * Common start nested.
 	 */
-	private void calculateContentType(String value) {
-		if (value.contains(",")) {
-			String[] mediaTypes = value.substring(1, value.length() - 1).split(", ");
-			for (String mediaType : mediaTypes)
-				if (routerFunctionData != null)
-					routerFunctionData.addConsumes(mediaType);
-				else
-					nestedContentTypeHeaders.addAll(Arrays.asList(mediaTypes));
-		}
-		else {
-			if (routerFunctionData != null)
-				routerFunctionData.addConsumes(value);
-			else
-				nestedContentTypeHeaders.add(value);
-		}
+	protected void commonStartNested() {
+		this.level++;
+		this.currentRouterFunctionDatas = null;
+	}
+
+	/**
+	 * Common route.
+	 */
+	protected void commonRoute() {
+		this.routerFunctionDatas.addAll(currentRouterFunctionDatas);
+		currentRouterFunctionDatas.forEach(routerFunctionData -> routerFunctionData.addAttributes(this.attributes));
+		this.attributes = new HashMap<>();
 	}
 
 	/**
-	 * Calculate accept.
+	 * Calculate header.
 	 *
 	 * @param value the value
+	 * @param headers the headers
+	 * @param header the header
 	 */
-	private void calculateAccept(String value) {
+	private void calculateHeader(String value, List<String> headers, String header) {
 		if (value.contains(",")) {
 			String[] mediaTypes = value.substring(1, value.length() - 1).split(", ");
 			for (String mediaType : mediaTypes)
-				if (routerFunctionData != null)
-					routerFunctionData.addProduces(mediaType);
+				if (CollectionUtils.isEmpty(currentRouterFunctionDatas))
+					headers.add(mediaType);
 				else
-					nestedAcceptHeaders.addAll(Arrays.asList(mediaTypes));
+					currentRouterFunctionDatas.forEach(routerFunctionData -> addHeader(mediaType, header, routerFunctionData));
 		}
 		else {
-			if (routerFunctionData != null)
-				routerFunctionData.addProduces(value);
+			if (CollectionUtils.isEmpty(currentRouterFunctionDatas))
+				headers.add(value);
 			else
-				nestedAcceptHeaders.add(value);
+				currentRouterFunctionDatas.forEach(routerFunctionData -> addHeader(value, header, routerFunctionData));
 		}
 	}
 
 	/**
-	 * Route.
+	 * Create router function data.
+	 *
+	 * @param path the path
 	 */
-	protected void route() {
-		this.routerFunctionData = new RouterFunctionData();
-		routerFunctionDatas.add(this.routerFunctionData);
-		this.routerFunctionData.addAttributes(this.attributes);
+	private void createRouterFunctionData(String path) {
+		RouterFunctionData routerFunctionData = new RouterFunctionData();
+		routerFunctionData.setPath(path);
+		routerFunctionData.setMethods(methods);
+		routerFunctionData.addConsumes(consumes);
+		routerFunctionData.addProduces(produces);
+		this.queryParams.forEach(routerFunctionData::addQueryParams);
+		this.currentRouterFunctionDatas.add(routerFunctionData);
 	}
 
 	/**
-	 * Attributes.
+	 * Add header.
 	 *
-	 * @param map the map
+	 * @param mediaType the media type
+	 * @param header the header
+	 * @param routerFunctionData the router function data
 	 */
-	public void attributes(Map<String, Object> map) {
-		this.attributes = map;
+	private void addHeader(String mediaType, String header,RouterFunctionData routerFunctionData) {
+		if (HttpHeaders.CONTENT_TYPE.equals(header))
+			routerFunctionData.addConsumes(mediaType);
+		else if (HttpHeaders.ACCEPT.equals(header))
+			routerFunctionData.addProduces(mediaType);
 	}
-
 }

springdoc-openapi-webflux-core/src/main/java/org/springdoc/webflux/core/visitor/RouterFunctionVisitor.java

@@ -20,7 +20,7 @@
 
 package org.springdoc.webflux.core.visitor;
 
-import java.util.HashMap;
+import java.util.ArrayList;
 import java.util.function.Function;
 
 import org.springdoc.core.fn.AbstractRouterFunctionVisitor;
@@ -42,20 +42,20 @@ public class RouterFunctionVisitor extends AbstractRouterFunctionVisitor impleme
 
 	@Override
 	public void route(RequestPredicate predicate, HandlerFunction<?> handlerFunction) {
-		super.route();
+		this.currentRouterFunctionDatas = new ArrayList<>();
 		predicate.accept(this);
-		this.attributes =  new HashMap<>();
+		commonRoute();
 	}
 
 	@Override
 	public void startNested(RequestPredicate predicate) {
-		this.isNested = true;
+		commonStartNested();
 		predicate.accept(this);
 	}
 
 	@Override
 	public void endNested(RequestPredicate predicate) {
-		computeNested();
+		commonEndNested();
 	}
 
 	@Override