Error handling

[kosiakk]

In case of exception, current implementation simply aborts the processing.

I've introduced an onError handler in the TagConsumer, so that the library:

1. Handles errors in a general manner
2. Always properly closes all the tags
3. If error handler does not re-trow the exception, the rendering continues

As the result, it's possible to use such TagConsumer:

class SafeHtmlOutput(val result: PrintWriter) : TagConsumer<PrintWriter> by result.appendHTML()

    override fun onError(exception: Exception) {
        // prints a very basic error block
        h4(classes = "error") {
            style = "background-color: red; text-color: white"
            onTagContent(exception.message ?: "Unknown error")
        }

        exception.printStackTrace() // send to stderr log
    }

}

It cannot get much simpler than that. As you see, it has all the freedom to properly react to the exception. For example, the tag contents might simply remain empty, while the rest of the page remains fully-functional.

I use Kotlinx.html for stream-like processing: page headers are sent almost instantly (by abusing TagConsumer.finalize and PrintWriter.flush), while the rest is generated gradually, like in the original PHP (but with good compiler) for lighting-fast zero-delay instant content delivery. Therefore errors are rather common and must be handled.

[kosiakk]

Do you think, such approach is reasonable? I have no idea how does it work in JS target.

My original implementation was very simple:

interface TagConsumer<out R> {
     // ...

    // default implementation simply re-throws the exception after closing the tag
    fun onError(exception: Exception) : Unit = throw exception
}

fun <T : Tag> T.visit(block: T.() -> Unit) {
    consumer.onTagStart(this)
    try {
        this.block()
    } catch (err: Exception) {
        consumer.onError(err)
    } finally {
        // all tags are properly closed
        consumer.onTagEnd(this)
    }
}

[cy6erGn0m]

The only problem I can see is that if we have a chain of consumers then the error handler in the middle of the chain can only write directly to the delegate rather than pass through the whole chain

pros: we can't get infinite error handling issue
cons: it's not clear what the state the outer consumer will have after writing directly inside of the error handler