Pretty Print Kotlin Data Class

PrettyPrint.kt

fun Any.prettyPrint(): String {

    var indentLevel = 0
    val indentWidth = 4

    fun padding() = "".padStart(indentLevel * indentWidth)

    val toString = toString()

    val stringBuilder = StringBuilder(toString.length)

    var i = 0
    while (i < toString.length) {
        when (val char = toString[i]) {
            '(', '[', '{' -> {
                indentLevel++
                stringBuilder.appendLine(char).append(padding())
            }
            ')', ']', '}' -> {
                indentLevel--
                stringBuilder.appendLine().append(padding()).append(char)
            }
            ',' -> {
                stringBuilder.appendLine(char).append(padding())
                // ignore space after comma as we have added a newline
                val nextChar = toString.getOrElse(i + 1) { char }
                if (nextChar == ' ') i++
            }
            else -> {
                stringBuilder.append(char)
            }
        }
        i++
    }

    return stringBuilder.toString()
}

Thanks for the analysis @Nilzor. It was something I developed for debugging purposes and was never meant to be used in production hence provided as a gist instead of a library, so performance was not a consideration.
Would you mind trying to identify the cause and optimize this method? Also, it would be great if you could share the project with which the benchmark was performed.

Thanks for posting this, it's been extremely helpful to my team and the logs recorded.

We did tweak your implementation slightly to get it closer to a "copy-and-paste" the logged model into the codebase. It's not perfect, but this gets us close:

fun Any?.toPrettyString(): String {
    if (this == null) return "(null)"

    var indentLevel = 0
    val indentWidth = 2

    fun padding() = "".padStart(indentLevel * indentWidth)

    val toString = toString()
    val stringBuilder = StringBuilder(toString.length)

    var nestingContext: Char? = null
    var i = 0

    // Replace standard '[' and '{' characters with Kotlin specific functions
    while (i < toString.length) {
        when (val char = toString[i]) {
            '(', '[', '{' -> {
                indentLevel++
                nestingContext = char
                stringBuilder
                    .appendLine(
                        when (char) {
                            '[' -> "listOf("
                            '{' -> "mapOf("
                            else -> '('
                        },
                    )
                    .append(padding())
            }

            ')', ']', '}' -> {
                indentLevel--
                nestingContext = null
                stringBuilder.appendLine().append(padding()).append(')')
            }

            ',' -> {
                stringBuilder.appendLine(char).append(padding())
                // ignore space after comma as we have added a newline
                val nextChar = toString.getOrElse(i + 1) { char }
                if (nextChar == ' ') i++
            }

            '=' -> {
                when (nestingContext) {
                    '{' -> stringBuilder.append(" to ")
                    else -> stringBuilder.append(" = ")
                }
            }

            else -> {
                stringBuilder.append(char)
            }
        }

        i++
    }

    return stringBuilder.toString()
}

If anyone notices any issues with this code or has a better idea, please feel free to tweak it and @ me. Thanks!

Awesome, thx!

That's great @odonckers ! Glad it helped. I remember implementing a custom serializer using Kotlinx serialization to achieve the same. It was hacky and dirty but sufficed my use case. This is much easier and can be useful in many places. Awesome work!

FWIW, this fails to produce a pretty output if you have strings that contain the , character

I cut this back and cleaned it up a little, and added some kotliny goodness, to make it a little cleaner and easier to read.

fun Any.pretty() = toString().let { toString ->
    var indentLevel = 0
    val indentWidth = 4
    var i = 0
    fun padding() = "".padStart(indentLevel * indentWidth)
    buildString {
        var ignoreSpace = false
        toString.onEach { char ->
            when (char) {
                '(', '[', '{' -> {
                    indentLevel++
                    appendLine(char)
                    append(padding())
                }

                ')', ']', '}' -> {
                    indentLevel--
                    appendLine()
                    append(padding())
                    append(char)
                }

                ',' -> {
                    appendLine(char)
                    append(padding())
                    ignoreSpace = true
                }
                ' ' -> {
                    if (!ignoreSpace) append(char)
                    ignoreSpace = false
                }

                else -> append(char)
            }
        }
    }
}

With this method I don't think there's any way to get around a string containing a closing bracket.

data class Fish(val message: String)

Fish("bobby),otherValue=fakeData").pretty()

@thought-police-000 Thanks for sharing your awesome code!

love it.

@thought-police-000 definitely love the buildString builder, i didn't know about that!

regarding the ): you could count the " as well in a "stringLevel" to decide whether one is still inside a string or to decrement the indentation level? adds complexity obviously :/

@thought-police-000 I cleaned it up more, replaced "=" by " = " and ruined it again by packing the code :)

fun Any.toPrettyDebugString(indentWidth : Int = 4) = buildString {
    fun StringBuilder.indent(level : Int) = append("".padStart(level * indentWidth))
    var ignoreSpace = false
    var indentLevel = 0
    this@toPrettyDebugString.toString().onEach {
        when (it) {
            '(', '[', '{' -> appendLine(it).indent(++indentLevel)
            ')', ']', '}' -> appendLine().indent(--indentLevel).append(it)
            ','           -> appendLine(it).indent(indentLevel).also { ignoreSpace = true }
            ' '           -> if (ignoreSpace) ignoreSpace = false else append(it)
            '='           -> append(" = ")
            else          -> append(it)
        }
    }
}

công đức vô lượng