refactor(input): parsing array

Author: v1def

input/iterable.go renamed to input/array.go

@@ -9,12 +9,12 @@ package input
 
 import "reflect"
 
-func ParseIterable(arg any) []any {
+func ParseArray(arg any) []any {
 	val := reflect.ValueOf(arg)
-	return parseIterableValue(&val)
+	return parseArrayValue(&val)
 }
 
-func parseIterableValue(v *reflect.Value) []any {
+func parseArrayValue(v *reflect.Value) []any {
 	e := v.Type().Elem()
 
 	switch e.Kind() {
@@ -29,7 +29,7 @@ func parseIterableValue(v *reflect.Value) []any {
 
 			pv := parseForeignValue(&field)
 			if pv == nil {
-				panic("error: unsupported nested struct")
+				panic("error: unsupported struct")
 			}
 
 			res[i] = pv

input/iterable_test.go renamed to input/array_test.go

@@ -14,7 +14,7 @@ import (
 	"github.com/durudex/go-polybase/input"
 )
 
-var ParseIterableTests = map[string]struct {
+var ParseArrayTests = map[string]struct {
 	arg  any
 	want []any
 }{
@@ -48,10 +48,10 @@ var ParseIterableTests = map[string]struct {
 	},
 }
 
-func TestParseIterable(t *testing.T) {
-	for name, test := range ParseIterableTests {
+func TestParseArray(t *testing.T) {
+	for name, test := range ParseArrayTests {
 		t.Run(name, func(t *testing.T) {
-			got := input.ParseIterable(test.arg)
+			got := input.ParseArray(test.arg)
 
 			if !reflect.DeepEqual(got, test.want) {
 				t.Fatal("error: want does not match")
@@ -60,11 +60,11 @@ func TestParseIterable(t *testing.T) {
 	}
 }
 
-func BenchmarkParseIterable(b *testing.B) {
-	for name, test := range ParseIterableTests {
+func BenchmarkParseArray(b *testing.B) {
+	for name, test := range ParseArrayTests {
 		b.Run(name, func(b *testing.B) {
 			for i := 0; i < b.N; i++ {
-				input.ParseIterable(test.arg)
+				input.ParseArray(test.arg)
 			}
 		})
 	}

input/input.go

@@ -17,7 +17,7 @@ func Parse(args []any) []any {
 
 		switch v.Kind() {
 		case reflect.Array, reflect.Slice:
-			pv := parseIterableValue(&v)
+			pv := parseArrayValue(&v)
 
 			if res == nil {
 				res = pv

input/input_test.go

@@ -48,7 +48,7 @@ var ParseTests = map[string]struct{ args, want []any }{
 			1, "durudex", true, &input.Foreign{
 				CollectionID: "example/example",
 				ID:           "1",
-			}, "", 0, false,
+			}, new(string), new(int), new(bool),
 		},
 	},
 	"Map": {

input/pointer.go

@@ -17,18 +17,29 @@ func ParsePointer(arg any) []any {
 func parsePointerValue(v *reflect.Value) []any {
 	e := v.Elem()
 
+	pv := parseSimplePointerValue(v)
+	if pv == nil {
+		return parseStructValue(&e)
+	}
+
+	return []any{pv}
+}
+
+func parseSimplePointerValue(v *reflect.Value) any {
+	e := v.Elem()
+
 	if v.IsNil() {
-		panic("error: unsupported nil value")
+		panic("error: unsupported pointer nil value")
 	} else if e.Kind() == reflect.Struct {
-		pf := parseForeignValue(v)
-		if pf != nil {
-			return []any{pf}
+		pv := parseForeignValue(v)
+		if pv == nil {
+			return nil
 		}
 
-		return parseStructValue(&e)
+		return pv
 	} else if !AllowedKindType[e.Kind()] {
-		panic("error: unsupported type")
+		panic("error: unsupported pointer type")
 	}
 
-	return []any{e.Interface()}
+	return v.Interface()
 }

input/pointer_test.go

@@ -20,15 +20,15 @@ var ParsePointerTests = map[string]struct {
 }{
 	"String": {
 		arg:  new(string),
-		want: []any{""},
+		want: []any{new(string)},
 	},
 	"Integer": {
 		arg:  new(int),
-		want: []any{0},
+		want: []any{new(int)},
 	},
 	"Boolean": {
 		arg:  new(bool),
-		want: []any{false},
+		want: []any{new(bool)},
 	},
 	"Struct": {
 		arg: &ParseStructMock{

input/struct.go

@@ -16,31 +16,35 @@ func ParseStruct(arg any) []any {
 
 func parseStructValue(v *reflect.Value) []any {
 	n := v.NumField()
-	res := make([]any, 0, n)
+	res := make([]any, n)
 
 	for i := 0; i < n; i++ {
 		field := v.Field(i)
 
 		switch field.Kind() {
 		case reflect.Pointer:
-			pv := parsePointerValue(&field)
-			res = append(res, pv...)
+			pv := parseSimplePointerValue(&field)
+			if pv == nil {
+				panic("error: unsupported pointer value")
+			}
+
+			res[i] = pv
 		case reflect.Map:
 			pv := parseMapValue(&field)
-			res = append(res, pv)
+			res[i] = pv
 		case reflect.Struct:
 			pv := parseForeignValue(&field)
 			if pv == nil {
 				panic("error: unsupported struct type")
 			}
 
-			res = append(res, pv)
+			res[i] = pv
 		default:
 			if !AllowedKindType[field.Kind()] {
 				panic("error: unsupported type")
 			}
 
-			res = append(res, field.Interface())
+			res[i] = field.Interface()
 		}
 	}
 

input/struct_test.go

@@ -44,7 +44,7 @@ var ParseStructTests = map[string]struct {
 			String:  new(string),
 			Boolean: new(bool),
 		},
-		want: []any{0, "", false},
+		want: []any{new(int), new(string), new(bool)},
 	},
 	"Foreign": {
 		arg: struct{ F input.Foreign }{