diff --git a/type_specific.go b/type_specific.go new file mode 100644 index 0000000..aab211e --- /dev/null +++ b/type_specific.go @@ -0,0 +1,324 @@ +package objx + +/* + MSI (map[string]interface{} and []map[string]interface{}) +*/ + +// MSI gets the value as a map[string]interface{}, returns the optionalDefault +// value or a system default object if the value is the wrong type. +func (v *Value) MSI(optionalDefault ...map[string]interface{}) map[string]interface{} { + if s, ok := v.data.(map[string]interface{}); ok { + return s + } + if s, ok := v.data.(Map); ok { + return map[string]interface{}(s) + } + if len(optionalDefault) == 1 { + return optionalDefault[0] + } + return nil +} + +// MustMSI gets the value as a map[string]interface{}. +// +// Panics if the object is not a map[string]interface{}. +func (v *Value) MustMSI() map[string]interface{} { + if s, ok := v.data.(Map); ok { + return map[string]interface{}(s) + } + return v.data.(map[string]interface{}) +} + +// MSISlice gets the value as a []map[string]interface{}, returns the optionalDefault +// value or nil if the value is not a []map[string]interface{}. +func (v *Value) MSISlice(optionalDefault ...[]map[string]interface{}) []map[string]interface{} { + if s, ok := v.data.([]map[string]interface{}); ok { + return s + } + + s, ok := v.data.([]Map) + if !ok { + if len(optionalDefault) == 1 { + return optionalDefault[0] + } + return nil + } + + result := make([]map[string]interface{}, len(s)) + for i := range s { + result[i] = s[i].Value().MSI() + } + return result +} + +// MustMSISlice gets the value as a []map[string]interface{}. +// +// Panics if the object is not a []map[string]interface{}. +func (v *Value) MustMSISlice() []map[string]interface{} { + s, ok := v.data.([]Map) + if !ok { + return v.data.([]map[string]interface{}) + } + + result := make([]map[string]interface{}, len(s)) + for i := range s { + result[i] = s[i].Value().MustMSI() + } + return result +} + +// IsMSI gets whether the object contained is a map[string]interface{} or not. +func (v *Value) IsMSI() bool { + _, ok := v.data.(map[string]interface{}) + if !ok { + _, ok = v.data.(Map) + } + return ok +} + +// IsMSISlice gets whether the object contained is a []map[string]interface{} or not. +func (v *Value) IsMSISlice() bool { + _, ok := v.data.([]map[string]interface{}) + if !ok { + _, ok = v.data.([]Map) + } + return ok +} + +// EachMSI calls the specified callback for each object +// in the []map[string]interface{}. +// +// Panics if the object is the wrong type. +func (v *Value) EachMSI(callback func(int, map[string]interface{}) bool) *Value { + for index, val := range v.MustMSISlice() { + carryon := callback(index, val) + if !carryon { + break + } + } + return v +} + +// WhereMSI uses the specified decider function to select items +// from the []map[string]interface{}. The object contained in the result will contain +// only the selected items. +func (v *Value) WhereMSI(decider func(int, map[string]interface{}) bool) *Value { + var selected []map[string]interface{} + v.EachMSI(func(index int, val map[string]interface{}) bool { + shouldSelect := decider(index, val) + if !shouldSelect { + selected = append(selected, val) + } + return true + }) + return &Value{data: selected} +} + +// GroupMSI uses the specified grouper function to group the items +// keyed by the return of the grouper. The object contained in the +// result will contain a map[string][]map[string]interface{}. +func (v *Value) GroupMSI(grouper func(int, map[string]interface{}) string) *Value { + groups := make(map[string][]map[string]interface{}) + v.EachMSI(func(index int, val map[string]interface{}) bool { + group := grouper(index, val) + if _, ok := groups[group]; !ok { + groups[group] = make([]map[string]interface{}, 0) + } + groups[group] = append(groups[group], val) + return true + }) + return &Value{data: groups} +} + +// ReplaceMSI uses the specified function to replace each map[string]interface{}s +// by iterating each item. The data in the returned result will be a +// []map[string]interface{} containing the replaced items. +func (v *Value) ReplaceMSI(replacer func(int, map[string]interface{}) map[string]interface{}) *Value { + arr := v.MustMSISlice() + replaced := make([]map[string]interface{}, len(arr)) + v.EachMSI(func(index int, val map[string]interface{}) bool { + replaced[index] = replacer(index, val) + return true + }) + return &Value{data: replaced} +} + +// CollectMSI uses the specified collector function to collect a value +// for each of the map[string]interface{}s in the slice. The data returned will be a +// []interface{}. +func (v *Value) CollectMSI(collector func(int, map[string]interface{}) interface{}) *Value { + arr := v.MustMSISlice() + collected := make([]interface{}, len(arr)) + v.EachMSI(func(index int, val map[string]interface{}) bool { + collected[index] = collector(index, val) + return true + }) + return &Value{data: collected} +} + +/* + ObjxMap ((Map) and [](Map)) +*/ + +// ObjxMap gets the value as a (Map), returns the optionalDefault +// value or a system default object if the value is the wrong type. +func (v *Value) ObjxMap(optionalDefault ...(Map)) Map { + if s, ok := v.data.((Map)); ok { + return s + } + if s, ok := v.data.(map[string]interface{}); ok { + return s + } + if len(optionalDefault) == 1 { + return optionalDefault[0] + } + return New(nil) +} + +// MustObjxMap gets the value as a (Map). +// +// Panics if the object is not a (Map). +func (v *Value) MustObjxMap() Map { + if s, ok := v.data.(map[string]interface{}); ok { + return s + } + return v.data.((Map)) +} + +// ObjxMapSlice gets the value as a [](Map), returns the optionalDefault +// value or nil if the value is not a [](Map). +func (v *Value) ObjxMapSlice(optionalDefault ...[](Map)) [](Map) { + if s, ok := v.data.([]Map); ok { + return s + } + + if s, ok := v.data.([]map[string]interface{}); ok { + result := make([]Map, len(s)) + for i := range s { + result[i] = s[i] + } + return result + } + + s, ok := v.data.([]interface{}) + if !ok { + if len(optionalDefault) == 1 { + return optionalDefault[0] + } + return nil + } + + result := make([]Map, len(s)) + for i := range s { + switch s[i].(type) { + case Map: + result[i] = s[i].(Map) + default: + return nil + } + } + return result +} + +// MustObjxMapSlice gets the value as a [](Map). +// +// Panics if the object is not a [](Map). +func (v *Value) MustObjxMapSlice() [](Map) { + if s, ok := v.data.([]map[string]interface{}); ok { + result := make([]Map, len(s)) + for i := range s { + result[i] = s[i] + } + return result + } + return v.data.([](Map)) +} + +// IsObjxMap gets whether the object contained is a (Map) or not. +func (v *Value) IsObjxMap() bool { + _, ok := v.data.((Map)) + if !ok { + _, ok = v.data.(map[string]interface{}) + } + return ok +} + +// IsObjxMapSlice gets whether the object contained is a [](Map) or not. +func (v *Value) IsObjxMapSlice() bool { + _, ok := v.data.([](Map)) + if !ok { + _, ok = v.data.([]map[string]interface{}) + } + return ok +} + +// EachObjxMap calls the specified callback for each object +// in the [](Map). +// +// Panics if the object is the wrong type. +func (v *Value) EachObjxMap(callback func(int, Map) bool) *Value { + for index, val := range v.MustObjxMapSlice() { + carryon := callback(index, val) + if !carryon { + break + } + } + return v +} + +// WhereObjxMap uses the specified decider function to select items +// from the [](Map). The object contained in the result will contain +// only the selected items. +func (v *Value) WhereObjxMap(decider func(int, Map) bool) *Value { + var selected [](Map) + v.EachObjxMap(func(index int, val Map) bool { + shouldSelect := decider(index, val) + if !shouldSelect { + selected = append(selected, val) + } + return true + }) + return &Value{data: selected} +} + +// GroupObjxMap uses the specified grouper function to group the items +// keyed by the return of the grouper. The object contained in the +// result will contain a map[string][](Map). +func (v *Value) GroupObjxMap(grouper func(int, Map) string) *Value { + groups := make(map[string][](Map)) + v.EachObjxMap(func(index int, val Map) bool { + group := grouper(index, val) + if _, ok := groups[group]; !ok { + groups[group] = make([](Map), 0) + } + groups[group] = append(groups[group], val) + return true + }) + return &Value{data: groups} +} + +// ReplaceObjxMap uses the specified function to replace each (Map)s +// by iterating each item. The data in the returned result will be a +// [](Map) containing the replaced items. +func (v *Value) ReplaceObjxMap(replacer func(int, Map) Map) *Value { + arr := v.MustObjxMapSlice() + replaced := make([](Map), len(arr)) + v.EachObjxMap(func(index int, val Map) bool { + replaced[index] = replacer(index, val) + return true + }) + return &Value{data: replaced} +} + +// CollectObjxMap uses the specified collector function to collect a value +// for each of the (Map)s in the slice. The data returned will be a +// []interface{}. +func (v *Value) CollectObjxMap(collector func(int, Map) interface{}) *Value { + arr := v.MustObjxMapSlice() + collected := make([]interface{}, len(arr)) + v.EachObjxMap(func(index int, val Map) bool { + collected[index] = collector(index, val) + return true + }) + return &Value{data: collected} +} diff --git a/type_specific_codegen.go b/type_specific_codegen.go index 08b9631..9859b40 100644 --- a/type_specific_codegen.go +++ b/type_specific_codegen.go @@ -125,275 +125,6 @@ func (v *Value) CollectInter(collector func(int, interface{}) interface{}) *Valu return &Value{data: collected} } -/* - MSI (map[string]interface{} and []map[string]interface{}) -*/ - -// MSI gets the value as a map[string]interface{}, returns the optionalDefault -// value or a system default object if the value is the wrong type. -// TODO: Find a better solution for the Map type as this code is autogenerated -func (v *Value) MSI(optionalDefault ...map[string]interface{}) map[string]interface{} { - if s, ok := v.data.(map[string]interface{}); ok { - return s - } - if s, ok := v.data.(Map); ok { - return map[string]interface{}(s) - } - if len(optionalDefault) == 1 { - return optionalDefault[0] - } - return nil -} - -// MustMSI gets the value as a map[string]interface{}. -// -// Panics if the object is not a map[string]interface{}. -func (v *Value) MustMSI() map[string]interface{} { - return v.data.(map[string]interface{}) -} - -// MSISlice gets the value as a []map[string]interface{}, returns the optionalDefault -// value or nil if the value is not a []map[string]interface{}. -func (v *Value) MSISlice(optionalDefault ...[]map[string]interface{}) []map[string]interface{} { - if s, ok := v.data.([]map[string]interface{}); ok { - return s - } - if len(optionalDefault) == 1 { - return optionalDefault[0] - } - return nil -} - -// MustMSISlice gets the value as a []map[string]interface{}. -// -// Panics if the object is not a []map[string]interface{}. -func (v *Value) MustMSISlice() []map[string]interface{} { - return v.data.([]map[string]interface{}) -} - -// IsMSI gets whether the object contained is a map[string]interface{} or not. -func (v *Value) IsMSI() bool { - _, ok := v.data.(map[string]interface{}) - return ok -} - -// IsMSISlice gets whether the object contained is a []map[string]interface{} or not. -func (v *Value) IsMSISlice() bool { - _, ok := v.data.([]map[string]interface{}) - return ok -} - -// EachMSI calls the specified callback for each object -// in the []map[string]interface{}. -// -// Panics if the object is the wrong type. -func (v *Value) EachMSI(callback func(int, map[string]interface{}) bool) *Value { - for index, val := range v.MustMSISlice() { - carryon := callback(index, val) - if !carryon { - break - } - } - return v -} - -// WhereMSI uses the specified decider function to select items -// from the []map[string]interface{}. The object contained in the result will contain -// only the selected items. -func (v *Value) WhereMSI(decider func(int, map[string]interface{}) bool) *Value { - var selected []map[string]interface{} - v.EachMSI(func(index int, val map[string]interface{}) bool { - shouldSelect := decider(index, val) - if !shouldSelect { - selected = append(selected, val) - } - return true - }) - return &Value{data: selected} -} - -// GroupMSI uses the specified grouper function to group the items -// keyed by the return of the grouper. The object contained in the -// result will contain a map[string][]map[string]interface{}. -func (v *Value) GroupMSI(grouper func(int, map[string]interface{}) string) *Value { - groups := make(map[string][]map[string]interface{}) - v.EachMSI(func(index int, val map[string]interface{}) bool { - group := grouper(index, val) - if _, ok := groups[group]; !ok { - groups[group] = make([]map[string]interface{}, 0) - } - groups[group] = append(groups[group], val) - return true - }) - return &Value{data: groups} -} - -// ReplaceMSI uses the specified function to replace each map[string]interface{}s -// by iterating each item. The data in the returned result will be a -// []map[string]interface{} containing the replaced items. -func (v *Value) ReplaceMSI(replacer func(int, map[string]interface{}) map[string]interface{}) *Value { - arr := v.MustMSISlice() - replaced := make([]map[string]interface{}, len(arr)) - v.EachMSI(func(index int, val map[string]interface{}) bool { - replaced[index] = replacer(index, val) - return true - }) - return &Value{data: replaced} -} - -// CollectMSI uses the specified collector function to collect a value -// for each of the map[string]interface{}s in the slice. The data returned will be a -// []interface{}. -func (v *Value) CollectMSI(collector func(int, map[string]interface{}) interface{}) *Value { - arr := v.MustMSISlice() - collected := make([]interface{}, len(arr)) - v.EachMSI(func(index int, val map[string]interface{}) bool { - collected[index] = collector(index, val) - return true - }) - return &Value{data: collected} -} - -/* - ObjxMap ((Map) and [](Map)) -*/ - -// ObjxMap gets the value as a (Map), returns the optionalDefault -// value or a system default object if the value is the wrong type. -func (v *Value) ObjxMap(optionalDefault ...(Map)) Map { - if s, ok := v.data.((Map)); ok { - return s - } - if len(optionalDefault) == 1 { - return optionalDefault[0] - } - return New(nil) -} - -// MustObjxMap gets the value as a (Map). -// -// Panics if the object is not a (Map). -func (v *Value) MustObjxMap() Map { - return v.data.((Map)) -} - -// ObjxMapSlice gets the value as a [](Map), returns the optionalDefault -// value or nil if the value is not a [](Map). -func (v *Value) ObjxMapSlice(optionalDefault ...[](Map)) [](Map) { - // TODO: Find a better solution for the Map type as this code is autogenerated - if s, ok := v.data.([]Map); ok { - return s - } - s, ok := v.data.([]interface{}) - if !ok { - if len(optionalDefault) == 1 { - return optionalDefault[0] - } - return nil - } - - result := make([]Map, len(s)) - for i := range s { - switch s[i].(type) { - case Map: - result[i] = s[i].(Map) - default: - return nil - } - } - return result -} - -// MustObjxMapSlice gets the value as a [](Map). -// -// Panics if the object is not a [](Map). -func (v *Value) MustObjxMapSlice() [](Map) { - return v.data.([](Map)) -} - -// IsObjxMap gets whether the object contained is a (Map) or not. -func (v *Value) IsObjxMap() bool { - _, ok := v.data.((Map)) - return ok -} - -// IsObjxMapSlice gets whether the object contained is a [](Map) or not. -func (v *Value) IsObjxMapSlice() bool { - _, ok := v.data.([](Map)) - return ok -} - -// EachObjxMap calls the specified callback for each object -// in the [](Map). -// -// Panics if the object is the wrong type. -func (v *Value) EachObjxMap(callback func(int, Map) bool) *Value { - for index, val := range v.MustObjxMapSlice() { - carryon := callback(index, val) - if !carryon { - break - } - } - return v -} - -// WhereObjxMap uses the specified decider function to select items -// from the [](Map). The object contained in the result will contain -// only the selected items. -func (v *Value) WhereObjxMap(decider func(int, Map) bool) *Value { - var selected [](Map) - v.EachObjxMap(func(index int, val Map) bool { - shouldSelect := decider(index, val) - if !shouldSelect { - selected = append(selected, val) - } - return true - }) - return &Value{data: selected} -} - -// GroupObjxMap uses the specified grouper function to group the items -// keyed by the return of the grouper. The object contained in the -// result will contain a map[string][](Map). -func (v *Value) GroupObjxMap(grouper func(int, Map) string) *Value { - groups := make(map[string][](Map)) - v.EachObjxMap(func(index int, val Map) bool { - group := grouper(index, val) - if _, ok := groups[group]; !ok { - groups[group] = make([](Map), 0) - } - groups[group] = append(groups[group], val) - return true - }) - return &Value{data: groups} -} - -// ReplaceObjxMap uses the specified function to replace each (Map)s -// by iterating each item. The data in the returned result will be a -// [](Map) containing the replaced items. -func (v *Value) ReplaceObjxMap(replacer func(int, Map) Map) *Value { - arr := v.MustObjxMapSlice() - replaced := make([](Map), len(arr)) - v.EachObjxMap(func(index int, val Map) bool { - replaced[index] = replacer(index, val) - return true - }) - return &Value{data: replaced} -} - -// CollectObjxMap uses the specified collector function to collect a value -// for each of the (Map)s in the slice. The data returned will be a -// []interface{}. -func (v *Value) CollectObjxMap(collector func(int, Map) interface{}) *Value { - arr := v.MustObjxMapSlice() - collected := make([]interface{}, len(arr)) - v.EachObjxMap(func(index int, val Map) bool { - collected[index] = collector(index, val) - return true - }) - return &Value{data: collected} -} - /* Bool (bool and []bool) */ diff --git a/type_specific_codegen_test.go b/type_specific_codegen_test.go index faae5dd..72fa8c8 100644 --- a/type_specific_codegen_test.go +++ b/type_specific_codegen_test.go @@ -129,249 +129,6 @@ func TestCollectInter(t *testing.T) { } } -/* - Tests for MSI (map[string]interface{} and []map[string]interface{}) -*/ -func TestMSI(t *testing.T) { - val := map[string]interface{}(map[string]interface{}{"name": "Tyler"}) - m := objx.Map{"value": val, "nothing": nil} - - assert.Equal(t, map[string]interface{}{"value": val, "nothing": nil}, m.Value().MSI()) - assert.Equal(t, val, m.Get("value").MSI()) - assert.Equal(t, val, m.Get("value").MustMSI()) - assert.Equal(t, map[string]interface{}(nil), m.Get("nothing").MSI()) - assert.Equal(t, val, m.Get("nothing").MSI(map[string]interface{}{"name": "Tyler"})) - assert.Panics(t, func() { - m.Get("age").MustMSI() - }) -} - -func TestMSISlice(t *testing.T) { - val := map[string]interface{}(map[string]interface{}{"name": "Tyler"}) - m := objx.Map{"value": []map[string]interface{}{val}, "nothing": nil} - - assert.Equal(t, val, m.Get("value").MSISlice()[0]) - assert.Equal(t, val, m.Get("value").MustMSISlice()[0]) - assert.Equal(t, []map[string]interface{}(nil), m.Get("nothing").MSISlice()) - assert.Equal(t, val, m.Get("nothing").MSISlice([]map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"})})[0]) - assert.Panics(t, func() { - m.Get("nothing").MustMSISlice() - }) -} - -func TestIsMSI(t *testing.T) { - m := objx.Map{"data": map[string]interface{}(map[string]interface{}{"name": "Tyler"})} - - assert.True(t, m.Get("data").IsMSI()) -} - -func TestIsMSISlice(t *testing.T) { - m := objx.Map{"data": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} - - assert.True(t, m.Get("data").IsMSISlice()) -} - -func TestEachMSI(t *testing.T) { - m := objx.Map{"data": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} - count := 0 - replacedVals := make([]map[string]interface{}, 0) - assert.Equal(t, m.Get("data"), m.Get("data").EachMSI(func(i int, val map[string]interface{}) bool { - count++ - replacedVals = append(replacedVals, val) - - // abort early - return i != 2 - })) - - assert.Equal(t, count, 3) - assert.Equal(t, replacedVals[0], m.Get("data").MustMSISlice()[0]) - assert.Equal(t, replacedVals[1], m.Get("data").MustMSISlice()[1]) - assert.Equal(t, replacedVals[2], m.Get("data").MustMSISlice()[2]) -} - -func TestWhereMSI(t *testing.T) { - m := objx.Map{"data": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} - - selected := m.Get("data").WhereMSI(func(i int, val map[string]interface{}) bool { - return i%2 == 0 - }).MustMSISlice() - - assert.Equal(t, 3, len(selected)) -} - -func TestGroupMSI(t *testing.T) { - m := objx.Map{"data": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} - - grouped := m.Get("data").GroupMSI(func(i int, val map[string]interface{}) string { - return fmt.Sprintf("%v", i%2 == 0) - }).Data().(map[string][]map[string]interface{}) - - assert.Equal(t, 2, len(grouped)) - assert.Equal(t, 3, len(grouped["true"])) - assert.Equal(t, 3, len(grouped["false"])) -} - -func TestReplaceMSI(t *testing.T) { - m := objx.Map{"data": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} - rawArr := m.Get("data").MustMSISlice() - - replaced := m.Get("data").ReplaceMSI(func(index int, val map[string]interface{}) map[string]interface{} { - if index < len(rawArr)-1 { - return rawArr[index+1] - } - return rawArr[0] - }) - replacedArr := replaced.MustMSISlice() - - if assert.Equal(t, 6, len(replacedArr)) { - assert.Equal(t, replacedArr[0], rawArr[1]) - assert.Equal(t, replacedArr[1], rawArr[2]) - assert.Equal(t, replacedArr[2], rawArr[3]) - assert.Equal(t, replacedArr[3], rawArr[4]) - assert.Equal(t, replacedArr[4], rawArr[5]) - assert.Equal(t, replacedArr[5], rawArr[0]) - } -} - -func TestCollectMSI(t *testing.T) { - m := objx.Map{"data": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} - - collected := m.Get("data").CollectMSI(func(index int, val map[string]interface{}) interface{} { - return index - }) - collectedArr := collected.MustInterSlice() - - if assert.Equal(t, 6, len(collectedArr)) { - assert.Equal(t, collectedArr[0], 0) - assert.Equal(t, collectedArr[1], 1) - assert.Equal(t, collectedArr[2], 2) - assert.Equal(t, collectedArr[3], 3) - assert.Equal(t, collectedArr[4], 4) - assert.Equal(t, collectedArr[5], 5) - } -} - -/* - Tests for ObjxMap ((objx.Map) and [](objx.Map)) -*/ -func TestObjxMap(t *testing.T) { - val := (objx.Map)(objx.New(1)) - m := objx.Map{"value": val, "nothing": nil} - - assert.Equal(t, val, m.Get("value").ObjxMap()) - assert.Equal(t, val, m.Get("value").MustObjxMap()) - assert.Equal(t, (objx.Map)(objx.New(nil)), m.Get("nothing").ObjxMap()) - assert.Equal(t, val, m.Get("nothing").ObjxMap(objx.New(1))) - assert.Panics(t, func() { - m.Get("age").MustObjxMap() - }) -} - -func TestObjxMapSlice(t *testing.T) { - val := (objx.Map)(objx.New(1)) - m := objx.Map{"value": [](objx.Map){val}, "nothing": nil} - - assert.Equal(t, val, m.Get("value").ObjxMapSlice()[0]) - assert.Equal(t, val, m.Get("value").MustObjxMapSlice()[0]) - assert.Equal(t, [](objx.Map)(nil), m.Get("nothing").ObjxMapSlice()) - assert.Equal(t, val, m.Get("nothing").ObjxMapSlice([](objx.Map){(objx.Map)(objx.New(1))})[0]) - assert.Panics(t, func() { - m.Get("nothing").MustObjxMapSlice() - }) -} - -func TestIsObjxMap(t *testing.T) { - m := objx.Map{"data": (objx.Map)(objx.New(1))} - - assert.True(t, m.Get("data").IsObjxMap()) -} - -func TestIsObjxMapSlice(t *testing.T) { - m := objx.Map{"data": [](objx.Map){(objx.Map)(objx.New(1))}} - - assert.True(t, m.Get("data").IsObjxMapSlice()) -} - -func TestEachObjxMap(t *testing.T) { - m := objx.Map{"data": [](objx.Map){(objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1))}} - count := 0 - replacedVals := make([](objx.Map), 0) - assert.Equal(t, m.Get("data"), m.Get("data").EachObjxMap(func(i int, val objx.Map) bool { - count++ - replacedVals = append(replacedVals, val) - - // abort early - return i != 2 - })) - - assert.Equal(t, count, 3) - assert.Equal(t, replacedVals[0], m.Get("data").MustObjxMapSlice()[0]) - assert.Equal(t, replacedVals[1], m.Get("data").MustObjxMapSlice()[1]) - assert.Equal(t, replacedVals[2], m.Get("data").MustObjxMapSlice()[2]) -} - -func TestWhereObjxMap(t *testing.T) { - m := objx.Map{"data": [](objx.Map){(objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1))}} - - selected := m.Get("data").WhereObjxMap(func(i int, val objx.Map) bool { - return i%2 == 0 - }).MustObjxMapSlice() - - assert.Equal(t, 3, len(selected)) -} - -func TestGroupObjxMap(t *testing.T) { - m := objx.Map{"data": [](objx.Map){(objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1))}} - - grouped := m.Get("data").GroupObjxMap(func(i int, val objx.Map) string { - return fmt.Sprintf("%v", i%2 == 0) - }).Data().(map[string][](objx.Map)) - - assert.Equal(t, 2, len(grouped)) - assert.Equal(t, 3, len(grouped["true"])) - assert.Equal(t, 3, len(grouped["false"])) -} - -func TestReplaceObjxMap(t *testing.T) { - m := objx.Map{"data": [](objx.Map){(objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1))}} - rawArr := m.Get("data").MustObjxMapSlice() - - replaced := m.Get("data").ReplaceObjxMap(func(index int, val objx.Map) objx.Map { - if index < len(rawArr)-1 { - return rawArr[index+1] - } - return rawArr[0] - }) - replacedArr := replaced.MustObjxMapSlice() - - if assert.Equal(t, 6, len(replacedArr)) { - assert.Equal(t, replacedArr[0], rawArr[1]) - assert.Equal(t, replacedArr[1], rawArr[2]) - assert.Equal(t, replacedArr[2], rawArr[3]) - assert.Equal(t, replacedArr[3], rawArr[4]) - assert.Equal(t, replacedArr[4], rawArr[5]) - assert.Equal(t, replacedArr[5], rawArr[0]) - } -} - -func TestCollectObjxMap(t *testing.T) { - m := objx.Map{"data": [](objx.Map){(objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1))}} - - collected := m.Get("data").CollectObjxMap(func(index int, val objx.Map) interface{} { - return index - }) - collectedArr := collected.MustInterSlice() - - if assert.Equal(t, 6, len(collectedArr)) { - assert.Equal(t, collectedArr[0], 0) - assert.Equal(t, collectedArr[1], 1) - assert.Equal(t, collectedArr[2], 2) - assert.Equal(t, collectedArr[3], 3) - assert.Equal(t, collectedArr[4], 4) - assert.Equal(t, collectedArr[5], 5) - } -} - /* Tests for Bool (bool and []bool) */ diff --git a/type_specific_test.go b/type_specific_test.go new file mode 100644 index 0000000..14fc4cc --- /dev/null +++ b/type_specific_test.go @@ -0,0 +1,411 @@ +package objx_test + +import ( + "fmt" + "testing" + + "github.com/stretchr/objx" + "github.com/stretchr/testify/assert" +) + +/* + Tests for MSI (map[string]interface{} and []map[string]interface{}) +*/ +func TestMSI(t *testing.T) { + val := map[string]interface{}(map[string]interface{}{"name": "Tyler"}) + m := objx.Map{"value": val, "nothing": nil} + mVal := map[string]interface{}{"value": val, "nothing": nil} + + assert.Equal(t, mVal, m.Value().MSI()) + assert.Equal(t, val, m.Get("value").MSI()) + assert.Equal(t, mVal, m.Value().MustMSI()) + assert.Equal(t, val, m.Get("value").MustMSI()) + assert.Equal(t, map[string]interface{}(nil), m.Get("nothing").MSI()) + assert.Equal(t, val, m.Get("nothing").MSI(map[string]interface{}{"name": "Tyler"})) + assert.Panics(t, func() { + m.Get("age").MustMSI() + }) +} + +func TestMSISlice(t *testing.T) { + val := map[string]interface{}(map[string]interface{}{"name": "Tyler"}) + m := objx.Map{"value": []map[string]interface{}{val}, "value2": []objx.Map{val}, "nothing": nil} + + assert.Equal(t, val, m.Get("value").MSISlice()[0]) + assert.Equal(t, val, m.Get("value2").MSISlice()[0]) + assert.Equal(t, val, m.Get("value").MustMSISlice()[0]) + assert.Equal(t, val, m.Get("value2").MustMSISlice()[0]) + assert.Equal(t, []map[string]interface{}(nil), m.Get("nothing").MSISlice()) + assert.Equal(t, val, m.Get("nothing").MSISlice([]map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"})})[0]) + assert.Panics(t, func() { + m.Get("nothing").MustMSISlice() + }) +} + +func TestIsMSI(t *testing.T) { + m := objx.Map{"data": map[string]interface{}(map[string]interface{}{"name": "Tyler"})} + + assert.True(t, m.Get("data").IsMSI()) + assert.True(t, m.Value().IsMSI()) +} + +func TestIsMSISlice(t *testing.T) { + val := map[string]interface{}(map[string]interface{}{"name": "Tyler"}) + m := objx.Map{"data": []map[string]interface{}{val}, "data2": []objx.Map{val}} + + assert.True(t, m.Get("data").IsMSISlice()) + assert.True(t, m.Get("data2").IsMSISlice()) +} + +func TestEachMSI(t *testing.T) { + m := objx.Map{"data": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} + count := 0 + replacedVals := make([]map[string]interface{}, 0) + assert.Equal(t, m.Get("data"), m.Get("data").EachMSI(func(i int, val map[string]interface{}) bool { + count++ + replacedVals = append(replacedVals, val) + + // abort early + return i != 2 + })) + + m2 := objx.Map{"data": []objx.Map{objx.Map{"name": "Taylor"}, objx.Map{"name": "Taylor"}, objx.Map{"name": "Taylor"}, objx.Map{"name": "Taylor"}, objx.Map{"name": "Taylor"}}} + assert.Equal(t, m2.Get("data"), m2.Get("data").EachMSI(func(i int, val map[string]interface{}) bool { + count++ + replacedVals = append(replacedVals, val) + + // abort early + return i != 2 + })) + + assert.Equal(t, count, 6) + assert.Equal(t, replacedVals[0], m.Get("data").MustMSISlice()[0]) + assert.Equal(t, replacedVals[1], m.Get("data").MustMSISlice()[1]) + assert.Equal(t, replacedVals[2], m.Get("data").MustMSISlice()[2]) + assert.Equal(t, replacedVals[3], m2.Get("data").MustMSISlice()[0]) + assert.Equal(t, replacedVals[4], m2.Get("data").MustMSISlice()[1]) + assert.Equal(t, replacedVals[5], m2.Get("data").MustMSISlice()[2]) +} + +func TestWhereMSI(t *testing.T) { + m := objx.Map{"data": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} + + selected := m.Get("data").WhereMSI(func(i int, val map[string]interface{}) bool { + return i%2 == 0 + }).MustMSISlice() + + assert.Equal(t, 3, len(selected)) +} + +func TestWhereMSI2(t *testing.T) { + m := objx.Map{"data": []objx.Map{objx.Map{"name": "Taylor"}, objx.Map{"name": "Taylor"}, objx.Map{"name": "Taylor"}, objx.Map{"name": "Taylor"}, objx.Map{"name": "Taylor"}}} + + selected := m.Get("data").WhereMSI(func(i int, val map[string]interface{}) bool { + return i%2 == 0 + }).MustMSISlice() + + assert.Equal(t, 2, len(selected)) +} + +func TestGroupMSI(t *testing.T) { + m := objx.Map{"data": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} + + grouped := m.Get("data").GroupMSI(func(i int, val map[string]interface{}) string { + return fmt.Sprintf("%v", i%2 == 0) + }).Data().(map[string][]map[string]interface{}) + + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 3, len(grouped["false"])) +} + +func TestGroupMSI2(t *testing.T) { + m := objx.Map{"data": []objx.Map{objx.Map{"name": "Taylor"}, objx.Map{"name": "Taylor"}, objx.Map{"name": "Taylor"}, objx.Map{"name": "Taylor"}, objx.Map{"name": "Taylor"}}} + + grouped := m.Get("data").GroupMSI(func(i int, val map[string]interface{}) string { + return fmt.Sprintf("%v", i%2 == 0) + }).Data().(map[string][]map[string]interface{}) + + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 2, len(grouped["false"])) +} + +func TestReplaceMSI(t *testing.T) { + m := objx.Map{"data": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} + rawArr := m.Get("data").MustMSISlice() + + replaced := m.Get("data").ReplaceMSI(func(index int, val map[string]interface{}) map[string]interface{} { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.MustMSISlice() + + if assert.Equal(t, 6, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[5]) + assert.Equal(t, replacedArr[5], rawArr[0]) + } +} + +func TestReplaceMSI2(t *testing.T) { + m := objx.Map{"data": []objx.Map{objx.Map{"name": "Taylor"}, objx.Map{"name": "Taylor"}, objx.Map{"name": "Taylor"}, objx.Map{"name": "Taylor"}, objx.Map{"name": "Taylor"}}} + rawArr := m.Get("data").MustMSISlice() + + replaced := m.Get("data").ReplaceMSI(func(index int, val map[string]interface{}) map[string]interface{} { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.MustMSISlice() + + if assert.Equal(t, 5, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[0]) + } +} + +func TestCollectMSI(t *testing.T) { + m := objx.Map{"data": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} + + collected := m.Get("data").CollectMSI(func(index int, val map[string]interface{}) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 6, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + assert.Equal(t, collectedArr[5], 5) + } +} + +func TestCollectMSI2(t *testing.T) { + m := objx.Map{"data": []objx.Map{objx.Map{"name": "Taylor"}, objx.Map{"name": "Taylor"}, objx.Map{"name": "Taylor"}, objx.Map{"name": "Taylor"}, objx.Map{"name": "Taylor"}}} + + collected := m.Get("data").CollectMSI(func(index int, val map[string]interface{}) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 5, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + } +} + +/* + Tests for ObjxMap ((objx.Map) and [](objx.Map)) +*/ +func TestObjxMap(t *testing.T) { + val := (objx.Map)(objx.New(1)) + m := objx.Map{"value": val, "value2": map[string]interface{}{"name": "Taylor"}, "nothing": nil} + valMSI := objx.Map{"name": "Taylor"} + + assert.Equal(t, val, m.Get("value").ObjxMap()) + assert.Equal(t, valMSI, m.Get("value2").ObjxMap()) + assert.Equal(t, val, m.Get("value").MustObjxMap()) + assert.Equal(t, valMSI, m.Get("value2").MustObjxMap()) + assert.Equal(t, (objx.Map)(objx.New(nil)), m.Get("nothing").ObjxMap()) + assert.Equal(t, val, m.Get("nothing").ObjxMap(objx.New(1))) + assert.Panics(t, func() { + m.Get("age").MustObjxMap() + }) +} + +func TestObjxMapSlice(t *testing.T) { + val := (objx.Map)(objx.New(1)) + m := objx.Map{"value": [](objx.Map){val}, "value2": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Taylor"})}, "nothing": nil} + valMSI := objx.Map{"name": "Taylor"} + + assert.Equal(t, val, m.Get("value").ObjxMapSlice()[0]) + assert.Equal(t, valMSI, m.Get("value2").ObjxMapSlice()[0]) + assert.Equal(t, val, m.Get("value").MustObjxMapSlice()[0]) + assert.Equal(t, valMSI, m.Get("value2").MustObjxMapSlice()[0]) + assert.Equal(t, [](objx.Map)(nil), m.Get("nothing").ObjxMapSlice()) + assert.Equal(t, val, m.Get("nothing").ObjxMapSlice([](objx.Map){(objx.Map)(objx.New(1))})[0]) + assert.Panics(t, func() { + m.Get("nothing").MustObjxMapSlice() + }) +} + +func TestIsObjxMap(t *testing.T) { + m := objx.Map{"data": (objx.Map)(objx.New(1)), "data2": map[string]interface{}{"name": "Taylor"}} + + assert.True(t, m.Get("data").IsObjxMap()) + assert.True(t, m.Get("data2").IsObjxMap()) +} + +func TestIsObjxMapSlice(t *testing.T) { + m := objx.Map{"data": [](objx.Map){(objx.Map)(objx.New(1))}, "data2": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Taylor"})}} + + assert.True(t, m.Get("data").IsObjxMapSlice()) + assert.True(t, m.Get("data2").IsObjxMapSlice()) +} + +func TestEachObjxMap(t *testing.T) { + m := objx.Map{"data": [](objx.Map){(objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1))}} + count := 0 + replacedVals := make([](objx.Map), 0) + assert.Equal(t, m.Get("data"), m.Get("data").EachObjxMap(func(i int, val objx.Map) bool { + count++ + replacedVals = append(replacedVals, val) + + // abort early + return i != 2 + })) + + m2 := objx.Map{"data": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} + assert.Equal(t, m2.Get("data"), m2.Get("data").EachObjxMap(func(i int, val objx.Map) bool { + count++ + replacedVals = append(replacedVals, val) + + // abort early + return i != 2 + })) + + assert.Equal(t, count, 6) + assert.Equal(t, replacedVals[0], m.Get("data").MustObjxMapSlice()[0]) + assert.Equal(t, replacedVals[1], m.Get("data").MustObjxMapSlice()[1]) + assert.Equal(t, replacedVals[2], m.Get("data").MustObjxMapSlice()[2]) + assert.Equal(t, replacedVals[3], m2.Get("data").MustObjxMapSlice()[0]) + assert.Equal(t, replacedVals[4], m2.Get("data").MustObjxMapSlice()[1]) + assert.Equal(t, replacedVals[5], m2.Get("data").MustObjxMapSlice()[2]) +} + +func TestWhereObjxMap(t *testing.T) { + m := objx.Map{"data": [](objx.Map){(objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1))}} + + selected := m.Get("data").WhereObjxMap(func(i int, val objx.Map) bool { + return i%2 == 0 + }).MustObjxMapSlice() + + assert.Equal(t, 3, len(selected)) +} + +func TestWhereObjxMap2(t *testing.T) { + m := objx.Map{"data": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} + + selected := m.Get("data").WhereObjxMap(func(i int, val objx.Map) bool { + return i%2 == 0 + }).MustObjxMapSlice() + + assert.Equal(t, 2, len(selected)) +} + +func TestGroupObjxMap(t *testing.T) { + m := objx.Map{"data": [](objx.Map){(objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1))}} + + grouped := m.Get("data").GroupObjxMap(func(i int, val objx.Map) string { + return fmt.Sprintf("%v", i%2 == 0) + }).Data().(map[string][](objx.Map)) + + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 3, len(grouped["false"])) +} + +func TestGroupObjxMap2(t *testing.T) { + m := objx.Map{"data": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} + + grouped := m.Get("data").GroupObjxMap(func(i int, val objx.Map) string { + return fmt.Sprintf("%v", i%2 == 0) + }).Data().(map[string][](objx.Map)) + + assert.Equal(t, 2, len(grouped)) + assert.Equal(t, 3, len(grouped["true"])) + assert.Equal(t, 2, len(grouped["false"])) +} + +func TestReplaceObjxMap(t *testing.T) { + m := objx.Map{"data": [](objx.Map){(objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1))}} + rawArr := m.Get("data").MustObjxMapSlice() + + replaced := m.Get("data").ReplaceObjxMap(func(index int, val objx.Map) objx.Map { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.MustObjxMapSlice() + + if assert.Equal(t, 6, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[5]) + assert.Equal(t, replacedArr[5], rawArr[0]) + } +} + +func TestReplaceObjxMap2(t *testing.T) { + m := objx.Map{"data": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} + rawArr := m.Get("data").MustObjxMapSlice() + + replaced := m.Get("data").ReplaceObjxMap(func(index int, val objx.Map) objx.Map { + if index < len(rawArr)-1 { + return rawArr[index+1] + } + return rawArr[0] + }) + replacedArr := replaced.MustObjxMapSlice() + + if assert.Equal(t, 5, len(replacedArr)) { + assert.Equal(t, replacedArr[0], rawArr[1]) + assert.Equal(t, replacedArr[1], rawArr[2]) + assert.Equal(t, replacedArr[2], rawArr[3]) + assert.Equal(t, replacedArr[3], rawArr[4]) + assert.Equal(t, replacedArr[4], rawArr[0]) + } +} + +func TestCollectObjxMap(t *testing.T) { + m := objx.Map{"data": [](objx.Map){(objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1)), (objx.Map)(objx.New(1))}} + + collected := m.Get("data").CollectObjxMap(func(index int, val objx.Map) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 6, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + assert.Equal(t, collectedArr[5], 5) + } +} + +func TestCollectObjxMap2(t *testing.T) { + m := objx.Map{"data": []map[string]interface{}{map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"}), map[string]interface{}(map[string]interface{}{"name": "Tyler"})}} + + collected := m.Get("data").CollectObjxMap(func(index int, val objx.Map) interface{} { + return index + }) + collectedArr := collected.MustInterSlice() + + if assert.Equal(t, 5, len(collectedArr)) { + assert.Equal(t, collectedArr[0], 0) + assert.Equal(t, collectedArr[1], 1) + assert.Equal(t, collectedArr[2], 2) + assert.Equal(t, collectedArr[3], 3) + assert.Equal(t, collectedArr[4], 4) + } +}