feat: nested routing and unregister path support

Author: programadorthi

README.md

@@ -265,6 +265,21 @@ router.emitEvent(
 )
 ```
 
+## Nested Routing
+
+With nested routing you can connect one `Routing`. It is good for projects that demand loading routes on demand 
+as Android Dynamic Feature that each module has your own navigation and are load at runtime.
+Checkout `RoutingTest` for more usages.
+
+```kotlin
+val parent = routing { }
+
+val router = routing(
+    rootPath = "/child",
+    parent = parent,
+) { }
+```
+
 ## Next steps
 
 [ ] - Helper modules for native platform navigation (Android, iOS, Web, Desktop, ...)

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

@@ -29,12 +29,14 @@ public open class Route(
      */
     public val children: List<Route> get() = childList
 
-    private val childList: MutableList<Route> = mutableListOf()
+    internal val childList: MutableList<Route> = mutableListOf()
 
     private var cachedPipeline: ApplicationCallPipeline? = null
 
     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.
      */
@@ -123,17 +125,6 @@ public fun Route.getAllRoutes(): List<Route> {
     return endpoints
 }
 
-public fun Route.routing(): Routing {
-    var parent: Route? = this
-    while (parent != null) {
-        if (parent is Routing) {
-            return parent
-        }
-        parent = parent.parent
-    }
-    error("Route not attached to a parent VoyagerRouting: $this")
-}
-
 internal fun Route.allSelectors(): List<RouteSelector> {
     val selectors = mutableListOf(selector)
     var other = parent

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

@@ -37,28 +37,40 @@ import kotlin.coroutines.EmptyCoroutineContext
 public class Routing internal constructor(
     internal val application: Application,
 ) : Route(
-    parent = null,
-    selector = RootRouteSelector(""),
+    parent = application.environment.parentRouting,
+    selector = RootRouteSelector(application.environment.rootPath),
     application.environment.developmentMode,
     application.environment
 ) {
     private val tracers = mutableListOf<(RoutingResolveTrace) -> Unit>()
     private val namedRoutes = mutableMapOf<String, Route>()
+    private var disposed = false
 
     init {
         addDefaultTracing()
     }
 
     public fun execute(call: ApplicationCall) {
-        with(application) {
+        var current: Routing? = this
+        while (current?.disposed == true && current.parent != null) {
+            current = current.parent?.routing
+        }
+        val scope = current?.application ?: return
+        with(scope) {
             launch {
                 execute(call)
             }
         }
     }
 
     public fun unregisterNamed(name: String) {
-        namedRoutes.remove(name)
+        val route = namedRoutes.remove(name) ?: return
+        removeChild(route)
+    }
+
+    public fun unregisterPath(path: String) {
+        val route = createRouteFromPath(path)
+        removeChild(route)
     }
 
     /**
@@ -71,7 +83,13 @@ public class Routing internal constructor(
     }
 
     public fun dispose() {
+        actionOnParent { parent, _, path ->
+            parent.unregisterPath(path)
+        }
+        childList.clear()
+        namedRoutes.clear()
         application.dispose()
+        disposed = true
     }
 
     internal fun registerNamed(name: String, route: Route) {
@@ -81,6 +99,41 @@ 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 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 mapNameToPath(name: String, pathParameters: Parameters): String {
         val namedRoute =
             namedRoutes[name]
@@ -237,7 +290,10 @@ public class Routing internal constructor(
 
         val resolveContext = RoutingResolveContext(this, call, tracers)
         when (val resolveResult = resolveContext.resolve()) {
-            is RoutingResolveResult.Failure -> throw RouteNotFoundException(message = resolveResult.reason)
+            is RoutingResolveResult.Failure -> {
+                val routing = parent?.routing ?: throw RouteNotFoundException(message = resolveResult.reason)
+                routing.execute(context.call)
+            }
 
             is RoutingResolveResult.Success -> {
                 val routingCallPipeline = resolveResult.route.buildPipeline()
@@ -257,12 +313,13 @@ public class Routing internal constructor(
      * An installation object of the [Routing] plugin.
      */
     @Suppress("PublicApiImplicitType")
-    public companion object Plugin : BaseApplicationPlugin<Application, Routing, Routing> {
+    public companion object Plugin : BaseApplicationPlugin<Application, Route, Routing> {
 
         override val key: AttributeKey<Routing> = AttributeKey("Routing")
 
-        override fun install(pipeline: Application, configure: Routing.() -> Unit): Routing {
+        override fun install(pipeline: Application, configure: Route.() -> Unit): Routing {
             val routing = Routing(pipeline).apply(configure)
+            routing.connectWithParents(configure)
             pipeline.intercept(Call) {
                 routing.interceptor(this)
             }
@@ -282,22 +339,35 @@ public val Route.application: Application
         )
     }
 
+public val Route.routing: Routing?
+    get() = when (this) {
+        is Routing -> this
+        else -> routingRef ?: parent?.routing
+    }
+
 public fun <B : Any, F : Any> Route.install(
     plugin: Plugin<Application, B, F>,
     configure: B.() -> Unit = {}
 ): F = application.install(plugin, configure)
 
 @KtorDsl
 public fun routing(
+    rootPath: String = "/",
+    parent: Routing? = null,
     parentCoroutineContext: CoroutineContext = EmptyCoroutineContext,
     log: Logger = KtorSimpleLogger("kotlin-routing"),
     developmentMode: Boolean = false,
-    configuration: Routing.() -> Unit
+    configuration: Route.() -> Unit
 ): Routing {
+    check(parent == null || rootPath != "/") {
+        "Child routing cannot have root path with '/' only. Please, provide a path to your child routing"
+    }
     val environment = ApplicationEnvironment(
         parentCoroutineContext = parentCoroutineContext,
-        log = log,
         developmentMode = developmentMode,
+        rootPath = rootPath,
+        parentRouting = parent,
+        log = log,
     )
     return with(Application(environment)) {
         install(Routing, configuration)

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

@@ -49,9 +49,24 @@ public fun Route.handle(
 ): Route = route(path, name) { handle(body) }
 
 /**
- * Creates a routing entry for the specified path.
+ * Creates a routing entry for the specified path and name
  */
 public fun Route.createRouteFromPath(path: String, name: String?): Route {
+    val route = createRouteFromPath(path)
+    // Registering named route
+    if (!name.isNullOrBlank()) {
+        val validRouting = requireNotNull(routing) {
+            "Named route '$name' must be a Routing child."
+        }
+        validRouting.registerNamed(name = name, route = route)
+    }
+    return route
+}
+
+/**
+ * Creates a routing entry for the specified path.
+ */
+internal fun Route.createRouteFromPath(path: String): Route {
     val parts = RoutingPath.parse(path).parts
     var current: Route = this
     for (index in parts.indices) {
@@ -66,10 +81,6 @@ public fun Route.createRouteFromPath(path: String, name: String?): Route {
     if (path.endsWith("/")) {
         current = current.createChild(TrailingSlashRouteSelector)
     }
-    // Registering named route
-    if (!name.isNullOrBlank()) {
-        routing().registerNamed(name = name, route = current)
-    }
     return current
 }
 

core/common/src/dev/programadorthi/routing/core/application/ApplicationEnvironment.kt

@@ -4,6 +4,7 @@
 
 package dev.programadorthi.routing.core.application
 
+import dev.programadorthi.routing.core.Routing
 import io.ktor.util.logging.Logger
 import kotlin.coroutines.CoroutineContext
 
@@ -25,4 +26,14 @@ public data class ApplicationEnvironment(
      * Indicates if development mode is enabled.
      */
     public val developmentMode: Boolean,
+
+    /**
+     * Application's root path (prefix, context path in servlet container).
+     */
+    public val rootPath: String,
+
+    /**
+     * Application's current [Routing] used to nested routing
+     */
+    public val parentRouting: Routing?
 )