package internal import ( "errors" "fmt" "reflect" "strings" ) // AddMetadata Adds metadata to a node. // nodes + element -> nodes func AddMetadata(structure interface{}, node *Node) error { if node == nil { return nil } if len(node.Children) == 0 { return fmt.Errorf("invalid node %s: no child", node.Name) } if structure == nil { return errors.New("nil structure") } rootType := reflect.TypeOf(structure) node.Kind = rootType.Kind() return browseChildren(rootType, node) } func addMetadata(rootType reflect.Type, node *Node) error { rType := rootType if rootType.Kind() == reflect.Ptr { rType = rootType.Elem() } field, err := findTypedField(rType, node) if err != nil { return err } if err = isSupportedType(field); err != nil { return err } fType := field.Type node.Kind = fType.Kind() if fType.Kind() == reflect.Struct || fType.Kind() == reflect.Ptr && fType.Elem().Kind() == reflect.Struct || fType.Kind() == reflect.Map { if len(node.Children) == 0 && field.Tag.Get(TagLabel) != "allowEmpty" { return fmt.Errorf("node %s (type %s) must have children", node.Name, fType) } node.Disabled = len(node.Value) > 0 && !strings.EqualFold(node.Value, "true") && field.Tag.Get(TagLabel) == "allowEmpty" } if len(node.Children) == 0 { return nil } if fType.Kind() == reflect.Struct || fType.Kind() == reflect.Ptr && fType.Elem().Kind() == reflect.Struct { return browseChildren(fType, node) } if fType.Kind() == reflect.Map { for _, child := range node.Children { // elem is a map entry value type elem := fType.Elem() child.Kind = elem.Kind() if elem.Kind() == reflect.Map || elem.Kind() == reflect.Struct || (elem.Kind() == reflect.Ptr && elem.Elem().Kind() == reflect.Struct) { if err = browseChildren(elem, child); err != nil { return err } } } return nil } // only for struct/Ptr with label-slice-as-struct tag if fType.Kind() == reflect.Slice { return browseChildren(fType.Elem(), node) } return fmt.Errorf("invalid node %s: %v", node.Name, fType.Kind()) } func findTypedField(rType reflect.Type, node *Node) (reflect.StructField, error) { for i := 0; i < rType.NumField(); i++ { cField := rType.Field(i) fieldName := cField.Tag.Get(TagLabelSliceAsStruct) if len(fieldName) == 0 { fieldName = cField.Name } if isExported(cField) && strings.EqualFold(fieldName, node.Name) { node.FieldName = cField.Name return cField, nil } } return reflect.StructField{}, fmt.Errorf("field not found, node: %s", node.Name) } func browseChildren(fType reflect.Type, node *Node) error { for _, child := range node.Children { if err := addMetadata(fType, child); err != nil { return err } } return nil } // isExported return true is a struct field is exported, else false // https://golang.org/pkg/reflect/#StructField func isExported(f reflect.StructField) bool { if f.PkgPath != "" && !f.Anonymous { return false } return true } func isSupportedType(field reflect.StructField) error { fType := field.Type if fType.Kind() == reflect.Slice { switch fType.Elem().Kind() { case reflect.String, reflect.Bool, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr, reflect.Float32, reflect.Float64: return nil default: if len(field.Tag.Get(TagLabelSliceAsStruct)) > 0 { return nil } return fmt.Errorf("unsupported slice type: %v", fType) } } if fType.Kind() == reflect.Ptr && fType.Elem().Kind() != reflect.Struct { return fmt.Errorf("unsupported pointer type: %v", fType.Elem()) } if fType.Kind() == reflect.Map && fType.Key().Kind() != reflect.String { return fmt.Errorf("unsupported map key type: %v", fType.Key()) } if fType.Kind() == reflect.Func { return fmt.Errorf("unsupported type: %v", fType) } return nil }