add klock in common and DateTimeSerializer

0.20.45

CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## 0.20.46
+
+* `Common`:
+    * Now this repo depends on `klock`
+    * Add new object-serializer `DateTimeSerializer` for `klock` serializer
+
+## 0.20.45
+
+* `Versions`:
+    * `Android Core KTX`: `1.12.0` -> `1.13.0`
+
+## 0.20.44
+
+* `Versions`:
+    * `Compose`: `1.6.1` -> `1.6.2`
+    * `Koin`: `3.5.4` -> `3.5.6`
+
+## 0.20.43
+
+* `Versions`:
+    * `Ktor`: `2.3.9` -> `2.3.10`
+    * `Koin`: `3.5.3` -> `3.5.4`
+
+## 0.20.42
+
+* `Repos`:
+    * `Generator`:
+        * Improvements
+
 ## 0.20.41
 
 * `Repos`:

common/build.gradle

@@ -8,6 +8,11 @@ apply from: "$mppJvmJsAndroidLinuxMingwLinuxArm64ProjectPresetPath"
 
 kotlin {
     sourceSets {
+        commonMain {
+            dependencies {
+                api libs.klock
+            }
+        }
         jvmMain {
             dependencies {
                 api project(":micro_utils.coroutines")

common/src/commonMain/kotlin/dev/inmo/micro_utils/common/DateTimeSerializer.kt

@@ -0,0 +1,23 @@
+package dev.inmo.micro_utils.common
+
+import korlibs.time.DateTime
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.Serializer
+import kotlinx.serialization.builtins.serializer
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+
+@Serializer(DateTime::class)
+object DateTimeSerializer : KSerializer<DateTime> {
+    override val descriptor: SerialDescriptor
+        get() = Double.serializer().descriptor
+
+    override fun deserialize(decoder: Decoder): DateTime {
+        return DateTime(decoder.decodeDouble())
+    }
+
+    override fun serialize(encoder: Encoder, value: DateTime) {
+        encoder.encodeDouble(value.unixMillis)
+    }
+}

gradle.properties

@@ -15,5 +15,5 @@ crypto_js_version=4.1.1
 # Project data
 
 group=dev.inmo
-version=0.20.41
-android_code_version=247
+version=0.20.46
+android_code_version=252

gradle/libs.versions.toml

@@ -6,30 +6,30 @@ kt-coroutines = "1.8.0"
 
 kslog = "1.3.3"
 
-jb-compose = "1.6.1"
+jb-compose = "1.6.2"
 jb-exposed = "0.49.0"
 jb-dokka = "1.9.20"
 
 korlibs = "5.4.0"
 uuid = "0.8.4"
 
-ktor = "2.3.9"
+ktor = "2.3.10"
 
 gh-release = "2.5.2"
 
-koin = "3.5.3"
+koin = "3.5.6"
 
 okio = "3.9.0"
 
-ksp = "1.9.23-1.0.19"
+ksp = "1.9.23-1.0.20"
 kotlin-poet = "1.16.0"
 
 versions = "0.51.0"
 
-android-gradle = "8.3.1"
+android-gradle = "8.3.2"
 dexcount = "4.0.0"
 
-android-coreKtx = "1.12.0"
+android-coreKtx = "1.13.0"
 android-recyclerView = "1.3.2"
 android-appCompat = "1.6.1"
 android-fragment = "1.6.2"

ktor/common/build.gradle

@@ -12,7 +12,6 @@ kotlin {
             dependencies {
                 api internalProject("micro_utils.common")
                 api libs.kt.serialization.cbor
-                api libs.klock
                 api libs.uuid
                 api libs.ktor.io
             }

repos/generator/src/main/kotlin/Processor.kt

@@ -1,8 +1,6 @@
 package dev.inmo.micro_utils.repos.generator
 
-import com.google.devtools.ksp.KspExperimental
-import com.google.devtools.ksp.getAnnotationsByType
-import com.google.devtools.ksp.isAnnotationPresent
+import com.google.devtools.ksp.*
 import com.google.devtools.ksp.processing.CodeGenerator
 import com.google.devtools.ksp.processing.Resolver
 import com.google.devtools.ksp.processing.SymbolProcessor
@@ -36,6 +34,7 @@ import kotlinx.serialization.Serializable
 import java.io.File
 import kotlin.reflect.KProperty1
 import kotlin.reflect.full.memberProperties
+import kotlin.reflect.jvm.jvmName
 
 private fun KSClassifierReference.quilifiedName(): String = "${qualifier ?.let { "${it.quilifiedName()}." } ?: ""}${referencedName()}"
 
@@ -75,16 +74,29 @@ class Processor(
                         ORIGINAL FILE: ${ksFile.fileName}
                     """.trimIndent()
                     )
+
                     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 excludedKSClassProperties = allKSClassProperties.filter { property ->
+                        property.isAnnotationPresent(GenerateCRUDModelExcludeOverride::class) || (property.findOverridee() ?.isAnnotationPresent(GenerateCRUDModelExcludeOverride::class) == true)
                     }
                     val excludedKSClassPropertiesNames = excludedKSClassProperties.map { it.simpleName.asString() }
                     val ksClassProperties = allKSClassProperties.filter {
                         it !in excludedKSClassProperties
+                    }.groupBy { it.simpleName.asString() }.map {
+                        var current = it.value.first()
+                        var currentType = current.type.resolve()
+                        it.value.forEach {
+                            val type = it.type.resolve()
+
+                            if (currentType.isAssignableFrom(type) && !type.isAssignableFrom(currentType)) {
+                                current = it
+                                currentType = type
+                            }
+                        }
+                        current
                     }
                     val ksClassPropertiesNames = ksClassProperties.map { it.simpleName.asString() }
                     val newNewType = TypeSpec.classBuilder(newName).apply {
@@ -99,17 +111,20 @@ class Processor(
                         }
                         primaryConstructor(
                             FunSpec.constructorBuilder().apply {
+                                val withoutDefaults = mutableListOf<Pair<ParameterSpec.Builder, PropertySpec.Builder>>()
                                 ksClassProperties.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()
-                                    )
+                                    val property = PropertySpec.builder(it.simpleName.getShortName(), it.type.toTypeName(), KModifier.OVERRIDE).apply {
+                                        initializer(it.simpleName.getShortName())
+                                    }
+                                    ParameterSpec.builder(it.simpleName.getShortName(), it.type.toTypeName()).apply {
+                                        withoutDefaults.add(this to property)
+                                        annotations += it.annotations.map { it.toAnnotationSpec() }
+                                    }
+                                }
+
+                                withoutDefaults.forEach {
+                                    addParameter(it.first.build())
+                                    addProperty(it.second.build())
                                 }
                             }.build()
                         )
@@ -125,14 +140,25 @@ class Processor(
                         (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()
+                        it.simpleName.asString() !in excludedKSClassPropertiesNames && !it.isAnnotationPresent(GenerateCRUDModelExcludeOverride::class)
                     }
-                    val allProperties: List<KSPropertyDeclaration> = ksClassProperties.toList() + registeredTypesProperties
-                    val propertiesToOverrideInRegistered = allProperties.distinctBy { it.simpleName.asString() }.sortedBy { property ->
+                    val allProperties: List<KSPropertyDeclaration> = registeredTypesProperties + ksClassProperties.toList()
+                    val propertiesToOverrideInRegistered = allProperties.groupBy { it.simpleName.asString() }.map {
+                        var current = it.value.first()
+                        var currentType = current.type.resolve()
+                        it.value.forEach {
+                            val type = it.type.resolve()
+
+                            if (currentType.isAssignableFrom(type) && !type.isAssignableFrom(currentType)) {
+                                current = it
+                                currentType = type
+                            }
+                        }
+                        current
+                    }.sortedBy { property ->
                         val name = property.simpleName.asString()
 
                         ksClassPropertiesNames.indexOf(name).takeIf { it > -1 } ?.let {
@@ -156,17 +182,20 @@ class Processor(
                         addModifiers(KModifier.DATA)
                         primaryConstructor(
                             FunSpec.constructorBuilder().apply {
+                                val withoutDefaults = mutableListOf<Pair<ParameterSpec.Builder, PropertySpec.Builder>>()
                                 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()
-                                    )
+                                    val property = PropertySpec.builder(it.simpleName.getShortName(), it.type.toTypeName(), KModifier.OVERRIDE).apply {
+                                        initializer(it.simpleName.getShortName())
+                                    }
+                                    ParameterSpec.builder(it.simpleName.getShortName(), it.type.toTypeName()).apply {
+                                        withoutDefaults.add(this to property)
+                                        annotations += it.annotations.map { it.toAnnotationSpec() }
+                                    }
+                                }
+
+                                withoutDefaults.forEach {
+                                    addParameter(it.first.build())
+                                    addProperty(it.second.build())
                                 }
                             }.build()
                         )
@@ -191,7 +220,7 @@ class Processor(
                         FunSpec.builder("asRegistered").apply {
                             receiver(ksClassDeclaration.toClassName())
                             (registeredTypesProperties.filter { it.simpleName.asString() !in ksClassPropertiesNames }).forEach {
-                                addParameter(it.simpleName.asString(), it.typeName)
+                                addParameter(it.simpleName.asString(), it.type.toTypeName())
                             }
                             addCode(
                                 CodeBlock.of(

repos/generator/test/src/commonMain/kotlin/GeneratedModelsTest.kt

@@ -14,6 +14,7 @@ public data class NewTest(
   override val property1: String,
   override val property2: Int,
   @Serializable
+  @SerialName(`value` = "custom_parent_name")
   override val parent: ParentTypeId?,
 ) : Test
 
@@ -24,6 +25,7 @@ public data class RegisteredTest(
   override val property1: String,
   override val property2: Int,
   @Serializable
+  @SerialName(`value` = "custom_parent_name")
   override val parent: ParentTypeId?,
 ) : Test, IRegisteredTest
 

repos/generator/test/src/commonMain/kotlin/Test.kt

@@ -2,6 +2,7 @@ package dev.inmo.micro_utils.repos.generator.test
 
 import dev.inmo.micro_utils.repos.annotations.GenerateCRUDModel
 import dev.inmo.micro_utils.repos.annotations.GenerateCRUDModelExcludeOverride
+import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 import kotlin.jvm.JvmInline
 
@@ -18,6 +19,7 @@ sealed interface Test {
     val property1: String
     val property2: Int
     @Serializable
+    @SerialName("custom_parent_name")
     val parent: ParentTypeId?
 
     @GenerateCRUDModelExcludeOverride