cast.go

package changeset

import (
	"math"
	"reflect"
	"strings"

	"github.com/go-rel/changeset/params"
)

// CastErrorMessage is the default error message for Cast.
var CastErrorMessage = "{field} is invalid"

// Cast params as changes for the given data according to the permitted fields. Returns a new changeset.
// params will only be added as changes if it does not have the same value as the field in the data.
func Cast(data interface{}, params params.Params, fields []string, opts ...Option) *Changeset {
	options := Options{
		message:     CastErrorMessage,
		emptyValues: []interface{}{""},
	}
	options.apply(opts)

	var ch *Changeset
	if existingCh, ok := data.(Changeset); ok {
		ch = &existingCh
	} else if existingCh, ok := data.(*Changeset); ok {
		ch = existingCh
	} else {
		ch = &Changeset{}
		ch.params = params
		ch.changes = make(map[string]interface{})
		ch.values, ch.types, ch.zero = mapSchema(data, true)
	}

	for _, field := range fields {
		typ, texist := ch.types[field]

		if !params.Exists(field) || !texist {
			continue
		}

		// ignore if it's an empty value
		if contains(options.emptyValues, params.Get(field)) {
			continue
		}

		if change, valid := params.GetWithType(field, typ); valid {
			value, vexist := ch.values[field]

			if (typ.Kind() == reflect.Slice || typ.Kind() == reflect.Array) || (ch.zero && change != nil) || (!vexist && change != nil) || (vexist && value != change) {
				ch.changes[field] = change
			}
		} else {
			msg := strings.Replace(options.message, "{field}", field, 1)
			AddError(ch, field, msg)
		}
	}

	return ch
}

func mapSchema(data interface{}, zero bool) (map[string]interface{}, map[string]reflect.Type, bool) {
	var (
		fields    = inferFields(data)
		types     = inferTypes(data)
		values    = inferValues(data)
		valuesMap = make(map[string]interface{}, len(fields))
		typesMap  = make(map[string]reflect.Type, len(fields))
	)

	for field, index := range fields {
		typesMap[field] = types[index]

		value := values[index]

		if value != nil {
			valuesMap[field] = values[index]

			if zero {
				zero = isZero(value)
			}
		}
	}

	return valuesMap, typesMap, zero
}

func contains(vs []interface{}, v interface{}) bool {
	for i := range vs {
		if vs[i] == v {
			return true
		}
	}

	return false
}

// isZero shallowly check wether a field in struct is zero or not
func isZero(i interface{}) bool {
	zero := true

	switch v := i.(type) {
	case bool:
		zero = v == false
	case string:
		zero = v == ""
	case int:
		zero = v == 0
	case int8:
		zero = v == 0
	case int16:
		zero = v == 0
	case int32:
		zero = v == 0
	case int64:
		zero = v == 0
	case uint:
		zero = v == 0
	case uint8:
		zero = v == 0
	case uint16:
		zero = v == 0
	case uint32:
		zero = v == 0
	case uint64:
		zero = v == 0
	case uintptr:
		zero = v == 0
	case float32:
		zero = v == 0
	case float64:
		zero = v == 0
	default:
		zero = isDeepZero(reflect.ValueOf(i), 0)
	}

	return zero
}

// modified from https://golang.org/src/reflect/value.go?s=33807:33835#L1077
func isDeepZero(rv reflect.Value, depth int) bool {
	if depth < 0 {
		return true
	}

	switch rv.Kind() {
	case reflect.Bool:
		return !rv.Bool()
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return rv.Int() == 0
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
		return rv.Uint() == 0
	case reflect.Float32, reflect.Float64:
		return math.Float64bits(rv.Float()) == 0
	case reflect.Complex64, reflect.Complex128:
		c := rv.Complex()
		return math.Float64bits(real(c)) == 0 && math.Float64bits(imag(c)) == 0
	case reflect.Array:
		for i := 0; i < rv.Len(); i++ {
			if !isDeepZero(rv.Index(i), depth-1) {
				return false
			}
		}
		return true
	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice, reflect.UnsafePointer:
		return rv.IsNil()
	case reflect.String:
		return rv.Len() == 0
	case reflect.Struct:
		for i := 0; i < rv.NumField(); i++ {
			if !isDeepZero(rv.Field(i), depth-1) {
				return false
			}
		}
		return true
	default:
		return true
	}
}