temporal solution of generating problem

2024-11-19 23:03:49 +00:00 · 2023-02-26 14:37:41 +06:00 · 2023-02-26 14:37:41 +06:00 · 8215f9d2c6
commit 8215f9d2c6
parent d2e6d2ec80
4 changed files with 178 additions and 148 deletions
--- a/publish.gradle
+++ b/publish.gradle
@ -89,17 +89,17 @@ publishing {
 }

 if (project.hasProperty("signing.gnupg.keyName")) {
-    apply plugin: 'signing'
-
-    signing {
-        useGpgCmd()
-
-        sign publishing.publications
-    }
-
-    task signAll {
-        tasks.withType(Sign).forEach {
-            dependsOn(it)
-        }
-    }
+//    apply plugin: 'signing'
+//
+//    signing {
+//        useGpgCmd()
+//
+//        sign publishing.publications
+//    }
+//
+//    task signAll {
+//        tasks.withType(Sign).forEach {
+//            dependsOn(it)
+//        }
+//    }
 }
--- a/repos/generator/src/main/kotlin/Processor.kt
+++ b/repos/generator/src/main/kotlin/Processor.kt
@ -8,8 +8,13 @@ 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.KSClassifierReference
 import com.google.devtools.ksp.symbol.KSPropertyDeclaration
+import com.google.devtools.ksp.symbol.KSReferenceElement
 import com.google.devtools.ksp.symbol.KSType
+import com.google.devtools.ksp.symbol.KSTypeAlias
+import com.google.devtools.ksp.symbol.KSValueArgument
+import com.google.devtools.ksp.symbol.Nullability
 import com.squareup.kotlinpoet.AnnotationSpec
 import com.squareup.kotlinpoet.ClassName
 import com.squareup.kotlinpoet.CodeBlock
@ -18,6 +23,7 @@ import com.squareup.kotlinpoet.FunSpec
 import com.squareup.kotlinpoet.KModifier
 import com.squareup.kotlinpoet.ParameterSpec
 import com.squareup.kotlinpoet.PropertySpec
+import com.squareup.kotlinpoet.TypeName
 import com.squareup.kotlinpoet.TypeSpec
 import com.squareup.kotlinpoet.asTypeName
 import com.squareup.kotlinpoet.ksp.toAnnotationSpec
@ -31,163 +37,181 @@ import java.io.File
 import kotlin.reflect.KProperty1
 import kotlin.reflect.full.memberProperties

+private fun KSClassifierReference.quilifiedName(): String = "${qualifier ?.let { "${it.quilifiedName()}." } ?: ""}${referencedName()}"
+
 class Processor(
    private val codeGenerator: CodeGenerator
 ) : SymbolProcessor {
+    private val KSPropertyDeclaration.typeName: TypeName
+        get() {
+            return runCatching {
+                type.toTypeName()
+            }.getOrElse {
+                val element = type.element as KSClassifierReference
+                (type.element as KSClassifierReference).let {
+                    ClassName(
+                        element.qualifier ?.quilifiedName() ?: "",
+                        element.referencedName()
+                    )
+                }
+            }
+        }
    @OptIn(KspExperimental::class)
    override fun process(resolver: Resolver): List<KSAnnotated> {
-        resolver.getSymbolsWithAnnotation(
+        val toRetry = resolver.getSymbolsWithAnnotation(
            GenerateCRUDModel::class.qualifiedName!!
-        ).filterIsInstance<KSClassDeclaration>().forEach { ksClassDeclaration ->
-            val ksFile = ksClassDeclaration.containingFile ?: return@forEach
-            FileSpec.builder(
-                ksClassDeclaration.packageName.asString(),
-                "GeneratedModels${ksFile.fileName.removeSuffix(".kt")}"
-            ).apply {
-                val annotation = ksClassDeclaration.getAnnotationsByType(GenerateCRUDModel::class).first()
-                addFileComment(
-                    """
+        ).filterIsInstance<KSClassDeclaration>().filterNot { ksClassDeclaration ->
+            val ksFile = ksClassDeclaration.containingFile ?: return@filterNot false
+            runCatching {
+                FileSpec.builder(
+                    ksClassDeclaration.packageName.asString(),
+                    "GeneratedModels${ksFile.fileName.removeSuffix(".kt")}"
+                ).apply {
+                    val annotation = ksClassDeclaration.getAnnotationsByType(GenerateCRUDModel::class).first()
+                    addFileComment(
+                        """
                        THIS CODE HAVE BEEN GENERATED AUTOMATICALLY
                        TO REGENERATE IT JUST DELETE FILE
                        ORIGINAL FILE: ${ksFile.fileName}
                    """.trimIndent()
-                )
-                val newName = "New${ksClassDeclaration.simpleName.getShortName()}"
-                val registeredName = "Registered${ksClassDeclaration.simpleName.getShortName()}"
+                    )
+                    val newName = "New${ksClassDeclaration.simpleName.getShortName()}"
+                    val registeredName = "Registered${ksClassDeclaration.simpleName.getShortName()}"

-                val allKSClassProperties = ksClassDeclaration.getAllProperties()
-                val excludedKSClassProperties = allKSClassProperties.filter {
-                    it.isAnnotationPresent(GenerateCRUDModelExcludeOverride::class)
-                }
-                val excludedKSClassPropertiesNames = excludedKSClassProperties.map { it.simpleName.asString() }
-                val ksClassProperties = allKSClassProperties.filter {
-                    it !in excludedKSClassProperties
-                }
-                val ksClassPropertiesNames = ksClassProperties.map { it.simpleName.asString() }
-                val newNewType = TypeSpec.classBuilder(newName).apply {
-                    val typeBuilder = this
-                    addSuperinterface(ksClassDeclaration.toClassName())
-                    addModifiers(KModifier.DATA)
-                    if (annotation.serializable) {
-                        addAnnotation(Serializable::class)
-                        if (annotation.generateSerialName) {
-                            addAnnotation(AnnotationSpec.get(SerialName(newName)))
-                        }
+                    val allKSClassProperties = ksClassDeclaration.getAllProperties()
+                    val excludedKSClassProperties = allKSClassProperties.filter {
+                        it.isAnnotationPresent(GenerateCRUDModelExcludeOverride::class)
                    }
-                    primaryConstructor(
-                        FunSpec.constructorBuilder().apply {
-                            ksClassProperties.forEach {
-                                addParameter(it.simpleName.getShortName(), it.type.toTypeName())
-                                typeBuilder.addProperty(
-                                    PropertySpec.builder(it.simpleName.getShortName(), it.type.toTypeName(), KModifier.OVERRIDE).apply {
-                                        initializer(it.simpleName.getShortName())
-                                    }.build()
+                    val excludedKSClassPropertiesNames = excludedKSClassProperties.map { it.simpleName.asString() }
+                    val ksClassProperties = allKSClassProperties.filter {
+                        it !in excludedKSClassProperties
+                    }
+                    val ksClassPropertiesNames = ksClassProperties.map { it.simpleName.asString() }
+                    val newNewType = TypeSpec.classBuilder(newName).apply {
+                        val typeBuilder = this
+                        addSuperinterface(ksClassDeclaration.toClassName())
+                        addModifiers(KModifier.DATA)
+                        if (annotation.serializable) {
+                            addAnnotation(Serializable::class)
+                            if (annotation.generateSerialName) {
+                                addAnnotation(AnnotationSpec.get(SerialName(newName)))
+                            }
+                        }
+                        primaryConstructor(
+                            FunSpec.constructorBuilder().apply {
+                                ksClassProperties.forEach {
+                                    addParameter(it.simpleName.getShortName(), it.typeName)
+                                    typeBuilder.addProperty(
+                                        PropertySpec.builder(it.simpleName.getShortName(), it.typeName, KModifier.OVERRIDE).apply {
+                                            initializer(it.simpleName.getShortName())
+                                        }.build()
+                                    )
+                                }
+                            }.build()
+                        )
+                    }.build()
+                    addType(
+                        newNewType
+                    )
+
+                    val registeredSupertypes = ksClassDeclaration.annotations.filter {
+                        it.shortName.asString() == GenerateCRUDModel::class.simpleName &&
+                            it.annotationType.resolve().declaration.qualifiedName ?.asString() == GenerateCRUDModel::class.qualifiedName
+                    }.flatMap {
+                        (it.arguments.first().value as List<KSType>).map { it.declaration as KSClassDeclaration }
+                    }.toList()
+
+
+                    val registeredTypesProperties: List<KSPropertyDeclaration> = registeredSupertypes.flatMap { registeredType ->
+                        registeredType.getAllProperties()
+                    }.filter {
+                        it.simpleName.asString() !in excludedKSClassPropertiesNames && it.getAnnotationsByType(GenerateCRUDModelExcludeOverride::class).none()
+                    }
+                    val allProperties: List<KSPropertyDeclaration> = ksClassProperties.toList() + registeredTypesProperties
+                    val propertiesToOverrideInRegistered = allProperties.distinctBy { it.simpleName.asString() }.sortedBy { property ->
+                        val name = property.simpleName.asString()
+
+                        ksClassPropertiesNames.indexOf(name).takeIf { it > -1 } ?.let {
+                            it + allProperties.size
+                        } ?: allProperties.indexOfFirst { it.simpleName.asString() == name }
+                    }
+
+                    val newRegisteredType = TypeSpec.classBuilder(registeredName).apply {
+                        val typeBuilder = this
+                        addSuperinterface(ksClassDeclaration.toClassName())
+                        if (annotation.serializable) {
+                            addAnnotation(Serializable::class)
+
+                            if (annotation.generateSerialName) {
+                                addAnnotation(
+                                    AnnotationSpec.get(SerialName(registeredName))
                                )
                            }
+                        }
+                        addSuperinterfaces(registeredSupertypes.map { it.toClassName() })
+                        addModifiers(KModifier.DATA)
+                        primaryConstructor(
+                            FunSpec.constructorBuilder().apply {
+                                propertiesToOverrideInRegistered.forEach {
+                                    addParameter(
+                                        ParameterSpec.builder(it.simpleName.getShortName(), it.typeName).apply {
+                                            annotations += it.annotations.map { it.toAnnotationSpec() }
+                                        }.build()
+                                    )
+                                    typeBuilder.addProperty(
+                                        PropertySpec.builder(it.simpleName.getShortName(), it.typeName, KModifier.OVERRIDE).apply {
+                                            initializer(it.simpleName.getShortName())
+                                        }.build()
+                                    )
+                                }
+                            }.build()
+                        )
+                    }.build()
+                    addType(
+                        newRegisteredType
+                    )
+
+                    addFunction(
+                        FunSpec.builder("asNew").apply {
+                            receiver(ksClassDeclaration.toClassName())
+                            addCode(
+                                CodeBlock.of(
+                                    "return ${newNewType.name}(${newNewType.propertySpecs.joinToString { it.name }})"
+                                )
+                            )
+                            returns(ClassName(packageName, newNewType.name!!))
                        }.build()
                    )
-                }.build()
-                addType(
-                    newNewType
-                )

-                val registeredSupertypes = ksClassDeclaration.annotations.filter {
-                    it.shortName.asString() == GenerateCRUDModel::class.simpleName &&
-                        it.annotationType.resolve().declaration.qualifiedName ?.asString() == GenerateCRUDModel::class.qualifiedName
-                }.flatMap {
-                    (it.arguments.first().value as List<KSType>).map { it.declaration as KSClassDeclaration }
-                }.toList()
-
-
-                val registeredTypesProperties: List<KSPropertyDeclaration> = registeredSupertypes.flatMap { registeredType ->
-                    registeredType.getAllProperties()
-                }.filter {
-                    it.simpleName.asString() !in excludedKSClassPropertiesNames && it.getAnnotationsByType(GenerateCRUDModelExcludeOverride::class).none()
-                }
-                val allProperties: List<KSPropertyDeclaration> = ksClassProperties.toList() + registeredTypesProperties
-                val propertiesToOverrideInRegistered = allProperties.distinctBy { it.simpleName.asString() }.sortedBy { property ->
-                    val name = property.simpleName.asString()
-
-                    ksClassPropertiesNames.indexOf(name).takeIf { it > -1 } ?.let {
-                        it + allProperties.size
-                    } ?: allProperties.indexOfFirst { it.simpleName.asString() == name }
-                }
-
-                val newRegisteredType = TypeSpec.classBuilder(registeredName).apply {
-                    val typeBuilder = this
-                    addSuperinterface(ksClassDeclaration.toClassName())
-                    if (annotation.serializable) {
-                        addAnnotation(Serializable::class)
-
-                        if (annotation.generateSerialName) {
-                            addAnnotation(
-                                AnnotationSpec.get(SerialName(registeredName))
-                            )
-                        }
-                    }
-                    addSuperinterfaces(registeredSupertypes.map { it.toClassName() })
-                    addModifiers(KModifier.DATA)
-                    primaryConstructor(
-                        FunSpec.constructorBuilder().apply {
-                            propertiesToOverrideInRegistered.forEach {
-                                addParameter(
-                                    ParameterSpec.builder(it.simpleName.getShortName(), it.type.toTypeName()).apply {
-                                        annotations += it.annotations.map { it.toAnnotationSpec() }
-                                    }.build()
-                                )
-                                typeBuilder.addProperty(
-                                    PropertySpec.builder(it.simpleName.getShortName(), it.type.toTypeName(), KModifier.OVERRIDE).apply {
-                                        initializer(it.simpleName.getShortName())
-                                    }.build()
-                                )
+                    addFunction(
+                        FunSpec.builder("asRegistered").apply {
+                            receiver(ksClassDeclaration.toClassName())
+                            (registeredTypesProperties.filter { it.simpleName.asString() !in ksClassPropertiesNames }).forEach {
+                                addParameter(it.simpleName.asString(), it.typeName)
                            }
+                            addCode(
+                                CodeBlock.of(
+                                    "return ${newRegisteredType.name}(${newRegisteredType.propertySpecs.joinToString { it.name }})"
+                                )
+                            )
+                            returns(ClassName(packageName, newRegisteredType.name!!))
                        }.build()
                    )
-                }.build()
-                addType(
-                    newRegisteredType
-                )
+                }.build().let {
+                    File(
+                        File(ksFile.filePath).parent,
+                        "GeneratedModels${ksFile.fileName}"
+                    ).takeIf { !it.exists() } ?.apply {
+                        parentFile.mkdirs()

-                addFunction(
-                    FunSpec.builder("asNew").apply {
-                        receiver(ksClassDeclaration.toClassName())
-                        addCode(
-                            CodeBlock.of(
-                                "return ${newNewType.name}(${newNewType.propertySpecs.joinToString { it.name }})"
-                            )
-                        )
-                        returns(ClassName(packageName, newNewType.name!!))
-                    }.build()
-                )
-
-                addFunction(
-                    FunSpec.builder("asRegistered").apply {
-                        receiver(ksClassDeclaration.toClassName())
-                        (registeredTypesProperties.filter { it.simpleName.asString() !in ksClassPropertiesNames }).forEach {
-                            addParameter(it.simpleName.asString(), it.type.toTypeName())
+                        writer().use { writer ->
+                            it.writeTo(writer)
                        }
-                        addCode(
-                            CodeBlock.of(
-                                "return ${newRegisteredType.name}(${newRegisteredType.propertySpecs.joinToString { it.name }})"
-                            )
-                        )
-                        returns(ClassName(packageName, newRegisteredType.name!!))
-                    }.build()
-                )
-            }.build().let {
-                File(
-                    File(ksFile.filePath).parent,
-                    "GeneratedModels${ksFile.fileName}"
-                ).takeIf { !it.exists() } ?.apply {
-                    parentFile.mkdirs()
-
-                    writer().use { writer ->
-                        it.writeTo(writer)
                    }
                }
-            }
-        }
+            }.isSuccess
+        }.toList()

-        return emptyList()
+        return toRetry
    }
 }
--- a/repos/generator/test/src/commonMain/kotlin/GeneratedModelsTest.kt
+++ b/repos/generator/test/src/commonMain/kotlin/GeneratedModelsTest.kt
@ -13,6 +13,7 @@ import kotlinx.serialization.Serializable
 public data class NewTest(
  public override val property1: String,
  public override val property2: Int,
+  public override val parent: ParentTypeId?,
 ) : Test

@Serializable
@ -21,8 +22,10 @@ public data class RegisteredTest(
  public override val id: TestId,
  public override val property1: String,
  public override val property2: Int,
+  public override val parent: ParentTypeId?,
 ) : Test, IRegisteredTest

-public fun Test.asNew(): NewTest = NewTest(property1, property2)
+public fun Test.asNew(): NewTest = NewTest(property1, property2, parent)

-public fun Test.asRegistered(id: TestId): RegisteredTest = RegisteredTest(id, property1, property2)
+public fun Test.asRegistered(id: TestId): RegisteredTest = RegisteredTest(id, property1, property2,
+    parent)
--- a/repos/generator/test/src/commonMain/kotlin/Test.kt
+++ b/repos/generator/test/src/commonMain/kotlin/Test.kt
@ -11,10 +11,13 @@ value class TestId(
    val long: Long
 )

+typealias ParentTypeId = TestId
+
@GenerateCRUDModel(IRegisteredTest::class)
 sealed interface Test {
    val property1: String
    val property2: Int
+    val parent: ParentTypeId?

    @GenerateCRUDModelExcludeOverride
    val excludedProperty: String