Document prompt-owned schemas and finalize migration
This commit is contained in:
@@ -2,93 +2,73 @@ package jsonvalue
|
||||
|
||||
import "reflect"
|
||||
|
||||
func cloneTrustedMap(src map[string]any) map[string]any {
|
||||
if src == nil {
|
||||
return nil
|
||||
}
|
||||
out := make(map[string]any, len(src))
|
||||
for k, v := range src {
|
||||
out[k] = CloneTrusted(v)
|
||||
}
|
||||
return out
|
||||
type cloneReference struct {
|
||||
typeOf reflect.Type
|
||||
pointer uintptr
|
||||
length int
|
||||
}
|
||||
|
||||
// CloneTrusted detaches a previously accepted value without revalidating it.
|
||||
// Cyclic values can also occur in inactive, uninterpreted request fields.
|
||||
func CloneTrusted(value any) any {
|
||||
if value == nil {
|
||||
return nil
|
||||
}
|
||||
switch v := value.(type) {
|
||||
case map[string]any:
|
||||
return cloneTrustedMap(v)
|
||||
case []any:
|
||||
out := make([]any, len(v))
|
||||
for i, item := range v {
|
||||
out[i] = CloneTrusted(item)
|
||||
}
|
||||
return out
|
||||
case []string:
|
||||
if v == nil {
|
||||
return []string(nil)
|
||||
}
|
||||
return append([]string{}, v...)
|
||||
case []byte:
|
||||
if v == nil {
|
||||
return []byte(nil)
|
||||
}
|
||||
return append([]byte{}, v...)
|
||||
default:
|
||||
return cloneTrustedReflect(reflect.ValueOf(value)).Interface()
|
||||
}
|
||||
return cloneTrustedReflect(reflect.ValueOf(value), make(map[cloneReference]reflect.Value)).Interface()
|
||||
}
|
||||
|
||||
func cloneTrustedReflect(value reflect.Value) reflect.Value {
|
||||
func cloneTrustedReflect(value reflect.Value, active map[cloneReference]reflect.Value) reflect.Value {
|
||||
if !value.IsValid() {
|
||||
return value
|
||||
}
|
||||
|
||||
switch value.Kind() {
|
||||
case reflect.Interface:
|
||||
if value.IsNil() {
|
||||
return reflect.Zero(value.Type())
|
||||
}
|
||||
copied := cloneTrustedReflect(value.Elem())
|
||||
if copied.IsValid() && copied.Type().AssignableTo(value.Type()) {
|
||||
return copied
|
||||
}
|
||||
out := reflect.New(value.Type()).Elem()
|
||||
out.Set(copied)
|
||||
out.Set(cloneTrustedReflect(value.Elem(), active))
|
||||
return out
|
||||
case reflect.Pointer:
|
||||
case reflect.Pointer, reflect.Map, reflect.Slice:
|
||||
if value.IsNil() {
|
||||
return reflect.Zero(value.Type())
|
||||
}
|
||||
out := reflect.New(value.Type().Elem())
|
||||
out.Elem().Set(cloneTrustedReflect(value.Elem()))
|
||||
return out
|
||||
case reflect.Map:
|
||||
if value.IsNil() {
|
||||
return reflect.Zero(value.Type())
|
||||
key := cloneReference{typeOf: value.Type(), pointer: uintptr(value.UnsafePointer())}
|
||||
if value.Kind() == reflect.Slice {
|
||||
key.length = value.Len()
|
||||
}
|
||||
out := reflect.MakeMapWithSize(value.Type(), value.Len())
|
||||
iter := value.MapRange()
|
||||
for iter.Next() {
|
||||
out.SetMapIndex(cloneTrustedReflect(iter.Key()), cloneTrustedReflect(iter.Value()))
|
||||
if existing, found := active[key]; found {
|
||||
return existing
|
||||
}
|
||||
return out
|
||||
case reflect.Slice:
|
||||
if value.IsNil() {
|
||||
return reflect.Zero(value.Type())
|
||||
var out reflect.Value
|
||||
switch value.Kind() {
|
||||
case reflect.Pointer:
|
||||
out = reflect.New(value.Type().Elem())
|
||||
case reflect.Map:
|
||||
out = reflect.MakeMapWithSize(value.Type(), value.Len())
|
||||
case reflect.Slice:
|
||||
out = reflect.MakeSlice(value.Type(), value.Len(), value.Cap())
|
||||
}
|
||||
out := reflect.MakeSlice(value.Type(), value.Len(), value.Cap())
|
||||
for i := 0; i < value.Len(); i++ {
|
||||
out.Index(i).Set(cloneTrustedReflect(value.Index(i)))
|
||||
active[key] = out
|
||||
defer delete(active, key)
|
||||
switch value.Kind() {
|
||||
case reflect.Pointer:
|
||||
out.Elem().Set(cloneTrustedReflect(value.Elem(), active))
|
||||
case reflect.Map:
|
||||
iter := value.MapRange()
|
||||
for iter.Next() {
|
||||
out.SetMapIndex(cloneTrustedReflect(iter.Key(), active), cloneTrustedReflect(iter.Value(), active))
|
||||
}
|
||||
case reflect.Slice:
|
||||
for i := 0; i < value.Len(); i++ {
|
||||
out.Index(i).Set(cloneTrustedReflect(value.Index(i), active))
|
||||
}
|
||||
}
|
||||
return out
|
||||
case reflect.Array:
|
||||
out := reflect.New(value.Type()).Elem()
|
||||
for i := 0; i < value.Len(); i++ {
|
||||
out.Index(i).Set(cloneTrustedReflect(value.Index(i)))
|
||||
out.Index(i).Set(cloneTrustedReflect(value.Index(i), active))
|
||||
}
|
||||
return out
|
||||
default:
|
||||
|
||||
@@ -25,3 +25,13 @@ func TestCloneTrustedPreservesTypesAndDetaches(t *testing.T) {
|
||||
t.Fatal("nil/empty shape changed")
|
||||
}
|
||||
}
|
||||
|
||||
func TestCloneTrustedDetachesCycles(t *testing.T) {
|
||||
original := map[string]any{}
|
||||
original["self"] = original
|
||||
copy := CloneTrusted(original).(map[string]any)
|
||||
copy["self"].(map[string]any)["changed"] = true
|
||||
if copy["changed"] != true || original["changed"] != nil {
|
||||
t.Fatal("cyclic copy did not preserve its cycle independently")
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user