Option to flat all substructs/maps

[notdodo]

Hi!

I'd like to know, if it's possible or if you planned to add it, an option to "flat" all the maps or structs during a Marshal or Decompose.

Something like:
from: {"a": "3", "b": {"c":true}}
to: {"a":"3","b.c":true}

but also for embedded structs and arrays

[ohler55]

There is no plan to do that. It is a rather specialized feature. A more generic feature that might help would be to have a callback parser that calls back on each node with a path and value. Maybe just leaf node. Not sure how performant that would be. Another option might be to add a function to flatten tree. Have to give it some thought.

[thadguidry]

@notdodo Depending on your use case, you might have some success with using https://github.com/filip26/ld-cli which I sponsored it's creation. It's a CLI created from their other project https://github.com/filip26/titanium-json-ld which uses the Jakarta JSON Processing. You can open an issue for the ld-cli if it doesn't work out for your use case and we might be able to help further.

But I know @ohler55 loves challenges for ojg. :-)

[notdodo]

@thadguidry not really what I "need" since I'd like to integrate ojg as a library in go program but thank you.

[ohler55]

Thanks for the compliment @thadguidry . I'm warming up to the idea of writing tree traverser. I could see how it would be a nice addition to the ojg/alt package.

[ohler55]

Have you looked at the jp.Walk() function? It seems like that may satisfy what you are looking for with a simple callback that builds the map you described.

[notdodo]

yeah kinda!

tested it with this code:

var flattt = make(map[string]any, 0)
jp.Walk(unflattenInterface, func(path jp.Expr, value any) {
	switch v := value.(type) {
	case string:
		flattt[path.String()] = v
	case bool:
		flattt[path.String()] = v
	case int64:
		flattt[path.String()] = v
	default:
	}
})
for p, f := range flattt {
	fmt.Println(p, f)
}

Input: {"a":"3","c":4,"b":{"d":"5","e":6}}
Output:

$.a 3
$.c 4
$.b.d 5
$.b.e 6

also with some arrays inside the object:

Input: [{"a": "3"}, {"b": "3", "C": [{"c": 10}, {"d": 11}]}]
Output:

$[0].a 3
$[1].b 3
$[1].C[0].c 10
$[1].C[1].d 11

not a fancy of that switch case but I'll try to invert it and match non-primitive types with the default to catch all the primitive ones.
do you think it's feasible to also customize the path string? for example without the "$" or changing the separator without using replace.

[ohler55]

Note that the path is a jp.Expr which is a slice. You can get the string of path[1:] to remove the "$." prefix. Since it is a slice you can write your own stringify function and form any string you want.

I could add some options to only callback on leaves although the type checking will still occur but it will be in the jp package.

[notdodo]

Amazing! Thank you!

[notdodo]

Since I wanted to better understand how to do it by myself I've create this package: https://github.com/notdodo/goflat

[ohler55]

Looks like it does exactly what you described. Nice job.

[ohler55]

Released v1.20.3 with a justLeaves option to jp.Walk().