Need help with config4k?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

config4k
188 Stars 26 Forks Apache License 2.0 138 Commits 13 Opened issues

Description

A Kotlin wrapper for Typesafe Config

Services available

!
?

Need anything else?

Contributors list

Config4k

Build Status codecov ktlint Maven Central Sonatype Nexus (Snapshots) javadoc GitHub

Config for Kotlin.

Config4k is a lightweight Typesafe Config wrapper for Kotlin and inspired by ficus, providing simple extension functions

Config.extract
and
Any.toConfig
to convert between
Config
and Kotlin Objects.

example

Table of Contents

Gradle:

repositories {
    mavenCentral()
}


dependencies { compile 'io.github.config4k:config4k:xxx' // See the Download badge }

Usage

Delegated Properties

By far the simplest way to use config4k is via Kotlin Delegated Properties:

val config = ConfigFactory.parseString("""
                                          |stringValue = hello
                                          |booleanValue = true
                                          |""".trimMargin())

val stringValue: String by config println(stringValue) // hello

val nullableStringValue: String? by config println(nullableStringValue) // null

val booleanValue: Boolean by config println(booleanValue) // true

Deserialization

Config.extract
converts
Config
to
T
.

Map

Maps can be serialized with

String
keys
kotlin
val config = ConfigFactory.parseString("""
                                          |map {  
                                          |  foo = 5
                                          |  bar = 6
                                          |}""".trimMargin())
val map: Map = config.extract>("map")
println(map["foo"] == 5) // true
println(map["bar"] == 6) // true
or with arbitrary keys
kotlin
val config = ConfigFactory.parseString("""
                                          |map = [{  
                                          |  key = 5
                                          |  value = "foo"
                                          |}
                                          |{
                                          |  key = 6
                                          |  value = "bar"
                                          |}]""".trimMargin())
val map: Map = config.extract>("map")
println(map[5] == "foo") // true
println(map[6] == "bar") // true
Test Class: TestMap.kt

Data Classes

Config4k has no option to use different names between code and config file. ```kotlin data class Person(val name: String, val age: Int)

val config = ConfigFactory.parseString(""" |key {
| name = "foo" | age = 20 |}""".trimMargin()) val person: Person = config.extract("key") println(person.name == "foo") // true println(person.age == 20) // true ``` For more details, please see TestArbitraryType.kt

Nullable

Using

extract
is the better way than
Config.hasPath()
.
extract
returns
T
when the path exists and
null
when it does not exist.
kotlin
val config = ConfigFactory.parseString("""key = 10""")
val key = config.extract("key")
val foo = config.extract("foo")
println(key == 10) // true
println(foo == null) // true
Test Class: TestNullable.kt

Enum

Config4k also supports Enum. Enum is converted to String of its name in the config file. ```kotlin enum class Size { SMALL, MEDIUM, LARGE }

val config = ConfigFactory.parseString("""key = SMALL""") val small = config.extract("key") println(small == Size.SMALL) // true ``` Test Class: TestEnum.kt

Serialization

Any.toConfig
converts the receiver object to
Config
.

String

You can use ConfigValue.render() to serialize

Config
. Config4k helps getting
Config
of the class you want to serialize.
kotlin
data class Person(val name: String, val age: Int)
val person = Person("foo", 20).toConfig("person")
println(person.root().render())
Output:
{
    # hardcoded value
    "person" : {
        # hardcoded value
        "age" : 20,
        # hardcoded value
        "name" : "foo"
    }
}
Test Class: TestToConfigForArbitraryType.kt

ConfigRenderOptions

Typesafe Config's class

ConfigRenderOptions
is the argument of
ConfigValue.render
.
kotlin
// If setJson(false) is called, ConfigValue.render returns HOCON
data class Person(val name: String, val age: Int)
val person = Person("foo", 20).toConfig("person")
val options = ConfigRenderOptions.defaults().setJson(false)
println(person.root().render(options))
Output:
    # hardcoded value
person {
    # hardcoded value
    age=20
    # hardcoded value
    name=foo
}
// setOriginComments(false) removes comments
data class Person(val name: String, val age: Int)
val person = Person("foo", 20).toConfig("person")
val options = ConfigRenderOptions.defaults()
                        .setJson(false)
                        .setOriginComments(false)
println(person.root().render(options))

Output:

person {
    age=20
    name=foo
}

Supported types

Property delegation,

extract
and
toConfig
support these types: - Primitive types -
Boolean
-
Byte
-
Int
-
Long
-
Float
-
Double
-
String
-
import java.io.File
-
import java.nio.file.Path
-
java.time.Duration
-
java.time.Period
-
java.time.temporal.TemporalAmount
-
kotlin.text.Regex
- Collections -
List
-
Set
-
Map
-
Array
(You can use
Array
, but can't use
Array>
) - Nullable
T?
- Typesafe Config classes(Calling
toConfig
is meaningless) -
com.typesafe.config.Config
-
com.typesafe.config.ConfigValue
-
com.typesafe.config.ConfigMemorySize
- Enum - Data classes

See SelectReader.kt for the exhaustive list.

Snapshots

All snapshot artifacts are available in the Sonatype snapshots repository.

Contribute

Would you like to contribute to Config4k?
Take a look at CONTRIBUTING.md

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.