brady-aiello / deepprint Goto Github PK

This will involve

1. Uploading some Sonatype secrets for GH Actions
2. Creating a publishing GH Action
3. Triggering this action when pushing a commit with a tag that conforms to semantic versioning. Looking at this one from KMM-ViewModel as an example.

DeepPrint currently just uses 4 space indentation. It would be nice if users could configure indentation to suit other coding styles and needs.

WithAList(
    name = "some list",
    items = listOf<Int>( 0, 1, 2, 3, 4,),
)

WithAList(
  name = "some list",
  items = listOf<Int>( 0, 1, 2, 3, 4,),
)

If we have a data class we don't own, we should be able to deep print it somehow.
Given:

data class SomeExternalClass(val name: String, val age: Int)

Not sure the best way to do this.

1. we might be able to generate SomeExternalClass.deepPrint() exactly once, and place it in a package that matches its declaration, if any instances are the properties of an annotated class, without any modification:

@DeepPrint
data class MyClass(val externalClass: SomeExternalClass)

2. or we give the processor a heads up about the class we need to generate it for:

@DeepPrint
data class MyClass(@DeepPrint val externalClass: SomeExternalClass)

3. or we can manually create a deep print function, and pass it as an optional parameter:

@DeepPrint
data class MyClass(@DeepPrint(with = ::myExternalClassDeepPrintFunction)val externalClass: SomeExternalClass)

fun myEternalClassDepPrintFunction(externalClass: SomeExternalClass) {
    println("""
        SomeExternalClass(
            val someProperty = ${externalClass.someProperty}
        )
    """).trimIndent()
}

Options 1 or 2 would be ideal, as it would require little to no extra work from the caller. The main issue with options 1 and 2 is getting enough information about the externally declared class. KSP is not being run on compiled code, and there is just less type information available. There might be a way to do this still, so it's worth taking another stab at.

Option 3 is probably the easiest to implement, and the most flexible. It would allow for any class from any module to be deep-printable. It does require an extra step. But, depending on the class in question, the benefit might outweigh the cost of writing another function.

Background: https://twitter.com/HandstandSam/status/1625653445045673984

Using KSP is cool because it works on all platforms, and printing should be faster than with reflection. However, the KSP approach is limited because it requires annotation of all data classes in an object tree. Besides adding extra work, it may also be impossible to get everything printing correctly if it contains a data class from an external library.

Making a lighter-weight reflection-based version of the library could cover more use cases for JVM-only consumers.

To start, we'll just cover data classes and primitives, and will add collections in another ticket + PR.

Like tests with lists, which are supported:

WithAList(
    name = "some list",
    items = listOf<Int>( 0, 1, 2, 3, 4,),
)

We should also support maps:

WithAMap(
    name = "some map",
    items = mapOf('a' to 5, 'b' to 23, 'c' to 11),
)

Need to support Map and MutableMap, both for standalone objects, and as properties of a data class.

Need to support standalone Arrays as well as Arrays as properties of data classes

Need to publish the deep-print-annotations module and the deep-print-processor module so they can actually be used 🙃

Describe how to:

• apply the KSP plugin
• add runtime dependencies
• configure KSP generated code locations for:
  • single platform Kotlin projects
  • multiplatform Kotlin projects

Make sure to add references

Manual text building is fine, but it would be great if the processor code was more readable.

https://square.github.io/kotlinpoet/