Add API for creating list comprehensions based on named paths.

Author: michael-simons

neo4j-cypher-dsl/src/main/java/org/neo4j/cypherdsl/core/Cypher.java

@@ -326,7 +326,7 @@ public static <T> Literal<T> literalOf(Object object) {
 			}
 
 			@SuppressWarnings("unchecked") // See above
-				ListLiteral listLiteral = new ListLiteral((Iterable<Literal<?>>) object);
+			ListLiteral listLiteral = new ListLiteral((Iterable<Literal<?>>) object);
 			return (Literal<T>) listLiteral;
 		}
 		if (object instanceof Boolean) {
@@ -368,12 +368,26 @@ public static StatementBuilder.OngoingReadingAndReturn returning(Expression... e
 		return Statement.builder().returning(expressions);
 	}
 
-	public static OngoingDefinitionWithPattern listBasedOn(Relationship pattern) {
-		return PatternComprehension.basedOn(pattern);
+	/**
+	 * Creates a list comprehension starting with a {@link Relationship} or a {@link RelationshipChain chain of relationships}.
+	 *
+	 * @param relationshipPattern The relationship pattern on which the new list comprehension is based on.
+	 * @return An ongoing definition.
+	 * @since 2020.0.0
+	 */
+	public static OngoingDefinitionWithPattern listBasedOn(RelationshipPattern relationshipPattern) {
+		return PatternComprehension.basedOn(relationshipPattern);
 	}
 
-	public static OngoingDefinitionWithPattern listBasedOn(RelationshipChain pattern) {
-		return PatternComprehension.basedOn(pattern);
+	/**
+	 * Creates a list comprehension starting with a {@link NamedPath named path}.
+	 *
+	 * @param namedPath The named path on which the new list comprehension is based on.
+	 * @return An ongoing definition.
+	 * @since 2020.1.1
+	 */
+	public static OngoingDefinitionWithPattern listBasedOn(NamedPath namedPath) {
+		return PatternComprehension.basedOn(namedPath);
 	}
 
 	/**

neo4j-cypher-dsl/src/main/java/org/neo4j/cypherdsl/core/PatternComprehension.java

@@ -35,17 +35,17 @@
 @API(status = EXPERIMENTAL, since = "1.0")
 public final class PatternComprehension implements Expression {
 
-	private final RelationshipPattern pattern;
+	private final PatternElement pattern;
 	private final Where where;
 	private final Expression listDefinition;
 
-	static OngoingDefinitionWithPattern basedOn(Relationship pattern) {
+	static OngoingDefinitionWithPattern basedOn(RelationshipPattern pattern) {
 
 		Assertions.notNull(pattern, "A pattern is required");
 		return new Builder(pattern);
 	}
 
-	static OngoingDefinitionWithPattern basedOn(RelationshipChain pattern) {
+	static OngoingDefinitionWithPattern basedOn(NamedPath pattern) {
 
 		Assertions.notNull(pattern, "A pattern is required");
 		return new Builder(pattern);
@@ -90,10 +90,10 @@ public interface OngoingDefinitionWithPatternAndWhere extends OngoingDefinitionW
 	 * Ongoing definition of a pattern comprehension. Can be defined without a where-clause now.
 	 */
 	private static class Builder implements OngoingDefinitionWithPattern, OngoingDefinitionWithPatternAndWhere  {
-		private final RelationshipPattern pattern;
+		private final PatternElement pattern;
 		private final DefaultStatementBuilder.ConditionBuilder conditionBuilder = new DefaultStatementBuilder.ConditionBuilder();
 
-		private Builder(RelationshipPattern pattern) {
+		private Builder(PatternElement pattern) {
 			this.pattern = pattern;
 		}
 
@@ -122,7 +122,7 @@ public PatternComprehension returning(Expression... expressions) {
 		}
 	}
 
-	private PatternComprehension(RelationshipPattern pattern, Where where, Expression listDefinition) {
+	private PatternComprehension(PatternElement pattern, Where where, Expression listDefinition) {
 		this.pattern = pattern;
 		this.where = where;
 		this.listDefinition = listDefinition;

neo4j-cypher-dsl/src/test/java/org/neo4j/cypherdsl/core/CypherIT.java

@@ -3221,11 +3221,22 @@ void doc3148() {
 			NamedPath p = Cypher.path("p").definedBy(
 				Cypher.anyNode("michael").withProperties("name", Cypher.literalOf("Michael Douglas"))
 					.relationshipTo(Cypher.anyNode()));
-			Statement statement = Cypher.match(p).returning(p.getRequiredSymbolicName()).build();
+			Statement statement = Cypher.match(p).returning(p).build();
 
 			assertThat(cypherRenderer.render(statement))
 				.isEqualTo("MATCH p = (michael {name: 'Michael Douglas'})-->() RETURN p");
 		}
+
+		@Test
+		void shouldWorkInListComprehensions() {
+
+			NamedPath p = Cypher.path("p").definedBy(
+				Cypher.anyNode("n").relationshipTo(Cypher.anyNode(), "LIKES", "OWNS").unbounded());
+			Statement statement = Cypher.returning(Cypher.listBasedOn(p).returning(p)).build();
+
+			assertThat(cypherRenderer.render(statement))
+				.isEqualTo("RETURN [p = (n)-[:`LIKES`|`OWNS`*]->() | p]");
+		}
 	}
 
 	@Nested