lewismj / kea Goto Github PK

Given something like:

 case class Foo(s: String, i: Int, b: Boolean, d: Double, l: Long)
  object Foo {
    def apply(config: Config): ValidatedNel[Foo] =
      (config.as[String]("example.foo.some-string") |@|
        config.as[Int]("example.foo.some-int") |@|
        config.as[Boolean]("example.foo.some-boolean") |@|
        config.as[Double]("example.foo.some-double") |@|
        config.as[Long]("example.foo.some-long")).map(Foo.apply)
  }

It should be possible to write something like

config.get[Foo]("example")

assuming (initially) the field names match the property names in the config file.
Think this should be doable (neatly) without macros, maybe using Shapeless.

Add an instance of ConfigReader for enumerations.

Possibly always call cfg.resolve on incoming configuration items so that environment variables are resolved automatically.

Generic Reader needs lazy schema

implicit def genericReader[A](implicit s: Lazy[Schema[A]]): ConfigReader[A]
= (config: Config, path: String) => s.value.from(config, path)

And

Similarly,
implicit def parsing[K <: Symbol, V, T <: HList](
implicit key: Witness.Aux[K],
next: Schema[T],
mapper: FieldNameMapper = DefaultFieldNameMapper,
reader: Lazy[ConfigReader[V]]): Schema[FieldType[K, V] :: T] = {

  Schema.instance { (config, path) =>
    val fieldName = key.value.name
    val f = reader.value.get(config, path + "." + mapper.replace(fieldName)).map(f => field[K](f))
    (f |@| next.from(config, path)).map(_ :: _)
  }
}