Support array of inline tables encoding (#350)

BOOMeranGG · web-flow · commit 9ab4f2279d32 · 2025-09-18T14:02:30.000+07:00
* Support array of inline tables encoding
diff --git a/ktoml-core/src/commonMain/kotlin/com/akuleshov7/ktoml/annotations/TomlInlineTable.kt b/ktoml-core/src/commonMain/kotlin/com/akuleshov7/ktoml/annotations/TomlInlineTable.kt
@@ -1,6 +1,5 @@
 package com.akuleshov7.ktoml.annotations
 
-import kotlin.annotation.AnnotationTarget.*
 import kotlinx.serialization.ExperimentalSerializationApi
 import kotlinx.serialization.SerialInfo
 
@@ -12,7 +11,8 @@ import kotlinx.serialization.SerialInfo
  * data class Data(
  *     @TomlInlineTable
  *     val inlineTable: Table,
- *     val tableArray: List<@TomlInlineTable Table>,
+ *     @TomlInlineTable
+ *     val tableArray: List<Table>,
  *     val inlineTable2: Table2
  * )
  *
@@ -44,9 +44,7 @@ import kotlinx.serialization.SerialInfo
 @OptIn(ExperimentalSerializationApi::class)
 @SerialInfo
 @Target(
-    PROPERTY,
-    TYPE_PARAMETER,
-    CLASS,
-    TYPE
+    AnnotationTarget.PROPERTY,
+    AnnotationTarget.CLASS,
 )
 public annotation class TomlInlineTable
diff --git a/ktoml-core/src/commonMain/kotlin/com/akuleshov7/ktoml/encoders/TomlArrayEncoder.kt b/ktoml-core/src/commonMain/kotlin/com/akuleshov7/ktoml/encoders/TomlArrayEncoder.kt
@@ -2,11 +2,11 @@ package com.akuleshov7.ktoml.encoders
 
 import com.akuleshov7.ktoml.TomlOutputConfig
 import com.akuleshov7.ktoml.exceptions.InternalEncodingException
-import com.akuleshov7.ktoml.exceptions.UnsupportedEncodingFeatureException
 import com.akuleshov7.ktoml.tree.nodes.*
 import com.akuleshov7.ktoml.tree.nodes.pairs.keys.TomlKey
 import com.akuleshov7.ktoml.tree.nodes.pairs.values.TomlArray
 import com.akuleshov7.ktoml.tree.nodes.pairs.values.TomlValue
+import com.akuleshov7.ktoml.tree.nodes.tables.InlineTableType
 import kotlinx.serialization.ExperimentalSerializationApi
 import kotlinx.serialization.descriptors.PolymorphicKind
 import kotlinx.serialization.descriptors.SerialDescriptor
@@ -95,10 +95,16 @@ public class TomlArrayEncoder internal constructor(
             is PolymorphicKind ->
                 // Nested primitive array
                 arrayEncoder(rootNode, attributes)
-            else ->
-                throw UnsupportedEncodingFeatureException(
-                    "Inline tables are not yet supported as array elements."
+            else -> {
+                val element = TomlArrayOfTablesElement(
+                    elementIndex,
+                    attributes.comments,
+                    attributes.inlineComment
                 )
+
+                tables += element
+                inlineTableEncoder(element)
+            }
         }
     } else {
         val element = TomlArrayOfTablesElement(
@@ -119,7 +125,7 @@ public class TomlArrayEncoder internal constructor(
     }
 
     override fun endStructure(descriptor: SerialDescriptor) {
-        if (attributes.isInline) {
+        if (attributes.isInline && tables.isEmpty()) {
             val array = TomlArray(values, attributes.isMultiline)
 
             parent?.let {
@@ -163,14 +169,31 @@ public class TomlArrayEncoder internal constructor(
             }
         }
 
-        val tableArray = TomlTable(
-            TomlKey(attributes.parent!!.getFullKey(), elementIndex),
-            elementIndex,
-            type = TableType.ARRAY,
-            isSynthetic = isSynthetic
-        )
+        appendParentalTable(isSynthetic)
+    }
 
-        tables.forEach(tableArray::appendChild)
+    private fun appendParentalTable(isSynthetic: Boolean) {
+        val allChildren = tables.flatMap { it.children }
+        val tableArray = if (allChildren.any { it is TomlInlineTable && it.key == null }) {
+            TomlInlineTable(
+                key = TomlKey(attributes.parent!!.key!!, elementIndex),
+                tomlKeyValues = tables,
+                inlineTableType = InlineTableType.ARRAY,
+                lineNo = elementIndex,
+                comments = emptyList(),
+                inlineComment = "",
+                multiline = attributes.isMultiline,
+            )
+        } else {
+            TomlTable(
+                TomlKey(attributes.parent!!.getFullKey(), elementIndex),
+                elementIndex,
+                type = TableType.ARRAY,
+                isSynthetic = isSynthetic
+            ).apply {
+                tables.forEach(this::appendChild)
+            }
+        }
 
         rootNode.appendChild(tableArray)
     }
diff --git a/ktoml-core/src/commonMain/kotlin/com/akuleshov7/ktoml/encoders/TomlInlineTableEncoder.kt b/ktoml-core/src/commonMain/kotlin/com/akuleshov7/ktoml/encoders/TomlInlineTableEncoder.kt
@@ -2,13 +2,11 @@ package com.akuleshov7.ktoml.encoders
 
 import com.akuleshov7.ktoml.TomlOutputConfig
 import com.akuleshov7.ktoml.exceptions.InternalEncodingException
-import com.akuleshov7.ktoml.tree.nodes.TomlInlineTable
-import com.akuleshov7.ktoml.tree.nodes.TomlKeyValueArray
-import com.akuleshov7.ktoml.tree.nodes.TomlKeyValuePrimitive
-import com.akuleshov7.ktoml.tree.nodes.TomlNode
+import com.akuleshov7.ktoml.tree.nodes.*
 import com.akuleshov7.ktoml.tree.nodes.pairs.keys.TomlKey
 import com.akuleshov7.ktoml.tree.nodes.pairs.values.TomlArray
 import com.akuleshov7.ktoml.tree.nodes.pairs.values.TomlValue
+import com.akuleshov7.ktoml.tree.nodes.tables.InlineTableType
 import kotlinx.serialization.ExperimentalSerializationApi
 import kotlinx.serialization.descriptors.SerialDescriptor
 import kotlinx.serialization.descriptors.SerialKind
@@ -102,21 +100,25 @@ public class TomlInlineTableEncoder internal constructor(
 
     override fun beginStructure(descriptor: SerialDescriptor): CompositeEncoder {
         val (_, _, _, _, _, _, comments, inlineComment) = attributes
-        val name = attributes.keyOrThrow()
+
+        val tomlKey = if (parent !is TomlArrayEncoder) {
+            TomlKey(attributes.keyOrThrow(), elementIndex)
+        } else {
+            null
+        }
 
         val inlineTable = TomlInlineTable(
-            TomlKey(name, elementIndex),
-            pairs,
-            elementIndex,
-            comments,
-            inlineComment
+            key = tomlKey,
+            tomlKeyValues = pairs,
+            inlineTableType = InlineTableType.PRIMITIVE,
+            lineNo = elementIndex,
+            comments = comments,
+            inlineComment = inlineComment,
         )
 
         when (parent) {
             is TomlInlineTableEncoder -> parent.pairs += inlineTable
-            is TomlArrayEncoder -> {
-                // Todo: Implement this when inline table arrays are supported.
-            }
+            is TomlArrayEncoder -> rootNode.appendChild(inlineTable)
             else -> rootNode.appendChild(inlineTable)
         }
 
@@ -143,21 +145,23 @@ public class TomlInlineTableEncoder internal constructor(
                 child.value,
                 child.lineNo,
                 child.comments,
-                child.inlineComment
+                child.inlineComment,
             )
             is TomlKeyValueArray -> TomlKeyValueArray(
                 TomlKey(name, child.lineNo),
                 child.value,
                 child.lineNo,
                 child.comments,
-                child.inlineComment
+                child.inlineComment,
             )
             is TomlInlineTable -> TomlInlineTable(
-                TomlKey(name, elementIndex),
-                child.tomlKeyValues,
-                child.lineNo,
-                child.comments,
-                child.inlineComment
+                key = TomlKey(name, elementIndex),
+                tomlKeyValues = child.tomlKeyValues,
+                inlineTableType = InlineTableType.PRIMITIVE,
+                lineNo = child.lineNo,
+                comments = child.comments,
+                inlineComment = child.inlineComment,
+                multiline = child.multiline,
             )
             else -> throw InternalEncodingException("Tried to encode $child as a pair, but it has unknown type.")
         }
diff --git a/ktoml-core/src/commonMain/kotlin/com/akuleshov7/ktoml/tree/nodes/tables/InlineTableType.kt b/ktoml-core/src/commonMain/kotlin/com/akuleshov7/ktoml/tree/nodes/tables/InlineTableType.kt
@@ -0,0 +1,11 @@
+package com.akuleshov7.ktoml.tree.nodes.tables
+
+/**
+ * Type of inline table: primitive = "table = { a = 5, b = 6 }" or array: "table_arr = [ { a = 5 }, { a = 6 } ]"
+ *
+ */
+public enum class InlineTableType {
+    ARRAY,
+    PRIMITIVE,
+    ;
+}
diff --git a/ktoml-core/src/commonMain/kotlin/com/akuleshov7/ktoml/tree/nodes/tables/TomlInlineTable.kt b/ktoml-core/src/commonMain/kotlin/com/akuleshov7/ktoml/tree/nodes/tables/TomlInlineTable.kt
@@ -5,6 +5,7 @@ import com.akuleshov7.ktoml.TomlOutputConfig
 import com.akuleshov7.ktoml.exceptions.ParseException
 import com.akuleshov7.ktoml.parsers.*
 import com.akuleshov7.ktoml.tree.nodes.pairs.keys.TomlKey
+import com.akuleshov7.ktoml.tree.nodes.tables.InlineTableType
 import com.akuleshov7.ktoml.writers.TomlEmitter
 
 /**
@@ -13,12 +14,16 @@ import com.akuleshov7.ktoml.writers.TomlEmitter
  * @param lineNo
  * @param comments
  * @param inlineComment
+ * @param inlineTableType type of inline table (primitive or array)
  * @property tomlKeyValues The key-value pairs in the inline table
- * @property key
+ * @property multiline whether the inline table should be written in multiple lines
+ * @property key null when this inline table is part of array of tables
  */
 public class TomlInlineTable internal constructor(
-    public val key: TomlKey,
+    public val key: TomlKey?,
     internal val tomlKeyValues: List<TomlNode>,
+    private val inlineTableType: InlineTableType,
+    public val multiline: Boolean = false,
     lineNo: Int,
     comments: List<String> = emptyList(),
     inlineComment: String = ""
@@ -35,13 +40,17 @@ public class TomlInlineTable internal constructor(
         lineNo: Int,
         comments: List<String> = emptyList(),
         inlineComment: String = "",
-        config: TomlInputConfig = TomlInputConfig()
+        config: TomlInputConfig = TomlInputConfig(),
+        inlineTableType: InlineTableType = InlineTableType.PRIMITIVE,
+        multiline: Boolean = false,
     ) : this(
         TomlKey(keyValuePair.first, lineNo),
         keyValuePair.second.parseInlineTableValue(keyValuePair, lineNo, config),
+        inlineTableType,
+        multiline,
         lineNo,
         comments,
-        inlineComment
+        inlineComment,
     )
 
     public fun returnTable(tomlFileHead: TomlFile, currentParentalNode: TomlNode): TomlTable {
@@ -77,31 +86,62 @@ public class TomlInlineTable internal constructor(
         emitter: TomlEmitter,
         config: TomlOutputConfig
     ) {
-        key.write(emitter)
+        key?.let {
+            it.write(emitter)
+            emitter.emitPairDelimiter()
+        }
 
-        emitter.emitPairDelimiter()
-            .startInlineTable()
+        when (inlineTableType) {
+            InlineTableType.PRIMITIVE -> emitter.startInlineTable()
+            InlineTableType.ARRAY -> emitter.startArray()
+        }
 
+        val isMultiline = multiline && inlineTableType == InlineTableType.ARRAY
+        if (isMultiline) {
+            emitter.indent()
+        }
         tomlKeyValues.forEachIndexed { i, pair ->
             if (i > 0) {
                 emitter.emitElementDelimiter()
             }
-
-            emitter.emitWhitespace()
+            if (isMultiline) {
+                emitter.emitNewLine()
+            } else {
+                emitter.emitWhitespace()
+            }
 
             pair.write(emitter, config)
         }
+        if (isMultiline) {
+            emitter.dedent()
+        }
 
-        emitter.emitWhitespace()
-            .endInlineTable()
+        if (!isMultiline) {
+            emitter.emitWhitespace()
+        }
+
+        writeEnding(emitter, isMultiline)
+    }
+
+    private fun writeEnding(emitter: TomlEmitter, isMultiline: Boolean) {
+        when (inlineTableType) {
+            InlineTableType.PRIMITIVE -> emitter.endInlineTable()
+            InlineTableType.ARRAY -> {
+                if (isMultiline) {
+                    emitter.emitNewLine()
+                }
+                emitter.emitIndent()
+                    .endArray()
+            }
+        }
     }
 
     private fun createTableRoot(currentParentalNode: TomlNode): TomlTable = TomlTable(
         TomlKey(
             when (currentParentalNode) {
-                is TomlTable -> currentParentalNode.fullTableKey.keyParts + key.keyParts
+                is TomlTable -> currentParentalNode.fullTableKey.keyParts + key!!.keyParts
                 is TomlArrayOfTablesElement -> (currentParentalNode.parent as TomlTable)
-                    .fullTableKey.keyParts + key.keyParts
+                    .fullTableKey.keyParts + key!!.keyParts
                 else -> listOf(name)
             },
         ),
diff --git a/ktoml-core/src/commonTest/kotlin/com/akuleshov7/ktoml/encoders/ArrayEncoderTest.kt b/ktoml-core/src/commonTest/kotlin/com/akuleshov7/ktoml/encoders/ArrayEncoderTest.kt
@@ -2,9 +2,7 @@ package com.akuleshov7.ktoml.encoders
 
 import com.akuleshov7.ktoml.annotations.TomlInlineTable
 import com.akuleshov7.ktoml.annotations.TomlLiteral
-import com.akuleshov7.ktoml.annotations.TomlMultiline
 import kotlinx.serialization.Serializable
-import kotlin.test.Ignore
 import kotlin.test.Test
 
 class ArrayEncoderTest {
@@ -54,32 +52,6 @@ class ArrayEncoderTest {
         )
     }
 
-    @Test
-    @Ignore
-    fun inlineTableArrayTest() {
-        @Serializable
-        @TomlInlineTable
-        data class InlineTable(val index: Long)
-
-        @Serializable
-        data class InlineTableArray(
-            @TomlMultiline
-            val inlineTables: List<InlineTable> =
-                    (0L..2L).map(::InlineTable)
-        )
-
-        assertEncodedEquals(
-            value = InlineTableArray(),
-            expectedToml = """
-                inlineTables = [
-                    { index = 0 },
-                    { index = 1 },
-                    { index = 2 }
-                ]
-            """.trimIndent()
-        )
-    }
-
     @Test
     fun nestedArrayTest() {
         @Serializable
diff --git a/ktoml-core/src/commonTest/kotlin/com/akuleshov7/ktoml/encoders/ArrayOfInlineTablesEncoderTest.kt b/ktoml-core/src/commonTest/kotlin/com/akuleshov7/ktoml/encoders/ArrayOfInlineTablesEncoderTest.kt
diff --git a/ktoml-core/src/commonTest/kotlin/com/akuleshov7/ktoml/encoders/EncodingAnnotationTest.kt b/ktoml-core/src/commonTest/kotlin/com/akuleshov7/ktoml/encoders/EncodingAnnotationTest.kt
