feat(fields): read/set all the fields from the given struct

refactor

Author: bkrukowski

fields/iterate.go

@@ -126,6 +126,7 @@ func iterate(strct any, cfg *config, path []reflect.StructField) error {
 				return intReflect.FieldCallbackResultStop()
 			}
 
+			// TODO do not use DeepEqual, return in the result whether the value has changed
 			valueHasChanged = valueHasChanged || !reflect.DeepEqual(original, value)
 		}
 

internal/reflect/iterate.go

@@ -82,120 +82,155 @@ func IterateFields(strct any, callback FieldCallback, convert bool, convertToPtr
 		return err
 	}
 
+	var iterator func(
+		reflectVal reflect.Value,
+		callback FieldCallback,
+		convert bool,
+		convertToPtr bool,
+	) error
+
 	switch {
 	case chain.equalTo(reflect.Struct):
 		strType = fmt.Sprintf("%T", reflect.Zero(reflectVal.Type()).Interface())
+		iterator = iterateStruct
 
-		for i := 0; i < reflectVal.Type().NumField(); i++ {
-			result := callback(reflectVal.Type().Field(i), valueFromField(reflectVal, i))
+	case chain.equalTo(reflect.Ptr, reflect.Struct):
+		strType = fmt.Sprintf("%T", reflect.Zero(reflectVal.Elem().Type()).Interface())
+		iterator = iteratePtrStruct
 
-			if result.set {
-				return fmt.Errorf("pointer is required to set fields")
-			}
+	case chain.equalTo(reflect.Ptr, reflect.Interface, reflect.Struct):
+		strType = fmt.Sprintf("%T", reflect.Zero(reflectVal.Type()).Interface())
+		iterator = iteratePtrInterfaceStruct
 
-			if result.stop {
-				return nil
-			}
+	default:
+		if err := ptrToNilStructError(strct); err != nil {
+			return err
 		}
 
-	case chain.equalTo(reflect.Ptr, reflect.Struct):
-		strType = fmt.Sprintf("%T", reflect.Zero(reflectVal.Elem().Type()).Interface())
-
-		for i := 0; i < reflectVal.Elem().Type().NumField(); i++ {
-			result := callback(reflectVal.Elem().Type().Field(i), valueFromField(reflectVal.Elem(), i))
+		return fmt.Errorf("expected struct or pointer to struct, %T given", strct)
+	}
 
-			if result.set {
-				f := reflectVal.Elem().Field(i)
-				if !f.CanSet() {
-					f = reflect.NewAt(f.Type(), unsafe.Pointer(f.UnsafeAddr())).Elem()
-				}
+	if err := iterator(reflectVal, callback, convert, convertToPtr); err != nil {
+		return err
+	}
 
-				newVal := result.value
+	return nil
+}
 
-				newRefVal, err := func() (reflect.Value, error) {
-					if convertToPtr && f.Kind() == reflect.Ptr && (newVal != nil || reflect.ValueOf(newVal).Kind() != reflect.Ptr) {
-						val, err := ValueOf(newVal, f.Type().Elem(), convert)
-						if err != nil {
-							return reflect.Value{}, err
-						}
+func valueFromField(strct reflect.Value, i int) any { //nolint:ireturn
+	f := strct.Field(i)
 
-						ptr := reflect.New(val.Type())
-						ptr.Elem().Set(val)
+	if !f.CanSet() { // handle unexported fields
+		if !f.CanAddr() {
+			tmpReflectVal := reflect.New(strct.Type()).Elem()
+			tmpReflectVal.Set(strct)
+			f = tmpReflectVal.Field(i)
+		}
 
-						return ptr, nil
-					}
+		f = reflect.NewAt(f.Type(), unsafe.Pointer(f.UnsafeAddr())).Elem()
+	}
 
-					return ValueOf(newVal, f.Type(), convert)
-				}()
+	return f.Interface()
+}
 
-				if err != nil {
-					return fmt.Errorf("field %d %+q: %w", i, reflectVal.Elem().Type().Field(i).Name, err)
-				}
+func iterateStruct(reflectVal reflect.Value, callback FieldCallback, convert bool, convertToPtr bool) error {
+	for i := 0; i < reflectVal.Type().NumField(); i++ {
+		result := callback(reflectVal.Type().Field(i), valueFromField(reflectVal, i))
 
-				f.Set(newRefVal)
-			}
+		if result.set {
+			return fmt.Errorf("pointer is required to set fields")
+		}
 
-			if result.stop {
-				return nil
-			}
+		if result.stop {
+			return nil
 		}
+	}
 
-	case chain.equalTo(reflect.Ptr, reflect.Interface, reflect.Struct):
-		strType = fmt.Sprintf("%T", reflect.Zero(reflectVal.Type()).Interface())
-		v := reflectVal.Elem()
-		tmp := reflect.New(v.Elem().Type())
-		tmp.Elem().Set(v.Elem())
-
-		// TODO find a better solution
-		stop := false
-
-		newCallback := func(f reflect.StructField, value any) FieldCallbackResult {
-			if stop {
-				return FieldCallbackResult{
-					value: nil,
-					set:   false,
-					stop:  true,
-				}
-			}
+	return nil
+}
 
-			result := callback(f, value)
+func iteratePtrStruct(reflectVal reflect.Value, callback FieldCallback, convert bool, convertToPtr bool) error {
+	for i := 0; i < reflectVal.Elem().Type().NumField(); i++ {
+		result := callback(reflectVal.Elem().Type().Field(i), valueFromField(reflectVal.Elem(), i))
 
-			if result.stop {
-				stop = true
+		if result.set {
+			f := reflectVal.Elem().Field(i)
+			if !f.CanSet() {
+				f = reflect.NewAt(f.Type(), unsafe.Pointer(f.UnsafeAddr())).Elem()
 			}
 
-			return result
-		}
+			newVal := result.value
 
-		if err := IterateFields(tmp.Interface(), newCallback, convert, convertToPtr); err != nil {
-			return err
-		}
+			newRefVal, err := func() (reflect.Value, error) {
+				if convertToPtr && f.Kind() == reflect.Ptr && (newVal != nil || reflect.ValueOf(newVal).Kind() != reflect.Ptr) {
+					val, err := ValueOf(newVal, f.Type().Elem(), convert)
+					if err != nil {
+						return reflect.Value{}, err
+					}
 
-		v.Set(tmp.Elem())
+					ptr := reflect.New(val.Type())
+					ptr.Elem().Set(val)
 
-	default:
-		if err := ptrToNilStructError(strct); err != nil {
-			return err
+					return ptr, nil
+				}
+
+				return ValueOf(newVal, f.Type(), convert)
+			}()
+
+			if err != nil {
+				return fmt.Errorf("field %d %+q: %w", i, reflectVal.Elem().Type().Field(i).Name, err)
+			}
+
+			f.Set(newRefVal)
 		}
 
-		return fmt.Errorf("expected struct or pointer to struct, %T given", strct)
+		if result.stop {
+			return nil
+		}
 	}
 
 	return nil
 }
 
-func valueFromField(strct reflect.Value, i int) any { //nolint:ireturn
-	f := strct.Field(i)
+func iteratePtrInterfaceStruct(reflectVal reflect.Value, callback FieldCallback, convert bool, convertToPtr bool) error {
+	v := reflectVal.Elem()
+	tmp := reflect.New(v.Elem().Type())
+	tmp.Elem().Set(v.Elem())
+
+	var (
+		stop = false
+		set  = false
+	)
+
+	newCallback := func(f reflect.StructField, value any) FieldCallbackResult {
+		if stop {
+			return FieldCallbackResult{
+				value: nil,
+				set:   false,
+				stop:  true,
+			}
+		}
 
-	if !f.CanSet() { // handle unexported fields
-		if !f.CanAddr() {
-			tmpReflectVal := reflect.New(strct.Type()).Elem()
-			tmpReflectVal.Set(strct)
-			f = tmpReflectVal.Field(i)
+		result := callback(f, value)
+
+		if result.stop {
+			stop = true
 		}
 
-		f = reflect.NewAt(f.Type(), unsafe.Pointer(f.UnsafeAddr())).Elem()
+		if result.set {
+			set = true
+		}
+
+		return result
 	}
 
-	return f.Interface()
+	if err := IterateFields(tmp.Interface(), newCallback, convert, convertToPtr); err != nil {
+		return err
+	}
+
+	if set {
+		v.Set(tmp.Elem())
+	}
+
+	return nil
 }