[feature]add new option that could disable kotlin data class, then all data clas will translate to kotlin normal class

Author: wuseal

src/main/kotlin/extensions/ExtensionsCollector.kt

@@ -1,13 +1,9 @@
 package extensions
 
 import extensions.chen.biao.KeepAnnotationSupport
-import extensions.wu.seal.KeepAnnotationSupportForAndroidX
 import extensions.jose.han.ParcelableAnnotationSupport
 import extensions.ted.zeng.PropertyAnnotationLineSupport
-import extensions.wu.seal.ClassNameSuffixSupport
-import extensions.wu.seal.ForceInitDefaultValueWithOriginJsonValueSupport
-import extensions.wu.seal.PropertyPrefixSupport
-import extensions.wu.seal.PropertySuffixSupport
+import extensions.wu.seal.*
 import extensions.xu.rui.PrimitiveTypeNonNullableSupport
 
 /**
@@ -18,14 +14,15 @@ object ExtensionsCollector {
      * all extensions
      */
     val extensions = listOf(
-        KeepAnnotationSupport,
-        KeepAnnotationSupportForAndroidX,
-        PropertyAnnotationLineSupport,
-        ParcelableAnnotationSupport,
-        PropertyPrefixSupport,
-        PropertySuffixSupport,
-        ClassNameSuffixSupport,
-        PrimitiveTypeNonNullableSupport,
-        ForceInitDefaultValueWithOriginJsonValueSupport
+            KeepAnnotationSupport,
+            KeepAnnotationSupportForAndroidX,
+            PropertyAnnotationLineSupport,
+            ParcelableAnnotationSupport,
+            PropertyPrefixSupport,
+            PropertySuffixSupport,
+            ClassNameSuffixSupport,
+            PrimitiveTypeNonNullableSupport,
+            ForceInitDefaultValueWithOriginJsonValueSupport,
+            DisableDataClassSupport
     )
 }

src/main/kotlin/extensions/wu/seal/DisableDataClassSupport.kt

@@ -0,0 +1,41 @@
+package extensions.wu.seal
+
+import extensions.Extension
+import wu.seal.jsontokotlin.model.classscodestruct.DataClass
+import wu.seal.jsontokotlin.model.classscodestruct.KotlinClass
+import wu.seal.jsontokotlin.model.classscodestruct.NormalClass
+import wu.seal.jsontokotlin.ui.checkBox
+import wu.seal.jsontokotlin.ui.horizontalLinearLayout
+import javax.swing.JPanel
+
+/**
+ * Extension support disable kotlin data class, after enable this, all kotlin data classes will be changed to [NormalClass]
+ */
+object DisableDataClassSupport : Extension() {
+
+    const val configKey = "wu.seal.disable_data_class_support"
+
+    override fun createUI(): JPanel {
+
+        return horizontalLinearLayout {
+            checkBox(
+                    "Disable Kotlin Data Class",
+                    getConfig(configKey).toBoolean()
+            ) { isSelectedAfterClick ->
+                setConfig(configKey, isSelectedAfterClick.toString())
+            }()
+            fillSpace()
+        }
+    }
+
+    override fun intercept(kotlinClass: KotlinClass): KotlinClass {
+
+        if (kotlinClass is DataClass && getConfig(configKey).toBoolean()) {
+            with(kotlinClass) {
+                return NormalClass(annotations, name, properties, parentClassTemplate, modifiable)
+            }
+        } else {
+            return kotlinClass
+        }
+    }
+}

src/main/kotlin/wu/seal/jsontokotlin/model/classscodestruct/NormalClass.kt

@@ -0,0 +1,121 @@
+package wu.seal.jsontokotlin.model.classscodestruct
+
+import wu.seal.jsontokotlin.interceptor.IKotlinClassInterceptor
+import wu.seal.jsontokotlin.utils.LogUtil
+import wu.seal.jsontokotlin.utils.getCommentCode
+import wu.seal.jsontokotlin.utils.getIndent
+import java.lang.IllegalStateException
+
+/**
+ * Created by Seal.Wu on 2020-03-05
+ * Normal general class code struct
+ * diff with data class is that there no 'data' modifier
+ */
+data class NormalClass(
+        val annotations: List<Annotation> = listOf(),
+        override val name: String,
+        val properties: List<Property> = listOf(),
+        val parentClassTemplate: String = "",
+        override val modifiable: Boolean = true
+) : ModifiableKotlinClass, NoGenericKotlinClass {
+
+    override val hasGeneric: Boolean = false
+
+    override val referencedClasses: List<KotlinClass>
+        get() {
+            return properties.flatMap { property ->
+                mutableListOf(property.typeObject).apply {
+                    addAll(property.typeObject.getAllGenericsRecursively())
+                }
+            }
+        }
+
+    override fun rename(newName: String): KotlinClass = copy(name = newName)
+
+    override fun replaceReferencedClasses(replaceRule: Map<KotlinClass, KotlinClass>): KotlinClass {
+        val propertiesReferencedModifiableKotlinClass = properties.flatMap {
+            if (it.typeObject is GenericKotlinClass) {
+                it.typeObject.getAllGenericsRecursively().toMutableList().also { list -> list.add(it.typeObject) }
+            } else {
+                listOf(it.typeObject)
+            }
+        }.filter { it.modifiable }
+        if (propertiesReferencedModifiableKotlinClass.size != replaceRule.size) {
+            throw IllegalStateException("properties used kotlin classes size should be equal referenced classes size!")
+        }
+        if (!replaceRule.all { it.key.modifiable }) {
+            throw IllegalStateException("to be replaced referenced class should be modifiable!")
+        }
+        val newProperties = properties.map { property ->
+            property.typeObject.let {
+                val newTypObj = when (it) {
+                    is GenericKotlinClass -> property.typeObject.replaceReferencedClasses(replaceRule)
+                    is ModifiableKotlinClass -> replaceRule[property.typeObject] ?: error("Modifiable Kotlin Class Must have a replacement")
+                    else -> it
+                }
+                LogUtil.i("replace type: ${property.type} to ${newTypObj.name}")
+                return@let property.copy(type = newTypObj.name, typeObject = newTypObj)
+            }
+        }
+
+        return copy(properties = newProperties)
+    }
+
+    override fun getCode(): String {
+        val indent = getIndent()
+        val code = buildString {
+            if (annotations.isNotEmpty()) {
+                val annotationsCode = annotations.joinToString("\n") { it.getAnnotationString() }
+                if (annotationsCode.isNotBlank()) {
+                    append(annotationsCode).append("\n")
+                }
+            }
+            if (properties.isEmpty()) {
+                append("class ").append(name).append("(").append("\n")
+            } else {
+                append("class ").append(name).append("(").append("\n")
+            }
+            properties.forEachIndexed { index, property ->
+                val code = property.getCode()
+                val addIndentCode = code.split("\n").joinToString("\n") { indent + it }
+                append(addIndentCode)
+                if (index != properties.size - 1) append(",")
+                if (property.comment.isNotBlank()) append(" // ").append(getCommentCode(property.comment))
+                append("\n")
+            }
+            append(")")
+            if (parentClassTemplate.isNotBlank()) {
+                append(" : ")
+                append(parentClassTemplate)
+            }
+            val nestedClasses = referencedClasses.filter { it.modifiable }
+            if (nestedClasses.isNotEmpty()) {
+                append(" {")
+                append("\n")
+                val nestedClassesCode = nestedClasses.joinToString("\n\n") { it.getCode() }
+                append(nestedClassesCode.lines().joinToString("\n") { if (it.isNotBlank()) "$indent$it" else it })
+                append("\n")
+                append("}")
+            }
+        }
+        return code
+    }
+
+
+    override fun <T : KotlinClass> applyInterceptors(enabledKotlinClassInterceptors: List<IKotlinClassInterceptor<T>>): KotlinClass {
+        val newProperties = mutableListOf<Property>()
+        properties.forEach {
+            newProperties.add(it.copy(typeObject = it.typeObject.applyInterceptors(enabledKotlinClassInterceptors)))
+        }
+        var newKotlinDataClass: KotlinClass = copy(properties = newProperties)
+        enabledKotlinClassInterceptors.forEach {
+            newKotlinDataClass = it.intercept(newKotlinDataClass)
+        }
+        return newKotlinDataClass
+    }
+
+    override fun getOnlyCurrentCode(): String {
+        val newProperties = properties.map { it.copy(typeObject = KotlinClass.ANY) }
+        return copy(properties = newProperties).getCode()
+    }
+}

src/test/kotlin/extensions/wu/seal/DisableDataClassSupportTest.kt

@@ -0,0 +1,30 @@
+package extensions.wu.seal
+
+import com.winterbe.expekt.should
+import org.junit.Test
+
+import org.junit.Assert.*
+import org.junit.Before
+import wu.seal.jsontokotlin.generateKotlinClassCode
+import wu.seal.jsontokotlin.test.TestConfig
+
+class DisableDataClassSupportTest {
+    private val json = """{"a":1}"""
+    private val expectCode: String = """
+        class Output(
+            @SerializedName("a")
+            val a: Int = 0 // 1
+        )
+    """.trimIndent()
+
+    @Before
+    fun setUp() {
+        TestConfig.setToTestInitState()
+    }
+
+    @Test
+    fun intercept() {
+        DisableDataClassSupport.getTestHelper().setConfig(DisableDataClassSupport.configKey, true.toString())
+        json.generateKotlinClassCode("Output").should.be.equal(expectCode)
+    }
+}