feat: Add introspectable ConfigSpec

.gitignore

@@ -1,8 +1,13 @@
+.bloop/
+.bsp/
+.metals/
+.vscode/
 /docs/_site/
 /website/blog/
 /website/build/
 /website/node_modules/
 /website/static/api/
 /website/variables.js
 /website/yarn.lock
+metals.sbt
 target/

build.sbt

@@ -390,7 +390,9 @@ lazy val mimaSettings = Seq(
     // format: off
     Seq(
       ProblemFilters.exclude[DirectMissingMethodProblem]("ciris.ConfigKey.file"),
-      ProblemFilters.exclude[DirectMissingMethodProblem]("ciris.package.file")
+      ProblemFilters.exclude[DirectMissingMethodProblem]("ciris.package.file"),
+      ProblemFilters.exclude[ReversedMissingMethodProblem]("ciris.ConfigValue.fieldsRec"),
+      ProblemFilters.exclude[ReversedMissingMethodProblem]("enumeratum.values.CirisValueEnum.cirisConfigCodec")
     )
     // format: on
   }

modules/circe-yaml/src/main/scala/ciris/circe/yaml/yaml.scala

@@ -8,11 +8,15 @@ package ciris.circe
 
 import cats.syntax.all._
 import ciris.{ConfigDecoder, ConfigError}
+import ciris.ConfigCodec
 import io.circe.{Decoder, Json}
 import io.circe.{DecodingFailure, ParsingFailure}
+import io.circe.Encoder
 import io.circe.yaml.parser.parse
 
 package object yaml {
+
+  @deprecated("Use ConfigCodec and circeYamlConfigCodec instead", "3.7.0")
   final def circeYamlConfigDecoder[A](
     typeName: String
   )(implicit decoder: Decoder[A]): ConfigDecoder[String, A] =
@@ -75,6 +79,72 @@ package object yaml {
       } yield a
     }
 
+  @deprecated("Use ConfigCodec instead", "3.7.0")
   implicit final val yamlConfigDecoder: ConfigDecoder[String, Json] =
     circeYamlConfigDecoder("Yaml")
+
+  final def circeYamlConfigCodec[A](
+    typeName: String
+  )(implicit decoder: Decoder[A], encoder: Encoder[A]): ConfigCodec[String, A] =
+    ConfigCodec[String].imapEither { (key, value) =>
+      def decodeError(json: Json, decodingFailure: DecodingFailure): ConfigError = {
+        def message(valueShown: Option[String], decodingFailureMessage: Option[String]): String = {
+          def trailingDecodingFailureMessage =
+            decodingFailureMessage match {
+              case Some(message) => s": $message"
+              case None          => ""
+            }
+
+          (key, valueShown) match {
+            case (Some(key), Some(value)) =>
+              s"${key.description.capitalize} with json $value cannot be decoded to $typeName$trailingDecodingFailureMessage"
+            case (Some(key), None) =>
+              s"${key.description.capitalize} cannot be decoded to $typeName$trailingDecodingFailureMessage"
+            case (None, Some(value)) =>
+              s"Unable to decode json $value to $typeName$trailingDecodingFailureMessage"
+            case (None, None) =>
+              s"Unable to decode json to $typeName$trailingDecodingFailureMessage"
+          }
+        }
+
+        ConfigError.sensitive(
+          message = message(Some(json.noSpaces), Some(decodingFailure.getMessage)),
+          redactedMessage = message(None, None)
+        )
+      }
+
+      def parseError(parsingFailure: ParsingFailure): ConfigError = {
+        def message(valueShown: Option[String], parsingFailureMessage: Option[String]): String = {
+          def trailingParsingFailureMessage =
+            parsingFailureMessage match {
+              case Some(message) => s": $message"
+              case None          => ""
+            }
+
+          (key, valueShown) match {
+            case (Some(key), Some(value)) =>
+              s"${key.description.capitalize} with value $value cannot be parsed as json$trailingParsingFailureMessage"
+            case (Some(key), None) =>
+              s"${key.description.capitalize} cannot be parsed as json$trailingParsingFailureMessage"
+            case (None, Some(value)) =>
+              s"Unable to parse value $value as json$trailingParsingFailureMessage"
+            case (None, None) =>
+              s"Unable to parse value as json$trailingParsingFailureMessage"
+          }
+        }
+
+        ConfigError.sensitive(
+          message = message(Some(value), Some(parsingFailure.getMessage)),
+          redactedMessage = message(None, None)
+        )
+      }
+
+      for {
+        json <- parse(value).leftMap(parseError)
+        a <- json.as[A].leftMap(decodeError(json, _))
+      } yield a
+    }(encoder(_).toString)
+
+  implicit final val yamlConfigCodec: ConfigCodec[String, Json] =
+    circeYamlConfigCodec("Yaml")
 }

modules/circe-yaml/src/test/scala/ciris/circe/yaml/CirceYamlSpec.scala

@@ -16,97 +16,97 @@ import io.circe.yaml.syntax._
 import munit.CatsEffectSuite
 
 final class CirceYamlSpec extends CatsEffectSuite {
-  test("circeYamlConfigDecoder.success") {
+  test("circeYamlConfigCodec.success") {
     default("123")
-      .as[Int](circeYamlConfigDecoder("Int"))
+      .asIso[Int](circeYamlConfigCodec("Int"))
       .load[IO]
       .assertEquals(123)
   }
 
-  test("circeYamlConfigDecoder.success.noquotes") {
+  test("circeYamlConfigCodec.success.noquotes") {
     default("abc")
-      .as[String](circeYamlConfigDecoder("String"))
+      .asIso[String](circeYamlConfigCodec("String"))
       .load[IO]
       .assertEquals("abc")
   }
 
-  test("circeYamlConfigDecoder.success.quotes") {
+  test("circeYamlConfigCodec.success.quotes") {
     default("\"abc\"")
-      .as[String](circeYamlConfigDecoder("String"))
+      .asIso[String](circeYamlConfigCodec("String"))
       .load[IO]
       .assertEquals("abc")
   }
 
-  test("circeYamlConfigDecoder.invalid.noquotes") {
+  test("circeYamlConfigCodec.invalid.noquotes") {
     checkError(
-      ConfigValue.default("abc").as[Int](circeYamlConfigDecoder("Int")),
+      ConfigValue.default("abc").asIso[Int](circeYamlConfigCodec("Int")),
       """Unable to decode json "abc" to Int: DecodingFailure at : Int"""
     )
   }
 
-  test("circeYamlConfigDecoder.invalid") {
+  test("circeYamlConfigCodec.invalid") {
     checkError(
-      ConfigValue.default("\"abc\"").as[Int](circeYamlConfigDecoder("Int")),
+      ConfigValue.default("\"abc\"").asIso[Int](circeYamlConfigCodec("Int")),
       """Unable to decode json "abc" to Int: DecodingFailure at : Int"""
     )
   }
 
-  test("circeYamlConfigDecoder.invalid.redacted") {
+  test("circeYamlConfigCodec.invalid.redacted") {
     checkError(
-      ConfigValue.default("\"abc\"").as[Int](circeYamlConfigDecoder("Int")).redacted,
+      ConfigValue.default("\"abc\"").asIso[Int](circeYamlConfigCodec("Int")).redacted,
       "Unable to decode json to Int"
     )
   }
 
-  test("circeYamlConfigDecoder.invalid.loaded") {
+  test("circeYamlConfigCodec.invalid.loaded") {
     checkError(
-      ConfigValue.loaded(ConfigKey("key"), "\"abc\"").as[Int](circeYamlConfigDecoder("Int")),
+      ConfigValue.loaded(ConfigKey("key"), "\"abc\"").asIso[Int](circeYamlConfigCodec("Int")),
       """Key with json "abc" cannot be decoded to Int: DecodingFailure at : Int"""
     )
   }
 
-  test("circeYamlConfigDecoder.invalid.loaded.redacted") {
+  test("circeYamlConfigCodec.invalid.loaded.redacted") {
     checkError(
       ConfigValue
         .loaded(ConfigKey("key"), "\"abc\"")
-        .as[Int](circeYamlConfigDecoder("Int"))
+        .asIso[Int](circeYamlConfigCodec("Int"))
         .redacted,
       "Key cannot be decoded to Int"
     )
   }
 
-  test("yamlConfigDecoder.success") {
+  test("yamlConfigCodec.success") {
     default("123")
-      .as[Json]
+      .asIso[Json]
       .load[IO]
       .map(_.asNumber.flatMap(_.toInt).contains(123))
       .assert
   }
 
-  test("yamlConfigDecoder.invalid") {
+  test("yamlConfigCodec.invalid") {
     checkError(
-      ConfigValue.default("\"no\"").as[Boolean],
+      ConfigValue.default("\"no\"").asIso[Boolean],
       "Unable to convert value \"no\" to Boolean"
     )
   }
 
-  test("yamlConfigDecoder.invalid.redacted") {
+  test("yamlConfigCodec.invalid.redacted") {
     checkError(
-      ConfigValue.default("\"no\"").as[Boolean].redacted,
+      ConfigValue.default("\"no\"").asIso[Boolean].redacted,
       "Unable to convert value to Boolean"
     )
   }
 
-  test("yamlConfigDecoder.invalid.loaded") {
+  test("yamlConfigCodec.invalid.loaded") {
     checkError(
-      ConfigValue.loaded(ConfigKey("key"), "\"no\"").as[Boolean],
+      ConfigValue.loaded(ConfigKey("key"), "\"no\"").asIso[Boolean],
       "Key with value \"no\" cannot be converted to Boolean"
     )
   }
 
-  test("yamlConfigDecoder.invalid.loaded.redacted") {
+  test("yamlConfigCodec.invalid.loaded.redacted") {
     checkError(
-      ConfigValue.loaded(ConfigKey("key"), "\"no\"").as[Boolean].redacted,
+      ConfigValue.loaded(ConfigKey("key"), "\"no\"").asIso[Boolean].redacted,
       "Key cannot be converted to Boolean"
     )
   }

modules/circe/shared/src/main/scala/ciris/circe/circe.scala

@@ -9,9 +9,12 @@ package ciris
 import cats.syntax.all._
 import io.circe.{Decoder, Json}
 import io.circe.{DecodingFailure, ParsingFailure}
+import io.circe.Encoder
 import io.circe.parser.parse
 
 package object circe {
+
+  @deprecated("Use ConfigCodec and circeConfigCodec instead", "3.7.0")
   final def circeConfigDecoder[A](
     typeName: String
   )(implicit decoder: Decoder[A]): ConfigDecoder[String, A] =
@@ -74,6 +77,72 @@ package object circe {
       } yield a
     }
 
+  @deprecated("Use ConfigCodec instead", "3.7.0")
   implicit final val jsonConfigDecoder: ConfigDecoder[String, Json] =
     circeConfigDecoder("Json")
+
+  final def circeConfigCodec[A](
+    typeName: String
+  )(implicit decoder: Decoder[A], encoder: Encoder[A]): ConfigCodec[String, A] =
+    ConfigCodec[String].imapEither { (key, value) =>
+      def decodeError(json: Json, decodingFailure: DecodingFailure): ConfigError = {
+        def message(valueShown: Option[String], decodingFailureMessage: Option[String]): String = {
+          def trailingDecodingFailureMessage =
+            decodingFailureMessage match {
+              case Some(message) => s": $message"
+              case None          => ""
+            }
+
+          (key, valueShown) match {
+            case (Some(key), Some(value)) =>
+              s"${key.description.capitalize} with json $value cannot be decoded to $typeName$trailingDecodingFailureMessage"
+            case (Some(key), None) =>
+              s"${key.description.capitalize} cannot be decoded to $typeName$trailingDecodingFailureMessage"
+            case (None, Some(value)) =>
+              s"Unable to decode json $value to $typeName$trailingDecodingFailureMessage"
+            case (None, None) =>
+              s"Unable to decode json to $typeName$trailingDecodingFailureMessage"
+          }
+        }
+
+        ConfigError.sensitive(
+          message = message(Some(json.noSpaces), Some(decodingFailure.getMessage)),
+          redactedMessage = message(None, None)
+        )
+      }
+
+      def parseError(parsingFailure: ParsingFailure): ConfigError = {
+        def message(valueShown: Option[String], parsingFailureMessage: Option[String]): String = {
+          def trailingParsingFailureMessage =
+            parsingFailureMessage match {
+              case Some(message) => s": $message"
+              case None          => ""
+            }
+
+          (key, valueShown) match {
+            case (Some(key), Some(value)) =>
+              s"${key.description.capitalize} with value $value cannot be parsed as json$trailingParsingFailureMessage"
+            case (Some(key), None) =>
+              s"${key.description.capitalize} cannot be parsed as json$trailingParsingFailureMessage"
+            case (None, Some(value)) =>
+              s"Unable to parse value $value as json$trailingParsingFailureMessage"
+            case (None, None) =>
+              s"Unable to parse value as json$trailingParsingFailureMessage"
+          }
+        }
+
+        ConfigError.sensitive(
+          message = message(Some(value), Some(parsingFailure.getMessage)),
+          redactedMessage = message(None, None)
+        )
+      }
+
+      for {
+        json <- parse(value).leftMap(parseError)
+        a <- json.as[A].leftMap(decodeError(json, _))
+      } yield a
+    }(encoder(_).toString)
+
+  implicit final val jsonConfigCodec: ConfigCodec[String, Json] =
+    circeConfigCodec("Json")
 }