Encoder multiline array (#520)

marshaler.go

@@ -33,21 +33,36 @@ type Encoder struct {
 	w io.Writer
 
 	// global settings
-	tablesInline bool
+	tablesInline    bool
+	arraysMultiline bool
+	indentSymbol    string
 }
 
 // NewEncoder returns a new Encoder that writes to w.
 func NewEncoder(w io.Writer) *Encoder {
 	return &Encoder{
-		w: w,
+		w:            w,
+		indentSymbol: "  ",
 	}
 }
 
 // SetTablesInline forces the encoder to emit all tables inline.
+//
+// This behavior can be controled on an individual struct field basis with the
+// `inline="true"` tag.
 func (e *Encoder) SetTablesInline(inline bool) {
 	e.tablesInline = inline
 }
 
+// SetArraysMultiline forces the encoder to emit all arrays with one element per
+// line.
+//
+// This behavior can be controled on an individual struct field basis with the
+// `multiline="true"` tag.
+func (e *Encoder) SetArraysMultiline(multiline bool) {
+	e.arraysMultiline = multiline
+}
+
 // Encode writes a TOML representation of v to the stream.
 //
 // If v cannot be represented to TOML it returns an error.
@@ -121,6 +136,10 @@ type encoderCtx struct {
 	// Should the next table be encoded as inline
 	inline bool
 
+	// Indentation level
+	indent int
+
+	// Options coming from struct tags
 	options valueOptions
 }
 
@@ -544,6 +563,7 @@ func (enc *Encoder) encodeTable(b []byte, ctx encoderCtx, t table) ([]byte, erro
 	for _, table := range t.tables {
 		ctx.setKey(table.Key)
 
+		ctx.options = table.Options
 		b, err = enc.encode(b, ctx, table.Value)
 		if err != nil {
 			return nil, err
@@ -721,25 +741,52 @@ func (enc *Encoder) encodeSliceAsArrayTable(b []byte, ctx encoderCtx, v reflect.
 }
 
 func (enc *Encoder) encodeSliceAsArray(b []byte, ctx encoderCtx, v reflect.Value) ([]byte, error) {
+	multiline := ctx.options.multiline || enc.arraysMultiline
+	separator := ", "
+
 	b = append(b, '[')
 
+	subCtx := ctx
+	subCtx.options = valueOptions{}
+
+	if multiline {
+		separator = ",\n"
+		b = append(b, '\n')
+		subCtx.indent++
+	}
+
 	var err error
 	first := true
 
 	for i := 0; i < v.Len(); i++ {
-		if !first {
-			b = append(b, ", "...)
+		if first {
+			first = false
+		} else {
+			b = append(b, separator...)
 		}
 
-		first = false
+		if multiline {
+			b = enc.indent(subCtx.indent, b)
+		}
 
-		b, err = enc.encode(b, ctx, v.Index(i))
+		b, err = enc.encode(b, subCtx, v.Index(i))
 		if err != nil {
 			return nil, err
 		}
 	}
 
+	if multiline {
+		b = append(b, '\n')
+		b = enc.indent(ctx.indent, b)
+	}
 	b = append(b, ']')
 
 	return b, nil
 }
+
+func (enc *Encoder) indent(level int, b []byte) []byte {
+	for i := 0; i < level; i++ {
+		b = append(b, enc.indentSymbol...)
+	}
+	return b
+}