fix: nested routing dispose, type-safe and events

Author: programadorthi

README.md

@@ -274,3 +274,31 @@ val router = routing(
     parent = parent,
 ) { }
 ```
+
+## Limitations
+
+- Nested routing with type-safe not support navigation from parent to child using the Type. You have to use path routing.
+```kotlin
+@Resource("/endpoint")
+class Endpoint
+
+val parent = routing { }
+
+val router = routing(
+    rootPath = "/child",
+    parent = parent,
+) {
+    handle<Endpoint> {
+        // ...
+    }
+}
+
+// IT WORKS
+router.execute(Endpoint())
+
+// IT DOES NOT WORK
+parent.execute(Endpoint())
+
+// IT WORKS
+parent.execute(YourCustomCall(uri = "/child/endpoint"))
+```

core-stack/common/test/dev/programadorthi/routing/core/StackRoutingTest.kt

@@ -506,4 +506,96 @@ class StackRoutingTest {
         assertEquals(parametersOf(), result?.parameters)
         assertEquals("/path", result?.stackManager?.last())
     }
+
+    @Test
+    fun shouldPushParentPathWhenRoutingFromChild() = runTest {
+        // GIVEN
+        val job = Job()
+        var result: ApplicationCall? = null
+
+        val parent = routing(
+            parentCoroutineContext = coroutineContext + job
+        ) {
+            install(StackRouting)
+
+            route(path = "/pathParent") {
+                push {
+                    result = call
+                    job.complete()
+                }
+            }
+        }
+
+        val routing = routing(
+            rootPath = "/child",
+            parent = parent,
+            parentCoroutineContext = coroutineContext + job
+        ) {
+            install(StackRouting)
+
+            route(path = "/pathChild") {
+                push {
+                    result = call
+                    job.complete()
+                }
+            }
+        }
+
+        // WHEN
+        routing.push(path = "/pathParent")
+        advanceTimeBy(99)
+
+        // THEN
+        assertNotNull(result)
+        assertEquals("/pathParent", "${result?.uri}")
+        assertEquals("", "${result?.name}")
+        assertEquals(StackRouteMethod.Push, result?.routeMethod)
+        assertEquals(Parameters.Empty, result?.parameters)
+    }
+
+    @Test
+    fun shouldPushChildPathWhenRoutingFromParent() = runTest {
+        // GIVEN
+        val job = Job()
+        var result: ApplicationCall? = null
+
+        val parent = routing(
+            parentCoroutineContext = coroutineContext + job
+        ) {
+            install(StackRouting)
+
+            route(path = "/pathParent") {
+                push {
+                    result = call
+                    job.complete()
+                }
+            }
+        }
+
+        routing(
+            rootPath = "/child",
+            parent = parent,
+            parentCoroutineContext = coroutineContext + job
+        ) {
+            install(StackRouting)
+
+            route(path = "/pathChild") {
+                push {
+                    result = call
+                    job.complete()
+                }
+            }
+        }
+
+        // WHEN
+        parent.push(path = "/child/pathChild")
+        advanceTimeBy(99)
+
+        // THEN
+        assertNotNull(result)
+        assertEquals("/child/pathChild", "${result?.uri}")
+        assertEquals("", "${result?.name}")
+        assertEquals(StackRouteMethod.Push, result?.routeMethod)
+        assertEquals(Parameters.Empty, result?.parameters)
+    }
 }

core/common/src/dev/programadorthi/routing/core/Route.kt

@@ -35,8 +35,6 @@ public open class Route(
 
     internal val handlers = mutableListOf<PipelineInterceptor<Unit, ApplicationCall>>()
 
-    internal var routingRef: Routing? = null
-
     /**
      * Creates a child node in this node with a given [selector] or returns an existing one with the same selector.
      */

core/common/src/dev/programadorthi/routing/core/Routing.kt

@@ -53,7 +53,7 @@ public class Routing internal constructor(
     public fun execute(call: ApplicationCall) {
         var current: Routing? = this
         while (current?.disposed == true && current.parent != null) {
-            current = current.parent?.routing
+            current = current.parent?.asRouting
         }
         val scope = current?.application ?: return
         with(scope) {
@@ -66,11 +66,13 @@ public class Routing internal constructor(
     public fun unregisterNamed(name: String) {
         val route = namedRoutes.remove(name) ?: return
         removeChild(route)
+        unregisterFromParents(route)
     }
 
     public fun unregisterPath(path: String) {
         val route = createRouteFromPath(path)
         removeChild(route)
+        unregisterFromParents(route)
     }
 
     /**
@@ -83,9 +85,7 @@ public class Routing internal constructor(
     }
 
     public fun dispose() {
-        actionOnParent { parent, _, path ->
-            parent.unregisterPath(path)
-        }
+        unregisterFromParents(this)
         childList.clear()
         namedRoutes.clear()
         application.dispose()
@@ -99,38 +99,21 @@ public class Routing internal constructor(
         namedRoutes[name] = route
     }
 
-    private fun removeChild(child: Route) {
-        val childParent = child.parent ?: return
-        val parentChildren = childParent.childList
-        parentChildren.remove(child)
-        if (parentChildren.isEmpty()) {
-            val toRemove = childParent.parent ?: return
-            removeChild(toRemove)
+    private fun removeChild(route: Route) {
+        val parentRoute = route.parent ?: return
+        parentRoute.childList.remove(route)
+        if (parentRoute.childList.isEmpty()) {
+            removeChild(parentRoute)
         }
     }
 
-    private fun connectWithParents(configure: Route.() -> Unit) {
-        actionOnParent { parent, child, path ->
-            val newChild = parent.route(
-                path = path,
-                name = null,
-                build = configure
-            )
-            newChild.routingRef = child.routing
-        }
-    }
-
-    private fun actionOnParent(action: (Routing, Routing, String) -> Unit) {
-        var child: Routing = this
-        var childParent: Route? = child.parent ?: return
-        var path = child.selector.toString()
-        while (childParent is Routing) {
-            action(childParent, child, path)
-
-            child = childParent
-            childParent = child.parent ?: return
-
-            path = child.selector.toString() + '/' + path
+    private fun unregisterFromParents(route: Route) {
+        val parentRouting = route.asRouting?.parent
+        if (parentRouting is Routing) {
+            val validPath = route.toString().substringAfter(parentRouting.toString())
+            val toRemove = parentRouting.createRouteFromPath(validPath)
+            removeChild(toRemove)
+            unregisterFromParents(toRemove)
         }
     }
 
@@ -291,7 +274,7 @@ public class Routing internal constructor(
         val resolveContext = RoutingResolveContext(this, call, tracers)
         when (val resolveResult = resolveContext.resolve()) {
             is RoutingResolveResult.Failure -> {
-                val routing = parent?.routing ?: throw RouteNotFoundException(message = resolveResult.reason)
+                val routing = parent?.asRouting ?: throw RouteNotFoundException(message = resolveResult.reason)
                 routing.execute(context.call)
             }
 
@@ -319,7 +302,6 @@ public class Routing internal constructor(
 
         override fun install(pipeline: Application, configure: Route.() -> Unit): Routing {
             val routing = Routing(pipeline).apply(configure)
-            routing.connectWithParents(configure)
             pipeline.intercept(Call) {
                 routing.interceptor(this)
             }
@@ -339,10 +321,10 @@ public val Route.application: Application
         )
     }
 
-public val Route.routing: Routing?
+public val Route.asRouting: Routing?
     get() = when (this) {
         is Routing -> this
-        else -> routingRef ?: parent?.routing
+        else -> parent?.asRouting
     }
 
 public fun <B : Any, F : Any> Route.install(

core/common/src/dev/programadorthi/routing/core/RoutingBuilder.kt

@@ -16,7 +16,7 @@ public fun Route.route(
     path: String,
     name: String? = null,
     build: Route.() -> Unit
-): Route = createRouteFromPath(path, name).apply(build)
+): Route = createRouteFromPath(path, name).apply(build).registerToParents(null, build)
 
 /**
  * Builds a route to match the specified [RouteMethod] and [path].
@@ -29,7 +29,7 @@ public fun Route.route(
     build: Route.() -> Unit,
 ): Route {
     val selector = RouteMethodRouteSelector(method)
-    return createRouteFromPath(path, name).createChild(selector).apply(build)
+    return createRouteFromPath(path, name).createChild(selector).apply(build).registerToParents(selector, build)
 }
 
 /**
@@ -38,7 +38,7 @@ public fun Route.route(
 @KtorDsl
 public fun Route.method(method: RouteMethod, body: Route.() -> Unit): Route {
     val selector = RouteMethodRouteSelector(method)
-    return createChild(selector).apply(body)
+    return createChild(selector).apply(body).registerToParents(selector, body)
 }
 
 @KtorDsl
@@ -55,7 +55,7 @@ public fun Route.createRouteFromPath(path: String, name: String?): Route {
     val route = createRouteFromPath(path)
     // Registering named route
     if (!name.isNullOrBlank()) {
-        val validRouting = requireNotNull(routing) {
+        val validRouting = requireNotNull(asRouting) {
             "Named route '$name' must be a Routing child."
         }
         validRouting.registerNamed(name = name, route = route)
@@ -84,6 +84,36 @@ internal fun Route.createRouteFromPath(path: String): Route {
     return current
 }
 
+/**
+ * Look for parents [Routing] and connect them to current [Route] creating a routing
+ * from top most parent until current: /topmostparent/moreparents/child
+ */
+private fun Route.registerToParents(
+    selector: RouteMethodRouteSelector?,
+    build: Route.() -> Unit
+): Route {
+    val parentRouting = asRouting?.parent as? Routing ?: return this
+    val validPath = when (val parentPath = parentRouting.toString()) {
+        "/" -> toString()
+        else -> toString().substringAfter(parentPath)
+    }
+    if (selector == null) {
+        parentRouting.route(path = validPath, name = null, build = build)
+    } else {
+        var path = validPath.substringBefore(selector.toString())
+        if (path.endsWith('/')) {
+            path = path.substring(0, path.length - 1)
+        }
+        parentRouting.route(
+            path = path,
+            method = selector.method,
+            name = null,
+            build = build
+        )
+    }
+    return this
+}
+
 /**
  * A helper object for building instances of [RouteSelector] from path segments.
  */

core/common/src/dev/programadorthi/routing/core/RoutingResolveContext.kt

@@ -21,7 +21,7 @@ private const val MIN_QUALITY = -Double.MAX_VALUE
  * @param call instance of [ApplicationCall] to use during resolution
  */
 public class RoutingResolveContext(
-    public val routing: Route,
+    public val routing: Routing,
     public val call: ApplicationCall,
     private val tracers: List<(RoutingResolveTrace) -> Unit>
 ) {
@@ -51,8 +51,14 @@ public class RoutingResolveContext(
         }
     }
 
-    private fun parse(path: String): List<String> {
-        if (path.isEmpty() || path == "/") return emptyList()
+    private fun parse(pathValue: String): List<String> {
+        if (pathValue.isEmpty() || pathValue == "/") return emptyList()
+        val routingPath = "/${routing.selector}"
+        val path = when {
+            pathValue.startsWith(routingPath) -> pathValue
+            pathValue.startsWith('/') -> "$routingPath$pathValue"
+            else -> "$routingPath/$pathValue"
+        }
         val length = path.length
         var beginSegment = 0
         var nextSegment = 0
@@ -175,7 +181,7 @@ public class RoutingResolveContext(
         if (finalResolve.isEmpty()) {
             return RoutingResolveResult.Failure(
                 routing,
-                "No matched subtrees found",
+                "No matched subtrees found for: ${call.path()}",
             )
         }