Merge pull request #1 from cdr/init

Init

Author: nhooyr

cmp_test.go

@@ -0,0 +1,53 @@
+package slog
+
+import (
+	"github.com/google/go-cmp/cmp"
+	"reflect"
+)
+
+// https://github.com/google/go-cmp/issues/40#issuecomment-328615283
+// Copied from https://github.com/nhooyr/websocket/blob/1b874731eab56c69c8bb3ebf8a029020c7863fc9/cmp_test.go
+func cmpDiff(exp, act interface{}) string {
+	return cmp.Diff(exp, act, deepAllowUnexported(exp, act))
+}
+
+func deepAllowUnexported(vs ...interface{}) cmp.Option {
+	m := make(map[reflect.Type]struct{})
+	for _, v := range vs {
+		structTypes(reflect.ValueOf(v), m)
+	}
+	var typs []interface{}
+	for t := range m {
+		typs = append(typs, reflect.New(t).Elem().Interface())
+	}
+	return cmp.AllowUnexported(typs...)
+}
+
+func structTypes(v reflect.Value, m map[reflect.Type]struct{}) {
+	if !v.IsValid() {
+		return
+	}
+	switch v.Kind() {
+	case reflect.Ptr:
+		if !v.IsNil() {
+			structTypes(v.Elem(), m)
+		}
+	case reflect.Interface:
+		if !v.IsNil() {
+			structTypes(v.Elem(), m)
+		}
+	case reflect.Slice, reflect.Array:
+		for i := 0; i < v.Len(); i++ {
+			structTypes(v.Index(i), m)
+		}
+	case reflect.Map:
+		for _, k := range v.MapKeys() {
+			structTypes(v.MapIndex(k), m)
+		}
+	case reflect.Struct:
+		m[v.Type()] = struct{}{}
+		for i := 0; i < v.NumField(); i++ {
+			structTypes(v.Field(i), m)
+		}
+	}
+}

console.go

@@ -0,0 +1,144 @@
+package slog
+
+import (
+	"strconv"
+	"strings"
+)
+
+// consoleMarshaller marshals a fieldValue into a human readable format.
+type consoleMarshaller struct {
+	out       strings.Builder
+	indentstr string
+}
+
+func marshalFields(v fieldMap) string {
+	var y consoleMarshaller
+	y.marshal(v)
+	return y.out.String()
+}
+
+func (y *consoleMarshaller) line() {
+	y.out.WriteString("\n" + y.indentstr)
+}
+
+func (y *consoleMarshaller) s(s string) {
+	y.out.WriteString(s)
+}
+
+func (y *consoleMarshaller) indent() {
+	// 2 works really well for yaml because of arrays.
+	// E.g. if you have a map inside of an list it looks like:
+	//
+	// - field: val
+	//   field: val
+	//
+	// See how the second field automatically gets indented to the correct level?
+	// We can use \t later and special case but for now this is simpler.
+	y.indentstr += "  "
+}
+
+func (y *consoleMarshaller) unindent() {
+	y.indentstr = y.indentstr[:len(y.indentstr)-2]
+}
+
+func (y *consoleMarshaller) marshal(v fieldValue) {
+	switch v := v.(type) {
+	case fieldString:
+		// Ensures indentation.
+		y.indent()
+		// Replaces every newline with a newline plus the correct indentation.
+		y.s(strings.ReplaceAll(string(v), "\n", "\n"+y.indentstr))
+		y.unindent()
+	case fieldBool:
+		y.s(strconv.FormatBool(bool(v)))
+	case fieldFloat:
+		y.s(strconv.FormatFloat(float64(v), 'f', -1, 64))
+	case fieldInt:
+		y.s(strconv.FormatInt(int64(v), 10))
+	case fieldUint:
+		y.s(strconv.FormatUint(uint64(v), 10))
+	case fieldMap:
+		for i, f := range v {
+			if i > 0 {
+				// Add newline before every field except first.
+				y.line()
+			}
+
+			y.s(quote(f.name) + ":")
+
+			y.marshalSub(f.value, true)
+		}
+	case fieldList:
+		y.indent()
+		for _, v := range v {
+			y.line()
+			y.s("-")
+
+			if _, ok := v.(fieldList); !ok {
+				// Non list values begin with the -.
+				y.s(" ")
+			}
+			y.marshalSub(v, false)
+		}
+		y.unindent()
+	case nil:
+		y.s("null")
+	default:
+		panicf("unknown fieldValue kind of type %T and value %#v", y, y)
+	}
+}
+
+func (y *consoleMarshaller) marshalSub(v fieldValue, isParentMap bool) {
+	switch v := v.(type) {
+	case fieldMap:
+		if isParentMap && len(v) == 0 {
+			// Nothing to output for this field. Without this line, we get additional newlines due to below code as
+			// the map field is expected to start on the next line given it is in a parentMap.
+			// See the emptyStruct test.
+			return
+		}
+
+		y.indent()
+
+		if isParentMap {
+			// If we are not inside a list and the value is a map, we need a newline.
+			// In other words, if we are inside a list and the value is a map, we want to start
+			// it with the `-` of the list.
+			y.line()
+		}
+	case fieldList:
+	default:
+		if isParentMap {
+			// Non map and non list values in structs begin on the same line with a space between the key and value.
+			y.s(" ")
+		}
+	}
+
+	y.marshal(v)
+
+	if _, ok := v.(fieldMap); ok {
+		y.unindent()
+	}
+}
+
+// quotes quotes a string so that it is suitable
+// as a key for a map or in general some output that
+// cannot span multiple lines or have weird characters.
+func quote(key string) string {
+	// strconv.Quote does not quote an empty string so we need this.
+	if key == "" {
+		return `""`
+	}
+
+	// Replace spaces in the map keys with underscores.
+	key = strings.ReplaceAll(key, " ", "_")
+
+	quoted := strconv.Quote(key)
+	// If the key doesn't need to be quoted, don't quote it.
+	// We do not use strconv.CanBackquote because it doesn't
+	// account tabs.
+	if quoted[1:len(quoted)-1] == key {
+		return key
+	}
+	return quoted
+}

console_test.go

@@ -0,0 +1,125 @@
+package slog
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Test_marshalFields(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name string
+		in   map[string]interface{}
+		out  string
+	}{
+		{
+			name: "stringWithNewlines",
+			in: map[string]interface{}{
+				"a": `hi
+two
+three`,
+			},
+			out: `a: hi
+  two
+  three`,
+		},
+		{
+			name: "bool",
+			in: map[string]interface{}{
+				"a": false,
+			},
+			out: `a: false`,
+		},
+		{
+			name: "float",
+			in: map[string]interface{}{
+				"a": 0.3,
+			},
+			out: `a: 0.3`,
+		},
+		{
+			name: "int",
+			in: map[string]interface{}{
+				"a": -1,
+			},
+			out: `a: -1`,
+		},
+		{
+			name: "uint",
+			in: map[string]interface{}{
+				"a": uint(3),
+			},
+			out: `a: 3`,
+		},
+		{
+			name: "list",
+			in: map[string]interface{}{
+				"a": []interface{}{
+					map[string]interface{}{
+						"hi":  "hello",
+						"hi3": "hello",
+					},
+					"3",
+					[]string{"a", "b", "c"},
+				},
+			},
+			out: `a:
+  - hi: hello
+    hi3: hello
+  - 3
+  -
+    - a
+    - b
+    - c`,
+		},
+		{
+			name: "emptyStruct",
+			in: map[string]interface{}{
+				"a": struct{}{},
+				"b": struct{}{},
+				"c": struct{}{},
+			},
+			out: `a:
+b:
+c:`,
+		},
+		{
+			name: "nestedMap",
+			in: map[string]interface{}{
+				"a": map[string]string{
+					"0": "hi",
+					"1": "hi",
+				},
+			},
+			out: `a:
+  0: hi
+  1: hi`,
+		},
+		{
+			name: "specialCharacterKey",
+			in: map[string]interface{}{
+				"nhooyr \tsoftware™️": "hi",
+				"\rxeow\r": `mdsla
+dsamkld`,
+			},
+			out: `"\rxeow\r": mdsla
+  dsamkld
+"nhooyr_\tsoftware™️": hi`,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			v := reflectFieldValue(reflect.ValueOf(tc.in))
+			actOut := marshalFields(v.(fieldMap))
+			t.Logf("yaml:\n%v", actOut)
+			if diff := cmpDiff(tc.out, actOut); diff != "" {
+				t.Fatalf("unexpected output: %v", diff)
+			}
+		})
+	}
+}