feat(formatter-utils): improve stringify with reflect func

olehan · olehan · commit b261fdcb9228 · 2019-08-01T02:14:23.000+06:00
diff --git a/formatters/utils_service.go b/formatters/utils_service.go
@@ -23,77 +23,149 @@ func (f *FormatterUtils) StringifyValues(ps *pool.State, v ...interface{}) {
 // StringifyValue writes into the buffer converted to string value that
 // it receives.
 func (f *FormatterUtils) StringifyValue(ps *pool.State, v interface{}) {
-    switch v.(type) {
+    switch t := v.(type) {
+    case nil:
+        ps.Buffer.WriteString("<nil>")
     case int:
-        ps.Buffer.WriteInt(int64(v.(int)))
+        ps.Buffer.WriteInt(int64(t))
     case int8:
-        ps.Buffer.WriteInt(int64(v.(int8)))
+        ps.Buffer.WriteInt(int64(t))
     case int16:
-        ps.Buffer.WriteInt(int64(v.(int16)))
+        ps.Buffer.WriteInt(int64(t))
     case int32:
-        ps.Buffer.WriteInt(int64(v.(int32)))
+        ps.Buffer.WriteInt(int64(t))
     case int64:
-        ps.Buffer.WriteInt(v.(int64))
+        ps.Buffer.WriteInt(t)
     case uint:
-        ps.Buffer.WriteUint(uint64(v.(uint)))
+        ps.Buffer.WriteUint(uint64(t))
     case uint8:
-        ps.Buffer.WriteUint(uint64(v.(uint8)))
+        ps.Buffer.WriteUint(uint64(t))
     case uint16:
-        ps.Buffer.WriteUint(uint64(v.(uint16)))
+        ps.Buffer.WriteUint(uint64(t))
     case uint32:
-        ps.Buffer.WriteUint(uint64(v.(uint32)))
+        ps.Buffer.WriteUint(uint64(t))
     case uint64:
-        ps.Buffer.WriteUint(v.(uint64))
+        ps.Buffer.WriteUint(t)
     case uintptr:
-        ps.Buffer.WriteUint(uint64(v.(uintptr)))
+        ps.Buffer.WriteUint(uint64(t))
     case string:
-        ps.Buffer.WriteString(v.(string))
+        ps.Buffer.WriteString(t)
     case bool:
-        ps.Buffer.WriteBool(v.(bool))
+        ps.Buffer.WriteBool(t)
     case float32:
-        ps.Buffer.WriteFloat(float64(v.(float32)), 32)
+        ps.Buffer.WriteFloat(float64(t), 32)
     case float64:
-        ps.Buffer.WriteFloat(v.(float64), 64)
-    case nil:
-        ps.Buffer.WriteString("<nil>")
+        ps.Buffer.WriteFloat(t, 64)
     case complex64:
+        f.writeComplex(ps, complex128(t), 64)
     case complex128:
+        f.writeComplex(ps, t, 128)
     default:
-        f.StringifyValueWithReflect(ps, v)
+        f.StringifyValueWithReflect(ps, reflect.ValueOf(v))
     }
 }
 
 // StringifyValueWithReflect converts the given value using the reflect.
-func (f *FormatterUtils) StringifyValueWithReflect(ps *pool.State, v interface{}) {
-    typeOfValue := reflect.TypeOf(v)
-    switch typeOfValue.Kind() {
+func (f *FormatterUtils) StringifyValueWithReflect(ps *pool.State, value reflect.Value) {
+    switch t := value.Kind(); t {
+    case reflect.Invalid:
+        ps.Buffer.WriteString("<invalid reflect.Value>")
+    case reflect.Bool:
+        ps.Buffer.WriteBool(value.Bool())
+    case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+        ps.Buffer.WriteInt(value.Int())
+    case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+        ps.Buffer.WriteUint(value.Uint())
+    case reflect.Float32:
+        ps.Buffer.WriteFloat(value.Float(), 32)
+    case reflect.Float64:
+        ps.Buffer.WriteFloat(value.Float(), 64)
+    case reflect.Complex64:
+        f.writeComplex(ps, value.Complex(), 64)
+    case reflect.Complex128:
+        f.writeComplex(ps, value.Complex(), 128)
+    case reflect.String:
+        ps.Buffer.WriteString(value.String())
+    case reflect.Map:
+        ps.Buffer.WriteString(value.Type().String())
+        if value.IsNil() {
+            ps.Buffer.WriteString("<nil>")
+            return
+        }
+        ps.Buffer.WriteByte('{')
+        ps.Buffer.WriteSpace()
+        keys := value.MapKeys()
+        for i, key := range keys {
+            if i > 0 {
+                ps.Buffer.WriteString(", ")
+            }
+            f.StringifyValueWithReflect(ps, key)
+            ps.Buffer.WriteString(": ")
+            f.StringifyValueWithReflect(ps, value.MapIndex(key))
+        }
+        ps.Buffer.WriteSpace()
+        ps.Buffer.WriteByte('}')
     case reflect.Struct:
-        f.StringifyStruct(ps, typeOfValue)
-    default:
-        ps.Buffer.WriteString(typeOfValue.Name())
-        ps.Buffer.WriteString(typeOfValue.String())
-    }
-}
+        ps.Buffer.WriteString(value.Type().String())
+        ps.Buffer.WriteByte('{')
+        ps.Buffer.WriteSpace()
 
-// StringifyStruct converts structure into a string.
-func (f *FormatterUtils) StringifyStruct(ps *pool.State, t reflect.Type) {
-    ps.Buffer.WriteNewLine()
-    ps.Buffer.WriteString(t.Name())
-    ps.Buffer.WriteSpace()
-    ps.Buffer.WriteByte('{')
-    ps.Buffer.WriteNewLine()
-
-    for i := 0; i < t.NumField(); i++ {
-        field := t.Field(i)
-        ps.Buffer.WriteByte('\t')
-        ps.Buffer.WriteString(field.Name)
-        ps.Buffer.WriteString(": ")
-        ps.Buffer.WriteString(field.Type.String())
-        ps.Buffer.WriteNewLine()
-    }
+        for i := 0; i < value.NumField(); i++ {
+            if i > 0 {
+                ps.Buffer.WriteString(", ")
+            }
 
-    ps.Buffer.WriteByte('}')
-    ps.Buffer.WriteNewLine()
+            field := value.Field(i)
+            ps.Buffer.WriteString(value.Type().Field(i).Name)
+            ps.Buffer.WriteString(": ")
+            f.StringifyValueWithReflect(ps, field)
+        }
+
+        ps.Buffer.WriteSpace()
+        ps.Buffer.WriteByte('}')
+    case reflect.Interface:
+        v := value.Elem()
+        if !v.IsValid() {
+            ps.Buffer.WriteString(v.Type().String())
+        } else {
+            f.StringifyValue(ps, v.Interface())
+        }
+    case reflect.Array, reflect.Slice:
+        ps.Buffer.WriteByte('[')
+        for i := 0; i < value.Len(); i++ {
+            if i > 0 {
+                ps.Buffer.WriteByte(' ')
+            }
+            f.StringifyValueWithReflect(ps, value.Index(i))
+        }
+        ps.Buffer.WriteByte(']')
+    case reflect.Ptr:
+        if value.Pointer() != 0 {
+            switch a := value.Elem(); value.Kind() {
+            case reflect.Array, reflect.Slice, reflect.Struct, reflect.Map:
+                ps.Buffer.WriteByte('&')
+                f.StringifyValueWithReflect(ps, a)
+                return
+            }
+        }
+        fallthrough
+    case reflect.Chan, reflect.Func, reflect.UnsafePointer:
+        switch value.Kind() {
+        case reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr, reflect.Slice, reflect.UnsafePointer:
+            ptr := value.Pointer()
+            ps.Buffer.WriteByte('(')
+            ps.Buffer.WriteString(value.Type().String())
+            ps.Buffer.WriteString(")(")
+            if ptr == 0 {
+                ps.Buffer.WriteString("<nil>")
+            } else {
+                ps.Buffer.WriteUint(uint64(ptr))
+            }
+            ps.Buffer.WriteByte(')')
+        }
+    default:
+        ps.Buffer.WriteString(value.String())
+    }
 }
 
 // StringifyByTemplate converts value into a string by the given format/template.
@@ -180,3 +252,10 @@ func (f *FormatterUtils) KeyValuesToMap(ps *pool.State, keyValues ...interface{}
         ps.Map.Set(key.(string), keyValues[i + 1])
     }
 }
+
+func (f *FormatterUtils) writeComplex(ps *pool.State, v complex128, size int) {
+    ps.Buffer.WriteByte('(')
+    ps.Buffer.WriteFloat(real(v), size / 2)
+    ps.Buffer.WriteFloat(imag(v), size / 2)
+    ps.Buffer.WriteString("i)")
+}
diff --git a/formatters/utils_service_test.go b/formatters/utils_service_test.go
@@ -4,6 +4,8 @@ import (
     "github.com/olehan/kek/buffer"
     "github.com/olehan/kek/ds"
     "github.com/olehan/kek/pool"
+    "os"
+    "reflect"
     "strings"
     "testing"
 )
@@ -33,33 +35,53 @@ func TestFormatterUtils_StringifyValues(t *testing.T) {
     uint32Value := uint32(13411334)
     uint64Value := uint64(13524636364)
     uintptrValue := uintptr(346457456356)
-    stringValue := string("oih24t9h334rad")
+    stringValue := "oih24t9h334rad"
     boolValue := true
+    mapValue := map[string]int{
+        "value2": 1,
+        "value1": 41,
+        "longvaluegoeshere": 354345245,
+    }
     float32Value := float32(245245.23423)
     float64Value := float64(2463621.351313)
     complex64Value := complex64(2346363623452.45235135134134)
     complex128Value := complex128(345346246134.13513513513413)
     structValue := struct {
         x int
         y int
+        b bool
+        f32 float32
+        f64 float64
+        u uint64
+        c128 complex128
+        c64 complex64
         a func() interface{}
         slice []string
+        nilFunc func()
+        nilMap map[string]bool
     }{
         x: 1,
         y: 2,
         a: func() interface{} {
             return ""
         },
-        slice: []string{""},
+        slice: []string{"a"},
     }
-    interfaceSlice := []interface{}{}
+    interfaceSlice := []interface{}{"stringval", 123}
 
     state := _testFormatterPool.Get()
 
     _testFormatter.StringifyValues(
         state,
         nil,
-        _namedStruct{},
+        _namedStruct{
+            "sd",
+        },
+        &interfaceSlice,
+        &_namedStruct{},
+        mapValue,
+        reflect.ValueOf(mapValue),
+        os.Stdout,
         intValue,
         int8Value,
         int16Value,
@@ -75,10 +97,10 @@ func TestFormatterUtils_StringifyValues(t *testing.T) {
         boolValue,
         float32Value,
         float64Value,
-        complex64Value,
-        complex128Value,
         structValue,
         interfaceSlice,
+        complex64Value,
+        complex128Value,
     )
 
     t.Log(string(state.Buffer))
