func TestNode_SetValueZero2(t *testing.T) {
cb, n := data.Empty(t)
test := func(t *testing.T, n *node.Node, m *data.Multi) {
sstring, ok := system.GetTypeFromCache(cb.Ctx(), "kego.io/system", "string")
assert.True(t, ok)
snumber, ok := system.GetTypeFromCache(cb.Ctx(), "kego.io/system", "number")
assert.True(t, ok)
require.NoError(t, n.Map["ss"].SetValueZero(cb.Ctx(), true, sstring))
assert.Nil(t, m.Ss)
require.NoError(t, n.Map["sn"].SetValueZero(cb.Ctx(), false, snumber))
assert.NotNil(t, m.Sn)
require.NoError(t, n.Map["mnri"].SetValueZero(cb.Ctx(), true, nil))
assert.Nil(t, m.Mnri)
require.NoError(t, n.Map["mi"].SetValueZero(cb.Ctx(), false, nil))
assert.NotNil(t, m.Mi)
assert.Equal(t, 0, len(m.Mi))
require.NoError(t, n.Map["anri"].SetValueZero(cb.Ctx(), true, nil))
assert.Nil(t, m.Anri)
require.NoError(t, n.Map["ai"].SetValueZero(cb.Ctx(), false, nil))
assert.NotNil(t, m.Ai)
assert.Equal(t, 0, len(m.Ai))
}
data.Run(t, n, n.Value.(*data.Multi), test)
}
func extractFields(ctx context.Context, fields map[string]*system.Field, t *system.Type) error {
for t.Alias != nil {
t = system.WrapRule(ctx, t.Alias).Parent
}
if !t.Basic && !t.Interface {
// All types apart from Basic types embed system:object
ob, ok := system.GetTypeFromCache(ctx, "kego.io/system", "object")
if !ok {
return kerr.New("YRFWOTIGFT", "Type system:object not found in sys ctx")
}
if err := extractFields(ctx, fields, ob); err != nil {
return kerr.Wrap("DTQEFALIMM", err)
}
}
for _, embedRef := range t.Embed {
embed, ok := system.GetTypeFromCache(ctx, embedRef.Package, embedRef.Name)
if !ok {
return kerr.New("SLIRILCARQ", "Type %s not found in sys ctx", embedRef)
}
if err := extractFields(ctx, fields, embed); err != nil {
return kerr.Wrap("JWAPCVIYBJ", err)
}
}
for name, rule := range t.Fields {
if _, ok := fields[name]; ok {
return kerr.New("BARXPFXQNB", "Duplicate field %s", name)
}
fields[name] = &system.Field{Name: name, Rule: rule, Origin: t.Id}
}
return nil
}
func TestNode_SetValueZero3(t *testing.T) {
cb, n := data.Empty(t)
f, ok := system.GetTypeFromCache(cb.Ctx(), "kego.io/tests/data", "face")
assert.True(t, ok)
err := n.SetValueZero(cb.Ctx(), true, f)
assert.HasError(t, err, "VHOSYBMDQL")
}
func TestAddMutationRoot(t *testing.T) {
cb, _ := data.Setup(t)
a := node.NewNode()
ty, ok := system.GetTypeFromCache(cb.Ctx(), "kego.io/tests/data", "multi")
require.True(t, ok)
require.NoError(t, mutateAddNode(cb.Ctx(), a, nil, "", 2, ty, "z"))
require.NotNil(t, a.Value.(*data.Multi).Id)
require.Equal(t, "z", a.Value.(*data.Multi).Id.Name)
}
func TestAddMutationRedo(t *testing.T) {
cb, n := data.Setup(t)
test := func(t *testing.T, n *node.Node, m *data.Multi) {
var a, p, b, a1, p1, b1 *node.Node
a = node.NewNode()
p = n.Map["am"]
b = node.NewNode()
ty, ok := system.GetTypeFromCache(cb.Ctx(), "kego.io/tests/data", "multi")
require.True(t, ok)
require.NoError(t, mutateAddNode(cb.Ctx(), a, p, "", 2, ty, ""))
require.Equal(t, `[{"js":"amjs0","type":"multi"},{"js":"amjs1","type":"multi"},{"type":"multi"}]`, p.Print(cb.Ctx()))
a1 = n.Map["am"].Array[2].Map["m"]
p1 = n.Map["am"].Array[2]
b1 = node.NewNode()
require.NoError(t, mutateAddNode(cb.Ctx(), a1, p1, "m", -1, ty, ""))
require.Equal(t, 3, len(n.Map["am"].Array))
require.Equal(t, 3, len(m.Am))
require.False(t, n.Map["am"].Array[2].Map["m"].Missing)
require.Equal(t, `[{"js":"amjs0","type":"multi"},{"js":"amjs1","type":"multi"},{"m":{"type":"multi"},"type":"multi"}]`, p.Print(cb.Ctx()))
require.NoError(t, mutateDeleteNode(cb.Ctx(), a, p, b))
require.NoError(t, mutateDeleteNode(cb.Ctx(), a1, p1, b1))
require.Equal(t, 2, len(n.Map["am"].Array))
require.Equal(t, 2, len(m.Am))
require.NoError(t, mutateRestoreNode(cb.Ctx(), a, p, b))
require.NoError(t, mutateRestoreNode(cb.Ctx(), a1, p1, b1))
require.Equal(t, 3, len(n.Map["am"].Array))
require.Equal(t, 3, len(m.Am))
require.NotNil(t, n.Map["am"].Array[2])
require.NotNil(t, m.Am[2])
}
test(t, n.Map["m"], n.Value.(*data.Multi).M)
}
func (v *AddPopupView) save() {
var t *system.Type
if len(v.model.Types) == 1 {
t = v.model.Types[0]
} else {
options := v.typeSelect.Node.Get("options")
selectedIndex := v.typeSelect.Node.Get("selectedIndex").Int()
value := options.Index(selectedIndex).Get("id").String()
if value == "" {
return
}
r, err := system.NewReferenceFromString(v.Ctx, value)
if err != nil {
v.App.Fail <- kerr.Wrap("SEMCIELKRN", err)
return
}
ty, ok := system.GetTypeFromCache(v.Ctx, r.Package, r.Name)
if !ok {
v.App.Fail <- kerr.New("RWHSCOFNQM", "Type %s not found in cache", r.Value())
return
}
t = ty
}
switch {
case v.model.IsMap():
key := v.nameInput.Node.Get("value").String()
if key == "" {
// TODO: show an error
return
}
if _, duplicate := v.model.Parent.Map[key]; duplicate {
// TODO: show an error
return
}
v.App.Dispatch(&actions.Add{
Undoer: &actions.Undoer{},
Node: node.NewNode(),
Parent: v.model.Parent,
Key: key,
Type: t,
})
case v.model.IsArray():
v.App.Dispatch(&actions.Add{
Undoer: &actions.Undoer{},
Node: node.NewNode(),
Parent: v.model.Parent,
Index: len(v.model.Parent.Array),
Type: t,
})
case v.model.IsField():
v.App.Dispatch(&actions.Add{
Undoer: &actions.Undoer{},
Parent: v.model.Parent,
Node: v.model.Node,
Key: v.model.Node.Key,
Type: t,
})
case v.model.IsFile():
name := v.nameInput.Node.Get("value").String()
if name == "" {
// TODO: show an error
return
}
// TODO: show an error if a duplicate file exists
v.App.Dispatch(&actions.Add{
Undoer: &actions.Undoer{},
Node: node.NewNode(),
Type: t,
BranchName: name,
BranchFile: name + ".json", // TODO: choose filename based on package
})
}
v.App.Dispatch(&actions.CloseAddPopup{})
}
func TestNode_SetValueZero(t *testing.T) {
cb, n := data.Setup(t)
test := func(t *testing.T, n *node.Node, m *data.Multi) {
sstring, ok := system.GetTypeFromCache(cb.Ctx(), "kego.io/system", "string")
assert.True(t, ok)
facea, ok := system.GetTypeFromCache(cb.Ctx(), "kego.io/tests/data", "facea")
assert.True(t, ok)
faceb, ok := system.GetTypeFromCache(cb.Ctx(), "kego.io/tests/data", "faceb")
assert.True(t, ok)
c1 := node.NewNode()
require.NoError(t, c1.InitialiseMapItem(cb.Ctx(), n.Map["mss"], "c"))
require.NoError(t, c1.AddToMap(cb.Ctx(), n.Map["mss"], "c", true))
require.NoError(t, c1.SetValueZero(cb.Ctx(), true, nil))
assert.False(t, n.Map["mss"].Map["c"].Missing)
assert.True(t, n.Map["mss"].Map["c"].Null)
assert.Nil(t, m.Mss["c"])
c1a := node.NewNode()
require.NoError(t, c1a.InitialiseMapItem(cb.Ctx(), n.Map["mss"], "d"))
require.NoError(t, c1a.AddToMap(cb.Ctx(), n.Map["mss"], "d", true))
require.NoError(t, c1a.SetValueZero(cb.Ctx(), false, nil))
assert.False(t, n.Map["mss"].Map["d"].Missing)
assert.False(t, n.Map["mss"].Map["d"].Null)
assert.NotNil(t, m.Mss["d"])
assert.Equal(t, "", m.Mss["d"].Value())
c2 := node.NewNode()
require.NoError(t, c2.InitialiseMapItem(cb.Ctx(), n.Map["mm"], "c"))
require.NoError(t, c2.AddToMap(cb.Ctx(), n.Map["mm"], "c", true))
require.NoError(t, c2.SetValueZero(cb.Ctx(), true, nil))
assert.Nil(t, m.Mm["c"])
c2a := node.NewNode()
require.NoError(t, c2a.InitialiseMapItem(cb.Ctx(), n.Map["mm"], "d"))
require.NoError(t, c2a.AddToMap(cb.Ctx(), n.Map["mm"], "d", true))
require.NoError(t, c2a.SetValueZero(cb.Ctx(), false, nil))
assert.NotNil(t, m.Mm["d"])
assert.Equal(t, "", m.Mm["d"].Js)
require.NoError(t, n.Map["i"].SetValueZero(cb.Ctx(), true, faceb))
assert.Nil(t, m.I)
assert.IsType(t, &data.Faceb{}, m.I)
require.NoError(t, n.Map["sri"].SetValueZero(cb.Ctx(), false, facea))
assert.NotNil(t, m.Sri)
assert.IsType(t, &data.Facea{}, m.Sri)
c3 := node.NewNode()
require.NoError(t, c3.InitialiseArrayItem(cb.Ctx(), n.Map["ass"], 4))
require.NoError(t, c3.AddToArray(cb.Ctx(), n.Map["ass"], 4, true))
require.NoError(t, c3.SetValueZero(cb.Ctx(), true, nil))
assert.Nil(t, m.Ass[4])
c3a := node.NewNode()
require.NoError(t, c3a.InitialiseArrayItem(cb.Ctx(), n.Map["ass"], 5))
require.NoError(t, c3a.AddToArray(cb.Ctx(), n.Map["ass"], 5, true))
require.NoError(t, c3a.SetValueZero(cb.Ctx(), false, nil))
assert.NotNil(t, m.Ass[5])
c4 := node.NewNode()
require.NoError(t, c4.InitialiseArrayItem(cb.Ctx(), n.Map["am"], 2))
require.NoError(t, c4.AddToArray(cb.Ctx(), n.Map["am"], 2, true))
require.NoError(t, c4.SetValueZero(cb.Ctx(), true, nil))
assert.Nil(t, m.Am[2])
c4a := node.NewNode()
require.NoError(t, c4a.InitialiseArrayItem(cb.Ctx(), n.Map["am"], 3))
require.NoError(t, c4a.AddToArray(cb.Ctx(), n.Map["am"], 3, true))
require.NoError(t, c4a.SetValueZero(cb.Ctx(), false, nil))
assert.NotNil(t, m.Am[3])
c5 := node.NewNode()
require.NoError(t, c5.InitialiseArrayItem(cb.Ctx(), n.Map["anri"], 3))
require.NoError(t, c5.AddToArray(cb.Ctx(), n.Map["anri"], 3, true))
require.NoError(t, c5.SetValueZero(cb.Ctx(), true, sstring))
assert.Nil(t, m.Anri[3])
assert.IsType(t, system.NewString(""), m.Anri[3])
c5a := node.NewNode()
require.NoError(t, c5a.InitialiseArrayItem(cb.Ctx(), n.Map["anri"], 4))
require.NoError(t, c5a.AddToArray(cb.Ctx(), n.Map["anri"], 4, true))
require.NoError(t, c5a.SetValueZero(cb.Ctx(), false, sstring))
assert.NotNil(t, m.Anri[4])
assert.IsType(t, system.NewString(""), m.Anri[4])
c6 := node.NewNode()
require.NoError(t, c6.InitialiseArrayItem(cb.Ctx(), n.Map["anri"], 5))
require.NoError(t, c6.AddToArray(cb.Ctx(), n.Map["anri"], 5, true))
require.NoError(t, c6.SetValueZero(cb.Ctx(), true, facea))
assert.Nil(t, m.Anri[5])
assert.IsType(t, &data.Facea{}, m.Anri[5])
c6a := node.NewNode()
require.NoError(t, c6a.InitialiseArrayItem(cb.Ctx(), n.Map["anri"], 6))
require.NoError(t, c6a.AddToArray(cb.Ctx(), n.Map["anri"], 6, true))
require.NoError(t, c6a.SetValueZero(cb.Ctx(), false, facea))
assert.NotNil(t, m.Anri[6])
assert.IsType(t, &data.Facea{}, m.Anri[6])
c7 := node.NewNode()
require.NoError(t, c7.InitialiseMapItem(cb.Ctx(), n.Map["mnri"], "d"))
require.NoError(t, c7.AddToMap(cb.Ctx(), n.Map["mnri"], "d", true))
require.NoError(t, c7.SetValueZero(cb.Ctx(), true, sstring))
assert.Nil(t, m.Mnri["d"])
assert.IsType(t, system.NewString(""), m.Mnri["d"])
c7a := node.NewNode()
require.NoError(t, c7a.InitialiseMapItem(cb.Ctx(), n.Map["mnri"], "e"))
require.NoError(t, c7a.AddToMap(cb.Ctx(), n.Map["mnri"], "e", true))
require.NoError(t, c7a.SetValueZero(cb.Ctx(), false, sstring))
assert.NotNil(t, m.Mnri["e"])
assert.IsType(t, system.NewString(""), m.Mnri["e"])
c8 := node.NewNode()
require.NoError(t, c8.InitialiseMapItem(cb.Ctx(), n.Map["mnri"], "f"))
require.NoError(t, c8.AddToMap(cb.Ctx(), n.Map["mnri"], "f", true))
require.NoError(t, c8.SetValueZero(cb.Ctx(), true, facea))
assert.Nil(t, m.Mnri["f"])
assert.IsType(t, &data.Facea{}, m.Mnri["f"])
c8a := node.NewNode()
require.NoError(t, c8a.InitialiseMapItem(cb.Ctx(), n.Map["mnri"], "g"))
require.NoError(t, c8a.AddToMap(cb.Ctx(), n.Map["mnri"], "g", true))
require.NoError(t, c8a.SetValueZero(cb.Ctx(), false, facea))
assert.NotNil(t, m.Mnri["g"])
assert.IsType(t, &data.Facea{}, m.Mnri["g"])
}
data.Run(t, n, n.Value.(*data.Multi), test)
}
func printUnpacker(ctx context.Context, env *envctx.Env, g *builder.Builder, typ *system.Type) error {
name := system.GoName(typ.Id.Name)
fmtPkg := g.Imports.Add("fmt")
g.Println("func (v *", name, ") Unpack(ctx ", g.SprintRef("context", "Context"), ", in ", g.SprintRef("kego.io/system", "Packed"), ", iface bool) error {")
{
g.Println("if in == nil || in.Type() == ", g.SprintRef("kego.io/system", "J_NULL"), " {")
{
g.Println("return nil")
}
g.Println("}")
kind, _ := typ.Kind(ctx)
switch kind {
case system.KindStruct:
structType := typ
if typ.Alias != nil {
structType = system.WrapRule(ctx, typ.Alias).Parent
}
for _, embedRef := range structType.AllEmbeds() {
embedType, ok := system.GetTypeFromCache(ctx, embedRef.Package, embedRef.Name)
if !ok {
return kerr.New("IOEEVJCDPU", "Type %s not found", embedRef.String())
}
embedName := system.GoName(embedRef.Name)
embedTypeName := builder.Reference(embedType.Id.Package, system.GoName(embedType.Id.Name), env.Path, g.Imports.Add)
g.Println("if v.", embedName, " == nil {")
{
g.Println("v.", embedName, " = new(", embedTypeName, ")")
}
g.Println("}")
g.Println("if err := v.", embedName, ".Unpack(ctx, in, false); err != nil {")
{
g.Println("return err")
}
g.Println("}")
if embedRef.Package == "kego.io/system" && embedRef.Name == "object" {
g.Println("if err := v.Object.InitializeType(", strconv.Quote(typ.Id.Package), ", ", strconv.Quote(typ.Id.Name), "); err != nil {")
{
g.Println("return err")
}
g.Println("}")
}
}
for _, f := range structType.SortedFields() {
g.Println("if field, ok := in.Map()[", strconv.Quote(f.Name), "]; ok && field.Type() != ", g.SprintRef("kego.io/system", "J_NULL"), " {")
{
in := "field"
out := "ob0"
depth := 0
if err := printUnpackCode(ctx, env, g, in, out, depth, f.Rule); err != nil {
return kerr.Wrap("QLARKEBDBJ", err)
}
g.Println("v.", system.GoName(f.Name), " = ", out)
}
if dr, ok := f.Rule.(system.DefaultRule); ok && dr.GetDefault() != nil {
g.Println("} else {")
{
b, err := json.Marshal(dr.GetDefault())
if err != nil {
return kerr.Wrap("DLOUEHXVJF", err)
}
in := g.SprintFunctionCall("kego.io/system", "Pack", string(b))
out := "ob0"
depth := 0
if err := printUnpackCode(ctx, env, g, in, out, depth, f.Rule); err != nil {
return kerr.Wrap("UOWRFWSTNT", err)
}
g.Println("v.", system.GoName(f.Name), " = ", out)
}
g.Println("}")
} else {
g.Println("}")
}
}
case system.KindValue:
g.Println("if in.Type() == ", g.SprintRef("kego.io/system", "J_MAP"), " {")
{
g.Println("in = in.Map()[\"value\"]")
}
g.Println("}")
switch typ.NativeJsonType(ctx) {
case system.J_BOOL:
g.Println("if in.Type() != ", g.SprintRef("kego.io/system", "J_BOOL"), " {")
{
g.Println("return ", fmtPkg, `.Errorf("Invalid type %s while unpacking a bool.", in.Type())`)
}
g.Println("}")
g.Println("*v = ", name, "(in.Bool())")
case system.J_STRING:
g.Println("if in.Type() != ", g.SprintRef("kego.io/system", "J_STRING"), " {")
{
g.Println("return ", fmtPkg, `.Errorf("Invalid type %s while unpacking a string.", in.Type())`)
}
g.Println("}")
g.Println("*v = ", name, "(in.String())")
case system.J_NUMBER:
g.Println("if in.Type() != ", g.SprintRef("kego.io/system", "J_NUMBER"), " {")
{
g.Println("return ", fmtPkg, `.Errorf("Invalid type %s while unpacking a number.", in.Type())`)
}
g.Println("}")
g.Println("*v = ", name, "(in.Number())")
default:
panic(fmt.Sprintf("invalid type kind: %s, json native: %s", kind, typ.NativeJsonType(ctx)))
}
case system.KindArray:
g.Println("if in.Type() == ", g.SprintRef("kego.io/system", "J_MAP"), " {")
{
g.Println("in = in.Map()[\"value\"]")
}
g.Println("}")
g.Println("if in.Type() != ", g.SprintRef("kego.io/system", "J_ARRAY"), " {")
{
g.Println("return ", fmtPkg, `.Errorf("Invalid type %s while unpacking an array.", in.Type())`)
}
g.Println("}")
in := "in"
out := "ob0"
depth := 0
if err := printUnpackCode(ctx, env, g, in, out, depth, typ.Alias); err != nil {
return kerr.Wrap("VELYRXXGMC", err)
}
g.Println("*v = ", out)
case system.KindMap:
g.Println("if iface {")
{
g.Println("if in.Type() != ", g.SprintRef("kego.io/system", "J_MAP"), " {")
{
g.Println("return ", fmtPkg, `.Errorf("Invalid type %s while unpacking a map.", in.Type())`)
}
g.Println("}")
g.Println("in = in.Map()[\"value\"]")
}
g.Println("}")
g.Println("if in.Type() != ", g.SprintRef("kego.io/system", "J_MAP"), " {")
{
g.Println("return ", fmtPkg, `.Errorf("Invalid type %s while unpacking an array.", in.Type())`)
}
g.Println("}")
in := "in"
out := "ob0"
depth := 0
if err := printUnpackCode(ctx, env, g, in, out, depth, typ.Alias); err != nil {
return kerr.Wrap("TNEIUAFUNY", err)
}
g.Println("*v = ", out)
}
}
g.Println("return nil")
g.Println("}")
return nil
}
