Преобразуйте все ключи из `underscore` в` camel case` объектов json в цирце

Ответ 1

Вот как я это написал. Это не так лаконично, как хотелось бы, но это не страшно:

import cats.free.Trampoline
import cats.std.list._
import cats.syntax.traverse._
import io.circe.{ Json, JsonObject }

/**
 * Helper method that transforms a single layer.
 */
def transformObjectKeys(obj: JsonObject, f: String => String): JsonObject =
  JsonObject.fromIterable(
    obj.toList.map {
      case (k, v) => f(k) -> v
    }
  )

def transformKeys(json: Json, f: String => String): Trampoline[Json] =
  json.arrayOrObject(
    Trampoline.done(json),
    _.traverse(j => Trampoline.suspend(transformKeys(j, f))).map(Json.fromValues),
    transformObjectKeys(_, f).traverse(obj => Trampoline.suspend(transformKeys(obj, f))).map(Json.fromJsonObject)
  )

И затем:

import io.circe.literal._

val doc = json"""
{
  "first_name" : "foo",
  "last_name" : "bar",
  "parent" : {
    "first_name" : "baz",
    "last_name" : "bazz"
  }
}
"""

def sc2cc(in: String) = "_([a-z\\d])".r.replaceAllIn(in, _.group(1).toUpperCase)

И наконец:

scala> import cats.std.function._
import cats.std.function._

scala> transformKeys(doc, sc2cc).run
res0: io.circe.Json =
{
  "firstName" : "foo",
  "lastName" : "bar",
  "parent" : {
    "firstName" : "baz",
    "lastName" : "bazz"
  }
}

Вероятно, мы должны каким-то образом рекурсивно применить преобразование Json => F[Json], как это удобно.

Ответ 2

def transformKeys(json: Json, f: String => String): TailRec[Json] = {
      if(json.isObject) {
        val obj = json.asObject.get
        val fields = obj.toList.foldLeft(done(List.empty[(String, Json)])) { (r, kv) =>
          val (k, v) = kv
          for {
            fs <- r
            fv <- tailcall(transformKeys(v, f))
          } yield fs :+ (f(k) -> fv)
        }
        fields.map(fs => Json.obj(fs: _*))
      } else if(json.isArray) {
        val arr = json.asArray.get
        val vsRec = arr.foldLeft(done(List.empty[Json])) { (vs, v) =>
          for {
            s <- vs
            e <- tailcall(transformKeys(v, f))
          } yield s :+ e
        }
        vsRec.map(vs => Json.arr(vs: _*))
      } else {
        done(json)
      }
    }

В настоящее время я так трансформируюсь, но довольно сложный, надеюсь, что есть простой способ.

Ответ 3

Я взял @Travis ответ и немного его модернизировал, я взял его код, и у меня было несколько ошибок и предупреждений, поэтому обновленная версия для Scala 2.12 с Cats 1.0.0-MF:

import io.circe.literal._
import cats.free.Trampoline, cats.instances.list._, cats.instances.function._, cats.syntax.traverse._, cats.instances.option._

def transformKeys(json: Json, f: String => String): Trampoline[Json] = {
  def transformObjectKeys(obj: JsonObject, f: String => String): JsonObject =
    JsonObject.fromIterable(
      obj.toList.map {
        case (k, v) => f(k) -> v
      }
    )
  json.arrayOrObject(
    Trampoline.done(json),
    _.toList.traverse(j => Trampoline.defer(transformKeys(j, f))).map(Json.fromValues(_)),
    transformObjectKeys(_, f).traverse(obj => Trampoline.defer(transformKeys(obj, f))).map(Json.fromJsonObject)
  )
}

def sc2cc(in: String) = "_([a-z\\d])".r.replaceAllIn(in, _.group(1).toUpperCase)

def camelizeKeys(json: io.circe.Json) = transformKeys(json, sc2cc).run