package toml import ( "bytes" "encoding" "errors" "fmt" "io" "reflect" "sort" "strconv" "strings" "time" ) const ( tagFieldName = "toml" tagFieldComment = "comment" tagCommented = "commented" tagMultiline = "multiline" tagDefault = "default" ) type tomlOpts struct { name string nameFromTag bool comment string commented bool multiline bool include bool omitempty bool defaultValue string } type encOpts struct { quoteMapKeys bool arraysOneElementPerLine bool } var encOptsDefaults = encOpts{ quoteMapKeys: false, } type annotation struct { tag string comment string commented string multiline string defaultValue string } var annotationDefault = annotation{ tag: tagFieldName, comment: tagFieldComment, commented: tagCommented, multiline: tagMultiline, defaultValue: tagDefault, } type marshalOrder int // Orders the Encoder can write the fields to the output stream. const ( // Sort fields alphabetically. OrderAlphabetical marshalOrder = iota + 1 // Preserve the order the fields are encountered. For example, the order of fields in // a struct. OrderPreserve ) var timeType = reflect.TypeOf(time.Time{}) var marshalerType = reflect.TypeOf(new(Marshaler)).Elem() var unmarshalerType = reflect.TypeOf(new(Unmarshaler)).Elem() var textMarshalerType = reflect.TypeOf(new(encoding.TextMarshaler)).Elem() var textUnmarshalerType = reflect.TypeOf(new(encoding.TextUnmarshaler)).Elem() var localDateType = reflect.TypeOf(LocalDate{}) var localTimeType = reflect.TypeOf(LocalTime{}) var localDateTimeType = reflect.TypeOf(LocalDateTime{}) var mapStringInterfaceType = reflect.TypeOf(map[string]interface{}{}) // Check if the given marshal type maps to a Tree primitive func isPrimitive(mtype reflect.Type) bool { switch mtype.Kind() { case reflect.Ptr: return isPrimitive(mtype.Elem()) case reflect.Bool: return true case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: return true case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: return true case reflect.Float32, reflect.Float64: return true case reflect.String: return true case reflect.Struct: return isTimeType(mtype) default: return false } } func isTimeType(mtype reflect.Type) bool { return mtype == timeType || mtype == localDateType || mtype == localDateTimeType || mtype == localTimeType } // Check if the given marshal type maps to a Tree slice or array func isTreeSequence(mtype reflect.Type) bool { switch mtype.Kind() { case reflect.Ptr: return isTreeSequence(mtype.Elem()) case reflect.Slice, reflect.Array: return isTree(mtype.Elem()) default: return false } } // Check if the given marshal type maps to a slice or array of a custom marshaler type func isCustomMarshalerSequence(mtype reflect.Type) bool { switch mtype.Kind() { case reflect.Ptr: return isCustomMarshalerSequence(mtype.Elem()) case reflect.Slice, reflect.Array: return isCustomMarshaler(mtype.Elem()) || isCustomMarshaler(reflect.New(mtype.Elem()).Type()) default: return false } } // Check if the given marshal type maps to a slice or array of a text marshaler type func isTextMarshalerSequence(mtype reflect.Type) bool { switch mtype.Kind() { case reflect.Ptr: return isTextMarshalerSequence(mtype.Elem()) case reflect.Slice, reflect.Array: return isTextMarshaler(mtype.Elem()) || isTextMarshaler(reflect.New(mtype.Elem()).Type()) default: return false } } // Check if the given marshal type maps to a non-Tree slice or array func isOtherSequence(mtype reflect.Type) bool { switch mtype.Kind() { case reflect.Ptr: return isOtherSequence(mtype.Elem()) case reflect.Slice, reflect.Array: return !isTreeSequence(mtype) default: return false } } // Check if the given marshal type maps to a Tree func isTree(mtype reflect.Type) bool { switch mtype.Kind() { case reflect.Ptr: return isTree(mtype.Elem()) case reflect.Map: return true case reflect.Struct: return !isPrimitive(mtype) default: return false } } func isCustomMarshaler(mtype reflect.Type) bool { return mtype.Implements(marshalerType) } func callCustomMarshaler(mval reflect.Value) ([]byte, error) { return mval.Interface().(Marshaler).MarshalTOML() } func isTextMarshaler(mtype reflect.Type) bool { return mtype.Implements(textMarshalerType) && !isTimeType(mtype) } func callTextMarshaler(mval reflect.Value) ([]byte, error) { return mval.Interface().(encoding.TextMarshaler).MarshalText() } func isCustomUnmarshaler(mtype reflect.Type) bool { return mtype.Implements(unmarshalerType) } func callCustomUnmarshaler(mval reflect.Value, tval interface{}) error { return mval.Interface().(Unmarshaler).UnmarshalTOML(tval) } func isTextUnmarshaler(mtype reflect.Type) bool { return mtype.Implements(textUnmarshalerType) } func callTextUnmarshaler(mval reflect.Value, text []byte) error { return mval.Interface().(encoding.TextUnmarshaler).UnmarshalText(text) } // Marshaler is the interface implemented by types that // can marshal themselves into valid TOML. type Marshaler interface { MarshalTOML() ([]byte, error) } // Unmarshaler is the interface implemented by types that // can unmarshal a TOML description of themselves. type Unmarshaler interface { UnmarshalTOML(interface{}) error } /* Marshal returns the TOML encoding of v. Behavior is similar to the Go json encoder, except that there is no concept of a Marshaler interface or MarshalTOML function for sub-structs, and currently only definite types can be marshaled (i.e. no `interface{}`). The following struct annotations are supported: toml:"Field" Overrides the field's name to output. omitempty When set, empty values and groups are not emitted. comment:"comment" Emits a # comment on the same line. This supports new lines. commented:"true" Emits the value as commented. Note that pointers are automatically assigned the "omitempty" option, as TOML explicitly does not handle null values (saying instead the label should be dropped). Tree structural types and corresponding marshal types: *Tree (*)struct, (*)map[string]interface{} []*Tree (*)[](*)struct, (*)[](*)map[string]interface{} []interface{} (as interface{}) (*)[]primitive, (*)[]([]interface{}) interface{} (*)primitive Tree primitive types and corresponding marshal types: uint64 uint, uint8-uint64, pointers to same int64 int, int8-uint64, pointers to same float64 float32, float64, pointers to same string string, pointers to same bool bool, pointers to same time.LocalTime time.LocalTime{}, pointers to same For additional flexibility, use the Encoder API. */ func Marshal(v interface{}) ([]byte, error) { return NewEncoder(nil).marshal(v) } // Encoder writes TOML values to an output stream. type Encoder struct { w io.Writer encOpts annotation line int col int order marshalOrder promoteAnon bool indentation string } // NewEncoder returns a new encoder that writes to w. func NewEncoder(w io.Writer) *Encoder { return &Encoder{ w: w, encOpts: encOptsDefaults, annotation: annotationDefault, line: 0, col: 1, order: OrderAlphabetical, indentation: " ", } } // Encode writes the TOML encoding of v to the stream. // // See the documentation for Marshal for details. func (e *Encoder) Encode(v interface{}) error { b, err := e.marshal(v) if err != nil { return err } if _, err := e.w.Write(b); err != nil { return err } return nil } // QuoteMapKeys sets up the encoder to encode // maps with string type keys with quoted TOML keys. // // This relieves the character limitations on map keys. func (e *Encoder) QuoteMapKeys(v bool) *Encoder { e.quoteMapKeys = v return e } // ArraysWithOneElementPerLine sets up the encoder to encode arrays // with more than one element on multiple lines instead of one. // // For example: // // A = [1,2,3] // // Becomes // // A = [ // 1, // 2, // 3, // ] func (e *Encoder) ArraysWithOneElementPerLine(v bool) *Encoder { e.arraysOneElementPerLine = v return e } // Order allows to change in which order fields will be written to the output stream. func (e *Encoder) Order(ord marshalOrder) *Encoder { e.order = ord return e } // Indentation allows to change indentation when marshalling. func (e *Encoder) Indentation(indent string) *Encoder { e.indentation = indent return e } // SetTagName allows changing default tag "toml" func (e *Encoder) SetTagName(v string) *Encoder { e.tag = v return e } // SetTagComment allows changing default tag "comment" func (e *Encoder) SetTagComment(v string) *Encoder { e.comment = v return e } // SetTagCommented allows changing default tag "commented" func (e *Encoder) SetTagCommented(v string) *Encoder { e.commented = v return e } // SetTagMultiline allows changing default tag "multiline" func (e *Encoder) SetTagMultiline(v string) *Encoder { e.multiline = v return e } // PromoteAnonymous allows to change how anonymous struct fields are marshaled. // Usually, they are marshaled as if the inner exported fields were fields in // the outer struct. However, if an anonymous struct field is given a name in // its TOML tag, it is treated like a regular struct field with that name. // rather than being anonymous. // // In case anonymous promotion is enabled, all anonymous structs are promoted // and treated like regular struct fields. func (e *Encoder) PromoteAnonymous(promote bool) *Encoder { e.promoteAnon = promote return e } func (e *Encoder) marshal(v interface{}) ([]byte, error) { // Check if indentation is valid for _, char := range e.indentation { if !isSpace(char) { return []byte{}, fmt.Errorf("invalid indentation: must only contains space or tab characters") } } mtype := reflect.TypeOf(v) if mtype == nil { return []byte{}, errors.New("nil cannot be marshaled to TOML") } switch mtype.Kind() { case reflect.Struct, reflect.Map: case reflect.Ptr: if mtype.Elem().Kind() != reflect.Struct { return []byte{}, errors.New("Only pointer to struct can be marshaled to TOML") } if reflect.ValueOf(v).IsNil() { return []byte{}, errors.New("nil pointer cannot be marshaled to TOML") } default: return []byte{}, errors.New("Only a struct or map can be marshaled to TOML") } sval := reflect.ValueOf(v) if isCustomMarshaler(mtype) { return callCustomMarshaler(sval) } if isTextMarshaler(mtype) { return callTextMarshaler(sval) } t, err := e.valueToTree(mtype, sval) if err != nil { return []byte{}, err } var buf bytes.Buffer _, err = t.writeToOrdered(&buf, "", "", 0, e.arraysOneElementPerLine, e.order, e.indentation, false) return buf.Bytes(), err } // Create next tree with a position based on Encoder.line func (e *Encoder) nextTree() *Tree { return newTreeWithPosition(Position{Line: e.line, Col: 1}) } // Convert given marshal struct or map value to toml tree func (e *Encoder) valueToTree(mtype reflect.Type, mval reflect.Value) (*Tree, error) { if mtype.Kind() == reflect.Ptr { return e.valueToTree(mtype.Elem(), mval.Elem()) } tval := e.nextTree() switch mtype.Kind() { case reflect.Struct: switch mval.Interface().(type) { case Tree: reflect.ValueOf(tval).Elem().Set(mval) default: for i := 0; i < mtype.NumField(); i++ { mtypef, mvalf := mtype.Field(i), mval.Field(i) opts := tomlOptions(mtypef, e.annotation) if opts.include && ((mtypef.Type.Kind() != reflect.Interface && !opts.omitempty) || !isZero(mvalf)) { val, err := e.valueToToml(mtypef.Type, mvalf) if err != nil { return nil, err } if tree, ok := val.(*Tree); ok && mtypef.Anonymous && !opts.nameFromTag && !e.promoteAnon { e.appendTree(tval, tree) } else { val = e.wrapTomlValue(val, tval) tval.SetPathWithOptions([]string{opts.name}, SetOptions{ Comment: opts.comment, Commented: opts.commented, Multiline: opts.multiline, }, val) } } } } case reflect.Map: keys := mval.MapKeys() if e.order == OrderPreserve && len(keys) > 0 { // Sorting []reflect.Value is not straight forward. // // OrderPreserve will support deterministic results when string is used // as the key to maps. typ := keys[0].Type() kind := keys[0].Kind() if kind == reflect.String { ikeys := make([]string, len(keys)) for i := range keys { ikeys[i] = keys[i].Interface().(string) } sort.Strings(ikeys) for i := range ikeys { keys[i] = reflect.ValueOf(ikeys[i]).Convert(typ) } } } for _, key := range keys { mvalf := mval.MapIndex(key) if (mtype.Elem().Kind() == reflect.Ptr || mtype.Elem().Kind() == reflect.Interface) && mvalf.IsNil() { continue } val, err := e.valueToToml(mtype.Elem(), mvalf) if err != nil { return nil, err } val = e.wrapTomlValue(val, tval) if e.quoteMapKeys { keyStr, err := tomlValueStringRepresentation(key.String(), "", "", e.order, e.arraysOneElementPerLine) if err != nil { return nil, err } tval.SetPath([]string{keyStr}, val) } else { tval.SetPath([]string{key.String()}, val) } } } return tval, nil } // Convert given marshal slice to slice of Toml trees func (e *Encoder) valueToTreeSlice(mtype reflect.Type, mval reflect.Value) ([]*Tree, error) { tval := make([]*Tree, mval.Len(), mval.Len()) for i := 0; i < mval.Len(); i++ { val, err := e.valueToTree(mtype.Elem(), mval.Index(i)) if err != nil { return nil, err } tval[i] = val } return tval, nil } // Convert given marshal slice to slice of toml values func (e *Encoder) valueToOtherSlice(mtype reflect.Type, mval reflect.Value) (interface{}, error) { tval := make([]interface{}, mval.Len(), mval.Len()) for i := 0; i < mval.Len(); i++ { val, err := e.valueToToml(mtype.Elem(), mval.Index(i)) if err != nil { return nil, err } tval[i] = val } return tval, nil } // Convert given marshal value to toml value func (e *Encoder) valueToToml(mtype reflect.Type, mval reflect.Value) (interface{}, error) { if mtype.Kind() == reflect.Ptr { switch { case isCustomMarshaler(mtype): return callCustomMarshaler(mval) case isTextMarshaler(mtype): b, err := callTextMarshaler(mval) return string(b), err default: return e.valueToToml(mtype.Elem(), mval.Elem()) } } if mtype.Kind() == reflect.Interface { return e.valueToToml(mval.Elem().Type(), mval.Elem()) } switch { case isCustomMarshaler(mtype): return callCustomMarshaler(mval) case isTextMarshaler(mtype): b, err := callTextMarshaler(mval) return string(b), err case isTree(mtype): return e.valueToTree(mtype, mval) case isOtherSequence(mtype), isCustomMarshalerSequence(mtype), isTextMarshalerSequence(mtype): return e.valueToOtherSlice(mtype, mval) case isTreeSequence(mtype): return e.valueToTreeSlice(mtype, mval) default: switch mtype.Kind() { case reflect.Bool: return mval.Bool(), nil case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: if mtype.Kind() == reflect.Int64 && mtype == reflect.TypeOf(time.Duration(1)) { return fmt.Sprint(mval), nil } return mval.Int(), nil case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: return mval.Uint(), nil case reflect.Float32, reflect.Float64: return mval.Float(), nil case reflect.String: return mval.String(), nil case reflect.Struct: return mval.Interface(), nil default: return nil, fmt.Errorf("Marshal can't handle %v(%v)", mtype, mtype.Kind()) } } } func (e *Encoder) appendTree(t, o *Tree) error { for key, value := range o.values { if _, ok := t.values[key]; ok { continue } if tomlValue, ok := value.(*tomlValue); ok { tomlValue.position.Col = t.position.Col } t.values[key] = value } return nil } // Create a toml value with the current line number as the position line func (e *Encoder) wrapTomlValue(val interface{}, parent *Tree) interface{} { _, isTree := val.(*Tree) _, isTreeS := val.([]*Tree) if isTree || isTreeS { return val } ret := &tomlValue{ value: val, position: Position{ e.line, parent.position.Col, }, } e.line++ return ret } // Unmarshal attempts to unmarshal the Tree into a Go struct pointed by v. // Neither Unmarshaler interfaces nor UnmarshalTOML functions are supported for // sub-structs, and only definite types can be unmarshaled. func (t *Tree) Unmarshal(v interface{}) error { d := Decoder{tval: t, tagName: tagFieldName} return d.unmarshal(v) } // Marshal returns the TOML encoding of Tree. // See Marshal() documentation for types mapping table. func (t *Tree) Marshal() ([]byte, error) { var buf bytes.Buffer _, err := t.WriteTo(&buf) if err != nil { return nil, err } return buf.Bytes(), nil } // Unmarshal parses the TOML-encoded data and stores the result in the value // pointed to by v. Behavior is similar to the Go json encoder, except that there // is no concept of an Unmarshaler interface or UnmarshalTOML function for // sub-structs, and currently only definite types can be unmarshaled to (i.e. no // `interface{}`). // // The following struct annotations are supported: // // toml:"Field" Overrides the field's name to map to. // default:"foo" Provides a default value. // // For default values, only fields of the following types are supported: // * string // * bool // * int // * int64 // * float64 // // See Marshal() documentation for types mapping table. func Unmarshal(data []byte, v interface{}) error { t, err := LoadReader(bytes.NewReader(data)) if err != nil { return err } return t.Unmarshal(v) } // Decoder reads and decodes TOML values from an input stream. type Decoder struct { r io.Reader tval *Tree encOpts tagName string strict bool visitor visitorState } // NewDecoder returns a new decoder that reads from r. func NewDecoder(r io.Reader) *Decoder { return &Decoder{ r: r, encOpts: encOptsDefaults, tagName: tagFieldName, } } // Decode reads a TOML-encoded value from it's input // and unmarshals it in the value pointed at by v. // // See the documentation for Marshal for details. func (d *Decoder) Decode(v interface{}) error { var err error d.tval, err = LoadReader(d.r) if err != nil { return err } return d.unmarshal(v) } // SetTagName allows changing default tag "toml" func (d *Decoder) SetTagName(v string) *Decoder { d.tagName = v return d } // Strict allows changing to strict decoding. Any fields that are found in the // input data and do not have a corresponding struct member cause an error. func (d *Decoder) Strict(strict bool) *Decoder { d.strict = strict return d } func (d *Decoder) unmarshal(v interface{}) error { mtype := reflect.TypeOf(v) if mtype == nil { return errors.New("nil cannot be unmarshaled from TOML") } if mtype.Kind() != reflect.Ptr { return errors.New("only a pointer to struct or map can be unmarshaled from TOML") } elem := mtype.Elem() switch elem.Kind() { case reflect.Struct, reflect.Map: case reflect.Interface: elem = mapStringInterfaceType default: return errors.New("only a pointer to struct or map can be unmarshaled from TOML") } if reflect.ValueOf(v).IsNil() { return errors.New("nil pointer cannot be unmarshaled from TOML") } vv := reflect.ValueOf(v).Elem() if d.strict { d.visitor = newVisitorState(d.tval) } sval, err := d.valueFromTree(elem, d.tval, &vv) if err != nil { return err } if err := d.visitor.validate(); err != nil { return err } reflect.ValueOf(v).Elem().Set(sval) return nil } // Convert toml tree to marshal struct or map, using marshal type. When mval1 // is non-nil, merge fields into the given value instead of allocating a new one. func (d *Decoder) valueFromTree(mtype reflect.Type, tval *Tree, mval1 *reflect.Value) (reflect.Value, error) { if mtype.Kind() == reflect.Ptr { return d.unwrapPointer(mtype, tval, mval1) } // Check if pointer to value implements the Unmarshaler interface. if mvalPtr := reflect.New(mtype); isCustomUnmarshaler(mvalPtr.Type()) { d.visitor.visitAll() if tval == nil { return mvalPtr.Elem(), nil } if err := callCustomUnmarshaler(mvalPtr, tval.ToMap()); err != nil { return reflect.ValueOf(nil), fmt.Errorf("unmarshal toml: %v", err) } return mvalPtr.Elem(), nil } var mval reflect.Value switch mtype.Kind() { case reflect.Struct: if mval1 != nil { mval = *mval1 } else { mval = reflect.New(mtype).Elem() } switch mval.Interface().(type) { case Tree: mval.Set(reflect.ValueOf(tval).Elem()) default: for i := 0; i < mtype.NumField(); i++ { mtypef := mtype.Field(i) an := annotation{tag: d.tagName} opts := tomlOptions(mtypef, an) if !opts.include { continue } baseKey := opts.name keysToTry := []string{ baseKey, strings.ToLower(baseKey), strings.ToTitle(baseKey), strings.ToLower(string(baseKey[0])) + baseKey[1:], } found := false if tval != nil { for _, key := range keysToTry { exists := tval.HasPath([]string{key}) if !exists { continue } d.visitor.push(key) val := tval.GetPath([]string{key}) fval := mval.Field(i) mvalf, err := d.valueFromToml(mtypef.Type, val, &fval) if err != nil { return mval, formatError(err, tval.GetPositionPath([]string{key})) } mval.Field(i).Set(mvalf) found = true d.visitor.pop() break } } if !found && opts.defaultValue != "" { mvalf := mval.Field(i) var val interface{} var err error switch mvalf.Kind() { case reflect.String: val = opts.defaultValue case reflect.Bool: val, err = strconv.ParseBool(opts.defaultValue) case reflect.Uint: val, err = strconv.ParseUint(opts.defaultValue, 10, 0) case reflect.Uint8: val, err = strconv.ParseUint(opts.defaultValue, 10, 8) case reflect.Uint16: val, err = strconv.ParseUint(opts.defaultValue, 10, 16) case reflect.Uint32: val, err = strconv.ParseUint(opts.defaultValue, 10, 32) case reflect.Uint64: val, err = strconv.ParseUint(opts.defaultValue, 10, 64) case reflect.Int: val, err = strconv.ParseInt(opts.defaultValue, 10, 0) case reflect.Int8: val, err = strconv.ParseInt(opts.defaultValue, 10, 8) case reflect.Int16: val, err = strconv.ParseInt(opts.defaultValue, 10, 16) case reflect.Int32: val, err = strconv.ParseInt(opts.defaultValue, 10, 32) case reflect.Int64: val, err = strconv.ParseInt(opts.defaultValue, 10, 64) case reflect.Float32: val, err = strconv.ParseFloat(opts.defaultValue, 32) case reflect.Float64: val, err = strconv.ParseFloat(opts.defaultValue, 64) default: return mvalf, fmt.Errorf("unsupported field type for default option") } if err != nil { return mvalf, err } mvalf.Set(reflect.ValueOf(val).Convert(mvalf.Type())) } // save the old behavior above and try to check structs if !found && opts.defaultValue == "" && mtypef.Type.Kind() == reflect.Struct { tmpTval := tval if !mtypef.Anonymous { tmpTval = nil } fval := mval.Field(i) v, err := d.valueFromTree(mtypef.Type, tmpTval, &fval) if err != nil { return v, err } mval.Field(i).Set(v) } } } case reflect.Map: mval = reflect.MakeMap(mtype) for _, key := range tval.Keys() { d.visitor.push(key) // TODO: path splits key val := tval.GetPath([]string{key}) mvalf, err := d.valueFromToml(mtype.Elem(), val, nil) if err != nil { return mval, formatError(err, tval.GetPositionPath([]string{key})) } mval.SetMapIndex(reflect.ValueOf(key).Convert(mtype.Key()), mvalf) d.visitor.pop() } } return mval, nil } // Convert toml value to marshal struct/map slice, using marshal type func (d *Decoder) valueFromTreeSlice(mtype reflect.Type, tval []*Tree) (reflect.Value, error) { mval, err := makeSliceOrArray(mtype, len(tval)) if err != nil { return mval, err } for i := 0; i < len(tval); i++ { d.visitor.push(strconv.Itoa(i)) val, err := d.valueFromTree(mtype.Elem(), tval[i], nil) if err != nil { return mval, err } mval.Index(i).Set(val) d.visitor.pop() } return mval, nil } // Convert toml value to marshal primitive slice, using marshal type func (d *Decoder) valueFromOtherSlice(mtype reflect.Type, tval []interface{}) (reflect.Value, error) { mval, err := makeSliceOrArray(mtype, len(tval)) if err != nil { return mval, err } for i := 0; i < len(tval); i++ { val, err := d.valueFromToml(mtype.Elem(), tval[i], nil) if err != nil { return mval, err } mval.Index(i).Set(val) } return mval, nil } // Convert toml value to marshal primitive slice, using marshal type func (d *Decoder) valueFromOtherSliceI(mtype reflect.Type, tval interface{}) (reflect.Value, error) { val := reflect.ValueOf(tval) length := val.Len() mval, err := makeSliceOrArray(mtype, length) if err != nil { return mval, err } for i := 0; i < length; i++ { val, err := d.valueFromToml(mtype.Elem(), val.Index(i).Interface(), nil) if err != nil { return mval, err } mval.Index(i).Set(val) } return mval, nil } // Create a new slice or a new array with specified length func makeSliceOrArray(mtype reflect.Type, tLength int) (reflect.Value, error) { var mval reflect.Value switch mtype.Kind() { case reflect.Slice: mval = reflect.MakeSlice(mtype, tLength, tLength) case reflect.Array: mval = reflect.New(reflect.ArrayOf(mtype.Len(), mtype.Elem())).Elem() if tLength > mtype.Len() { return mval, fmt.Errorf("unmarshal: TOML array length (%v) exceeds destination array length (%v)", tLength, mtype.Len()) } } return mval, nil } // Convert toml value to marshal value, using marshal type. When mval1 is non-nil // and the given type is a struct value, merge fields into it. func (d *Decoder) valueFromToml(mtype reflect.Type, tval interface{}, mval1 *reflect.Value) (reflect.Value, error) { if mtype.Kind() == reflect.Ptr { return d.unwrapPointer(mtype, tval, mval1) } switch t := tval.(type) { case *Tree: var mval11 *reflect.Value if mtype.Kind() == reflect.Struct { mval11 = mval1 } if isTree(mtype) { return d.valueFromTree(mtype, t, mval11) } if mtype.Kind() == reflect.Interface { if mval1 == nil || mval1.IsNil() { return d.valueFromTree(reflect.TypeOf(map[string]interface{}{}), t, nil) } else { return d.valueFromToml(mval1.Elem().Type(), t, nil) } } return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to a tree", tval, tval) case []*Tree: if isTreeSequence(mtype) { return d.valueFromTreeSlice(mtype, t) } if mtype.Kind() == reflect.Interface { if mval1 == nil || mval1.IsNil() { return d.valueFromTreeSlice(reflect.TypeOf([]map[string]interface{}{}), t) } else { ival := mval1.Elem() return d.valueFromToml(mval1.Elem().Type(), t, &ival) } } return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to trees", tval, tval) case []interface{}: d.visitor.visit() if isOtherSequence(mtype) { return d.valueFromOtherSlice(mtype, t) } if mtype.Kind() == reflect.Interface { if mval1 == nil || mval1.IsNil() { return d.valueFromOtherSlice(reflect.TypeOf([]interface{}{}), t) } else { ival := mval1.Elem() return d.valueFromToml(mval1.Elem().Type(), t, &ival) } } return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to a slice", tval, tval) default: d.visitor.visit() // Check if pointer to value implements the encoding.TextUnmarshaler. if mvalPtr := reflect.New(mtype); isTextUnmarshaler(mvalPtr.Type()) && !isTimeType(mtype) { if err := d.unmarshalText(tval, mvalPtr); err != nil { return reflect.ValueOf(nil), fmt.Errorf("unmarshal text: %v", err) } return mvalPtr.Elem(), nil } switch mtype.Kind() { case reflect.Bool, reflect.Struct: val := reflect.ValueOf(tval) switch val.Type() { case localDateType: localDate := val.Interface().(LocalDate) switch mtype { case timeType: return reflect.ValueOf(time.Date(localDate.Year, localDate.Month, localDate.Day, 0, 0, 0, 0, time.Local)), nil } case localDateTimeType: localDateTime := val.Interface().(LocalDateTime) switch mtype { case timeType: return reflect.ValueOf(time.Date( localDateTime.Date.Year, localDateTime.Date.Month, localDateTime.Date.Day, localDateTime.Time.Hour, localDateTime.Time.Minute, localDateTime.Time.Second, localDateTime.Time.Nanosecond, time.Local)), nil } } // if this passes for when mtype is reflect.Struct, tval is a time.LocalTime if !val.Type().ConvertibleTo(mtype) { return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to %v", tval, tval, mtype.String()) } return val.Convert(mtype), nil case reflect.String: val := reflect.ValueOf(tval) // stupidly, int64 is convertible to string. So special case this. if !val.Type().ConvertibleTo(mtype) || val.Kind() == reflect.Int64 { return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to %v", tval, tval, mtype.String()) } return val.Convert(mtype), nil case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: val := reflect.ValueOf(tval) if mtype.Kind() == reflect.Int64 && mtype == reflect.TypeOf(time.Duration(1)) && val.Kind() == reflect.String { d, err := time.ParseDuration(val.String()) if err != nil { return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to %v. %s", tval, tval, mtype.String(), err) } return reflect.ValueOf(d), nil } if !val.Type().ConvertibleTo(mtype) || val.Kind() == reflect.Float64 { return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to %v", tval, tval, mtype.String()) } if reflect.Indirect(reflect.New(mtype)).OverflowInt(val.Convert(reflect.TypeOf(int64(0))).Int()) { return reflect.ValueOf(nil), fmt.Errorf("%v(%T) would overflow %v", tval, tval, mtype.String()) } return val.Convert(mtype), nil case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: val := reflect.ValueOf(tval) if !val.Type().ConvertibleTo(mtype) || val.Kind() == reflect.Float64 { return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to %v", tval, tval, mtype.String()) } if val.Convert(reflect.TypeOf(int(1))).Int() < 0 { return reflect.ValueOf(nil), fmt.Errorf("%v(%T) is negative so does not fit in %v", tval, tval, mtype.String()) } if reflect.Indirect(reflect.New(mtype)).OverflowUint(val.Convert(reflect.TypeOf(uint64(0))).Uint()) { return reflect.ValueOf(nil), fmt.Errorf("%v(%T) would overflow %v", tval, tval, mtype.String()) } return val.Convert(mtype), nil case reflect.Float32, reflect.Float64: val := reflect.ValueOf(tval) if !val.Type().ConvertibleTo(mtype) || val.Kind() == reflect.Int64 { return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to %v", tval, tval, mtype.String()) } if reflect.Indirect(reflect.New(mtype)).OverflowFloat(val.Convert(reflect.TypeOf(float64(0))).Float()) { return reflect.ValueOf(nil), fmt.Errorf("%v(%T) would overflow %v", tval, tval, mtype.String()) } return val.Convert(mtype), nil case reflect.Interface: if mval1 == nil || mval1.IsNil() { return reflect.ValueOf(tval), nil } else { ival := mval1.Elem() return d.valueFromToml(mval1.Elem().Type(), t, &ival) } case reflect.Slice, reflect.Array: if isOtherSequence(mtype) && isOtherSequence(reflect.TypeOf(t)) { return d.valueFromOtherSliceI(mtype, t) } return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to %v(%v)", tval, tval, mtype, mtype.Kind()) default: return reflect.ValueOf(nil), fmt.Errorf("Can't convert %v(%T) to %v(%v)", tval, tval, mtype, mtype.Kind()) } } } func (d *Decoder) unwrapPointer(mtype reflect.Type, tval interface{}, mval1 *reflect.Value) (reflect.Value, error) { var melem *reflect.Value if mval1 != nil && !mval1.IsNil() && (mtype.Elem().Kind() == reflect.Struct || mtype.Elem().Kind() == reflect.Interface) { elem := mval1.Elem() melem = &elem } val, err := d.valueFromToml(mtype.Elem(), tval, melem) if err != nil { return reflect.ValueOf(nil), err } mval := reflect.New(mtype.Elem()) mval.Elem().Set(val) return mval, nil } func (d *Decoder) unmarshalText(tval interface{}, mval reflect.Value) error { var buf bytes.Buffer fmt.Fprint(&buf, tval) return callTextUnmarshaler(mval, buf.Bytes()) } func tomlOptions(vf reflect.StructField, an annotation) tomlOpts { tag := vf.Tag.Get(an.tag) parse := strings.Split(tag, ",") var comment string if c := vf.Tag.Get(an.comment); c != "" { comment = c } commented, _ := strconv.ParseBool(vf.Tag.Get(an.commented)) multiline, _ := strconv.ParseBool(vf.Tag.Get(an.multiline)) defaultValue := vf.Tag.Get(tagDefault) result := tomlOpts{ name: vf.Name, nameFromTag: false, comment: comment, commented: commented, multiline: multiline, include: true, omitempty: false, defaultValue: defaultValue, } if parse[0] != "" { if parse[0] == "-" && len(parse) == 1 { result.include = false } else { result.name = strings.Trim(parse[0], " ") result.nameFromTag = true } } if vf.PkgPath != "" { result.include = false } if len(parse) > 1 && strings.Trim(parse[1], " ") == "omitempty" { result.omitempty = true } if vf.Type.Kind() == reflect.Ptr { result.omitempty = true } return result } func isZero(val reflect.Value) bool { switch val.Type().Kind() { case reflect.Slice, reflect.Array, reflect.Map: return val.Len() == 0 default: return reflect.DeepEqual(val.Interface(), reflect.Zero(val.Type()).Interface()) } } func formatError(err error, pos Position) error { if err.Error()[0] == '(' { // Error already contains position information return err } return fmt.Errorf("%s: %s", pos, err) } // visitorState keeps track of which keys were unmarshaled. type visitorState struct { tree *Tree path []string keys map[string]struct{} active bool } func newVisitorState(tree *Tree) visitorState { path, result := []string{}, map[string]struct{}{} insertKeys(path, result, tree) return visitorState{ tree: tree, path: path[:0], keys: result, active: true, } } func (s *visitorState) push(key string) { if s.active { s.path = append(s.path, key) } } func (s *visitorState) pop() { if s.active { s.path = s.path[:len(s.path)-1] } } func (s *visitorState) visit() { if s.active { delete(s.keys, strings.Join(s.path, ".")) } } func (s *visitorState) visitAll() { if s.active { for k := range s.keys { if strings.HasPrefix(k, strings.Join(s.path, ".")) { delete(s.keys, k) } } } } func (s *visitorState) validate() error { if !s.active { return nil } undecoded := make([]string, 0, len(s.keys)) for key := range s.keys { undecoded = append(undecoded, key) } sort.Strings(undecoded) if len(undecoded) > 0 { return fmt.Errorf("undecoded keys: %q", undecoded) } return nil } func insertKeys(path []string, m map[string]struct{}, tree *Tree) { for k, v := range tree.values { switch node := v.(type) { case []*Tree: for i, item := range node { insertKeys(append(path, k, strconv.Itoa(i)), m, item) } case *Tree: insertKeys(append(path, k), m, node) case *tomlValue: m[strings.Join(append(path, k), ".")] = struct{}{} } } }