Type-safe Kotlin configuration by delegates

Part one of #36

This allows to define arguments in plain classes, i.e. without extending Arkenv.

For example:

object Arguments {

    val country: String by argument()

    val bool: Boolean by argument("-b")

    val port: Int by argument()
}

fun main(args: Array<String>) {
    Arkenv.parse(Arguments, args)
}

This example below is straight forward, but it fails as some how USER get's mapped into --db-user

@Test fun `should only use fully qualified env name`() {
    MockSystem("USER" to "jeggy")
    object: Arkenv() {
        val user: String by argument("--db-user") {
            defaultValue = { "postgres" }
        }
    }.parse().user shouldBeEqualTo "postgres"
}

closes #45

Tasks:

• [x] Setup SonaType account and get com.apurebase approved there
• [x] Gradle configuration for publishing to Maven Central
• [x] Make sure it's using 1.8
• [x] Setup Jupiter again
• [x] Create GitHub action to publish to Maven Central
• [x] Publish old versions to Maven Central

When passing an argument via CLI that contains whitespace, it would be good if quoting was supported.

data class Configuration(
    val notesFileName: String
)

--notes-file-name "My Clippings.txt"

Explore options to support argument classes without inheritance.

1. Class without inheritance / no class X : Arkenv()
2. Class / data class with arguments in constructor class Ark(val port: Int, val host: String)

As the current trend is to use main instead of master, I would suggest we will do the same.

• [ ] Update github actions
• [ ] Update default branch in git
• [ ] (optional) Update gitlab badges

Allow nesting Arkenv instances, so that different parts of the configuration can be defined in separate classes.

Proposed syntax:

private inner class DatabaseConfig : Arkenv() {
	val port: Int by argument()
}

private inner class Ark : Arkenv() {
	val name: String by argument()
	val database = module(DatabaseConfig())
}

@Test fun `modules should be parsed by root`() {
	val myApp = "MyApp"
	val port = 8080
	Ark().parse("--name", myApp, "--port", port.toString())
		.expectThat {
			get { name }.isEqualTo(myApp)
			get { database.port }.isEqualTo(port)
		}
}

Instead of calling .parse() it could happen automatically on the first call to access any prop or get call.

• isParsed Bool to indicate if it has been parsed. Can also be useful output for exceptions
• provide lazy parsing on accessing first prop or ::get

There is no reason to not have the ProfileFeature on by default.

If you don't provide any configuration, nothing gets loaded.

Once you decide to use profiles, it is automatically available without recompilation.

As for the overall default order, follow Spring: https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html#boot-features-external-config

1. CLI
2. Properties
3. SysEnv

The remote config scenario needs a good guide with examples.

I am thinking of walking through a light ktor app that uses Arkenv for remote config. Either refresh periodically, or via a web hook.

Upcoming optimization for delegates coming in 1.4: https://blog.jetbrains.com/kotlin/2019/12/what-to-expect-in-kotlin-1-4-and-beyond/ (Optimized delegated properties)

Module support is more natural if we can just supply our nested modules via the constructor.

Out of the box we get defaults and easy injection in tests.

Either convention based, for example, all data classes are parsed as modules parameter.type.jvmErasure.isData.

Or with annotation @Module

A common setup is to have a application.* in main and one in test, where test adds or overwrites values specified in main.

Currently, it seems only one is loaded.

Investigate the current behavior and see if we can enable a merging of both. How would we determine the order?

I'm thinking we should remove our whole dependency to gitlab.com by removing our .gitlab-ci.yml and when finished with that we would update the https://apurebase.gitlab.io/arkenv/ website to just forward all requests to https://arkenv.io/

Some tasks I can think of:

• [ ] Create Code coverage badge via GitHub Actions [An idea how]
• [x] Make sure all links work on the new arkenv.io webiste
• [x] Change references in this GitHub repo to point to arkenv.io
• [x] Update generated POM files to use new arkenv.io website
• [x] Stop mirror settings on GitLab & Create 1 commit on GitLab that:
  • [ ] Will publish a new website, which only forwards the link directly over to the new site.
  • [ ] A small note in the README to say we are not using GitLab anymore and a link to this repo instead.

class OtherArks: Arkenv() {
    val customConfig: String? by argument("--custom")
}
class Arks: Arkenv("My App") {
    val other = module(OtherArks())
    val port: Int by argument("--port") {
        defaultValue = { 8080 }
    }
}

fun main(args: Array<String>) {
    val arks = Arks().parse(args)

    if (arks.help) {
        println(arks.toString())
    }
}

outputs:

My App: 
    [-h, --HELP]        
        help        true
    [--ARKENV_APPLICATION_NAME]        
        programName        My App
    [--PORT]        
        port        8080