package ast
import (
"bytes"
"fmt"
"reflect"
"strconv"
"strings"
)
// Dump turns ast into a stable string format for assertions in tests
func Dump(i interface{}) string {
v := reflect.ValueOf(i)
d := dumper{Buffer: &bytes.Buffer{}}
d.dump(v)
return d.String()
}
type dumper struct {
*bytes.Buffer
indent int
}
type Dumpable interface {
Dump() string
}
func (d *dumper) dump(v reflect.Value) {
if dumpable, isDumpable := v.Interface().(Dumpable); isDumpable {
d.WriteString(dumpable.Dump())
return
}
switch v.Kind() {
case reflect.Bool:
if v.Bool() {
d.WriteString("true")
} else {
d.WriteString("false")
}
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
d.WriteString(fmt.Sprintf("%d", v.Int()))
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
d.WriteString(fmt.Sprintf("%d", v.Uint()))
case reflect.Float32, reflect.Float64:
d.WriteString(fmt.Sprintf("%.2f", v.Float()))
case reflect.String:
if v.Type().Name() != "string" {
d.WriteString(v.Type().Name() + "(" + strconv.Quote(v.String()) + ")")
} else {
d.WriteString(strconv.Quote(v.String()))
}
case reflect.Array, reflect.Slice:
d.dumpArray(v)
case reflect.Interface, reflect.Ptr:
d.dumpPtr(v)
case reflect.Struct:
d.dumpStruct(v)
default:
panic(fmt.Errorf("unsupported kind: %s\n buf: %s", v.Kind().String(), d.String()))
}
}
func (d *dumper) writeIndent() {
d.Buffer.WriteString(strings.Repeat(" ", d.indent))
}
func (d *dumper) nl() {
d.Buffer.WriteByte('\n')
d.writeIndent()
}
func typeName(t reflect.Type) string {
if t.Kind() == reflect.Ptr {
return typeName(t.Elem())
}
return t.Name()
}
func (d *dumper) dumpArray(v reflect.Value) {
d.WriteString("[" + typeName(v.Type().Elem()) + "]")
for i := 0; i < v.Len(); i++ {
d.nl()
d.WriteString("- ")
d.indent++
d.dump(v.Index(i))
d.indent--
}
}
func (d *dumper) dumpStruct(v reflect.Value) {
d.WriteString("<" + v.Type().Name() + ">")
d.indent++
typ := v.Type()
for i := 0; i < v.NumField(); i++ {
f := v.Field(i)
if typ.Field(i).Tag.Get("dump") == "-" {
continue
}
if isZero(f) {
continue
}
d.nl()
d.WriteString(typ.Field(i).Name)
d.WriteString(": ")
d.dump(v.Field(i))
}
d.indent--
}
func isZero(v reflect.Value) bool {
switch v.Kind() {
case reflect.Ptr, reflect.Interface:
return v.IsNil()
case reflect.Func, reflect.Map:
return v.IsNil()
case reflect.Array, reflect.Slice:
if v.IsNil() {
return true
}
z := true
for i := 0; i < v.Len(); i++ {
z = z && isZero(v.Index(i))
}
return z
case reflect.Struct:
z := true
for i := 0; i < v.NumField(); i++ {
z = z && isZero(v.Field(i))
}
return z
case reflect.String:
return v.String() == ""
}
// Compare other types directly:
return reflect.DeepEqual(v.Interface(), reflect.Zero(v.Type()))
}
func (d *dumper) dumpPtr(v reflect.Value) {
if v.IsNil() {
d.WriteString("nil")
return
}
d.dump(v.Elem())
}
