Always attempt to print element first, Introduce metadata

Author: deusaquilus

build.gradle.kts

@@ -20,7 +20,7 @@ allprojects {
 
 allprojects {
     group = "io.exoquery"
-    version = "2.0.2"
+    version = "3.0.0.D"
 }
 
 subprojects {

pprint-kotlin-core/build.gradle.kts

@@ -22,10 +22,11 @@ kotlin {
   val isWindows = platform == "windows"
 
   // If we're not the CI build a limited set of standard targets
+  jvm {
+    jvmToolchain(11)
+  }
+
   if(!isCI) {
-    jvm {
-      jvmToolchain(11)
-    }
     js {
       browser()
       nodejs()
@@ -38,9 +39,6 @@ kotlin {
 
   // If we are a CI, build all the targets for the specified platform
   if (isLinux && isCI) {
-    jvm {
-      jvmToolchain(11)
-    }
     js {
       browser()
       nodejs()

pprint-kotlin-core/src/commonMain/kotlin/io/exoquery/pprint/PPrinterBase.kt

@@ -94,7 +94,7 @@ abstract class PPrinterBase<T>(open val config: PPrinterConfig): Walker<T> {
     // The three stages within the pretty-printing process:
 
     // Convert the Any into a lazy Tree of `Apply`, `Infix` and `Lazy`/`Strict` literals
-    val tree = this.treeify(x, escapeUnicode, showFieldNames)
+    val tree = this.treeify(x, null, escapeUnicode, showFieldNames)
     // Render the `Any` into a stream of tokens, properly indented and wrapped
     // at the given width
     val renderer = Renderer(width, config.colorApplyPrefix, config.colorLiteral, indent)

pprint-kotlin-core/src/commonMain/kotlin/io/exoquery/pprint/Walker.kt

@@ -10,33 +10,34 @@ import io.exoquery.fansi.Attrs
  * `foo op bar`, and terminals `foo` in both lazy and eager forms
  */
 sealed interface Tree {
+  val elementName: String?
 
   /**
    * Foo(aa, bbb, cccc)
    */
-  data class Apply(val prefix: String, val body: Iterator<Tree>): Tree
+  data class Apply(val prefix: String, val body: Iterator<Tree>, override val elementName: String?): Tree
 
   /**
    * LHS op RHS
    */
-  data class Infix(val lhs: Tree, val op: String, val rhs: Tree): Tree
+  data class Infix(val lhs: Tree, val op: String, val rhs: Tree, override val elementName: String?): Tree
 
   /**
    * "xyz"
    */
-  data class Literal(val body: String): Tree{
+  data class Literal(val body: String, override val elementName: String?): Tree{
     val hasNewLine = body.any { c -> c == '\n' || c == '\r' }
   }
 
   /**
    * x = y
    */
-  data class KeyValue(val key: String, val value: Tree): Tree
+  data class KeyValue(val key: String, val value: Tree, override val elementName: String?): Tree
 
   /**
    * xyz
    */
-  data class Lazy(val body0: (Ctx) -> Iterator<String>): Tree
+  data class Lazy(val body0: (Ctx) -> Iterator<String>, override val elementName: String?): Tree
 
   data class Ctx(
     val width: Int,
@@ -51,17 +52,17 @@ sealed interface Tree {
 abstract class EncodeHelper {
   abstract fun makeHexString(c: Char): String
 
-  fun encodeChar(x: Char, escapeUnicode: Boolean): Tree.Literal {
+  fun encodeChar(x: Char, escapeUnicode: Boolean, elementName: String?): Tree.Literal {
     val sb = StringBuilder()
     sb.append('\'')
     Util.escapeChar(x, sb, escapeUnicode, ::makeHexString)
     sb.append('\'')
-    return Tree.Literal(sb.toString())
+    return Tree.Literal(sb.toString(), elementName)
   }
 
-  fun encodeString(x: String, escapeUnicode: Boolean): Tree.Literal {
-    return if (x.any {c -> c == '\n' || c == '\r'}) Tree.Literal("\"\"\"" + x + "\"\"\"")
-    else Tree.Literal(Util.literalize(x.toCharArray(), escapeUnicode, ::makeHexString))
+  fun encodeString(x: String, escapeUnicode: Boolean, elementName: String?): Tree.Literal {
+    return if (x.any {c -> c == '\n' || c == '\r'}) Tree.Literal("\"\"\"" + x + "\"\"\"", elementName)
+    else Tree.Literal(Util.literalize(x.toCharArray(), escapeUnicode, ::makeHexString), elementName)
   }
 }
 
@@ -73,7 +74,7 @@ interface Walker<T> {
   // No additional handlers. To extend, override the treeify function
   // fun additionalHandlers: PartialFunction<Any, Tree>
 
-  fun treeify(x: T, escapeUnicode: Boolean, showFieldNames: Boolean): Tree
+  fun treeify(x: T, elementName: String?, escapeUnicode: Boolean, showFieldNames: Boolean): Tree
 }
 
 

pprint-kotlin-kmp/build.gradle.kts

@@ -23,10 +23,11 @@ kotlin {
   val isWindows = platform == "windows"
 
   // If we're not the CI build a limited set of standard targets
+  jvm {
+    jvmToolchain(11)
+  }
+
   if(!isCI) {
-    jvm {
-      jvmToolchain(11)
-    }
     js {
       browser()
       nodejs()
@@ -39,9 +40,6 @@ kotlin {
 
   // If we are a CI, build all the targets for the specified platform
   if (isLinux && isCI) {
-    jvm {
-      jvmToolchain(11)
-    }
     js {
       browser()
       nodejs()

pprint-kotlin-kmp/src/commonMain/kotlin/io/exoquery/kmp/pprint/PPrinter.kt

@@ -38,46 +38,62 @@ open class PPrinter<T>(open val serializer: SerializationStrategy<T>, override o
   }
 
 
-  override fun treeify(x: T, escapeUnicode: Boolean, showFieldNames: Boolean): Tree =
-    treeifyWith(Treeifyable.Elem(x, serializer), escapeUnicode, showFieldNames)
+  override fun treeify(x: T, elementName: String?, escapeUnicode: Boolean, showFieldNames: Boolean): Tree =
+    treeifyElement(Treeifyable.Elem(x, serializer), elementName, escapeUnicode, showFieldNames)
 
-  open fun <R> treeifyWith(treeifyable: Treeifyable<R>, escapeUnicode: Boolean, showFieldNames: Boolean): Tree {
-    val value = treeifyable.value
-    return when {
-      value == null -> Tree.Literal("null")
-      value is Boolean -> Tree.Literal(value.toString())
-      value is Byte -> Tree.Literal(value.toString())
-      value is Short -> Tree.Literal(value.toString())
-      value is Int -> Tree.Literal(value.toString())
-      value is Long -> Tree.Literal("${value}L")
-      value is Float -> Tree.Literal("${value}F")
-      value is Double -> Tree.Literal(value.toString())
-      value is Char -> EncodeHelperImpl.encodeChar(value, escapeUnicode)
-      value is String -> EncodeHelperImpl.encodeString(value, escapeUnicode)
-      // Empty iterator case which for some reason causes an exception with the regular kotlin serializer
-      value is Iterator<*> && !value.hasNext() -> Tree.Literal("empty iterator")
-      value is Iterator<*> && value.hasNext() -> Tree.Literal("non-empty iterator")
-      // If it is a sequence and the user is using the correct serializer i.e. PPrintSequenceSerializer
-      value is Sequence<*> && treeifyable is Treeifyable.Elem && treeifyable.serializer is PPrintSequenceSerializer<*> -> {
-        @Suppress("UNCHECKED_CAST")
-        val elementSerializer = treeifyable.serializer.element as KSerializer<Any?>
-        Tree.Apply("Sequence", value.map { treeifyWith(Treeifyable.Elem(it, elementSerializer), escapeUnicode, showFieldNames) }.iterator())
-      }
-      treeifyable is Treeifyable.Elem -> {
-        val encoder = TreeElementEncoder(this)
-        treeifyable.serializer.serialize(encoder, treeifyable.value)
-        val elements = encoder.retrieve()
-        PPrinterHelper.encodeComposite(
-          treeifyable.value,
-          treeifyable.serializer.descriptor,
-          elements,
-          showFieldNames,
-          config
-        )
-      }
-      else -> Tree.Literal(value.toString())
+  open fun <E> treeifyComposite(elem: Treeifyable.Elem<E>, elementName: String?, showFieldNames: Boolean) = run {
+    val encoder = TreeElementEncoder(this)
+    elem.serializer.serialize(encoder, elem.value)
+    val elements = encoder.retrieve()
+    PPrinterHelper.encodeComposite(
+      elem.value,
+      elementName,
+      elem.serializer.descriptor,
+      elements,
+      showFieldNames,
+      config
+    )
+  }
+
+  open fun <R> treeifyElement(treeifyable: Treeifyable<R>, elementName: String?, escapeUnicode: Boolean, showFieldNames: Boolean): Tree {
+    return when(treeifyable) {
+      is Treeifyable.Elem<*> ->
+        // try to treeify it with the treeifyValueOrNull function in case there's an override for the element
+        treeifyValueOrNull(treeifyable.value, elementName, escapeUnicode, showFieldNames) ?: run {
+          when {
+            // If it is a sequence and the user is using the correct serializer i.e. PPrintSequenceSerializer
+            treeifyable.value is Sequence<*> && treeifyable.serializer is PPrintSequenceSerializer<*> -> {
+              @Suppress("UNCHECKED_CAST")
+              val elementSerializer = treeifyable.serializer.element as KSerializer<Any?>
+              Tree.Apply("Sequence", (treeifyable.value as Sequence<*>).map { treeifyElement(Treeifyable.Elem(it, elementSerializer), null, escapeUnicode, showFieldNames) }.iterator(), elementName)
+            }
+            // Otherwise it's a regular composite
+            else -> treeifyComposite(treeifyable, elementName, showFieldNames)
+          }
+        }
+      is Treeifyable.Leaf ->
+        treeifyValueOrNull(treeifyable.value, elementName, escapeUnicode, showFieldNames) ?:
+          Tree.Literal(treeifyable.value.toString(), elementName)
     }
   }
+
+  open fun <R> treeifyValueOrNull(value: R, elementName: String?, escapeUnicode: Boolean, showFieldNames: Boolean): Tree? =
+    when {
+      value == null -> Tree.Literal("null", elementName)
+      value is Boolean -> Tree.Literal(value.toString(), elementName)
+      value is Byte -> Tree.Literal(value.toString(), elementName)
+      value is Short -> Tree.Literal(value.toString(), elementName)
+      value is Int -> Tree.Literal(value.toString(), elementName)
+      value is Long -> Tree.Literal("${value}L", elementName)
+      value is Float -> Tree.Literal("${value}F", elementName)
+      value is Double -> Tree.Literal(value.toString(), elementName)
+      value is Char -> EncodeHelperImpl.encodeChar(value, escapeUnicode, elementName)
+      value is String -> EncodeHelperImpl.encodeString(value, escapeUnicode, elementName)
+      // Empty iterator case which for some reason causes an exception with the regular kotlin serializer
+      value is Iterator<*> && !value.hasNext() -> Tree.Literal("empty iterator", elementName)
+      value is Iterator<*> && value.hasNext() -> Tree.Literal("non-empty iterator", elementName)
+      else -> null
+    }
 }
 
 class PPrintSequenceSerializer<T>(val element: KSerializer<T>) : KSerializer<Sequence<T>> {

pprint-kotlin-kmp/src/commonMain/kotlin/io/exoquery/kmp/pprint/PPrinterHelper.kt

@@ -7,7 +7,7 @@ import kotlinx.serialization.descriptors.*
 
 object PPrinterHelper {
   @OptIn(ExperimentalSerializationApi::class)
-  fun <T> encodeComposite(value: T, descriptor: SerialDescriptor, childrenRaw: List<ChildElement>, showFieldNames: Boolean, config: PPrinterConfig): Tree {
+  fun <T> encodeComposite(value: T, elementName: String?, descriptor: SerialDescriptor, childrenRaw: List<ChildElement>, showFieldNames: Boolean, config: PPrinterConfig): Tree {
     // important to make the sequence lazy in case doing a call to ChildElement.tree() causes an infinite loop
     val children = childrenRaw.asSequence()
 
@@ -18,7 +18,7 @@ object PPrinterHelper {
       if (showFieldNamesIfPossible)
         children.map { when (it) {
           is ChildElement.Atom -> it.tree()
-          is ChildElement.Member -> Tree.KeyValue(it.name, it.tree())
+          is ChildElement.Member -> Tree.KeyValue(it.name, it.tree(), it.name)
         } }
       else
         children.map { it.tree() }
@@ -32,7 +32,7 @@ object PPrinterHelper {
           val childTrees = processChildren(false)
           //require(childTrees.size % 2 == 0)
           childTrees.asSequence().chunked(2).map { (k, v) ->
-            Tree.Infix(k, "->", v)
+            Tree.Infix(k, "->", v, null)
           }
         }
         // If it's a list the keys would be the indexes, don't bother printing that
@@ -61,7 +61,7 @@ object PPrinterHelper {
       // sealed interface Colors { object Red: Colors; object Blue: Colors; data class Custom(val hex: String): Colors }
       // for Colors.Red we should just print "Red"
       kind == StructureKind.OBJECT && !childrenIterator.hasNext() ->
-        Tree.Literal(serialNameParsed)
+        Tree.Literal(serialNameParsed, elementName)
 
 
       // The kotlinx-serlization mechanism will attempt to identify a polymorphic type by adding a type-field
@@ -80,11 +80,11 @@ object PPrinterHelper {
       kind == PolymorphicKind.OPEN || kind == PolymorphicKind.SEALED -> {
         childrenRaw.find { it is ChildElement.Member && it.name == "value" }?.let {
           it.tree()
-        } ?: Tree.Apply(serialNameParsed, childrenIterator)
+        } ?: Tree.Apply(serialNameParsed, childrenIterator, elementName)
       }
 
       else -> {
-        Tree.Apply(serialNameParsed, childrenIterator)
+        Tree.Apply(serialNameParsed, childrenIterator, elementName)
       }
     }
   }

pprint-kotlin-kmp/src/commonMain/kotlin/io/exoquery/kmp/pprint/TreeElementEncoder.kt

@@ -14,7 +14,9 @@ import kotlinx.serialization.modules.SerializersModule
 sealed interface ChildElement {
   val tree: () -> Tree
 
-  data class Member(val name: String, override val tree: () -> Tree): ChildElement
+  data class Member(val name: String, val makeTree: (String) -> Tree): ChildElement {
+    override val tree = { makeTree(name) }
+  }
   data class Atom(override val tree: () -> Tree): ChildElement
 }
 
@@ -86,16 +88,16 @@ open class TreeElementEncoder private constructor (val pprinter: PPrinter<*>) :
 
   protected val currChildren = mutableListOf<ChildElement>()
 
-  protected fun add(name: String, tree: () -> Tree): Unit {
+  protected fun add(name: String, tree: (name: String) -> Tree): Unit {
     currChildren.add(ChildElement.Member(name, tree))
   }
 
   protected fun addAtom(tree: () -> Tree): Unit {
     currChildren.add(ChildElement.Atom(tree))
   }
 
-  private fun treeifyLeaf(value: Any?): Tree =
-    pprinter.treeifyWith<Any?>(PPrinter.Treeifyable.Leaf(value), escapeUnicode, showFieldNames)
+  private fun treeifyLeaf(value: Any?, elementName: String?): Tree =
+    pprinter.treeifyElement<Any?>(PPrinter.Treeifyable.Leaf(value), elementName, escapeUnicode, showFieldNames)
 
   override fun beginStructure(descriptor: SerialDescriptor): CompositeEncoder = this
 
@@ -113,34 +115,34 @@ open class TreeElementEncoder private constructor (val pprinter: PPrinter<*>) :
   /**
    * Invoked to encode a value when specialized `encode*` method was not overridden.
    */
-  public fun encodeValue(value: Any): Unit = addAtom { treeifyLeaf(value) }
+  public fun encodeValue(value: Any): Unit = addAtom { treeifyLeaf(value, null) }
 
-  override fun encodeNull(): Unit = addAtom { treeifyLeaf(null) }
+  override fun encodeNull(): Unit = addAtom { treeifyLeaf(null, null) }
 
   override fun encodeInline(descriptor: SerialDescriptor): Encoder = this
 
   // Delegating implementation of CompositeEncoder
-  override fun encodeBooleanElement(desc: SerialDescriptor, index: Int, value: Boolean) = add(desc.getElementName(index), { treeifyLeaf(value) })
-  override fun encodeByteElement(desc: SerialDescriptor, index: Int, value: Byte) = add(desc.getElementName(index), { treeifyLeaf(value) })
-  override fun encodeShortElement(desc: SerialDescriptor, index: Int, value: Short) = add(desc.getElementName(index), { treeifyLeaf(value) })
-  override fun encodeIntElement(desc: SerialDescriptor, index: Int, value: Int) = add(desc.getElementName(index), { treeifyLeaf(value) })
-  override fun encodeLongElement(desc: SerialDescriptor, index: Int, value: Long) = add(desc.getElementName(index), { treeifyLeaf(value) })
-  override fun encodeFloatElement(desc: SerialDescriptor, index: Int, value: Float) = add(desc.getElementName(index), { treeifyLeaf(value) })
-  override fun encodeDoubleElement(desc: SerialDescriptor, index: Int, value: Double) = add(desc.getElementName(index), { treeifyLeaf(value) })
-  override fun encodeCharElement(desc: SerialDescriptor, index: Int, value: Char) = add(desc.getElementName(index), { treeifyLeaf(value) })
-  override fun encodeStringElement(desc: SerialDescriptor, index: Int, value: String) = add(desc.getElementName(index), { treeifyLeaf(value) })
-
-  override fun encodeBoolean(value: Boolean): Unit = addAtom { treeifyLeaf(value) }
-  override fun encodeByte(value: Byte): Unit = addAtom { treeifyLeaf(value) }
-  override fun encodeShort(value: Short): Unit = addAtom { treeifyLeaf(value) }
-  override fun encodeInt(value: Int): Unit = addAtom { treeifyLeaf(value) }
-  override fun encodeLong(value: Long): Unit = addAtom { treeifyLeaf(value) }
-  override fun encodeFloat(value: Float): Unit = addAtom { treeifyLeaf(value) }
-  override fun encodeDouble(value: Double): Unit = addAtom { treeifyLeaf(value) }
-  override fun encodeChar(value: Char): Unit = addAtom { treeifyLeaf(value) }
-  override fun encodeString(value: String): Unit = addAtom { treeifyLeaf(value) }
-
-  override fun encodeEnum(enumDescriptor: SerialDescriptor, index: Int): Unit = addAtom { treeifyLeaf(enumDescriptor.getElementName(index)) }
+  override fun encodeBooleanElement(desc: SerialDescriptor, index: Int, value: Boolean) = add(desc.getElementName(index), { treeifyLeaf(value, it) })
+  override fun encodeByteElement(desc: SerialDescriptor, index: Int, value: Byte) = add(desc.getElementName(index), { treeifyLeaf(value, it) })
+  override fun encodeShortElement(desc: SerialDescriptor, index: Int, value: Short) = add(desc.getElementName(index), { treeifyLeaf(value, it) })
+  override fun encodeIntElement(desc: SerialDescriptor, index: Int, value: Int) = add(desc.getElementName(index), { treeifyLeaf(value, it) })
+  override fun encodeLongElement(desc: SerialDescriptor, index: Int, value: Long) = add(desc.getElementName(index), { treeifyLeaf(value, it) })
+  override fun encodeFloatElement(desc: SerialDescriptor, index: Int, value: Float) = add(desc.getElementName(index), { treeifyLeaf(value, it) })
+  override fun encodeDoubleElement(desc: SerialDescriptor, index: Int, value: Double) = add(desc.getElementName(index), { treeifyLeaf(value, it) })
+  override fun encodeCharElement(desc: SerialDescriptor, index: Int, value: Char) = add(desc.getElementName(index), { treeifyLeaf(value, it) })
+  override fun encodeStringElement(desc: SerialDescriptor, index: Int, value: String) = add(desc.getElementName(index), { treeifyLeaf(value, it) })
+
+  override fun encodeBoolean(value: Boolean): Unit = addAtom { treeifyLeaf(value, null) }
+  override fun encodeByte(value: Byte): Unit = addAtom { treeifyLeaf(value, null) }
+  override fun encodeShort(value: Short): Unit = addAtom { treeifyLeaf(value, null) }
+  override fun encodeInt(value: Int): Unit = addAtom { treeifyLeaf(value, null) }
+  override fun encodeLong(value: Long): Unit = addAtom { treeifyLeaf(value, null) }
+  override fun encodeFloat(value: Float): Unit = addAtom { treeifyLeaf(value, null) }
+  override fun encodeDouble(value: Double): Unit = addAtom { treeifyLeaf(value, null) }
+  override fun encodeChar(value: Char): Unit = addAtom { treeifyLeaf(value, null) }
+  override fun encodeString(value: String): Unit = addAtom { treeifyLeaf(value, null) }
+
+  override fun encodeEnum(enumDescriptor: SerialDescriptor, index: Int): Unit = addAtom { treeifyLeaf(enumDescriptor.getElementName(index), enumDescriptor.getElementName(index)) }
 
   override fun beginCollection(descriptor: SerialDescriptor, collectionSize: Int): CompositeEncoder {
     return super.beginCollection(descriptor, collectionSize)
@@ -159,8 +161,9 @@ open class TreeElementEncoder private constructor (val pprinter: PPrinter<*>) :
     value: T
   ) {
     if (encodeElement(descriptor, index)) {
-      add(descriptor.getElementName(index)) {
-        pprinter.treeifyWith<T>(PPrinter.Treeifyable.Elem(value, serializer), escapeUnicode, showFieldNames)
+      val elemName = descriptor.getElementName(index)
+      add(elemName) {
+        pprinter.treeifyElement<T>(PPrinter.Treeifyable.Elem(value, serializer), it, escapeUnicode, showFieldNames)
       }
     }
   }

pprint-kotlin-kmp/src/commonTest/kotlin/io/exoquery/pprint/DerivationTests.kt

@@ -15,7 +15,7 @@ data class CustomToString(val value: Int = 1){
 }
 sealed interface Customs {
   data class A(val i: Int): Customs
-  data class B(val s: String): Customs{
+  data class B(val s: String): Customs {
     override fun toString() = "Beeee"
   }
 }