func TestNode_Label(t *testing.T) {
n := node.NewNode()
n.Parent = node.NewNode()
n.Key = ""
n.Value = ""
n.Index = -1
assert.Equal(t, "(?)", n.Label(context.Background()))
n.Index = 1
assert.Equal(t, "1", n.Label(context.Background()))
n.Value = &lab{}
assert.Equal(t, "b", n.Label(context.Background()))
n.Key = "a"
assert.Equal(t, "a", n.Label(context.Background()))
n.Value = &system.Object{Id: system.NewReference("a.b/c", "d")}
n.Parent = nil
assert.Equal(t, "d", n.Label(context.Background()))
n.Value = nil
assert.Equal(t, "root", n.Label(context.Background()))
n = nil
assert.Equal(t, "(nil)", n.Label(context.Background()))
}
func TestNode_InitialiseMapChild(t *testing.T) {
cb, n := data.Setup(t)
test := func(t *testing.T, n *node.Node, m *data.Multi) {
c := node.NewNode()
require.NoError(t, c.InitialiseMapItem(cb.Ctx(), n.Map["mjs"], "c"))
require.NoError(t, c.AddToMap(cb.Ctx(), n.Map["mjs"], "c", true))
assert.Equal(t, 3, len(n.Map["mjs"].Map))
assert.True(t, n.Map["mjs"].Map["c"].Null)
assert.False(t, n.Map["mjs"].Map["c"].Missing)
assert.Equal(t, c, n.Map["mjs"].Map["c"])
assert.Equal(t, "", m.Mjs["c"])
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))
assert.Equal(t, 3, len(n.Map["mss"].Map))
assert.Nil(t, m.Mss["c"])
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))
assert.Equal(t, 3, len(m.Mm))
assert.Nil(t, m.Mm["c"])
}
data.Run(t, n, n.Value.(*data.Multi), test)
}
func TestNode_Path(t *testing.T) {
r := node.NewNode()
a := node.NewNode()
b := node.NewNode()
a.Key = "a"
b.Key = "b"
a.Parent = r
b.Parent = a
assert.Equal(t, "root/a/b", b.Path())
}
func TestNode_Root(t *testing.T) {
r := node.NewNode()
a := node.NewNode()
b := node.NewNode()
a.Parent = r
b.Parent = a
assert.Equal(t, r, a.Root())
assert.Equal(t, r, b.Root())
n := (*node.Node)(nil)
assert.Nil(t, n.Root())
}
func TestDeleteMutation1(t *testing.T) {
cb, n := data.Setup(t)
test := func(t *testing.T, n *node.Node, m *data.Multi) {
var b, d, p *node.Node
b = node.NewNode()
d = n.Map["am"].Array[0]
p = n.Map["am"]
assert.Equal(t, "amjs0", n.Map["am"].Array[0].Map["js"].ValueString)
assert.Equal(t, "amjs1", n.Map["am"].Array[1].Map["js"].ValueString)
assert.Equal(t, "amjs0", m.Am[0].Js)
assert.Equal(t, "amjs1", m.Am[1].Js)
require.NoError(t, mutateDeleteNode(cb.Ctx(), d, p, b))
assert.Equal(t, 1, len(n.Map["am"].Array))
assert.Equal(t, 1, len(m.Am))
assert.Equal(t, "amjs1", n.Map["am"].Array[0].Map["js"].ValueString)
assert.Equal(t, "amjs1", m.Am[0].Js)
require.NoError(t, mutateRestoreNode(cb.Ctx(), d, p, b))
assert.Equal(t, 2, len(n.Map["am"].Array))
assert.Equal(t, 2, len(m.Am))
assert.Equal(t, "amjs0", n.Map["am"].Array[0].Map["js"].ValueString)
assert.Equal(t, "amjs1", n.Map["am"].Array[1].Map["js"].ValueString)
assert.Equal(t, "amjs0", m.Am[0].Js)
assert.Equal(t, "amjs1", m.Am[1].Js)
}
test(t, n.Map["m"], n.Value.(*data.Multi).M)
}
func TestNode_Unpack5(t *testing.T) {
cb := tests.Context("kego.io/tests/data").Jauto().Sauto(parser.Parse)
s := `{
"type": "multi",
"sri": {"type":"system:string", "value": "b"},
"nri": {"type":"system:number", "value": 2},
"bri": {"type":"system:bool", "value": true},
"aljbi": {"type":"aljb", "value": true},
"aljni": {"type":"aljn", "value": 3.0},
"aljsi": {"type":"aljs", "value": "aljs2"}
}`
n := node.NewNode()
err := n.Unpack(cb.Ctx(), system.MustPackString(s), false)
require.NoError(t, err)
assert.Equal(t, "b", n.Value.(*data.Multi).Sri.GetString(cb.Ctx()).Value())
assert.Equal(t, 2.0, n.Value.(*data.Multi).Nri.GetNumber(cb.Ctx()).Value())
assert.Equal(t, true, n.Value.(*data.Multi).Bri.GetBool(cb.Ctx()).Value())
assert.Equal(t, data.Aljb(true), *n.Value.(*data.Multi).Aljbi.GetAljb(cb.Ctx()))
assert.Equal(t, data.Aljn(3.0), *n.Value.(*data.Multi).Aljni.GetAljn(cb.Ctx()))
assert.Equal(t, data.Aljs("aljs2"), *n.Value.(*data.Multi).Aljsi.GetAljs(cb.Ctx()))
}
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 TestNode_InitialiseArrayChild(t *testing.T) {
cb, n := data.Setup(t)
test := func(t *testing.T, n *node.Node, m *data.Multi) {
c := node.NewNode()
require.NoError(t, c.InitialiseArrayItem(cb.Ctx(), n.Map["ajs"], 4))
require.NoError(t, c.AddToArray(cb.Ctx(), n.Map["ajs"], 4, true))
assert.Equal(t, 5, len(n.Map["ajs"].Array))
assert.True(t, n.Map["ajs"].Array[4].Null)
assert.False(t, n.Map["ajs"].Array[4].Missing)
assert.Equal(t, c, n.Map["ajs"].Array[4])
assert.Equal(t, []string{"ajs0", "ajs1", "ajs2", "ajs3", ""}, m.Ajs)
c1 := node.NewNode()
require.NoError(t, c1.InitialiseArrayItem(cb.Ctx(), n.Map["ass"], 4))
require.NoError(t, c1.AddToArray(cb.Ctx(), n.Map["ass"], 4, true))
assert.Equal(t, 5, len(m.Ass))
assert.Nil(t, m.Ass[4])
c2 := node.NewNode()
require.NoError(t, c2.InitialiseArrayItem(cb.Ctx(), n.Map["ajs"], 0))
require.NoError(t, c2.AddToArray(cb.Ctx(), n.Map["ajs"], 0, true))
assert.Equal(t, 6, len(n.Map["ajs"].Array))
assert.Equal(t, []string{"", "ajs0", "ajs1", "ajs2", "ajs3", ""}, m.Ajs)
c3 := node.NewNode()
require.NoError(t, c3.InitialiseArrayItem(cb.Ctx(), n.Map["ass"], 0))
require.NoError(t, c3.AddToArray(cb.Ctx(), n.Map["ass"], 0, true))
assert.Equal(t, 6, len(m.Ass))
assert.Nil(t, m.Ass[0])
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))
assert.Equal(t, 3, len(m.Am))
assert.Nil(t, m.Am[2])
}
data.Run(t, n, n.Value.(*data.Multi), test)
}
func Empty(t *testing.T) (*tests.ContextBuilder, *node.Node) {
cb := tests.Context("kego.io/tests/data").Jauto().Sauto(parser.Parse)
s := `{
"type": "multi",
"m": { "type": "multi" },
"am": [ { "type": "multi" }, { "type": "multi" } ],
"mm": { "a": { "type": "multi" }, "b": { "type": "multi" } }
}`
n := node.NewNode()
require.NoError(t, n.Unpack(cb.Ctx(), system.MustPackString(s), false))
return cb, n
}
func TestNode_InitialiseArrayChild2(t *testing.T) {
cb, n := data.Setup(t)
c := node.NewNode()
require.NoError(t, c.InitialiseArrayItem(cb.Ctx(), n.Map["ajs"], 5))
err := c.AddToArray(cb.Ctx(), n.Map["ajs"], 5, true)
assert.IsError(t, err, "GHJIDXABLL")
// kludge the Val to be empty
n.Map["ajs"].Val.Set(reflect.ValueOf([]string{}))
require.NoError(t, c.InitialiseArrayItem(cb.Ctx(), n.Map["ajs"], 1))
err = c.AddToArray(cb.Ctx(), n.Map["ajs"], 1, true)
assert.IsError(t, err, "YFKMXFUPHY")
}
func TestNode_Unpack3(t *testing.T) {
cb := tests.Context("kego.io/tests/data").Jauto().Sauto(parser.Parse)
s := `{
"type": "multi",
"a": "b"
}`
n := node.NewNode()
err := n.Unpack(cb.Ctx(), system.MustPackString(s), false)
assert.HasError(t, err, "SRANLETJRS")
}
func TestAddMutation2(t *testing.T) {
cb, n := data.Setup(t)
test := func(t *testing.T, n *node.Node, m *data.Multi) {
var a, p, b *node.Node
a = node.NewNode()
p = n.Map["am"]
b = node.NewNode()
require.NoError(t, mutateAddNode(cb.Ctx(), a, p, "", 0, nil, ""))
assert.Equal(t, 3, len(n.Map["am"].Array))
assert.Equal(t, 3, len(n.Map["am"].Value.([]*data.Multi)))
assert.Equal(t, 3, len(m.Am))
assert.Equal(t, "", m.Am[0].Js)
assert.Equal(t, "amjs0", m.Am[1].Js)
assert.Equal(t, "amjs1", m.Am[2].Js)
require.NoError(t, mutateDeleteNode(cb.Ctx(), a, p, b))
assert.Equal(t, 2, len(n.Map["am"].Array))
assert.Equal(t, 2, len(n.Map["am"].Value.([]*data.Multi)))
assert.Equal(t, 2, len(m.Am))
assert.Equal(t, "amjs0", m.Am[0].Js)
assert.Equal(t, "amjs1", m.Am[1].Js)
}
test(t, n.Map["m"], n.Value.(*data.Multi).M)
}
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 TestNode_Unpack(t *testing.T) {
cb := tests.Context("kego.io/tests/data").Jauto().Sauto(parser.Parse)
s := `{
"type": "multi",
"js": "a"
}`
n := node.NewNode()
require.NoError(t, n.Unpack(cb.Ctx(), system.MustPackString(s), false))
m, ok := n.Value.(*data.Multi)
require.True(t, ok)
assert.Equal(t, "a", m.Js)
}
func TestAddMutation(t *testing.T) {
cb, n := data.Setup(t)
test := func(t *testing.T, n *node.Node, m *data.Multi) {
var a, p, b *node.Node
a = node.NewNode()
p = n.Map["ajs"]
b = node.NewNode()
require.NoError(t, mutateAddNode(cb.Ctx(), a, p, "", 0, nil, ""))
assert.Equal(t, 5, len(n.Map["ajs"].Array))
assert.Equal(t, 5, len(m.Ajs))
require.NoError(t, mutateDeleteNode(cb.Ctx(), a, p, b))
assert.Equal(t, 4, len(n.Map["ajs"].Array))
assert.Equal(t, 4, len(m.Ajs))
a = node.NewNode()
p = n.Map["ass"]
b = node.NewNode()
require.NoError(t, mutateAddNode(cb.Ctx(), a, p, "", 0, nil, ""))
assert.Equal(t, 5, len(n.Map["ass"].Array))
assert.Equal(t, 5, len(m.Ass))
require.NoError(t, mutateDeleteNode(cb.Ctx(), a, p, b))
assert.Equal(t, 4, len(n.Map["ass"].Array))
assert.Equal(t, 4, len(m.Ass))
a = node.NewNode()
p = n.Map["am"]
b = node.NewNode()
require.NoError(t, mutateAddNode(cb.Ctx(), a, p, "", 0, nil, ""))
assert.Equal(t, 3, len(n.Map["am"].Array))
assert.Equal(t, 3, len(n.Map["am"].Value.([]*data.Multi)))
assert.Equal(t, 3, len(m.Am))
require.NoError(t, mutateDeleteNode(cb.Ctx(), a, p, b))
assert.Equal(t, 2, len(n.Map["am"].Array))
assert.Equal(t, 2, len(n.Map["am"].Value.([]*data.Multi)))
assert.Equal(t, 2, len(m.Am))
}
data.Run(t, n, n.Value.(*data.Multi), test)
}
func newNonEmptyNode() *node.Node {
n := node.NewNode()
n.Parent = node.NewNode()
n.Array = []*node.Node{node.NewNode(), node.NewNode()}
n.Map = map[string]*node.Node{"a": node.NewNode(), "b": node.NewNode()}
n.Key = "a"
n.Index = 1
n.Origin = system.NewReference("a", "b")
n.ValueString = "a"
n.ValueNumber = 2.0
n.ValueBool = true
n.Value = "a"
n.Val = reflect.ValueOf("a")
n.Null = false
n.Missing = false
n.Rule = &system.RuleWrapper{}
n.Type = &system.Type{}
n.JsonType = system.J_OBJECT
return n
}
func Setup(t *testing.T) (*tests.ContextBuilder, *node.Node) {
simple := false
if !simple {
cb := tests.Context("kego.io/tests/data").Jauto().Sauto(parser.Parse)
m := `"type": "multi",
"js": "js1",
"ss": "ss1",
"sr": "sr1",
"jn": 1.1,
"sn": 1.2,
"jb": true,
"sb": false,
"alajs": ["alajs0", "alajs1", "alajs2"],
"alas": [{"type": "simple", "js": "alas0"}, {"type": "simple", "js": "alas1"}],
"alass": ["alass0", "alass1", "alass2"],
"aljb": true,
"aljn": 2.0,
"aljs": "aljs",
"almjs": {"a": "almjsa", "b": "almjsb"},
"alms": {"a": {"type": "simple", "js": "almsa"}, "b": {"type": "simple", "js": "almsb"}},
"almss": {"a": "almssa", "b": "almssb"},
"alss": "alss",
"als": {"type": "als", "js": "als"},
"i": { "type": "facea", "a": "ia" },
"ajs": [ "ajs0", "ajs1", "ajs2", "ajs3" ],
"ass": [ "ass0", "ass1", "ass2", "ass3" ],
"ajn": [ 2.1, 2.2, 2.3, 2.4 ],
"asn": [ 3.1, 3.2, 3.3, 3.4 ],
"ajb": [ true, false, false, false ],
"asb": [ false, true, false, false ],
"mjs": { "a": "mjsa", "b": "mjsb" },
"mss": { "a": "mssa", "b": "mssb" },
"mjn": { "a": 4.1, "b": 4.2 },
"msn": { "a": 5.1, "b": 5.2 },
"mjb": { "a": true, "b": false },
"msb": { "a": false, "b": true },
"anri": [ "anri0", { "type": "facea", "a": "anri1" }, { "type": "multi", "ss": "anri2" } ],
"mnri": { "a": "mnria", "b": { "type": "facea", "a": "mnrib" }, "c": { "type": "multi", "ss": "mnric" } }
`
mm := m + `,
"m": { "type": "multi" },
"am": [ { "type": "multi", "js": "amjs0" }, { "type": "multi", "js": "amjs1" } ],
"mm": { "a": { "type": "multi", "js": "mmjsa" }, "b": { "type": "multi", "js": "mmjsb" } }`
s := `{
` + m + `,
"m": {` + mm + `},
"am": [ {` + mm + `}, {` + mm + `} ],
"mm": { "a": {` + mm + `}, "b": {` + mm + `} }
}`
n := node.NewNode()
require.NoError(t, n.Unpack(cb.Ctx(), system.MustPackString(s), false))
return cb, n
} else {
cb := tests.Context("kego.io/tests/data").Jauto().Sauto(parser.Parse)
m := `"type": "multi",
"alms": {"a": {"type": "simple", "js": "almsa"}, "b": {"type": "simple", "js": "almsb"}}
`
mm := m + `,
"m": { "type": "multi" },
"am": [ { "type": "multi", "js": "amjs0" }, { "type": "multi", "js": "amjs1" } ],
"mm": { "a": { "type": "multi", "js": "mmjsa" }, "b": { "type": "multi", "js": "mmjsb" } }`
s := `{
` + m + `,
"m": {` + mm + `},
"am": [ {` + mm + `}, {` + mm + `} ],
"mm": { "a": {` + mm + `}, "b": {` + mm + `} }
}`
n := node.NewNode()
require.NoError(t, n.Unpack(cb.Ctx(), system.MustPackString(s), false))
return cb, n
}
}
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 (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 TestDeleteMutation(t *testing.T) {
cb, n := data.Setup(t)
test := func(t *testing.T, n *node.Node, m *data.Multi) {
var b, d, p *node.Node
b = node.NewNode()
d = n.Map["jb"]
p = n
require.NoError(t, mutateDeleteNode(cb.Ctx(), d, p, b))
assert.False(t, n.Map["jb"].ValueBool)
assert.False(t, m.Jb)
require.NoError(t, mutateRestoreNode(cb.Ctx(), d, p, b))
assert.True(t, n.Map["jb"].ValueBool)
assert.True(t, m.Jb)
b = node.NewNode()
d = n.Map["ss"]
p = n
require.NoError(t, mutateDeleteNode(cb.Ctx(), d, p, b))
assert.True(t, n.Map["ss"].Missing)
assert.Equal(t, "", n.Map["ss"].ValueString)
assert.Nil(t, m.Ss)
require.NoError(t, mutateRestoreNode(cb.Ctx(), d, p, b))
assert.False(t, n.Map["ss"].Missing)
assert.Equal(t, "ss1", n.Map["ss"].ValueString)
require.NotNil(t, m.Ss)
assert.Equal(t, "ss1", m.Ss.Value())
b = node.NewNode()
d = n.Map["i"]
p = n
require.NoError(t, mutateDeleteNode(cb.Ctx(), d, p, b))
assert.True(t, n.Map["i"].Missing)
assert.Nil(t, m.I)
require.NoError(t, mutateRestoreNode(cb.Ctx(), d, p, b))
assert.False(t, n.Map["i"].Missing)
assert.Equal(t, "ia", n.Map["i"].Value.(*data.Facea).A.Value())
require.NotNil(t, m.I)
assert.Equal(t, "ia", m.I.Face())
b = node.NewNode()
d = n.Map["ass"]
p = n
require.NoError(t, mutateDeleteNode(cb.Ctx(), d, p, b))
assert.True(t, n.Map["ass"].Missing)
assert.Equal(t, 0, len(m.Ass))
require.NoError(t, mutateRestoreNode(cb.Ctx(), d, p, b))
assert.False(t, n.Map["ass"].Missing)
assert.Equal(t, 4, len(m.Ass))
b = node.NewNode()
d = n.Map["mss"]
p = n
require.NoError(t, mutateDeleteNode(cb.Ctx(), d, p, b))
assert.True(t, n.Map["mss"].Missing)
assert.Nil(t, m.Mss)
require.NoError(t, mutateRestoreNode(cb.Ctx(), d, p, b))
assert.False(t, n.Map["mss"].Missing)
require.NotNil(t, m.Mss)
assert.Equal(t, 2, len(m.Mss))
require.NotNil(t, m.Mss["a"])
assert.Equal(t, "mssa", m.Mss["a"].Value())
b = node.NewNode()
d = n.Map["ass"].Array[0]
p = n.Map["ass"]
require.NoError(t, mutateDeleteNode(cb.Ctx(), d, p, b))
assert.Equal(t, 3, len(n.Map["ass"].Array))
assert.Equal(t, 3, len(m.Ass))
require.NoError(t, mutateRestoreNode(cb.Ctx(), d, p, b))
assert.Equal(t, 4, len(n.Map["ass"].Array))
assert.Equal(t, 4, len(m.Ass))
assert.Equal(t, "ass0", n.Map["ass"].Array[0].ValueString)
require.NotNil(t, m.Ass[0])
assert.Equal(t, "ass0", m.Ass[0].Value())
}
data.Run(t, n, n.Value.(*data.Multi), test)
}
func (s *NodeStore) Handle(payload *flux.Payload) bool {
switch action := payload.Action.(type) {
case *actions.ToggleSystemControls:
m := s.Get(action.Node)
m.ShowSystemControls = !m.ShowSystemControls
payload.Notify(action.Node, NodeSystemControls)
case *actions.Add:
payload.Wait(s.app.Actions)
switch action.Direction() {
case actions.New:
if err := mutateAddNode(s.ctx, action.Node, action.Parent, action.Key, action.Index, action.Type, action.BranchName); err != nil {
s.app.Fail <- kerr.Wrap("HUOGBUQCAO", err)
break
}
payload.Notify(action.Node, NodeInitialised)
if action.Parent != nil {
payload.Notify(action.Parent, NodeChildAdded)
}
payload.Notify(action.Node, NodeFocus)
case actions.Undo:
action.Backup = node.NewNode()
if err := mutateDeleteNode(s.ctx, action.Node, action.Parent, action.Backup); err != nil {
s.app.Fail <- kerr.Wrap("RTAGMUIKMD", err)
break
}
payload.Notify(action.Node, NodeDeleted)
if action.Parent != nil {
payload.Notify(action.Parent, NodeChildDeleted)
}
case actions.Redo:
if err := mutateRestoreNode(s.ctx, action.Node, action.Parent, action.Backup); err != nil {
s.app.Fail <- kerr.Wrap("MHUTMXOGBP", err)
break
}
payload.Notify(action.Node, NodeInitialised)
payload.Notify(action.Parent, NodeChildAdded)
payload.Notify(action.Node, NodeFocus)
}
if action.Parent != nil {
model := s.app.Nodes.Get(action.Parent)
changed, err := model.Validate(s.ctx, s.app.Rule.Get(action.Parent.Root(), action.Parent))
if err != nil {
s.app.Fail <- kerr.Wrap("AKIUPRWGLV", err)
break
}
if changed {
payload.Notify(action.Parent, NodeErrorsChanged)
}
}
c := action.Parent
for c != nil {
payload.Notify(c, NodeDescendantChanged)
c = c.Parent
}
case *actions.Delete:
payload.Wait(s.app.Actions)
switch action.Direction() {
case actions.New, actions.Redo:
action.Backup = node.NewNode()
if err := mutateDeleteNode(s.ctx, action.Node, action.Parent, action.Backup); err != nil {
s.app.Fail <- kerr.Wrap("DFHTKJRLQC", err)
break
}
payload.Notify(action.Node, NodeDeleted)
payload.Notify(action.Parent, NodeChildDeleted)
case actions.Undo:
if err := mutateRestoreNode(s.ctx, action.Node, action.Parent, action.Backup); err != nil {
s.app.Fail <- kerr.Wrap("HAPWUOPBTW", err)
break
}
payload.Notify(action.Node, NodeInitialised)
payload.Notify(action.Parent, NodeChildAdded)
payload.Notify(action.Node, NodeFocus)
}
if action.Parent != nil {
model := s.app.Nodes.Get(action.Parent)
changed, err := model.Validate(s.ctx, s.app.Rule.Get(action.Parent.Root(), action.Parent))
if err != nil {
s.app.Fail <- kerr.Wrap("IOFCSITVXB", err)
break
}
if changed {
payload.Notify(action.Parent, NodeErrorsChanged)
}
}
c := action.Parent
for c != nil {
payload.Notify(c, NodeDescendantChanged)
c = c.Parent
}
case *actions.Reorder:
payload.Wait(s.app.Actions)
if !action.Model.Node.Type.IsNativeArray() {
s.app.Fail <- kerr.New("EPBQVIICFM", "Must be array")
break
}
from := action.Before
to := action.After
if action.Direction() == actions.Undo {
from = action.After
to = action.Before
}
if err := action.Model.Node.ReorderArrayChild(from, to); err != nil {
s.app.Fail <- kerr.Wrap("HMIFPKVJCN", err)
break
}
payload.Notify(action.Model.Node, NodeArrayReorder)
c := action.Model.Node.Parent
for c != nil {
payload.Notify(c, NodeDescendantChanged)
c = c.Parent
}
case *actions.Modify:
payload.Wait(s.app.Actions)
n := action.Editor.Node
val := action.After
if action.Direction() == actions.Undo {
val = action.Before
}
if err := n.SetValue(s.ctx, val); err != nil {
s.app.Fail <- kerr.Wrap("VIMXVIHPFY", err)
break
}
model := s.app.Nodes.Get(n)
changed, err := model.Validate(s.ctx, s.app.Rule.Get(n.Root(), n))
if err != nil {
s.app.Fail <- kerr.Wrap("EEIYMGQCCA", err)
break
}
if changed {
payload.Notify(n, NodeErrorsChanged)
}
payload.Notify(n, NodeValueChanged)
c := n.Parent
for c != nil {
payload.Notify(c, NodeDescendantChanged)
c = c.Parent
}
case *actions.EditorFocus:
payload.Notify(action.Editor.Node, NodeFocus)
case *actions.InitialState:
payload.Wait(s.app.Package, s.app.Types)
n := s.app.Package.Node()
if err := n.RecomputeHash(s.ctx, true); err != nil {
s.app.Fail <- kerr.Wrap("NDMDVGISWR", err)
}
for _, ti := range s.app.Types.All() {
if err := ti.Node.RecomputeHash(s.ctx, true); err != nil {
s.app.Fail <- kerr.Wrap("YLRDBXIYJH", err)
}
}
case *actions.LoadFileSuccess:
nci, ok := action.Branch.Contents.(models.NodeContentsInterface)
if !ok {
break
}
if err := nci.GetNode().RecomputeHash(s.ctx, true); err != nil {
s.app.Fail <- kerr.Wrap("BWUPWAFALG", err)
}
}
if m, ok := payload.Action.(actions.Mutator); ok {
n := m.CommonAncestor()
c := n
for c != nil {
// For the actual node, we recompute the whole hash. For ancestors,
// we recompute the hash without recomputing child nodes.
recomputeChildren := c == n
if err := c.RecomputeHash(s.ctx, recomputeChildren); err != nil {
s.app.Fail <- kerr.Wrap("SWHIXHLHXM", err)
}
c = c.Parent
}
}
return true
}