Implementation of AST for ArrayOfTables (#104)

### What's done:
- Changes in the logic of inserting Arrays of Tables
- Reworked the logic of insretion of tables in the AST
- Fixed small issues related to technical nodes in the tree
- Intentionally broke partial decoding as it is not applicable for array structures. Need to rework that in future

README.md

@@ -67,6 +67,7 @@ We are still developing and testing this library, so it has several limitations:
 :x: Multiline Strings \
 :x: Inline Tables \
 :x: Array of Tables \
+:x: Inline Array of Tables \
 :x: Offset Date-Time, Local: Date-Time; Date; Time
 
 ## Dependency

ktoml-core/src/commonMain/kotlin/com/akuleshov7/ktoml/Toml.kt

@@ -1,9 +1,7 @@
 package com.akuleshov7.ktoml
 
 import com.akuleshov7.ktoml.decoders.TomlMainDecoder
-import com.akuleshov7.ktoml.exceptions.MissingRequiredPropertyException
 import com.akuleshov7.ktoml.parsers.TomlParser
-import com.akuleshov7.ktoml.tree.TableType
 import com.akuleshov7.ktoml.tree.TomlFile
 import com.akuleshov7.ktoml.writers.TomlWriter
 
@@ -90,7 +88,7 @@ public open class Toml(
  tomlTableName: String,
  config: TomlConfig = TomlConfig()
  ): T {
- val fakeFileNode = generateFakeTomlStructureForPartialParsing(toml, tomlTableName, config, TableType.PRIMITIVE, TomlParser::parseString)
+ val fakeFileNode = TomlFile()
  return TomlMainDecoder.decode(deserializer, fakeFileNode, this.config)
  }
 
@@ -114,40 +112,11 @@ public open class Toml(
  tomlTableName: String,
  config: TomlConfig = TomlConfig()
  ): T {
- val fakeFileNode = generateFakeTomlStructureForPartialParsing(
- toml.joinToString("\n"),
- tomlTableName,
- config,
- TableType.PRIMITIVE,
- TomlParser::parseString,
- )
+ val fakeFileNode = TomlFile()
  return TomlMainDecoder.decode(deserializer, fakeFileNode, this.config)
  }
 
  // ================== other ===============
- @Suppress("TYPE_ALIAS")
- private fun generateFakeTomlStructureForPartialParsing(
- toml: String,
- tomlTableName: String,
- config: TomlConfig = TomlConfig(),
- type: TableType,
- parsingFunction: (TomlParser, String) -> TomlFile
- ): TomlFile {
- val parsedToml = parsingFunction(TomlParser(this.config), toml)
- .findTableInAstByName(tomlTableName, tomlTableName.count { it == '.' } + 1, type)
- ?: throw MissingRequiredPropertyException(
- "Cannot find table with name <$tomlTableName> in the toml input. " +
- "Not able to decode this toml part."
- )
-
- // adding a fake file node to restore the structure and parse only the part of te toml
- val fakeFileNode = TomlFile(config)
- parsedToml.children.forEach {
- fakeFileNode.appendChild(it)
- }
-
- return fakeFileNode
- }
 
  /**
  * The default instance of [Toml] with the default configuration.

ktoml-core/src/commonMain/kotlin/com/akuleshov7/ktoml/decoders/TomlMainDecoder.kt

@@ -151,7 +151,7 @@ public class TomlMainDecoder(
  * Actually this method is not needed as serialization lib should do everything for us, but let's
  * fail-fast in the very beginning if the structure is inconsistent and required properties are missing
  */
- private fun checkMissingRequiredProperties(children: MutableSet<TomlNode>?, descriptor: SerialDescriptor) {
+ private fun checkMissingRequiredProperties(children: MutableList<TomlNode>?, descriptor: SerialDescriptor) {
  val propertyNames = children?.map {
  it.name
  } ?: emptyList()

ktoml-core/src/commonMain/kotlin/com/akuleshov7/ktoml/parsers/TomlParser.kt

@@ -35,9 +35,12 @@ public value class TomlParser(private val config: TomlConfig) {
  @Suppress("TOO_LONG_FUNCTION")
  public fun parseStringsToTomlTree(tomlLines: List<String>, config: TomlConfig): TomlFile {
  var currentParentalNode: TomlNode = TomlFile(config)
+ // link to the head of the tree
  val tomlFileHead = currentParentalNode as TomlFile
  // need to trim empty lines BEFORE the start of processing
  val mutableTomlLines = tomlLines.toMutableList().trimEmptyLines()
+ // here we always store the bucket of the latest created array of tables
+ var latestCreatedBucket: TomlArrayOfTablesElement? = null
 
  mutableTomlLines.forEachIndexed { index, line ->
  val lineNo = index + 1
@@ -48,13 +51,19 @@ public value class TomlParser(private val config: TomlConfig) {
  if (line.isArrayOfTables()) {
  // TomlArrayOfTables contains all information about the ArrayOfTables ([[array of tables]])
  val tableArray = TomlArrayOfTables(line, lineNo, config)
- val arrayOfTables = tomlFileHead.insertTableToTree(tableArray, TableType.ARRAY)
+ val arrayOfTables = tomlFileHead.insertTableToTree(tableArray, latestCreatedBucket)
  // creating a new empty element that will be used as an element in array and the parent for next key-value records
  val newArrayElement = TomlArrayOfTablesElement(lineNo, config)
  // adding this element as a child to the array of tables
  arrayOfTables.appendChild(newArrayElement)
+ // covering the case when the processed table does not contain nor key-value pairs neither tables (after our insertion)
+ // adding fake nodes to a previous table (it has no children because we have found another table right after)
+ if (currentParentalNode.hasNoChildren() && currentParentalNode !is TomlFile && currentParentalNode !is TomlArrayOfTablesElement) {
+ currentParentalNode.appendChild(TomlStubEmptyNode(currentParentalNode.lineNo, config))
+ }
  // and setting this element as a current parent, so new key-records will be added to this bucket
  currentParentalNode = newArrayElement
+ latestCreatedBucket = newArrayElement
  } else {
  val tableSection = TomlTablePrimitive(line, lineNo, config)
  // if the table is the last line in toml, then it has no children, and we need to
@@ -64,10 +73,10 @@ public value class TomlParser(private val config: TomlConfig) {
  }
  // covering the case when the processed table does not contain nor key-value pairs neither tables (after our insertion)
  // adding fake nodes to a previous table (it has no children because we have found another table right after)
- if (currentParentalNode.hasNoChildren()) {
+ if (currentParentalNode.hasNoChildren() && currentParentalNode !is TomlFile && currentParentalNode !is TomlArrayOfTablesElement) {
  currentParentalNode.appendChild(TomlStubEmptyNode(currentParentalNode.lineNo, config))
  }
- currentParentalNode = tomlFileHead.insertTableToTree(tableSection, TableType.PRIMITIVE)
+ currentParentalNode = tomlFileHead.insertTableToTree(tableSection)
  }
  } else {
  val keyValue = line.parseTomlKeyValue(lineNo, config)
@@ -80,8 +89,9 @@ public value class TomlParser(private val config: TomlConfig) {
  // in case parser has faced dot-separated complex key (a.b.c) it should create proper table [a.b],
  // because table is the same as dotted key
  val newTableSection = keyValue.createTomlTableFromDottedKey(currentParentalNode, config)
+
  tomlFileHead
- .insertTableToTree(newTableSection, TableType.PRIMITIVE)
+ .insertTableToTree(newTableSection)
  .appendChild(keyValue)
  } else {
  // otherwise it should simply append the keyValue to the parent

ktoml-core/src/commonMain/kotlin/com/akuleshov7/ktoml/tree/TomlArrayOfTables.kt

@@ -18,11 +18,12 @@ public class TomlArrayOfTables(
  content: String,
  lineNo: Int,
  config: TomlConfig = TomlConfig(),
- public val isSynthetic: Boolean = false
+ isSynthetic: Boolean = false
 ) : TomlTable(
  content,
  lineNo,
- config
+ config,
+ isSynthetic
 ) {
  public override val type: TableType = TableType.ARRAY
 

ktoml-core/src/commonMain/kotlin/com/akuleshov7/ktoml/tree/TomlFile.kt

@@ -13,6 +13,6 @@ public class TomlFile(config: TomlConfig = TomlConfig()) : TomlNode(
 ) {
  override val name: String = "rootNode"
 
- override fun getNeighbourNodes(): MutableSet<TomlNode> =
+ override fun getNeighbourNodes(): MutableList<TomlNode> =
  throw InternalAstException("Invalid call to getNeighbourNodes() for TomlFile node")
 }

ktoml-core/src/commonMain/kotlin/com/akuleshov7/ktoml/tree/TomlKeyValue.kt

@@ -30,7 +30,7 @@ internal interface TomlKeyValue {
  // updating current KeyValue with this key
  this.key = realKeyWithoutDottedPrefix
  // tables should contain fully qualified name, so we need to add parental name
- val parentalPrefix = if (parentNode is TomlTablePrimitive) "${parentNode.fullTableName}." else ""
+ val parentalPrefix = if (parentNode is TomlTable) "${parentNode.fullTableName}." else ""
  // and creating a new table that will be created from dotted key
  return TomlTablePrimitive(
  "[$parentalPrefix${syntheticTablePrefix.joinToString(".")}]",