Feat/#12 WispRegistry 코드 생성 기능 구현

wisp-processor/src/main/java/com/angrypodo/wisp/WispClassName.kt

@@ -0,0 +1,10 @@
+package com.angrypodo.wisp
+
+import com.squareup.kotlinpoet.ClassName
+
+internal object WispClassName {
+    private const val RUNTIME_PACKAGE = "com.angrypodo.wisp.runtime"
+    const val GENERATED_PACKAGE = "com.angrypodo.wisp.generated"
+
+    val ROUTE_FACTORY = ClassName(RUNTIME_PACKAGE, "RouteFactory")
+}

wisp-processor/src/main/java/com/angrypodo/wisp/WispProcessor.kt

@@ -2,6 +2,7 @@ package com.angrypodo.wisp
 
 import com.angrypodo.wisp.annotations.Wisp
 import com.angrypodo.wisp.generator.RouteFactoryGenerator
+import com.angrypodo.wisp.generator.WispRegistryGenerator
 import com.angrypodo.wisp.mapper.toRouteInfo
 import com.angrypodo.wisp.model.RouteInfo
 import com.google.devtools.ksp.processing.CodeGenerator
@@ -11,6 +12,7 @@ import com.google.devtools.ksp.processing.Resolver
 import com.google.devtools.ksp.processing.SymbolProcessor
 import com.google.devtools.ksp.symbol.KSAnnotated
 import com.google.devtools.ksp.symbol.KSClassDeclaration
+import com.google.devtools.ksp.symbol.KSFile
 import com.google.devtools.ksp.validate
 import com.squareup.kotlinpoet.ksp.writeTo
 
@@ -32,22 +34,53 @@ internal class WispProcessor(
 
         val (processableSymbols, deferredSymbols) = symbols.partition { it.validate() }
 
-        processableSymbols.forEach { processSymbol(it) }
+        val routesWithSymbols = processableSymbols.mapNotNull { routeClass ->
+            val routeInfo = processSymbol(routeClass) ?: return@mapNotNull null
+            routeInfo to routeClass
+        }
+
+        if (!validateDuplicatePaths(routesWithSymbols)) return deferredSymbols
+
+        if (routesWithSymbols.isNotEmpty()) {
+            val routeInfos = routesWithSymbols.map { it.first }
+            val sourceFiles = routesWithSymbols.mapNotNull { it.second.containingFile }.distinct()
+
+            generateRouteRegistry(routeInfos, sourceFiles)
+        }
 
         return deferredSymbols
     }
 
-    private fun processSymbol(routeClass: KSClassDeclaration) {
-        if (!validateSerializable(routeClass)) {
-            return
-        }
+    private fun processSymbol(routeClass: KSClassDeclaration): RouteInfo? {
+        if (!validateSerializable(routeClass)) return null
 
         val routeInfo = routeClass.toRouteInfo() ?: run {
             logInvalidRouteError(routeClass)
-            return
+            return null
         }
 
         generateRouteFactory(routeClass, routeInfo)
+
+        return routeInfo
+    }
+
+    private fun validateDuplicatePaths(
+        routesWithSymbols: List<Pair<RouteInfo, KSClassDeclaration>>
+    ): Boolean {
+        val duplicates = routesWithSymbols.groupBy { it.first.wispPath }
+            .filter { it.value.size > 1 }
+
+        if (duplicates.isEmpty()) return true
+
+        duplicates.forEach { (path, pairs) ->
+            pairs.forEach { (_, symbol) ->
+                logger.error(
+                    "Wisp Error: The path '$path' is already used by another route.",
+                    symbol
+                )
+            }
+        }
+        return false
     }
 
     private fun validateSerializable(routeClass: KSClassDeclaration): Boolean {
@@ -77,6 +110,15 @@ internal class WispProcessor(
         fileSpec.writeTo(codeGenerator, dependencies)
     }
 
+    private fun generateRouteRegistry(
+        routeInfos: List<RouteInfo>,
+        sourceFiles: List<KSFile>
+    ) {
+        val fileSpec = WispRegistryGenerator.generate(routeInfos)
+        val dependencies = Dependencies(true, *sourceFiles.toTypedArray())
+        fileSpec.writeTo(codeGenerator, dependencies)
+    }
+
     private fun KSClassDeclaration.hasSerializableAnnotation(): Boolean {
         return annotations.any { annotation ->
             val shortName = annotation.shortName.asString()

wisp-processor/src/main/java/com/angrypodo/wisp/generator/RouteFactoryGenerator.kt

@@ -1,5 +1,6 @@
 package com.angrypodo.wisp.generator
 
+import com.angrypodo.wisp.WispClassName.ROUTE_FACTORY
 import com.angrypodo.wisp.model.ClassRouteInfo
 import com.angrypodo.wisp.model.ObjectRouteInfo
 import com.angrypodo.wisp.model.ParameterInfo
@@ -25,7 +26,6 @@ internal class RouteFactoryGenerator(
     private val logger: KSPLogger
 ) {
 
-    private val routeFactoryInterface = ClassName("com.angrypodo.wisp.runtime", "RouteFactory")
     private val missingParameterError = ClassName(
         "com.angrypodo.wisp.runtime",
         "WispError",
@@ -47,7 +47,7 @@ internal class RouteFactoryGenerator(
 
         val factoryObject = TypeSpec.objectBuilder(routeInfo.factoryClassName)
             .addModifiers(KModifier.INTERNAL)
-            .addSuperinterface(routeFactoryInterface)
+            .addSuperinterface(ROUTE_FACTORY)
             .addFunction(createFun)
             .build()
 

wisp-processor/src/main/java/com/angrypodo/wisp/generator/WispRegistryGenerator.kt

@@ -0,0 +1,45 @@
+package com.angrypodo.wisp.generator
+
+import com.angrypodo.wisp.WispClassName.GENERATED_PACKAGE
+import com.angrypodo.wisp.WispClassName.ROUTE_FACTORY
+import com.angrypodo.wisp.model.RouteInfo
+import com.squareup.kotlinpoet.CodeBlock
+import com.squareup.kotlinpoet.FileSpec
+import com.squareup.kotlinpoet.KModifier
+import com.squareup.kotlinpoet.MAP
+import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
+import com.squareup.kotlinpoet.PropertySpec
+import com.squareup.kotlinpoet.STRING
+import com.squareup.kotlinpoet.TypeSpec
+
+internal object WispRegistryGenerator {
+    private const val REGISTRY_NAME = "WispRegistry"
+
+    fun generate(routes: List<RouteInfo>): FileSpec {
+        val mapType = MAP.parameterizedBy(STRING, ROUTE_FACTORY)
+
+        val initializerBlock = CodeBlock.builder()
+            .add("mapOf(\n")
+            .indent()
+
+        routes.forEach { route ->
+            initializerBlock.add("%S to %T,\n", route.wispPath, route.factoryClassName)
+        }
+
+        initializerBlock.unindent().add(")")
+
+        val factoriesProperty = PropertySpec.builder("factories", mapType)
+            .addModifiers(KModifier.INTERNAL)
+            .initializer(initializerBlock.build())
+            .build()
+
+        val registryObject = TypeSpec.objectBuilder(REGISTRY_NAME)
+            .addModifiers(KModifier.INTERNAL)
+            .addProperty(factoriesProperty)
+            .build()
+
+        return FileSpec.builder(GENERATED_PACKAGE, REGISTRY_NAME)
+            .addType(registryObject)
+            .build()
+    }
+}

wisp-processor/src/test/java/com/angrypodo/wisp/generator/RegistryGeneratorTest.kt

@@ -0,0 +1,47 @@
+package com.angrypodo.wisp.generator
+
+import com.angrypodo.wisp.model.ClassRouteInfo
+import com.angrypodo.wisp.model.ObjectRouteInfo
+import com.squareup.kotlinpoet.ClassName
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Test
+
+internal class RegistryGeneratorTest {
+
+    @Test
+    @DisplayName("RouteInfo를 받아 WispRegistry 오브젝트와 맵을 생성한다")
+    fun `generate_registry_with_multiple_routes`() {
+        // Given: RouteInfo 데이터 2개
+        val homeRoute = ObjectRouteInfo(
+            routeClassName = ClassName("com.example", "Home"),
+            factoryClassName = ClassName("com.example", "HomeRouteFactory"),
+            wispPath = "home"
+        )
+
+        val profileRoute = ClassRouteInfo(
+            routeClassName = ClassName("com.example", "Profile"),
+            factoryClassName = ClassName("com.example", "ProfileRouteFactory"),
+            wispPath = "profile/{id}",
+            parameters = emptyList()
+        )
+
+        val routes = listOf(homeRoute, profileRoute)
+
+        // When: 코드 생성 실행
+        val fileSpec = WispRegistryGenerator.generate(routes)
+        val generatedCode = fileSpec.toString()
+
+        println(generatedCode)
+
+        // Then: 생성된 WispRegistry 객체를 반환
+        assertTrue(generatedCode.contains("object WispRegistry"))
+        assertTrue(generatedCode.contains("val factories: Map<String, RouteFactory> = mapOf("))
+
+        assertTrue(generatedCode.contains("import com.example.HomeRouteFactory"))
+        assertTrue(generatedCode.contains("\"home\" to HomeRouteFactory"))
+
+        assertTrue(generatedCode.contains("import com.example.ProfileRouteFactory"))
+        assertTrue(generatedCode.contains("\"profile/{id}\" to ProfileRouteFactory"))
+    }
+}