Add truncatedBeforeFirstParameter

Author: prdoyle

bosk-core/src/main/java/works/bosk/Bosk.java

@@ -754,48 +754,41 @@ private <S> void triggerCascade(Reference<S> effectiveScope, @Nullable R priorRo
 				action.accept(effectiveScope);
 			}
 		} else {
-			try {
-				// There's at least one parameter that hasn't been bound yet. This means
-				// we need to locate all the matching objects that may have changed.
-				// We do so by filling in the first parameter with all possible values that
-				// could correspond to changed objects and then recursing.
-				//
-				Path containerPath = effectiveScope.path().truncatedTo(effectiveScope.path().firstParameterIndex());
-				Reference<EnumerableByIdentifier<?>> containerRef = rootReference().then(enumerableByIdentifierClass(), containerPath);
-				EnumerableByIdentifier<?> priorContainer = refValueIfExists(containerRef, priorRoot);
-				EnumerableByIdentifier<?> newContainer = refValueIfExists(containerRef, newRoot);
+			// There's at least one parameter that hasn't been bound yet. This means
+			// we need to locate all the matching objects that may have changed.
+			// We do so by filling in the first parameter with all possible values that
+			// could correspond to changed objects and then recursing.
+			//
+			Reference<EnumerableByIdentifier<?>> containerRef = effectiveScope.truncatedBeforeFirstParameter();
+			EnumerableByIdentifier<?> priorContainer = refValueIfExists(containerRef, priorRoot);
+			EnumerableByIdentifier<?> newContainer = refValueIfExists(containerRef, newRoot);
 
-				// TODO: If priorContainer == newContainer, can we stop immediately?
+			// TODO: If priorContainer == newContainer, can we stop immediately?
 
-				// Process any deleted items first. This can allow the hook to free some memory
-				// that can be used by subsequent hooks.
-				// We do them in reverse order just because that's likely to be the preferred
-				// order for cleanup activities.
-				//
-				// TODO: Should we actually process the hooks themselves in reverse order for the same reason?
-				//
-				if (priorContainer != null) {
-					List<Identifier> priorIDs = priorContainer.ids();
-					for (Identifier id : priorIDs.reversed()) {
-						if (newContainer == null || newContainer.get(id) == null) {
-							triggerCascade(effectiveScope.boundTo(id), priorRoot, newRoot, action);
-						}
+			// Process any deleted items first. This can allow the hook to free some memory
+			// that can be used by subsequent hooks.
+			// We do them in reverse order just because that's likely to be the preferred
+			// order for cleanup activities.
+			//
+			// TODO: Should we actually process the hooks themselves in reverse order for the same reason?
+			//
+			if (priorContainer != null) {
+				List<Identifier> priorIDs = priorContainer.ids();
+				for (Identifier id : priorIDs.reversed()) {
+					if (newContainer == null || newContainer.get(id) == null) {
+						triggerCascade(effectiveScope.boundTo(id), priorRoot, newRoot, action);
 					}
 				}
+			}
 
-				// Then process updated items
-				//
-				if (newContainer != null) {
-					for (Identifier id : newContainer.ids()) {
-						if (priorContainer == null || priorContainer.get(id) != newContainer.get(id)) {
-							triggerCascade(effectiveScope.boundTo(id), priorRoot, newRoot, action);
-						}
+			// Then process updated items
+			//
+			if (newContainer != null) {
+				for (Identifier id : newContainer.ids()) {
+					if (priorContainer == null || priorContainer.get(id) != newContainer.get(id)) {
+						triggerCascade(effectiveScope.boundTo(id), priorRoot, newRoot, action);
 					}
 				}
-			} catch (InvalidTypeException e) {
-				// TODO: Add truncation methods to Reference so we can refactor this to create
-				// the container reference without risking an InvalidTypeException
-				throw new AssertionError("Parameterized reference must be truncatable at the location of the parameter", e);
 			}
 		}
 	}

bosk-core/src/main/java/works/bosk/Path.java

@@ -255,6 +255,10 @@ public final String segment(int index) {
 	public abstract String lastSegment();
 
 	public abstract int numParameters();
+
+	/**
+	 * @throws IllegalArgumentException if {@link #numParameters()} is 0
+	 */
 	public abstract int firstParameterIndex();
 
 	@Override

bosk-core/src/main/java/works/bosk/Reference.java

@@ -172,6 +172,18 @@ default <TT> Reference<TT> truncatedTo(Class<TT> targetClass, int remainingSegme
 		return root().then(targetClass, path().truncatedTo(remainingSegments));
 	}
 
+	/**
+	 * @throws IllegalArgumentException if this reference has no parameters
+	 */
+	@SuppressWarnings({"rawtypes", "unchecked"})
+	default Reference<EnumerableByIdentifier<?>> truncatedBeforeFirstParameter() {
+		try {
+			return (Reference<EnumerableByIdentifier<?>>) (Reference) root().then(EnumerableByIdentifier.class, path().truncatedTo(path().firstParameterIndex()));
+		} catch (InvalidTypeException e) {
+			throw new AssertionError("Every parameter must belongs to an EnumerableByIdentifier", e);
+		}
+	}
+
 	/**
 	 * Returns a {@link Reference} with the {@link Path#lastSegment() last segment} removed.
 	 *

bosk-core/src/test/java/works/bosk/ReferenceTest.java

@@ -16,6 +16,7 @@
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static works.bosk.BoskConfig.simpleDriver;
 
@@ -198,6 +199,17 @@ void truncatedTo() throws InvalidTypeException {
 		assertEquals(stringRef, stringRef.truncatedTo(String.class, 3));
 	}
 
+	@Test
+	void truncatedBeforeFirstParameter() {
+		Identifier id = Identifier.from("id");
+
+		assertEquals(refs.catalog(), refs.anyEntity().truncatedBeforeFirstParameter());
+		assertEquals(refs.catalog(), refs.anySideTableEntry().truncatedBeforeFirstParameter());
+		assertEquals(refs.stringSideTable(id), refs.anySideTableEntry(id).truncatedBeforeFirstParameter());
+		assertThrows(IllegalArgumentException.class, () -> refs.anySideTableEntry(id, id).truncatedBeforeFirstParameter(),
+			"Should throw when called on a reference with no parameters");
+	}
+
 	@Test
 	void idAt() {
 		Identifier parentID = Identifier.from("parent");
@@ -320,6 +332,7 @@ public interface Refs {
 		@ReferencePath("/someStrings") Reference<StringListValueSubclass> someStrings();
 		@ReferencePath("/someMappedStrings") Reference<MapValue<String>> someMappedStrings();
 
+		@ReferencePath("/entities/-entity-") Reference<TestEntity> anyEntity();
 		@ReferencePath("/entities/-entity-") Reference<TestEntity> entity(Identifier entity);
 		@ReferencePath("/entities/-entity-/string") Reference<String> string(Identifier entity);
 		@ReferencePath("/entities/-entity-/testEnum") Reference<TestEnum> testEnum(Identifier entity);
@@ -344,8 +357,7 @@ public interface Refs {
 		@ReferencePath("/entities/-entity-/optionals/optionalListing") ListingReference<TestChild> optionalListing(Identifier entity);
 		@ReferencePath("/entities/-entity-/optionals/optionalSideTable") SideTableReference<TestChild, String> optionalSideTable(Identifier entity);
 
-		@ReferencePath("/entities/-entity-/stringSideTable/-child-") Reference<String> sideTableEntry(Identifier entity, Identifier child);
-		@ReferencePath("/entities/-entity-/stringSideTable/-child-") Reference<String> anySideTableEntry(Identifier entity);
+		@ReferencePath("/entities/-entity-/stringSideTable/-child-") Reference<String> anySideTableEntry(Identifier... parameters);
 		@ReferencePath("/entities/-entity-/children/-child-") Reference<TestChild> child(Identifier entity, Identifier child);
 		@ReferencePath("/entities/-entity-/children/-child-") Reference<TestChild> anyChild(Identifier entity);
 	}