databricks-cli/libs/dyn/convert/normalize.go

236 lines
5.9 KiB
Go

package convert
import (
"fmt"
"reflect"
"strconv"
"github.com/databricks/cli/libs/diag"
"github.com/databricks/cli/libs/dyn"
)
func Normalize(dst any, src dyn.Value) (dyn.Value, diag.Diagnostics) {
return normalizeType(reflect.TypeOf(dst), src)
}
func normalizeType(typ reflect.Type, src dyn.Value) (dyn.Value, diag.Diagnostics) {
for typ.Kind() == reflect.Pointer {
typ = typ.Elem()
}
switch typ.Kind() {
case reflect.Struct:
return normalizeStruct(typ, src)
case reflect.Map:
return normalizeMap(typ, src)
case reflect.Slice:
return normalizeSlice(typ, src)
case reflect.String:
return normalizeString(typ, src)
case reflect.Bool:
return normalizeBool(typ, src)
case reflect.Int, reflect.Int32, reflect.Int64:
return normalizeInt(typ, src)
case reflect.Float32, reflect.Float64:
return normalizeFloat(typ, src)
}
return dyn.NilValue, diag.Errorf("unsupported type: %s", typ.Kind())
}
func typeMismatch(expected dyn.Kind, src dyn.Value) diag.Diagnostic {
return diag.Diagnostic{
Severity: diag.Error,
Summary: fmt.Sprintf("expected %s, found %s", expected, src.Kind()),
Location: src.Location(),
}
}
func normalizeStruct(typ reflect.Type, src dyn.Value) (dyn.Value, diag.Diagnostics) {
var diags diag.Diagnostics
switch src.Kind() {
case dyn.KindMap:
out := make(map[string]dyn.Value)
info := getStructInfo(typ)
for k, v := range src.MustMap() {
index, ok := info.Fields[k]
if !ok {
diags = diags.Append(diag.Diagnostic{
Severity: diag.Warning,
Summary: fmt.Sprintf("unknown field: %s", k),
Location: src.Location(),
})
continue
}
// Normalize the value according to the field type.
v, err := normalizeType(typ.FieldByIndex(index).Type, v)
if err != nil {
diags = diags.Extend(err)
// Skip the element if it cannot be normalized.
if err.HasError() {
continue
}
}
out[k] = v
}
return dyn.NewValue(out, src.Location()), diags
case dyn.KindNil:
return src, diags
}
return dyn.NilValue, diags.Append(typeMismatch(dyn.KindMap, src))
}
func normalizeMap(typ reflect.Type, src dyn.Value) (dyn.Value, diag.Diagnostics) {
var diags diag.Diagnostics
switch src.Kind() {
case dyn.KindMap:
out := make(map[string]dyn.Value)
for k, v := range src.MustMap() {
// Normalize the value according to the map element type.
v, err := normalizeType(typ.Elem(), v)
if err != nil {
diags = diags.Extend(err)
// Skip the element if it cannot be normalized.
if err.HasError() {
continue
}
}
out[k] = v
}
return dyn.NewValue(out, src.Location()), diags
case dyn.KindNil:
return src, diags
}
return dyn.NilValue, diags.Append(typeMismatch(dyn.KindMap, src))
}
func normalizeSlice(typ reflect.Type, src dyn.Value) (dyn.Value, diag.Diagnostics) {
var diags diag.Diagnostics
switch src.Kind() {
case dyn.KindSequence:
out := make([]dyn.Value, 0, len(src.MustSequence()))
for _, v := range src.MustSequence() {
// Normalize the value according to the slice element type.
v, err := normalizeType(typ.Elem(), v)
if err != nil {
diags = diags.Extend(err)
// Skip the element if it cannot be normalized.
if err.HasError() {
continue
}
}
out = append(out, v)
}
return dyn.NewValue(out, src.Location()), diags
case dyn.KindNil:
return src, diags
}
return dyn.NilValue, diags.Append(typeMismatch(dyn.KindSequence, src))
}
func normalizeString(typ reflect.Type, src dyn.Value) (dyn.Value, diag.Diagnostics) {
var diags diag.Diagnostics
var out string
switch src.Kind() {
case dyn.KindString:
out = src.MustString()
case dyn.KindBool:
out = strconv.FormatBool(src.MustBool())
case dyn.KindInt:
out = strconv.FormatInt(src.MustInt(), 10)
case dyn.KindFloat:
out = strconv.FormatFloat(src.MustFloat(), 'f', -1, 64)
default:
return dyn.NilValue, diags.Append(typeMismatch(dyn.KindString, src))
}
return dyn.NewValue(out, src.Location()), diags
}
func normalizeBool(typ reflect.Type, src dyn.Value) (dyn.Value, diag.Diagnostics) {
var diags diag.Diagnostics
var out bool
switch src.Kind() {
case dyn.KindBool:
out = src.MustBool()
case dyn.KindString:
// See https://github.com/go-yaml/yaml/blob/f6f7691b1fdeb513f56608cd2c32c51f8194bf51/decode.go#L684-L693.
switch src.MustString() {
case "true", "y", "Y", "yes", "Yes", "YES", "on", "On", "ON":
out = true
case "false", "n", "N", "no", "No", "NO", "off", "Off", "OFF":
out = false
default:
// Cannot interpret as a boolean.
return dyn.NilValue, diags.Append(typeMismatch(dyn.KindBool, src))
}
default:
return dyn.NilValue, diags.Append(typeMismatch(dyn.KindBool, src))
}
return dyn.NewValue(out, src.Location()), diags
}
func normalizeInt(typ reflect.Type, src dyn.Value) (dyn.Value, diag.Diagnostics) {
var diags diag.Diagnostics
var out int64
switch src.Kind() {
case dyn.KindInt:
out = src.MustInt()
case dyn.KindString:
var err error
out, err = strconv.ParseInt(src.MustString(), 10, 64)
if err != nil {
return dyn.NilValue, diags.Append(diag.Diagnostic{
Severity: diag.Error,
Summary: fmt.Sprintf("cannot parse %q as an integer", src.MustString()),
Location: src.Location(),
})
}
default:
return dyn.NilValue, diags.Append(typeMismatch(dyn.KindInt, src))
}
return dyn.NewValue(out, src.Location()), diags
}
func normalizeFloat(typ reflect.Type, src dyn.Value) (dyn.Value, diag.Diagnostics) {
var diags diag.Diagnostics
var out float64
switch src.Kind() {
case dyn.KindFloat:
out = src.MustFloat()
case dyn.KindString:
var err error
out, err = strconv.ParseFloat(src.MustString(), 64)
if err != nil {
return dyn.NilValue, diags.Append(diag.Diagnostic{
Severity: diag.Error,
Summary: fmt.Sprintf("cannot parse %q as a floating point number", src.MustString()),
Location: src.Location(),
})
}
default:
return dyn.NilValue, diags.Append(typeMismatch(dyn.KindFloat, src))
}
return dyn.NewValue(out, src.Location()), diags
}