lewismj / kea Goto Github PK

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(_ :: _)
  }
}

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

Add an instance of ConfigReader for enumerations.

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.