399 lines
10 KiB
Go
399 lines
10 KiB
Go
package toml
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding"
|
|
"fmt"
|
|
"io"
|
|
"reflect"
|
|
"sort"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/naoina/toml/ast"
|
|
)
|
|
|
|
const (
|
|
tagOmitempty = "omitempty"
|
|
tagSkip = "-"
|
|
)
|
|
|
|
// Marshal returns the TOML encoding of v.
|
|
//
|
|
// Struct values encode as TOML. Each exported struct field becomes a field of
|
|
// the TOML structure unless
|
|
// - the field's tag is "-", or
|
|
// - the field is empty and its tag specifies the "omitempty" option.
|
|
//
|
|
// The "toml" key in the struct field's tag value is the key name, followed by
|
|
// an optional comma and options. Examples:
|
|
//
|
|
// // Field is ignored by this package.
|
|
// Field int `toml:"-"`
|
|
//
|
|
// // Field appears in TOML as key "myName".
|
|
// Field int `toml:"myName"`
|
|
//
|
|
// // Field appears in TOML as key "myName" and the field is omitted from the
|
|
// // result of encoding if its value is empty.
|
|
// Field int `toml:"myName,omitempty"`
|
|
//
|
|
// // Field appears in TOML as key "field", but the field is skipped if
|
|
// // empty. Note the leading comma.
|
|
// Field int `toml:",omitempty"`
|
|
func (cfg *Config) Marshal(v interface{}) ([]byte, error) {
|
|
buf := new(bytes.Buffer)
|
|
err := cfg.NewEncoder(buf).Encode(v)
|
|
return buf.Bytes(), err
|
|
}
|
|
|
|
// A Encoder writes TOML to an output stream.
|
|
type Encoder struct {
|
|
w io.Writer
|
|
cfg *Config
|
|
}
|
|
|
|
// NewEncoder returns a new Encoder that writes to w.
|
|
func (cfg *Config) NewEncoder(w io.Writer) *Encoder {
|
|
return &Encoder{w, cfg}
|
|
}
|
|
|
|
// Encode writes the TOML of v to the stream.
|
|
// See the documentation for Marshal for details about the conversion of Go values to TOML.
|
|
func (e *Encoder) Encode(v interface{}) error {
|
|
rv := reflect.ValueOf(v)
|
|
for rv.Kind() == reflect.Ptr {
|
|
if rv.IsNil() {
|
|
return &marshalNilError{rv.Type()}
|
|
}
|
|
rv = rv.Elem()
|
|
}
|
|
buf := &tableBuf{typ: ast.TableTypeNormal}
|
|
var err error
|
|
switch rv.Kind() {
|
|
case reflect.Struct:
|
|
err = buf.structFields(e.cfg, rv)
|
|
case reflect.Map:
|
|
err = buf.mapFields(e.cfg, rv)
|
|
default:
|
|
err = &marshalTableError{rv.Type()}
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return buf.writeTo(e.w, "")
|
|
}
|
|
|
|
// Marshaler can be implemented to override the encoding of TOML values. The returned text
|
|
// must be a simple TOML value (i.e. not a table) and is inserted into marshaler output.
|
|
//
|
|
// This interface exists for backwards-compatibility reasons. You probably want to
|
|
// implement encoding.TextMarshaler or MarshalerRec instead.
|
|
type Marshaler interface {
|
|
MarshalTOML() ([]byte, error)
|
|
}
|
|
|
|
// MarshalerRec can be implemented to override the TOML encoding of a type.
|
|
// The returned value is marshaled in place of the receiver.
|
|
type MarshalerRec interface {
|
|
MarshalTOML() (interface{}, error)
|
|
}
|
|
|
|
type tableBuf struct {
|
|
name string // already escaped / quoted
|
|
body []byte
|
|
children []*tableBuf
|
|
typ ast.TableType
|
|
arrayDepth int
|
|
}
|
|
|
|
func (b *tableBuf) writeTo(w io.Writer, prefix string) error {
|
|
key := b.name // TODO: escape dots
|
|
if prefix != "" {
|
|
key = prefix + "." + key
|
|
}
|
|
|
|
if b.name != "" {
|
|
head := "[" + key + "]"
|
|
if b.typ == ast.TableTypeArray {
|
|
head = "[" + head + "]"
|
|
}
|
|
head += "\n"
|
|
if _, err := io.WriteString(w, head); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if _, err := w.Write(b.body); err != nil {
|
|
return err
|
|
}
|
|
|
|
for i, child := range b.children {
|
|
if len(b.body) > 0 || i > 0 {
|
|
if _, err := w.Write([]byte("\n")); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if err := child.writeTo(w, key); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (b *tableBuf) newChild(name string) *tableBuf {
|
|
child := &tableBuf{name: quoteName(name), typ: ast.TableTypeNormal}
|
|
if b.arrayDepth > 0 {
|
|
child.typ = ast.TableTypeArray
|
|
}
|
|
return child
|
|
}
|
|
|
|
func (b *tableBuf) addChild(child *tableBuf) {
|
|
// Empty table elision: we can avoid writing a table that doesn't have any keys on its
|
|
// own. Array tables can't be elided because they define array elements (which would
|
|
// be missing if elided).
|
|
if len(child.body) == 0 && child.typ == ast.TableTypeNormal {
|
|
for _, gchild := range child.children {
|
|
gchild.name = child.name + "." + gchild.name
|
|
b.addChild(gchild)
|
|
}
|
|
return
|
|
}
|
|
b.children = append(b.children, child)
|
|
}
|
|
|
|
func (b *tableBuf) structFields(cfg *Config, rv reflect.Value) error {
|
|
rt := rv.Type()
|
|
for i := 0; i < rv.NumField(); i++ {
|
|
ft := rt.Field(i)
|
|
if ft.PkgPath != "" && !ft.Anonymous { // not exported
|
|
continue
|
|
}
|
|
name, rest := extractTag(ft.Tag.Get(fieldTagName))
|
|
if name == tagSkip {
|
|
continue
|
|
}
|
|
fv := rv.Field(i)
|
|
if rest == tagOmitempty && isEmptyValue(fv) {
|
|
continue
|
|
}
|
|
if name == "" {
|
|
name = cfg.FieldToKey(rt, ft.Name)
|
|
}
|
|
if err := b.field(cfg, name, fv); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type mapKeyList []struct {
|
|
key string
|
|
value reflect.Value
|
|
}
|
|
|
|
func (l mapKeyList) Len() int { return len(l) }
|
|
func (l mapKeyList) Swap(i, j int) { l[i], l[j] = l[j], l[i] }
|
|
func (l mapKeyList) Less(i, j int) bool { return l[i].key < l[j].key }
|
|
|
|
func (b *tableBuf) mapFields(cfg *Config, rv reflect.Value) error {
|
|
keys := rv.MapKeys()
|
|
keylist := make(mapKeyList, len(keys))
|
|
for i, key := range keys {
|
|
var err error
|
|
keylist[i].key, err = encodeMapKey(key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
keylist[i].value = rv.MapIndex(key)
|
|
}
|
|
sort.Sort(keylist)
|
|
|
|
for _, kv := range keylist {
|
|
if err := b.field(cfg, kv.key, kv.value); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (b *tableBuf) field(cfg *Config, name string, rv reflect.Value) error {
|
|
off := len(b.body)
|
|
b.body = append(b.body, quoteName(name)...)
|
|
b.body = append(b.body, " = "...)
|
|
isTable, err := b.value(cfg, rv, name)
|
|
if isTable {
|
|
b.body = b.body[:off] // rub out "key ="
|
|
} else {
|
|
b.body = append(b.body, '\n')
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (b *tableBuf) value(cfg *Config, rv reflect.Value, name string) (bool, error) {
|
|
isMarshaler, isTable, err := b.marshaler(cfg, rv, name)
|
|
if isMarshaler {
|
|
return isTable, err
|
|
}
|
|
switch rv.Kind() {
|
|
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
|
b.body = strconv.AppendInt(b.body, rv.Int(), 10)
|
|
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
|
|
b.body = strconv.AppendUint(b.body, rv.Uint(), 10)
|
|
case reflect.Float32, reflect.Float64:
|
|
b.body = strconv.AppendFloat(b.body, rv.Float(), 'e', -1, 64)
|
|
case reflect.Bool:
|
|
b.body = strconv.AppendBool(b.body, rv.Bool())
|
|
case reflect.String:
|
|
b.body = strconv.AppendQuote(b.body, rv.String())
|
|
case reflect.Ptr, reflect.Interface:
|
|
if rv.IsNil() {
|
|
return false, &marshalNilError{rv.Type()}
|
|
}
|
|
return b.value(cfg, rv.Elem(), name)
|
|
case reflect.Slice, reflect.Array:
|
|
rvlen := rv.Len()
|
|
if rvlen == 0 {
|
|
b.body = append(b.body, '[', ']')
|
|
return false, nil
|
|
}
|
|
|
|
b.arrayDepth++
|
|
wroteElem := false
|
|
b.body = append(b.body, '[')
|
|
for i := 0; i < rvlen; i++ {
|
|
isTable, err := b.value(cfg, rv.Index(i), name)
|
|
if err != nil {
|
|
return isTable, err
|
|
}
|
|
wroteElem = wroteElem || !isTable
|
|
if wroteElem {
|
|
if i < rvlen-1 {
|
|
b.body = append(b.body, ',', ' ')
|
|
} else {
|
|
b.body = append(b.body, ']')
|
|
}
|
|
}
|
|
}
|
|
if !wroteElem {
|
|
b.body = b.body[:len(b.body)-1] // rub out '['
|
|
}
|
|
b.arrayDepth--
|
|
return !wroteElem, nil
|
|
case reflect.Struct:
|
|
child := b.newChild(name)
|
|
err := child.structFields(cfg, rv)
|
|
b.addChild(child)
|
|
return true, err
|
|
case reflect.Map:
|
|
child := b.newChild(name)
|
|
err := child.mapFields(cfg, rv)
|
|
b.addChild(child)
|
|
return true, err
|
|
default:
|
|
return false, fmt.Errorf("toml: marshal: unsupported type %v", rv.Kind())
|
|
}
|
|
return false, nil
|
|
}
|
|
|
|
func (b *tableBuf) marshaler(cfg *Config, rv reflect.Value, name string) (handled, isTable bool, err error) {
|
|
switch t := rv.Interface().(type) {
|
|
case encoding.TextMarshaler:
|
|
enc, err := t.MarshalText()
|
|
if err != nil {
|
|
return true, false, err
|
|
}
|
|
b.body = encodeTextMarshaler(b.body, string(enc))
|
|
return true, false, nil
|
|
case MarshalerRec:
|
|
newval, err := t.MarshalTOML()
|
|
if err != nil {
|
|
return true, false, err
|
|
}
|
|
isTable, err = b.value(cfg, reflect.ValueOf(newval), name)
|
|
return true, isTable, err
|
|
case Marshaler:
|
|
enc, err := t.MarshalTOML()
|
|
if err != nil {
|
|
return true, false, err
|
|
}
|
|
b.body = append(b.body, enc...)
|
|
return true, false, nil
|
|
}
|
|
return false, false, nil
|
|
}
|
|
|
|
func encodeTextMarshaler(buf []byte, v string) []byte {
|
|
// Emit the value without quotes if possible.
|
|
if v == "true" || v == "false" {
|
|
return append(buf, v...)
|
|
} else if _, err := time.Parse(time.RFC3339Nano, v); err == nil {
|
|
return append(buf, v...)
|
|
} else if _, err := strconv.ParseInt(v, 10, 64); err == nil {
|
|
return append(buf, v...)
|
|
} else if _, err := strconv.ParseUint(v, 10, 64); err == nil {
|
|
return append(buf, v...)
|
|
} else if _, err := strconv.ParseFloat(v, 64); err == nil {
|
|
return append(buf, v...)
|
|
}
|
|
return strconv.AppendQuote(buf, v)
|
|
}
|
|
|
|
func encodeMapKey(rv reflect.Value) (string, error) {
|
|
if rv.Kind() == reflect.String {
|
|
return rv.String(), nil
|
|
}
|
|
if tm, ok := rv.Interface().(encoding.TextMarshaler); ok {
|
|
b, err := tm.MarshalText()
|
|
return string(b), err
|
|
}
|
|
switch rv.Kind() {
|
|
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
|
return strconv.FormatInt(rv.Int(), 10), nil
|
|
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
|
|
return strconv.FormatUint(rv.Uint(), 10), nil
|
|
}
|
|
return "", fmt.Errorf("toml: invalid map key type %v", rv.Type())
|
|
}
|
|
|
|
func isEmptyValue(v reflect.Value) bool {
|
|
switch v.Kind() {
|
|
case reflect.Array:
|
|
// encoding/json treats all arrays with non-zero length as non-empty. We check the
|
|
// array content here because zero-length arrays are almost never used.
|
|
len := v.Len()
|
|
for i := 0; i < len; i++ {
|
|
if !isEmptyValue(v.Index(i)) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
case reflect.Map, reflect.Slice, reflect.String:
|
|
return v.Len() == 0
|
|
case reflect.Bool:
|
|
return !v.Bool()
|
|
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
|
return v.Int() == 0
|
|
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
|
|
return v.Uint() == 0
|
|
case reflect.Float32, reflect.Float64:
|
|
return v.Float() == 0
|
|
case reflect.Interface, reflect.Ptr:
|
|
return v.IsNil()
|
|
}
|
|
return false
|
|
}
|
|
|
|
func quoteName(s string) string {
|
|
if len(s) == 0 {
|
|
return strconv.Quote(s)
|
|
}
|
|
for _, r := range s {
|
|
if r >= '0' && r <= '9' || r >= 'A' && r <= 'Z' || r >= 'a' && r <= 'z' || r == '-' || r == '_' {
|
|
continue
|
|
}
|
|
return strconv.Quote(s)
|
|
}
|
|
return s
|
|
}
|