123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269 |
- 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{}{}
- }
- }
- }
|