Get golint passing

Author: nhooyr

README.md

@@ -20,7 +20,7 @@ go get go.coder.com/slog
 - First class [context.Context](https://blog.golang.org/context) support
 - Beautiful logging output by default
 - Multiple adapters
-- First class [\testing.TB](https://godoc.org/go.coder.com/slog/slogtest) support
+- First class [testing.TB](https://godoc.org/go.coder.com/slog/slogtest) support
 
 ## Example
 

examples_test.go

@@ -1,10 +1,11 @@
 package slog_test
 
 import (
-	"golang.org/x/xerrors"
 	"io"
 	"testing"
 
+	"golang.org/x/xerrors"
+
 	"go.coder.com/slog"
 	"go.coder.com/slog/sloggers/slogtest"
 )

internal/humanfmt/humanfmt.go

@@ -52,14 +52,16 @@ func Entry(ent slog.Entry, enableColor bool) string {
 }
 
 func pinnedFields(ent slog.Entry) string {
-	pinned := slogval.Map{}
-
-	if ent.SpanContext != (trace.SpanContext{}) {
-		pinned = pinned.Append("trace", slogval.String(ent.SpanContext.TraceID.String()))
-		pinned = pinned.Append("span", slogval.String(ent.SpanContext.SpanID.String()))
+	if ent.SpanContext == (trace.SpanContext{}) {
+		return ""
 	}
 
-	return humanFields(pinned)
+	m := slog.Map(
+		slog.F("trace", ent.SpanContext.TraceID),
+		slog.F("span", ent.SpanContext.SpanID),
+	)
+
+	return humanFields(slogval.Reflect(m))
 }
 
 func stringFields(ent slog.Entry) string {
@@ -92,6 +94,7 @@ func levelColor(level slog.Level) color.Attribute {
 	panic("humanfmt: unexpected level: " + string(level))
 }
 
+// IsTTY checks whether the given writer is a *os.File TTY.
 func IsTTY(w io.Writer) bool {
 	f, ok := w.(interface {
 		Fd() uintptr

internal/humanfmt/marshal_test.go

@@ -3,6 +3,7 @@ package humanfmt
 import (
 	"testing"
 
+	"go.coder.com/slog"
 	"go.coder.com/slog/internal/diff"
 	"go.coder.com/slog/slogval"
 )
@@ -12,60 +13,60 @@ func Test_marshalFields(t *testing.T) {
 
 	testCases := []struct {
 		name string
-		in   map[string]interface{}
+		in   []slog.Field
 		out  string
 	}{
 		{
 			name: "stringWithNewlines",
-			in: map[string]interface{}{
-				"a": `hi
+			in: slog.Map(
+				slog.F("a", `hi
 two
-three`,
-			},
+three`),
+			),
 			out: `a: hi
   two
   three`,
 		},
 		{
 			name: "bool",
-			in: map[string]interface{}{
-				"a": false,
-			},
+			in: slog.Map(
+				slog.F("a", false),
+			),
 			out: `a: false`,
 		},
 		{
 			name: "float",
-			in: map[string]interface{}{
-				"a": 0.3,
-			},
+			in: slog.Map(
+				slog.F("a", 0.3),
+			),
 			out: `a: 0.3`,
 		},
 		{
 			name: "int",
-			in: map[string]interface{}{
-				"a": -1,
-			},
+			in: slog.Map(
+				slog.F("a", -1),
+			),
 			out: `a: -1`,
 		},
 		{
 			name: "uint",
-			in: map[string]interface{}{
-				"a": uint(3),
-			},
+			in: slog.Map(
+				slog.F("a", uint(3)),
+			),
 			out: `a: 3`,
 		},
 		{
 			name: "list",
-			in: map[string]interface{}{
-				"a": []interface{}{
-					map[string]interface{}{
-						"hi":  "hello",
-						"hi3": "hello",
-					},
+			in: slog.Map(
+				slog.F("a", []interface{}{
+					slog.Map(
+						slog.F("hi", "hello"),
+						slog.F("hi3", "hello"),
+					),
 					"3",
 					[]string{"a", "b", "c"},
 				},
-			},
+				)),
 			out: `a:
   - hi: hello
     hi3: hello
@@ -77,37 +78,37 @@ three`,
 		},
 		{
 			name: "emptyStruct",
-			in: map[string]interface{}{
-				"a": struct{}{},
-				"b": struct{}{},
-				"c": struct{}{},
-			},
+			in: slog.Map(
+				slog.F("a", struct{}{}),
+				slog.F("b", struct{}{}),
+				slog.F("c", struct{}{}),
+			),
 			out: `a:
 b:
 c:`,
 		},
 		{
 			name: "nestedMap",
-			in: map[string]interface{}{
-				"a": map[string]string{
-					"0": "hi",
+			in: slog.Map(
+				slog.F("a", map[string]string{
 					"1": "hi",
-				},
-			},
+					"0": "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`,
+			in: slog.Map(
+				slog.F("nhooyr \tsoftware™️", "hi"),
+				slog.F("\rxeow\r", `mdsla
+dsamkld`),
+			),
+			out: `"nhooyr_\tsoftware™️": hi
+"\rxeow\r": mdsla
+  dsamkld`,
 		},
 	}
 
@@ -116,8 +117,8 @@ dsamkld`,
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 
-			v := slogval.ReflectUnsafe(tc.in)
-			actOut := humanFields(v.(slogval.Map))
+			v := slogval.Reflect(tc.in)
+			actOut := humanFields(v)
 			t.Logf("yaml:\n%v", actOut)
 			if diff := diff.Diff(tc.out, actOut); diff != "" {
 				t.Fatalf("unexpected output: %v", diff)

slog.go

@@ -86,15 +86,17 @@ func fromContext(ctx context.Context) parsedFields {
 }
 
 // Context returns a context that contains the given fields.
-// Any logs written with the provided context will contain
-// the given fields.
+// Any logs written with the provided context will have
+// the given logs prepended.
 // It will append to any fields already in ctx.
 func Context(ctx context.Context, fields ...Field) context.Context {
 	l := fromContext(ctx)
 	l = l.withFields(fields)
 	return withContext(ctx, l)
 }
 
+// Entry represents the structure of a log entry.
+// It is the argument to the sink when logging.
 type Entry struct {
 	Time time.Time
 
@@ -112,8 +114,10 @@ type Entry struct {
 	Fields []Field
 }
 
+// Level represents a log level.
 type Level int
 
+// The supported log levels.
 const (
 	LevelDebug Level = iota
 	LevelInfo
@@ -171,6 +175,8 @@ type sink struct {
 	pl    parsedFields
 }
 
+// Logger allows logging a ordered slice of fields
+// to an underlying set of sinks.
 type Logger struct {
 	testingHelper func()
 
@@ -183,36 +189,45 @@ func (l Logger) clone() Logger {
 	return l
 }
 
+// Debug logs the msg and fields at LevelDebug.
 func (l Logger) Debug(ctx context.Context, msg string, fields ...Field) {
 	l.testingHelper()
 	l.log(ctx, LevelDebug, msg, fields)
 }
 
+// Info logs the msg and fields at LevelInfo.
 func (l Logger) Info(ctx context.Context, msg string, fields ...Field) {
 	l.testingHelper()
 	l.log(ctx, LevelInfo, msg, fields)
 }
 
+// Warn logs the msg and fields at LevelWarn.
 func (l Logger) Warn(ctx context.Context, msg string, fields ...Field) {
 	l.testingHelper()
 	l.log(ctx, LevelWarn, msg, fields)
 }
 
+// Error logs the msg and fields at LevelError.
 func (l Logger) Error(ctx context.Context, msg string, fields ...Field) {
 	l.testingHelper()
 	l.log(ctx, LevelError, msg, fields)
 }
 
+// Critical logs the msg and fields at LevelCritical.
 func (l Logger) Critical(ctx context.Context, msg string, fields ...Field) {
 	l.testingHelper()
 	l.log(ctx, LevelCritical, msg, fields)
 }
 
+// Fatal logs the msg and fields at LevelFatal.
 func (l Logger) Fatal(ctx context.Context, msg string, fields ...Field) {
 	l.testingHelper()
 	l.log(ctx, LevelFatal, msg, fields)
 }
 
+// With returns a Logger that prepends the given fields on every
+// logged entry.
+// It will append to any fields already in the Logger.
 func (l Logger) With(fields ...Field) Logger {
 	l = l.clone()
 	for i, s := range l.sinks {

sloggers/sloghuman/sloghuman.go

@@ -44,7 +44,7 @@ func (s *humanSink) writeString(str string) {
 	io.WriteString(s.w, str)
 }
 
-// Human creates a logger that writes logs in a human
+// Make creates a logger that writes logs in a human
 // readable YAML like format to the given writer.
 func Make(w io.Writer) slog.Logger {
 	return slog.Make(&humanSink{

sloggers/slogtest/slogtest.go

@@ -12,14 +12,14 @@ import (
 )
 
 // TestOptions represents the options for the logger returned
-// by Test.
+// by Make.
 type TestOptions struct {
 	// IgnoreErrors causes the test logger to not fatal the test
 	// on Fatal and not error the test on Error or Critical.
 	IgnoreErrors bool
 }
 
-// Test creates a Logger that writes logs to tb in a human readable format.
+// Make creates a Logger that writes logs to tb in a human readable format.
 func Make(tb testing.TB, opts *TestOptions) slog.Logger {
 	if opts == nil {
 		opts = &TestOptions{}

slogval/reflect.go

@@ -12,24 +12,21 @@ import (
 	"go.coder.com/slog"
 )
 
+// Reflect uses reflection to convert the slice of fields into a ordered
+// map that uses only the primitive value types defined in this package.
 func Reflect(fs []slog.Field) Map {
 	var m Map
 	for _, f := range fs {
-		m = m.Append(f.LogKey(), reflectValue(reflect.ValueOf(f.LogValue())))
+		m = m.appendVal(f.LogKey(), reflectValue(reflect.ValueOf(f.LogValue())))
 	}
 	return m
 }
 
-// TODO
-func ReflectMap() {
+// PureReflect is like reflect but only uses
+func PureReflect(v interface{}) {
 	panic("TODO")
 }
 
-// TODO remove later.
-func ReflectUnsafe(v interface{}) Value {
-	return reflectValue(reflect.ValueOf(v))
-}
-
 func reflectValue(rv reflect.Value) Value {
 	if !rv.IsValid() {
 		// reflect.ValueOf(nil).IsValid == false
@@ -99,7 +96,7 @@ func reflectValue(rv reflect.Value) Value {
 				f := rv.Index(i)
 				key := f.MethodByName("LogKey").Call(nil)[0].String()
 				val := f.MethodByName("LogValue").Call(nil)[0]
-				m = m.Append(key, reflectValue(val))
+				m = m.appendVal(key, reflectValue(val))
 			}
 			return m
 		}
@@ -112,9 +109,9 @@ func reflectValue(rv reflect.Value) Value {
 		m := make(Map, 0, rv.Len())
 		for _, k := range rv.MapKeys() {
 			mv := rv.MapIndex(k)
-			m = m.Append(fmt.Sprintf("%v", k), reflectValue(mv))
+			m = m.appendVal(fmt.Sprintf("%v", k), reflectValue(mv))
 		}
-		m.Sort()
+		m.sort()
 		return m
 	case reflect.Struct:
 		typ := rv.Type()
@@ -138,7 +135,7 @@ func reflectValue(rv reflect.Value) Value {
 			if name == "" {
 				name = snakecase(ft.Name)
 			}
-			f = f.Append(name, v)
+			f = f.appendVal(name, v)
 
 		}