literal: rewrite Map() to cover more types

pkg/policy/literal/literal.go

@@ -3,9 +3,12 @@ package literal
 
 import (
 	"fmt"
+	"reflect"
 
 	"github.com/ipfs/go-cid"
 	"github.com/ipld/go-ipld-prime"
+	"github.com/ipld/go-ipld-prime/datamodel"
+	"github.com/ipld/go-ipld-prime/fluent/qp"
 	cidlink "github.com/ipld/go-ipld-prime/linking/cid"
 	"github.com/ipld/go-ipld-prime/node/basicnode"
 )
@@ -29,68 +32,61 @@ func Null() ipld.Node {
 
 // Map creates an IPLD node from a map[string]any
 func Map(m map[string]any) (ipld.Node, error) {
-	nb := basicnode.Prototype.Map.NewBuilder()
+	return qp.BuildMap(basicnode.Prototype.Any, int64(len(m)), func(ma datamodel.MapAssembler) {
-	ma, err := nb.BeginMap(int64(len(m)))
+		for k, v := range m {
-	if err != nil {
+			qp.MapEntry(ma, k, anyAssemble(v))
-		return nil, err
-	}
-
-	for k, v := range m {
-		if err := ma.AssembleKey().AssignString(k); err != nil {
-			return nil, err
 		}
-
+	})
-		switch x := v.(type) {
+}
-		case string:
+
-			if err := ma.AssembleValue().AssignString(x); err != nil {
+func anyAssemble(val any) qp.Assemble {
-				return nil, err
+	var rt reflect.Type
-			}
+	var rv reflect.Value
-		case []any:
+
-			lb := basicnode.Prototype.List.NewBuilder()
+	// support for recursive calls, staying in reflection land
-			la, err := lb.BeginList(int64(len(x)))
+	if cast, ok := val.(reflect.Value); ok {
-			if err != nil {
+		rt = cast.Type()
-				return nil, err
+		rv = cast
-			}
+	} else {
-			for _, elem := range x {
+		rt = reflect.TypeOf(val)
-				switch e := elem.(type) {
+		rv = reflect.ValueOf(val)
-				case string:
+	}
-					if err := la.AssembleValue().AssignString(e); err != nil {
+
-						return nil, err
+	// we need to dereference in some cases, to get the real value type
-					}
+	if rt.Kind() == reflect.Ptr || rt.Kind() == reflect.Interface {
-				case map[string]any:
+		rv = rv.Elem()
-					nestedNode, err := Map(e)
+		rt = rv.Type()
-					if err != nil {
+	}
-						return nil, err
+
-					}
+	switch rt.Kind() {
-					if err := la.AssembleValue().AssignNode(nestedNode); err != nil {
+	case reflect.Array, reflect.Slice:
-						return nil, err
+		return qp.List(int64(rv.Len()), func(la datamodel.ListAssembler) {
-					}
+			for i := range rv.Len() {
-				default:
+				qp.ListEntry(la, anyAssemble(rv.Index(i)))
-					return nil, fmt.Errorf("unsupported array element type: %T", elem)
+			}
-				}
+		})
-			}
+	case reflect.Map:
-			if err := la.Finish(); err != nil {
+		if rt.Key().Kind() != reflect.String {
-				return nil, err
+			break
-			}
+		}
-			if err := ma.AssembleValue().AssignNode(lb.Build()); err != nil {
+		it := rv.MapRange()
-				return nil, err
+		return qp.Map(int64(rv.Len()), func(ma datamodel.MapAssembler) {
-			}
+			for it.Next() {
-		case map[string]any:
+				qp.MapEntry(ma, it.Key().String(), anyAssemble(it.Value()))
-			nestedNode, err := Map(x) // recursive call for nested maps
+			}
-			if err != nil {
+		})
-				return nil, err
+	case reflect.Bool:
-			}
+		return qp.Bool(rv.Bool())
-			if err := ma.AssembleValue().AssignNode(nestedNode); err != nil {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-				return nil, err
+		return qp.Int(rv.Int())
-			}
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		default:
+		return qp.Int(int64(rv.Uint()))
-			return nil, fmt.Errorf("unsupported value type: %T", v)
+	case reflect.Float32, reflect.Float64:
-		}
+		return qp.Float(rv.Float())
-	}
+	case reflect.String:
-
+		return qp.String(rv.String())
-	if err := ma.Finish(); err != nil {
+	default:
-		return nil, err
+	}
-	}
+
-
+	panic(fmt.Sprintf("unsupported type %T", val))
-	return nb.Build(), nil
 }