Remove Value interface and ForceJSON

Realized we can replace ForceJSON now that we only marshal
structs as JSON if they have a json struct tag and json.Marshaller
can be used in place of Value as well so its not necessary.

go.mod

@@ -3,15 +3,19 @@ module cdr.dev/slog
 go 1.13
 
 require (
-	cloud.google.com/go v0.43.0
-	github.com/alecthomas/chroma v0.6.6
+	cloud.google.com/go v0.49.0
+	github.com/alecthomas/chroma v0.7.0
+	github.com/dlclark/regexp2 v1.2.0 // indirect
 	github.com/fatih/color v1.7.0
-	github.com/kylelemons/godebug v1.1.0
-	github.com/mattn/go-colorable v0.1.2 // indirect
-	github.com/mattn/go-isatty v0.0.9 // indirect
-	go.opencensus.io v0.22.1
-	golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5
-	golang.org/x/sys v0.0.0-20190904154756-749cb33beabd // indirect
-	golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7
-	google.golang.org/genproto v0.0.0-20190716160619-c506a9f90610
+	github.com/golang/groupcache v0.0.0-20191027212112-611e8accdfc9 // indirect
+	github.com/google/go-cmp v0.3.2-0.20191216170541-340f1ebe299e
+	github.com/mattn/go-colorable v0.1.4 // indirect
+	github.com/mattn/go-isatty v0.0.11 // indirect
+	go.opencensus.io v0.22.2
+	golang.org/x/crypto v0.0.0-20191206172530-e9b2fee46413
+	golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553 // indirect
+	golang.org/x/sys v0.0.0-20191210023423-ac6580df4449 // indirect
+	golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543
+	google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1
+	google.golang.org/grpc v1.25.1 // indirect
 )

internal/assert/assert.go

@@ -5,15 +5,24 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/kylelemons/godebug/pretty"
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
 )
 
+// Diff returns a diff between exp and act.
+func Diff(exp, act interface{}, opts ...cmp.Option) string {
+	opts = append(opts, cmpopts.EquateErrors(), cmp.Exporter(func(r reflect.Type) bool {
+		return true
+	}))
+	return cmp.Diff(exp, act, opts...)
+}
+
 // Equal asserts exp == act.
 func Equal(t testing.TB, name string, exp, act interface{}) {
 	t.Helper()
-	if !reflect.DeepEqual(exp, act) {
+	if diff := Diff(exp, act); diff != "" {
 		t.Fatalf(`unexpected %v: diff:
-%v`, name, pretty.Compare(exp, act))
+%v`, name, diff)
 	}
 }
 

map.go

@@ -13,11 +13,6 @@ import (
 // Map represents an ordered map of fields.
 type Map []Field
 
-// SlogValue implements Value.
-func (m Map) SlogValue() interface{} {
-	return ForceJSON(m)
-}
-
 var _ json.Marshaler = Map(nil)
 
 // MarshalJSON implements json.Marshaler.
@@ -27,23 +22,20 @@ var _ json.Marshaler = Map(nil)
 //
 // Every field value is encoded with the following process:
 //
-// 1. slog.Value is checked to allow any type to replace its representation for logging.
-//
-// 2. json.Marshaller is handled.
+// 1. json.Marshaller is handled.
 //
 // 2. xerrors.Formatter is handled.
 //
-// 3. Protobufs are encoded with json.Marshal.
+// 3. structs that have a field with a json tag are encoded with json.Marshal.
 //
-// 4. error and fmt.Stringer are used if possible.
+// 4. error and fmt.Stringer is handled.
 //
 // 5. slices and arrays go through the encode function for every element.
 //
-// 6. If the value is a struct without exported fields or a type that
-//    cannot be encoded with json.Marshal (like channels) then
-//    fmt.Sprintf("%+v") is used.
+// 6. If the value cannot be encoded directly with json.Marshal (like channels)
+//    then fmt.Sprintf("%+v") is used.
 //
-// 8. json.Marshal(v) is used for all other values.
+// 7. json.Marshal(v) is used for all other values.
 func (m Map) MarshalJSON() ([]byte, error) {
 	b := &bytes.Buffer{}
 	b.WriteByte('{')
@@ -62,19 +54,6 @@ func (m Map) MarshalJSON() ([]byte, error) {
 	return b.Bytes(), nil
 }
 
-// ForceJSON ensures the value is logged via json.Marshal.
-//
-// Use it when implementing SlogValue to ensure a structured
-// representation of a struct if you know it's capable even
-// when it implements fmt.Stringer or error.
-func ForceJSON(v interface{}) interface{} {
-	return jsonVal{v: v}
-}
-
-type jsonVal struct {
-	v interface{}
-}
-
 func marshalList(rv reflect.Value) []byte {
 	b := &bytes.Buffer{}
 	b.WriteByte('[')
@@ -93,51 +72,57 @@ func marshalList(rv reflect.Value) []byte {
 
 func encode(v interface{}) []byte {
 	switch v := v.(type) {
-	case Value:
-		return encode(v.SlogValue())
 	case json.Marshaler:
 		return encodeJSON(v)
-	case jsonVal:
-		return encodeJSON(v.v)
 	case xerrors.Formatter:
 		return encode(errorChain(v))
-	case interface {
-		ProtoMessage()
-	}:
-		return encode(ForceJSON(v))
+	}
+
+	rv := reflect.Indirect(reflect.ValueOf(v))
+	if !rv.IsValid() {
+		return encodeJSON(v)
+	}
+
+	if rv.Kind() == reflect.Struct {
+		b, ok := encodeStruct(rv)
+		if ok {
+			return b
+		}
+	}
+
+	switch v.(type) {
 	case error, fmt.Stringer:
 		return encode(fmt.Sprint(v))
-	default:
-		rv := reflect.Indirect(reflect.ValueOf(v))
-		if !rv.IsValid() {
-			return encodeJSON(v)
-		}
+	}
 
-		switch rv.Type().Kind() {
-		case reflect.Slice:
-			if !rv.IsNil() {
-				return marshalList(rv)
-			}
-		case reflect.Array:
+	switch rv.Type().Kind() {
+	case reflect.Slice:
+		if !rv.IsNil() {
 			return marshalList(rv)
-		case reflect.Struct:
-			typ := rv.Type()
-			for i := 0; i < rv.NumField(); i++ {
-				// Found an exported field.
-				if typ.Field(i).PkgPath == "" {
-					return encodeJSON(v)
-				}
-			}
-
-			return encodeJSON(fmt.Sprintf("%+v", v))
-		case reflect.Chan, reflect.Complex64, reflect.Complex128, reflect.Func:
-			// These types cannot be directly encoded with json.Marshal.
-			// See https://golang.org/pkg/encoding/json/#Marshal
-			return encodeJSON(fmt.Sprintf("%+v", v))
 		}
+	case reflect.Array:
+		return marshalList(rv)
+	case reflect.Struct, reflect.Chan, reflect.Complex64, reflect.Complex128, reflect.Func:
+		// These types cannot be directly encoded with json.Marshal.
+		// See https://golang.org/pkg/encoding/json/#Marshal
+		return encodeJSON(fmt.Sprintf("%+v", v))
+	}
 
-		return encodeJSON(v)
+	return encodeJSON(v)
+}
+
+func encodeStruct(rv reflect.Value) ([]byte, bool) {
+	if rv.Kind() == reflect.Struct {
+		for i := 0; i < rv.NumField(); i++ {
+			ft := rv.Type().Field(i)
+			// Found a field with a json tag.
+			if ft.Tag.Get("json") != "" {
+				return encodeJSON(rv.Interface()), true
+			}
+		}
 	}
+
+	return nil, false
 }
 
 func encodeJSON(v interface{}) []byte {

map_test.go

@@ -86,18 +86,18 @@ func TestMap(t *testing.T) {
 		mapTestFile := strings.Replace(mapTestFile, "_test", "", 1)
 
 		test(t, slog.M(
-			slog.F("meow", slog.ForceJSON(complex(10, 10))),
+			slog.F("meow", complexJSON(complex(10, 10))),
 		), `{
 			"meow": {
 				"error": [
 					{
 						"msg": "failed to marshal to JSON",
 						"fun": "cdr.dev/slog.encodeJSON",
-						"loc": "`+mapTestFile+`:147"
+						"loc": "`+mapTestFile+`:132"
 					},
-					"json: unsupported type: complex128"
+					"json: error calling MarshalJSON for type slog_test.complexJSON: json: unsupported type: complex128"
 				],
-				"type": "complex128",
+				"type": "slog_test.complexJSON",
 				"value": "(10+10i)"
 			}
 		}`)
@@ -163,26 +163,6 @@ func TestMap(t *testing.T) {
 		}`)
 	})
 
-	t.Run("forceJSON", func(t *testing.T) {
-		t.Parallel()
-
-		test(t, slog.M(
-			slog.F("error", slog.ForceJSON(io.EOF)),
-		), `{
-			"error": {}
-		}`)
-	})
-
-	t.Run("value", func(t *testing.T) {
-		t.Parallel()
-
-		test(t, slog.M(
-			slog.F("error", meow{1}),
-		), `{
-			"error": "xdxd"
-		}`)
-	})
-
 	t.Run("nilSlice", func(t *testing.T) {
 		t.Parallel()
 
@@ -246,10 +226,6 @@ type meow struct {
 	a int
 }
 
-func (m meow) SlogValue() interface{} {
-	return "xdxd"
-}
-
 func indentJSON(t *testing.T, j string) string {
 	b := &bytes.Buffer{}
 	err := json.Indent(b, []byte(j), "", strings.Repeat(" ", 4))
@@ -263,3 +239,9 @@ func marshalJSON(t *testing.T, m slog.Map) string {
 	assert.Success(t, "marshal map to JSON", err)
 	return indentJSON(t, string(actb))
 }
+
+type complexJSON complex128
+
+func (c complexJSON) MarshalJSON() ([]byte, error) {
+	return json.Marshal(complex128(c))
+}

slog.go

@@ -226,14 +226,6 @@ func M(fs ...Field) Map {
 	return fs
 }
 
-// Value represents a log value.
-//
-// Implement SlogValue in your own types to override
-// the value encoded when logging.
-type Value interface {
-	SlogValue() interface{}
-}
-
 // Error is the standard key used for logging a Go error value.
 func Error(err error) Field {
 	return F("error", err)