Dynamically setting data in JSON?

[kabukky]

Hi!

Thanks again for answering my question in #94 .

I've realized that I've generalized too much when posing that question.
Here's something closer to what I would actually like to do:

package main

import (
	"fmt"
	"strings"

	"github.com/ohler55/ojg/jp"
	"github.com/ohler55/ojg/oj"
	"github.com/ohler55/ojg/pretty"
)

var (
	input = oj.MustParseString(`{
		"a":[
			{"x":1,"name":"jack"},
			{"x":2,"name":"alice"},
			{"x":3,"name":"bob"}
		]
	}`)
)

type nameSetter []string

func (n nameSetter) Set(value interface{}) interface{} {
	if v, ok := value.(string); ok {
		n = append(n, v)
	}
	return n
}

func (n nameSetter) MarshalJSON() ([]byte, error) {
	return []byte(strings.Join(n, " and ")), nil
}

func main() {
	x := jp.MustParseString("a[?(@.x > 1)].name")
	x.MustSet(input, nameSetter)    // Note: This doesn't work, but "MustSet" would recognize and accept an interface with method "Set(value interface{}) interface{}" in this example.
	fmt.Println(pretty.JSON(input)) // Note: "pretty.JSON" would use the custom "MarshalJSON()" method on the "nameSetter" type when building the JSON just as Go's build-in "json.Marshal" does.
	// Wanted output:
	// {
	// 	"a": [
	//		{"x": 1, "name":"jack"},
	// 		{"x": 2, "name":"alice and bob"},
	// 		{"x": 3, "name":"alice and bob"}
	// 	]
	// }
}

I'm not asking you to expand ojg to support the "Set" and "MarshalJSON" methods.
I just hope that the above illustrates what I'm trying to achieve:

Dynamically setting JSON values based on calculations that can only happen after all values have been collected via the JSONPath expression.

Thanks!

[ohler55]

Seems like the most direct way is probably best here. Step one is collect the values. Then prepare the value to be set. Finally set the value in the data. In the example it seems that the setter traverses all of the data to calculate a value for setting so it doesn't really make sense to localize it to an individual field that reaches across the data.

A similar situation might be converting a slice of strings into a string. That is supported using the recently added Modify() in the jp package.

[kabukky]

Thank you so much @ohler55!

The new "Modify" method is a great solution to my problem. Here's what I'm doing now and it works great:

package main

import (
	"fmt"

	"github.com/ohler55/ojg/jp"
	"github.com/ohler55/ojg/oj"
	"github.com/ohler55/ojg/pretty"
)

var (
	input = oj.MustParseString(`{
		"a":[
			{"x":1,"name":"jack"},
			{"x":2,"name":"alice"},
			{"x":3,"name":"bob"}
		]
	}`)
	alteredValues []map[string]interface{}
)

func main() {
	x := jp.MustParseString("a[?(@.x > 1)].name")
	_, err := x.Modify(input, modifierFunc)
	if err != nil {
		panic(err)
	}
	// Change values after call to "Modify"
	for index := range alteredValues {
		if name, ok := alteredValues[index]["name"].(string); ok {
			alteredValues[index]["greeting"] = "hello " + name
			delete(alteredValues[index], "name")
		}
	}
	fmt.Println(pretty.JSON(input))
	// Result:
	// {
	// 	"a": [
	// 		{"name": "jack", "x": 1},
	// 		{"name": {"greeting": "hello alice"}, "x": 2},
	// 		{"name": {"greeting": "hello bob"}, "x": 3}
	// 	]
	// }
}

func modifierFunc(element any) (altered any, changes bool) {
	alteredValue := make(map[string]interface{})
	alteredValue["name"] = element
	alteredValues = append(alteredValues, alteredValue)
	return alteredValue, true
}

The only thing I'm not sure about is this sentence in the "Modify" documentation:
"Unless the data is a slice and modified the returned data will be the same object as the original."
See: https://pkg.go.dev/github.com/ohler55/[email protected]/jp#Expr.Modify
Does that mean changing the value type (as in my example string to map[string]interface{}) is not permitted?

Thanks again!

[ohler55]

It is permitted. If the element being modified is a map then the map can be modified by adding or deleting entries in the map so the replacement can be the same as the original. If the element is a slice then then specific element in the slice can be changed but if the slice grows or shrinks the element in the data is replaces with the modified version. It's more of a detail for most people.

Glad it worked for you.