Utilisation de circe pour pré-traiter les champs de style de notation par points

Question

J'ai un fichier json qui inclut des champs qui sont aplatis dans un format bson-ish comme dans {"foo.bar" : "bash"}. Je voudrais transformer cela à la représentation suivante {"foo" : { "bar" : "bash"}} et se demandant où je ferais une telle opération. Pour compliquer le problème, il peut y avoir plusieurs champs de ce type qui doivent être correctement fusionnés, par ex. {"foo.bar" : "a", "foo.bash" : "b", "foo.baz" : "c"} ->{"foo" : { "bar" : "a", "bash" : "b", "baz" : "c"}}.

Answer 1

Voici une mise en œuvre rapide:

import io.circe.Json 

val Dotted = "([^\\.]*)\\.(.*)".r 

def expandDotted(j: Json): Json = j.arrayOrObject(
    j, 
    js => Json.fromValues(js.map(expandDotted)), 
    _.toList.map { 
    case (Dotted(k, rest), v) => Json.obj(k -> expandDotted(Json.obj(rest -> v))) 
    case (k, v) => Json.obj(k -> expandDotted(v)) 
    }.reduceOption(_.deepMerge(_)).getOrElse(Json.obj()) 
) 

Je ne l'ai pas vraiment utilisé ou testé en détail, mais il semble fonctionner:

scala> import io.circe.literal._ 
import io.circe.literal._ 

scala> val j1 = json"""{"foo.bar" : "a", "foo.bash" : "b", "foo.baz" : "c"}""" 
j1: io.circe.Json = 
{ 
    "foo.bar" : "a", 
    "foo.bash" : "b", 
    "foo.baz" : "c" 
} 

scala> expandDotted(j1) 
res1: io.circe.Json = 
{ 
    "foo" : { 
    "baz" : "c", 
    "bash" : "b", 
    "bar" : "a" 
    } 
} 

Et avec imbrication plus profond:

scala> expandDotted(json"""{ "x.y.z": true, "a.b": { "c": 1 } }""") 
res2: io.circe.Json = 
{ 
    "a" : { 
    "b" : { 
     "c" : 1 
    } 
    }, 
    "x" : { 
    "y" : { 
     "z" : true 
    } 
    } 
} 

Et juste pour confirmer qu'il ne plaisante pas avec les touches non-marquées:

scala> expandDotted(json"""{ "a.b": true, "x": 1 }""").noSpaces 
res3: String = {"x":1,"a":{"b":true}} 

On notera que dans le cas des « collisions » (chemins qui mènent à la fois des objets JSON et les valeurs JSON non-objet, ou à plusieurs valeurs non-objet), le comportement est celui d'Json#deepMerge:

scala> expandDotted(json"""{ "a.b": true, "a": 1 }""").noSpaces 
res4: String = {"a":1} 

scala> expandDotted(json"""{ "a": 1, "a.b": true }""").noSpaces 
res5: String = {"a":{"b":true}} 

... ce qui est probablement ce que vous voudriez, mais vous pourriez aussi l'avoir dans ces cas, ou ne pas étendre le chemin de collision, ou faire à peu près tout ce que vous pouvez penser.