Update to 8.3.0 | MVC Models and Bindings and fix of #723 , read HISTORY.md

Former-commit-id: d8f66d8d370c583a288333df2a14c6ee2dc56466

mvc/activator/binder.go

@@ -0,0 +1,118 @@
+package activator
+
+import (
+	"reflect"
+)
+
+type binder struct {
+	values []interface{}
+	fields []field
+}
+
+// binder accepts a value of something
+// and tries to find its equalivent type
+// inside the controller and sets that to it,
+// after that each new instance of the controller will have
+// this value on the specific field, like persistence data control does.
+//
+// returns a nil binder if values are not valid bindable data to the controller type.
+func newBinder(elemType reflect.Type, values []interface{}) *binder {
+	if len(values) == 0 {
+		return nil
+	}
+
+	b := &binder{values: values}
+	b.fields = b.lookup(elemType)
+
+	// if nothing valid found return nil, so the caller
+	// can omit the binder.
+	if len(b.fields) == 0 {
+		return nil
+	}
+
+	return b
+}
+
+func (b *binder) lookup(elem reflect.Type) (fields []field) {
+	for _, v := range b.values {
+		value := reflect.ValueOf(v)
+		for i, n := 0, elem.NumField(); i < n; i++ {
+			elemField := elem.Field(i)
+
+			if elemField.Type == value.Type() {
+				// we area inside the correct type
+				// println("[0] prepare bind filed for " + elemField.Name)
+				fields = append(fields, field{
+					Index: i,
+					Name:  elemField.Name,
+					Type:  elemField.Type,
+					Value: value,
+				})
+				continue
+			}
+
+			f := lookupStruct(elemField.Type, value)
+			if f != nil {
+				fields = append(fields, field{
+					Index:    i,
+					Name:     elemField.Name,
+					Type:     elemField.Type,
+					embedded: f,
+				})
+			}
+
+		}
+	}
+	return
+}
+
+func lookupStruct(elem reflect.Type, value reflect.Value) *field {
+	// ignore if that field is not a struct
+	if elem.Kind() != reflect.Struct {
+		// and it's not a controller because we don't want to accidentally
+		// set fields to other user fields. Or no?
+		//  ||
+		// 	(elem.Name() != "" && !strings.HasSuffix(elem.Name(), "Controller")) {
+		return nil
+	}
+
+	// search by fields.
+	for i, n := 0, elem.NumField(); i < n; i++ {
+		elemField := elem.Field(i)
+		if elemField.Type == value.Type() {
+			// println("Types are equal of: " + elemField.Type.Name() + " " + elemField.Name + " and " + value.Type().Name())
+			// we area inside the correct type.
+			return &field{
+				Index: i,
+				Name:  elemField.Name,
+				Type:  elemField.Type,
+				Value: value,
+			}
+		}
+
+		// if field is struct and the value is struct
+		// then try inside its fields for a compatible
+		// field type.
+		if elemField.Type.Kind() == reflect.Struct && value.Type().Kind() == reflect.Struct {
+			elemFieldEmb := elem.Field(i)
+			f := lookupStruct(elemFieldEmb.Type, value)
+			if f != nil {
+				fp := &field{
+					Index:    i,
+					Name:     elemFieldEmb.Name,
+					Type:     elemFieldEmb.Type,
+					embedded: f,
+				}
+				return fp
+			}
+		}
+	}
+	return nil
+}
+
+func (b *binder) handle(c reflect.Value) {
+	elem := c.Elem() // controller should always be a pointer at this state
+	for _, f := range b.fields {
+		f.sendTo(elem)
+	}
+}