Set,Delete: fix missing materialization

Apply materialization when modifying a document based on raw JSON
(json.RawMessage, json.Decoder). This fixes Set/Delete that didn't
properly apply the modification from root.

Note that, for now, documents are fully decoded. We do not apply layered
decoding yet.

Author: dolmen

jsonptr.go

@@ -268,8 +268,70 @@ func Get(doc interface{}, ptr string) (interface{}, error) {
 	return doc, err
 }
 
+// materialize walks *pdoc along ptr[p:] (ptr[:p] is the already walked part)
+// and replaces in place any [encoding/json.RawMessage] or JSONDecoder found on
+// the way (including at the end of the path) by its decoded value.
+// Once done, the value at ptr (if any) is attached to the tree at *pdoc and
+// can be modified in place.
+//
+// Only JSON decoding errors are reported: navigation errors are left for Get
+// to report.
+func materialize(pdoc *interface{}, ptr string, p int) error {
+	switch raw := (*pdoc).(type) {
+	case json.RawMessage:
+		var v interface{}
+		if err := json.Unmarshal(raw, &v); err != nil {
+			return jsonError(ptr[:p], err)
+		}
+		*pdoc = v
+	case JSONDecoder:
+		var v interface{}
+		if err := raw.Decode(&v); err != nil {
+			return jsonError(ptr[:p], err)
+		}
+		*pdoc = v
+	}
+
+	if p >= len(ptr) {
+		return nil
+	}
+	// ptr[p] == '/'
+	p++
+	q := strings.IndexByte(ptr[p:], '/')
+	if q == -1 {
+		q = len(ptr) - p
+	}
+	token := ptr[p : p+q]
+	p += q
+
+	switch here := (*pdoc).(type) {
+	case map[string]interface{}:
+		key, err := UnescapeString(token)
+		if err != nil {
+			return nil
+		}
+		v, ok := here[key]
+		if !ok {
+			return nil
+		}
+		err = materialize(&v, ptr, p)
+		here[key] = v
+		return err
+	case []interface{}:
+		n, err := arrayIndex(token)
+		if err != nil || n < 0 || n >= len(here) {
+			return nil
+		}
+		return materialize(&here[n], ptr, p)
+	}
+	return nil
+}
+
 // Set modifies a JSON-like data tree.
 //
+// Any [encoding/json.RawMessage] or JSONDecoder on the path to the value
+// is replaced in the tree by its decoded value.
+//
 // In case of error a PtrError is returned.
 func Set(doc *interface{}, ptr string, value interface{}) error {
 	if len(ptr) == 0 {
@@ -283,13 +345,13 @@ func Set(doc *interface{}, ptr string, value interface{}) error {
 	prop := ptr[p+1:]
 	parentPtr := ptr[:p]
 
+	if err := materialize(doc, parentPtr, 0); err != nil {
+		return err
+	}
 	parent, err := Get(*doc, parentPtr)
 	if err != nil {
 		return err
 	}
-	if len(parentPtr) == 0 {
-		*doc = parent
-	}
 
 	switch parent := (parent).(type) {
 	case map[string]interface{}:
@@ -336,6 +398,9 @@ func Set(doc *interface{}, ptr string, value interface{}) error {
 
 // Delete removes an object property or an array element (and shifts remaining ones).
 // It can't be applied on root.
+//
+// Any [encoding/json.RawMessage] or JSONDecoder on the path to the value
+// is replaced in the tree by its decoded value.
 func Delete(pdoc *interface{}, ptr string) (interface{}, error) {
 	if len(ptr) == 0 {
 		return nil, &BadPointerError{ptr, ErrDeleteRoot}
@@ -348,6 +413,9 @@ func Delete(pdoc *interface{}, ptr string) (interface{}, error) {
 	prop := ptr[p+1:]
 	parentPtr := ptr[:p]
 
+	if err := materialize(pdoc, parentPtr, 0); err != nil {
+		return nil, err
+	}
 	parent, err := Get(*pdoc, parentPtr)
 	if err != nil {
 		return nil, err

jsonptr_test.go

@@ -237,4 +237,94 @@ func TestSet(t *testing.T) {
 	checkSet(t, `[0,1]`, `/-`, true, `[0,1,true]`)
 	checkSet(t, `{}`, `/ok`, true, `{"ok":true}`)
 	checkSet(t, `{"x":[]}`, `/x/-`, true, `{"x":[true]}`)
+
+	// json.RawMessage nested in the tree: it must be decoded and stored in
+	// the tree before being modified
+	checkSet(t, map[string]interface{}{"a": json.RawMessage(`{}`)}, `/a/b`, 1, `{"a":{"b":1}}`)
+	checkSet(t, map[string]interface{}{"a": json.RawMessage(`{"x":{"y":[]}}`)}, `/a/x/y/-`, true, `{"a":{"x":{"y":[true]}}}`)
+	checkSet(t, map[string]interface{}{"a": json.RawMessage(`[]`)}, `/a/-`, true, `{"a":[true]}`)
+	checkSet(t, []interface{}{json.RawMessage(`[1]`)}, `/0/-`, 2, `[[1,2]]`)
+	checkSet(t, []interface{}{json.RawMessage(`[1]`)}, `/0/0`, 2, `[[2]]`)
+	checkSet(t, map[string]interface{}{"a": json.RawMessage(`{"b":{"c":1}}`)}, `/a/b/c`, 2, `{"a":{"b":{"c":2}}}`)
+	// Replacing the RawMessage itself
+	checkSet(t, map[string]interface{}{"a": json.RawMessage(`{}`)}, `/a`, 1, `{"a":1}`)
+	// Nested streamed decoder
+	checkSet(t, map[string]interface{}{"a": json.NewDecoder(strings.NewReader(`{"x":[1]}`))}, `/a/x/-`, 2, `{"a":{"x":[1,2]}}`)
+	// Nested in a RawMessage root
+	checkSet(t, `{"a":{"b":[]}}`, `/a/b/0`, true, `{"a":{"b":[true]}}`)
+
+	// Invalid JSON in a nested RawMessage
+	doc := interface{}(map[string]interface{}{"a": json.RawMessage(`{`)})
+	err := jsonptr.Set(&doc, `/a/b`, 1)
+	var docErr *jsonptr.DocumentError
+	if !errors.As(err, &docErr) {
+		t.Errorf("invalid nested JSON: got %T %v, want *DocumentError", err, err)
+	}
+}
+
+func checkDelete(t *testing.T, data interface{}, ptr string, expectedValue interface{}, jsonOut string) {
+	t.Logf("%#v - \"%v\"", data, ptr)
+	got, err := jsonptr.Delete(&data, ptr)
+	if err != nil {
+		t.Errorf("  unexpected error: %s", err)
+		return
+	}
+	if !reflect.DeepEqual(got, expectedValue) {
+		t.Errorf("  deleted value: got %T %v, want %T %v", got, got, expectedValue, expectedValue)
+	}
+	out, err := json.Marshal(data)
+	if err != nil {
+		t.Errorf("  can't marshal output: %s", err)
+		return
+	}
+	if string(out) != jsonOut {
+		t.Errorf("  got %s, want %s", out, jsonOut)
+	}
+}
+
+func TestDelete(t *testing.T) {
+	checkDelete(t, map[string]interface{}{"a": 1, "b": 2}, `/a`, 1, `{"b":2}`)
+	checkDelete(t, []interface{}{1, 2, 3}, `/1`, 2, `[1,3]`)
+	checkDelete(t, []interface{}{1, 2, 3}, `/2`, 3, `[1,2]`)
+	checkDelete(t, []interface{}{1}, `/0`, 1, `[]`)
+	checkDelete(t, map[string]interface{}{"a": []interface{}{1, 2}}, `/a/0`, 1, `{"a":[2]}`)
+
+	// json.RawMessage in the tree, at root or nested
+	checkDelete(t, json.RawMessage(`{"a":1,"b":2}`), `/a`, float64(1), `{"b":2}`)
+	checkDelete(t, json.RawMessage(`[1,2,3]`), `/1`, float64(2), `[1,3]`)
+	checkDelete(t, map[string]interface{}{"a": json.RawMessage(`{"b":1,"c":2}`)}, `/a/b`, float64(1), `{"a":{"c":2}}`)
+	checkDelete(t, map[string]interface{}{"a": json.RawMessage(`[1,2,3]`)}, `/a/1`, float64(2), `{"a":[1,3]}`)
+	checkDelete(t, map[string]interface{}{"a": json.RawMessage(`{"b":{"c":[true]}}`)}, `/a/b/c/0`, true, `{"a":{"b":{"c":[]}}}`)
+	checkDelete(t, map[string]interface{}{"a": json.NewDecoder(strings.NewReader(`{"b":1,"c":2}`))}, `/a/b`, float64(1), `{"a":{"c":2}}`)
+
+	// Errors
+	for _, test := range []struct {
+		doc interface{}
+		ptr string
+		err error
+	}{
+		{map[string]interface{}{}, ``, jsonptr.ErrDeleteRoot},
+		{map[string]interface{}{}, `a`, jsonptr.ErrSyntax},
+		{map[string]interface{}{}, `/a`, jsonptr.ErrProperty},
+		{map[string]interface{}{"a": 1}, `/a/b`, nil}, // DocumentError
+		{[]interface{}{1}, `/1`, jsonptr.ErrIndex},
+		{[]interface{}{1}, `/-`, jsonptr.ErrIndex},
+		{[]interface{}{1}, `/x`, jsonptr.ErrSyntax},
+		{map[string]interface{}{"a": json.RawMessage(`{`)}, `/a/b`, nil}, // DocumentError
+	} {
+		doc := test.doc
+		_, err := jsonptr.Delete(&doc, test.ptr)
+		if err == nil {
+			t.Errorf("%#v - %q: expected error", test.doc, test.ptr)
+			continue
+		}
+		if test.err == nil {
+			var docErr *jsonptr.DocumentError
+			if !errors.As(err, &docErr) {
+				t.Errorf("%#v - %q: got %T %v, want *DocumentError", test.doc, test.ptr, err, err)
+			}
+		} else if !errors.Is(err, test.err) {
+			t.Errorf("%#v - %q: got %T %v, want %v", test.doc, test.ptr, err, err, test.err)
+		}
+	}
 }