def apply()

in multiversion/src/main/scala/multiversion/configs/VersionsConfig.scala [31:86]
56 lines of code
9 McCabe index (conditional complexity)

  def apply(default: String): VersionsConfig =
    VersionsConfig(JsonString(default))
  def apply(default: String, extras: Map[String, String]): VersionsConfig =
    VersionsConfig(
      JsonString(default),
      extras.mapValues(JsonString(_)).toMap
    )
  implicit lazy val default: VersionsConfig = VersionsConfig()
  implicit lazy val encoder: JsonEncoder[VersionsConfig] =
    moped.macros.deriveEncoder[VersionsConfig]
  implicit lazy val decoder: JsonDecoder[VersionsConfig] =
    new JsonDecoder[VersionsConfig] {
      def decode(context: DecodingContext): Result[VersionsConfig] = {
        context.json match {
          case s: JsonString => ValueResult(VersionsConfig(s))
          case obj @ JsonObject(members) =>
            obj.value.get("default") match {
              case Some(default: JsonString) =>
                val results = (obj.value - "default").map {
                  case (label, version: JsonString) =>
                    ValueResult(label -> version)
                  case (label, other) =>
                    ErrorResult(
                      Diagnostic.typeMismatch(
                        "String",
                        context.withCursor(
                          SelectMemberCursor(label).withParent(context.cursor)
                        )
                      )
                    )
                }
                Result.fromResults(results).map { extras =>
                  VersionsConfig(default, extras.toMap)
                }
              case Some(other) =>
                ErrorResult(
                  Diagnostic.typeMismatch(
                    "String",
                    context.withCursor(
                      SelectMemberCursor("default").withParent(context.cursor)
                    )
                  )
                )
              case None =>
                ErrorResult(
                  Diagnostic.error(
                    "missing 'default' version",
                    context.json.position
                  )
                )
            }
          case other =>
            ErrorResult(Diagnostic.typeMismatch("String", context))
        }
      }
    }