# Conflicts: # caste.gopull/73/head
@@ -1,8 +1,9 @@ | |||
language: go | |||
env: | |||
- GO111MODULE=on | |||
sudo: required | |||
go: | |||
- 1.7.5 | |||
- 1.8 | |||
- "1.11.x" | |||
- tip | |||
os: | |||
- linux | |||
@@ -122,6 +122,18 @@ func ToStringMapBool(i interface{}) map[string]bool { | |||
return v | |||
} | |||
// ToStringMapInt casts an interface to a map[string]int type. | |||
func ToStringMapInt(i interface{}) map[string]int { | |||
v, _ := ToStringMapIntE(i) | |||
return v | |||
} | |||
// ToStringMapInt64 casts an interface to a map[string]int64 type. | |||
func ToStringMapInt64(i interface{}) map[string]int64 { | |||
v, _ := ToStringMapInt64E(i) | |||
return v | |||
} | |||
// ToStringMap casts an interface to a map[string]interface{} type. | |||
func ToStringMap(i interface{}) map[string]interface{} { | |||
v, _ := ToStringMapE(i) | |||
@@ -821,6 +821,83 @@ func TestToStringMapBoolE(t *testing.T) { | |||
} | |||
} | |||
func TestToStringMapIntE(t *testing.T) { | |||
tests := []struct { | |||
input interface{} | |||
expect map[string]int | |||
iserr bool | |||
}{ | |||
{map[interface{}]interface{}{"v1": 1, "v2": 222}, map[string]int{"v1": 1, "v2": 222}, false}, | |||
{map[string]interface{}{"v1": 342, "v2": 5141}, map[string]int{"v1": 342, "v2": 5141}, false}, | |||
{map[string]int{"v1": 33, "v2": 88}, map[string]int{"v1": 33, "v2": 88}, false}, | |||
{map[string]int32{"v1": int32(33), "v2": int32(88)}, map[string]int{"v1": 33, "v2": 88}, false}, | |||
{map[string]uint16{"v1": uint16(33), "v2": uint16(88)}, map[string]int{"v1": 33, "v2": 88}, false}, | |||
{map[string]float64{"v1": float64(8.22), "v2": float64(43.32)}, map[string]int{"v1": 8, "v2": 43}, false}, | |||
{`{"v1": 67, "v2": 56}`, map[string]int{"v1": 67, "v2": 56}, false}, | |||
// errors | |||
{nil, nil, true}, | |||
{testing.T{}, nil, true}, | |||
{"", nil, true}, | |||
} | |||
for i, test := range tests { | |||
errmsg := fmt.Sprintf("i = %d", i) // assert helper message | |||
v, err := ToStringMapIntE(test.input) | |||
if test.iserr { | |||
assert.Error(t, err, errmsg) | |||
continue | |||
} | |||
assert.NoError(t, err, errmsg) | |||
assert.Equal(t, test.expect, v, errmsg) | |||
// Non-E test | |||
v = ToStringMapInt(test.input) | |||
assert.Equal(t, test.expect, v, errmsg) | |||
} | |||
} | |||
func TestToStringMapInt64E(t *testing.T) { | |||
tests := []struct { | |||
input interface{} | |||
expect map[string]int64 | |||
iserr bool | |||
}{ | |||
{map[interface{}]interface{}{"v1": int32(8), "v2": int32(888)}, map[string]int64{"v1": int64(8), "v2": int64(888)}, false}, | |||
{map[string]interface{}{"v1": int64(45), "v2": int64(67)}, map[string]int64{"v1": 45, "v2": 67}, false}, | |||
{map[string]int64{"v1": 33, "v2": 88}, map[string]int64{"v1": 33, "v2": 88}, false}, | |||
{map[string]int{"v1": 33, "v2": 88}, map[string]int64{"v1": 33, "v2": 88}, false}, | |||
{map[string]int32{"v1": int32(33), "v2": int32(88)}, map[string]int64{"v1": 33, "v2": 88}, false}, | |||
{map[string]uint16{"v1": uint16(33), "v2": uint16(88)}, map[string]int64{"v1": 33, "v2": 88}, false}, | |||
{map[string]float64{"v1": float64(8.22), "v2": float64(43.32)}, map[string]int64{"v1": 8, "v2": 43}, false}, | |||
{`{"v1": 67, "v2": 56}`, map[string]int64{"v1": 67, "v2": 56}, false}, | |||
// errors | |||
{nil, nil, true}, | |||
{testing.T{}, nil, true}, | |||
{"", nil, true}, | |||
} | |||
for i, test := range tests { | |||
errmsg := fmt.Sprintf("i = %d", i) // assert helper message | |||
v, err := ToStringMapInt64E(test.input) | |||
if test.iserr { | |||
assert.Error(t, err, errmsg) | |||
continue | |||
} | |||
assert.NoError(t, err, errmsg) | |||
assert.Equal(t, test.expect, v, errmsg) | |||
// Non-E test | |||
v = ToStringMapInt64(test.input) | |||
assert.Equal(t, test.expect, v, errmsg) | |||
} | |||
} | |||
func TestToStringMapStringE(t *testing.T) { | |||
var stringMapString = map[string]string{"key 1": "value 1", "key 2": "value 2", "key 3": "value 3"} | |||
var stringMapInterface = map[string]interface{}{"key 1": "value 1", "key 2": "value 2", "key 3": "value 3"} | |||
@@ -1112,6 +1189,7 @@ func TestToTimeEE(t *testing.T) { | |||
{"Tue, 10 Nov 2009 23:00:00 UTC", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), false}, // RFC1123 | |||
{"Tue, 10 Nov 2009 23:00:00 +0000", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), false}, // RFC1123Z | |||
{"2009-11-10T23:00:00Z", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), false}, // RFC3339 | |||
{"2018-10-21T23:21:29+0200", time.Date(2018, 10, 21, 21, 21, 29, 0, time.UTC), false}, // RFC3339 without timezone hh:mm colon | |||
{"2009-11-10T23:00:00Z", time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), false}, // RFC3339Nano | |||
{"11:00PM", time.Date(0, 1, 1, 23, 0, 0, 0, time.UTC), false}, // Kitchen | |||
{"Nov 10 23:00:00", time.Date(0, 11, 10, 23, 0, 0, 0, time.UTC), false}, // Stamp | |||
@@ -1119,6 +1197,7 @@ func TestToTimeEE(t *testing.T) { | |||
{"Nov 10 23:00:00.000000", time.Date(0, 11, 10, 23, 0, 0, 0, time.UTC), false}, // StampMicro | |||
{"Nov 10 23:00:00.000000000", time.Date(0, 11, 10, 23, 0, 0, 0, time.UTC), false}, // StampNano | |||
{"2016-03-06 15:28:01-00:00", time.Date(2016, 3, 6, 15, 28, 1, 0, time.UTC), false}, // RFC3339 without T | |||
{"2016-03-06 15:28:01-0000", time.Date(2016, 3, 6, 15, 28, 1, 0, time.UTC), false}, // RFC3339 without T or timezone hh:mm colon | |||
{"2016-03-06 15:28:01", time.Date(2016, 3, 6, 15, 28, 1, 0, time.UTC), false}, | |||
{"2016-03-06 15:28:01 -0000", time.Date(2016, 3, 6, 15, 28, 1, 0, time.UTC), false}, | |||
{"2016-03-06 15:28:01 -00:00", time.Date(2016, 3, 6, 15, 28, 1, 0, time.UTC), false}, | |||
@@ -32,9 +32,11 @@ var ParseDateFormats = []string{ | |||
"2006-01-02 15:04:05.999999999 -0700 MST", // Time.String() | |||
"2006-01-02", | |||
"02 Jan 2006", | |||
"2006-01-02T15:04:05-0700", // RFC3339 without timezone hh:mm colon | |||
"2006-01-02 15:04:05 -07:00", | |||
"2006-01-02 15:04:05 -0700", | |||
"2006-01-02 15:04:05Z07:00", // RFC3339 without T | |||
"2006-01-02 15:04:05Z0700", // RFC3339 without T or timezone hh:mm colon | |||
"2006-01-02 15:04:05", | |||
time.Kitchen, | |||
time.Stamp, | |||
@@ -1019,6 +1021,87 @@ func ToStringMapE(i interface{}) (map[string]interface{}, error) { | |||
} | |||
} | |||
// ToStringMapIntE casts an interface to a map[string]int{} type. | |||
func ToStringMapIntE(i interface{}) (map[string]int, error) { | |||
var m = map[string]int{} | |||
if i == nil { | |||
return m, fmt.Errorf("unable to cast %#v of type %T to map[string]int", i, i) | |||
} | |||
switch v := i.(type) { | |||
case map[interface{}]interface{}: | |||
for k, val := range v { | |||
m[ToString(k)] = ToInt(val) | |||
} | |||
return m, nil | |||
case map[string]interface{}: | |||
for k, val := range v { | |||
m[k] = ToInt(val) | |||
} | |||
return m, nil | |||
case map[string]int: | |||
return v, nil | |||
case string: | |||
err := jsonStringToObject(v, &m) | |||
return m, err | |||
} | |||
if reflect.TypeOf(i).Kind() != reflect.Map { | |||
return m, fmt.Errorf("unable to cast %#v of type %T to map[string]int", i, i) | |||
} | |||
mVal := reflect.ValueOf(m) | |||
v := reflect.ValueOf(i) | |||
for _, keyVal := range v.MapKeys() { | |||
val, err := ToIntE(v.MapIndex(keyVal).Interface()) | |||
if err != nil { | |||
return m, fmt.Errorf("unable to cast %#v of type %T to map[string]int", i, i) | |||
} | |||
mVal.SetMapIndex(keyVal, reflect.ValueOf(val)) | |||
} | |||
return m, nil | |||
} | |||
// ToStringMapInt64E casts an interface to a map[string]int64{} type. | |||
func ToStringMapInt64E(i interface{}) (map[string]int64, error) { | |||
var m = map[string]int64{} | |||
if i == nil { | |||
return m, fmt.Errorf("unable to cast %#v of type %T to map[string]int64", i, i) | |||
} | |||
switch v := i.(type) { | |||
case map[interface{}]interface{}: | |||
for k, val := range v { | |||
m[ToString(k)] = ToInt64(val) | |||
} | |||
return m, nil | |||
case map[string]interface{}: | |||
for k, val := range v { | |||
m[k] = ToInt64(val) | |||
} | |||
return m, nil | |||
case map[string]int64: | |||
return v, nil | |||
case string: | |||
err := jsonStringToObject(v, &m) | |||
return m, err | |||
} | |||
if reflect.TypeOf(i).Kind() != reflect.Map { | |||
return m, fmt.Errorf("unable to cast %#v of type %T to map[string]int64", i, i) | |||
} | |||
mVal := reflect.ValueOf(m) | |||
v := reflect.ValueOf(i) | |||
for _, keyVal := range v.MapKeys() { | |||
val, err := ToInt64E(v.MapIndex(keyVal).Interface()) | |||
if err != nil { | |||
return m, fmt.Errorf("unable to cast %#v of type %T to map[string]int64", i, i) | |||
} | |||
mVal.SetMapIndex(keyVal, reflect.ValueOf(val)) | |||
} | |||
return m, nil | |||
} | |||
// ToSliceE casts an interface to a []interface{} type. | |||
func ToSliceE(i interface{}) ([]interface{}, error) { | |||
var s []interface{} | |||
@@ -0,0 +1,7 @@ | |||
module github.com/spf13/cast | |||
require ( | |||
github.com/davecgh/go-spew v1.1.1 // indirect | |||
github.com/pmezard/go-difflib v1.0.0 // indirect | |||
github.com/stretchr/testify v1.2.2 | |||
) |
@@ -0,0 +1,6 @@ | |||
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= | |||
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= | |||
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= | |||
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= | |||
github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w= | |||
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= |