1
0
mirror of https://github.com/danog/liquid.git synced 2024-12-13 00:27:22 +01:00
liquid/evaluator/convert.go
Oliver Steele a78d95d73f Coverage
2017-07-18 18:40:19 -04:00

135 lines
3.8 KiB
Go

package evaluator
import (
"fmt"
"reflect"
"strconv"
"time"
)
// A TypeError is an error during type conversion.
type TypeError string
func (e TypeError) Error() string { return string(e) }
func typeErrorf(format string, a ...interface{}) TypeError {
return TypeError(fmt.Sprintf(format, a...))
}
var timeType = reflect.TypeOf(time.Now())
func conversionError(modifier string, value interface{}, typ reflect.Type) error {
if modifier != "" {
modifier += " "
}
switch ref := value.(type) {
case reflect.Value:
value = ref.Interface()
}
return typeErrorf("can't convert %s%T(%v) to type %s", modifier, value, value, typ)
}
// Convert value to the type. This is a more aggressive conversion, that will
// recursively create new map and slice values as necessary. It doesn't
// handle circular references.
func Convert(value interface{}, typ reflect.Type) (interface{}, error) { // nolint: gocyclo
value = ToLiquid(value)
r := reflect.ValueOf(value)
// int.Convert(string) returns "\x01" not "1", so guard against that in the following test
if typ.Kind() != reflect.String && value != nil && r.Type().ConvertibleTo(typ) {
return r.Convert(typ).Interface(), nil
}
if typ == timeType && r.Kind() == reflect.String {
return ParseDate(value.(string))
}
// currently unused:
// case reflect.PtrTo(r.Type()) == typ:
// return &value, nil
// }
switch typ.Kind() {
case reflect.Bool:
return !(value == nil || value == false), nil
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
switch value := value.(type) {
case bool:
if value {
return 1, nil
}
return 0, nil
case string:
return strconv.Atoi(value)
}
case reflect.Float32, reflect.Float64:
switch value := value.(type) {
// case int is handled by r.Convert(type) above
case string:
return strconv.ParseFloat(value, 64)
}
case reflect.Map:
out := reflect.MakeMap(typ)
for _, key := range r.MapKeys() {
if typ.Key().Kind() == reflect.String {
key = reflect.ValueOf(fmt.Sprint(key))
}
if !key.Type().ConvertibleTo(typ.Key()) {
return nil, conversionError("map key", key, typ.Key())
}
key = key.Convert(typ.Key())
value := r.MapIndex(key)
if typ.Elem().Kind() == reflect.String {
value = reflect.ValueOf(fmt.Sprint(value))
}
if !value.Type().ConvertibleTo(typ.Elem()) {
return nil, conversionError("map value", value, typ.Elem())
}
out.SetMapIndex(key, value.Convert(typ.Elem()))
}
return out.Interface(), nil
case reflect.Slice:
switch r.Kind() {
case reflect.Array, reflect.Slice:
out := reflect.MakeSlice(typ, 0, r.Len())
for i := 0; i < r.Len(); i++ {
item, err := Convert(r.Index(i).Interface(), typ.Elem())
if err != nil {
return nil, err
}
out = reflect.Append(out, reflect.ValueOf(item))
}
return out.Interface(), nil
case reflect.Map:
out := reflect.MakeSlice(typ, 0, r.Len())
for _, key := range r.MapKeys() {
item, err := Convert(r.MapIndex(key).Interface(), typ.Elem())
if err != nil {
return nil, err
}
out = reflect.Append(out, reflect.ValueOf(item))
}
return out.Interface(), nil
}
case reflect.String:
return fmt.Sprint(value), nil
}
return nil, conversionError("", value, typ)
}
// MustConvert is like Convert, but panics if conversion fails.
func MustConvert(value interface{}, t reflect.Type) interface{} {
out, err := Convert(value, t)
if err != nil {
panic(err)
}
return out
}
// MustConvertItem converts item to conform to the type array's element, else panics.
// Unlike MustConvert, the second argument is a value not a type.
func MustConvertItem(item interface{}, array interface{}) interface{} {
item, err := Convert(item, reflect.TypeOf(array).Elem())
if err != nil {
panic(typeErrorf("can't convert %#v to %s: %s", item, reflect.TypeOf(array).Elem(), err))
}
return item
}