kotlinpoet-dsl's Introduction

KotlinPoet DSL

Lightweight Kotlin extension of KotlinPoet, providing Kotlin DSL functionality and other convenient solutions.

Full of convenient methods to achieve minimum code writing possible.
Options to invoke DSL. For example, method("main") { ... } is as good as methods { "main" { ... } }. Scroll down for more information.
Smooth transition, existing KotlinPoet native specs can still be configured with DSL.

buildFileSpec("com.example.helloworld", "HelloWorld") {
    classType("HelloWorld") {
        modifiers(PUBLIC, FINAL)
        methods {
            "main" {
                modifiers(PUBLIC, STATIC)
                returns = UNIT
                parameter("args", STRING.array)
                appendLine("%T.out.println(%S)", System::class, "Hello, KotlinPoet!")
            }
        }
    }
}.writeTo(System.out)

Download

repositories {
    mavenCentral()
}
dependencies {
    implementation "com.hendraanggrian:kotlinpoet-dsl:$version"
}

Usage

Use `T::class` as parameters

KClass<*> can now be used as format arguments. There is also inline reified type function whenever possible.

buildMethodSpec("sortList") {
    returns = int
    parameters.add(classNamed("java.util", "List").parameterizedBy(hoverboard), "list")
    appendLine("%T.sort(list)", Collections::class)
    appendLine("return list")
}

buildFieldSpec("count", INT) {
    initializer("%L", 0)
}

Optional DSL

Some elements (field, method, parameter, etc.) are wrapped in container class. These containers have ability to add components with/without invoking DSL.

For example, 2 examples below will produce the same result.

types.addClass("Car") {
    methods {
        "getWheels" {
            returns = INT
            appendLine("return wheels")
        }
        "setWheels" {
            parameter("wheels", INT)
            appendLine("this.wheels = wheels")
        }
    }
}

types.addClass("Car") {
    method("getWheels") {
        returns = INT
        appendLine("return wheels")
    }
    method("setWheels") {
        paraneter("wheels", INT)
        appendLine("this.wheels = wheels")
    }
}

Property delegation

In spirit of Gradle Kotlin DSL, creating a spec can be done by delegating to a property.

val title by parametering(String::class) {
    annotation<NotNull>
}

val message by parametering(String::class) {
    annotation<Nullable>
}

Fluent TypeName API

Write TypeName and all its subtypes fluently.

val myClass: ClassName =
    classNamed("com.example", "MyClass")

val listener: LambdaTypeName =
    STRING.lambdaBy(returns = UNIT)

val memberOfString: MemberTypeName =
    myClass.memberOf("myField")

val pairOfInteger: ParameterizedTypeName =
    Pair::class.name.parameterizedBy(Int::class, Int::class)

val tVariable: TypeVariableName =
    "T".generics

val producerOfCharSequence: WildcardTypeName =
    CharSequence::class.name.producerOf()

kotlinpoet-dsl's People

Contributors

Stargazers

Watchers

kotlinpoet-dsl's Issues

A simpler control flow api?

Now, if I need to generated:

forEach {
  println(it.toString())
}

I must call the following code:

beginFlow("forEach")
appendLine("println(it.toString())")
endFlow()

But I think there is a better way to do this:

flow("forEach") {
  appendLine("println(it.toString())")
}

Because I think this is more in line with dsl syntax~

Call function feature request

For {}, have beginFlow. But for (), may should add an easier way to generate code?

fun save(tag: String, vararg data: Any) {}

Generated:

save("foo", a, b, c, d)

I may need to do this sometimes:

append("save(")
append("%S, ", "foo")
append("a, ")
append("b, ")
append("c, ")
append("d")
append(")")

So is there a way to simplify these steps?

appendCall("save") {
  appendLine("%S, ", "foo")
  appendLine("a")
  appendLine("a")
  appendLine("b")
  appendLine("c")
  appendLine("d")
}
// or simply...
appendCall("save") {
  +"%S".format("foo")
  +"a"
  +"b"
  +"c"
  +"d"
}

Recommend Projects