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 }