Update dump package with better user interface and fixed dump format.

- Add ability to indent dumped messages.

Author: rzajac

internal/playground/check_test.go

@@ -41,8 +41,8 @@ func Test_Name(t *testing.T) {
 		},
 	}
 
-	wantD := dump.DefaultDump().DumpAny(want)
-	haveD := dump.DefaultDump().DumpAny(have)
+	wantD := dump.Default().Any(want)
+	haveD := dump.Default().Any(have)
 
 	// --- When ---
 	edits := diff.Strings(wantD, haveD)

internal/types/types.go

@@ -23,8 +23,8 @@ func init() {
 
 // /////////////////////////////////////////////////////////////////////////////
 
-// IntType is type alias used in tests.
-type IntType int
+// TIntType is type alias used in tests.
+type TIntType int
 
 // /////////////////////////////////////////////////////////////////////////////
 

pkg/check/collection.go

@@ -40,7 +40,7 @@ func Has[T comparable](want T, bag []T, opts ...Option) error {
 	return notice.New("expected slice to have a value").
 		Trail(ops.Trail).
 		Want("%#v", want).
-		Append("slice", "%s", dmp.DumpAny(bag))
+		Append("slice", "%s", dmp.Any(bag))
 }
 
 // HasNo checks slice does not have "want" value. Returns nil if it doesn't,
@@ -55,7 +55,7 @@ func HasNo[T comparable](want T, set []T, opts ...Option) error {
 				Trail(ops.Trail).
 				Want("%#v", want).
 				Append("index", "%d", i).
-				Append("slice", "%s", dmp.DumpAny(set))
+				Append("slice", "%s", dmp.Any(set))
 		}
 	}
 	return nil
@@ -74,7 +74,7 @@ func HasKey[K comparable, V any](key K, set map[K]V, opts ...Option) (V, error)
 	return val, notice.New("expected map to have a key").
 		Trail(ops.Trail).
 		Append("key", "%#v", key).
-		Append("map", "%s", dmp.DumpAny(set))
+		Append("map", "%s", dmp.Any(set))
 }
 
 // HasNoKey checks map has no key. Returns nil if it doesn't, otherwise it
@@ -90,7 +90,7 @@ func HasNoKey[K comparable, V any](key K, set map[K]V, opts ...Option) error {
 		Trail(ops.Trail).
 		Append("key", "%#v", key).
 		Append("value", "%#v", val).
-		Append("map", "%s", dmp.DumpAny(set))
+		Append("map", "%s", dmp.Any(set))
 }
 
 // HasKeyValue checks map has a key with given value. Returns nil if it doesn't,
@@ -138,5 +138,5 @@ func SliceSubset[V comparable](want, have []V, opts ...Option) error {
 	const hHeader = "expected \"want\" slice to be a subset of \"have\" slice"
 	return notice.New(hHeader).
 		Trail(ops.Trail).
-		Append("missing values", "%s", dmp.DumpAny(missing))
+		Append("missing values", "%s", dmp.Any(missing))
 }

pkg/check/collection_test.go

@@ -117,7 +117,7 @@ func Test_Has(t *testing.T) {
 		affirm.NotNil(t, err)
 		wMsg := "expected slice to have a value:\n" +
 			"\t want: 42\n" +
-			"\tslice: []int{\n1,\n2,\n3,\n}"
+			"\tslice: []int{\n\t1,\n\t2,\n\t3,\n}"
 		affirm.Equal(t, wMsg, err.Error())
 	})
 
@@ -134,7 +134,7 @@ func Test_Has(t *testing.T) {
 		wMsg := "expected slice to have a value:\n" +
 			"\ttrail: type.field\n" +
 			"\t want: 42\n" +
-			"\tslice: []int{\n1,\n2,\n3,\n}"
+			"\tslice: []int{\n\t1,\n\t2,\n\t3,\n}"
 		affirm.Equal(t, wMsg, err.Error())
 	})
 }
@@ -163,7 +163,7 @@ func Test_HasNo(t *testing.T) {
 		wMsg := "expected slice not to have value:\n" +
 			"\t want: 2\n" +
 			"\tindex: 1\n" +
-			"\tslice: []int{\n1,\n2,\n3,\n}"
+			"\tslice: []int{\n\t1,\n\t2,\n\t3,\n}"
 		affirm.Equal(t, wMsg, err.Error())
 	})
 
@@ -181,7 +181,7 @@ func Test_HasNo(t *testing.T) {
 			"\ttrail: type.field\n" +
 			"\t want: 2\n" +
 			"\tindex: 1\n" +
-			"\tslice: []int{\n1,\n2,\n3,\n}"
+			"\tslice: []int{\n\t1,\n\t2,\n\t3,\n}"
 		affirm.Equal(t, wMsg, err.Error())
 	})
 
@@ -392,7 +392,7 @@ func Test_SliceSubset(t *testing.T) {
 		// --- Then ---
 		affirm.NotNil(t, err)
 		wMsg := "expected \"want\" slice to be a subset of \"have\" slice:\n" +
-			"\tmissing values: []string{\n\"X\",\n\"Y\",\n}"
+			"\tmissing values: []string{\n\t\"X\",\n\t\"Y\",\n}"
 		affirm.Equal(t, wMsg, err.Error())
 	})
 
@@ -409,7 +409,7 @@ func Test_SliceSubset(t *testing.T) {
 		affirm.NotNil(t, err)
 		wMsg := "expected \"want\" slice to be a subset of \"have\" slice:\n" +
 			"\t         trail: type.field\n" +
-			"\tmissing values: []string{\n\"X\",\n\"Y\",\n}"
+			"\tmissing values: []string{\n\t\"X\",\n\t\"Y\",\n}"
 		affirm.Equal(t, wMsg, err.Error())
 	})
 }

pkg/check/nil.go

@@ -20,7 +20,7 @@ func Nil(have any, opts ...Option) error {
 	const mHeader = "expected value to be nil"
 	return notice.New(mHeader).Want("<nil>").
 		Trail(ops.Trail).
-		Have("%s", dump.New(ops.DumpCfg).DumpAny(have))
+		Have("%s", dump.New(ops.DumpCfg).Any(have))
 }
 
 // isNil returns true if "have" is nil.

pkg/check/options.go

@@ -112,7 +112,7 @@ func DefaultOptions() Options {
 	return Options{
 		DumpCfg: dump.NewConfig(
 			dump.WithTimeFormat(DumpTimeFormat),
-			dump.WithDepth(DumpDepth),
+			dump.WithMaxDepth(DumpDepth),
 		),
 		Recent:     RecentDuration,
 		TimeFormat: ParseTimeFormat,

pkg/check/options_test.go

@@ -52,11 +52,11 @@ func Test_WithDump(t *testing.T) {
 	ops := Options{}
 
 	// --- When ---
-	have := WithDump(dump.WithDepth(100))(ops)
+	have := WithDump(dump.WithMaxDepth(100))(ops)
 
 	// --- Then ---
-	affirm.Equal(t, 0, ops.DumpCfg.Depth)
-	affirm.Equal(t, 100, have.DumpCfg.Depth)
+	affirm.Equal(t, 0, ops.DumpCfg.MaxDepth)
+	affirm.Equal(t, 100, have.DumpCfg.MaxDepth)
 }
 
 func Test_DefaultOptions(t *testing.T) {

pkg/dump/README.md

@@ -38,7 +38,7 @@ val := types.TA{
     TAp: nil,
 }
 
-have := dump.DefaultDump().DumpAny(val)
+have := dump.Default().Any(val)
 
 fmt.Println(have)
 // Output:
@@ -73,7 +73,7 @@ val := map[string]any{
 }
 
 cfg := dump.NewConfig(dump.Flat)
-have := dump.New(cfg).DumpAny(val)
+have := dump.New(cfg).Any(val)
 
 fmt.Println(have)
 // Output:
@@ -91,7 +91,7 @@ You can customize how `time.Time` values are displayed using the
 val := map[time.Time]int{time.Date(2000, 1, 2, 3, 4, 5, 0, time.UTC): 42}
 
 cfg := dump.NewConfig(dump.Flat, dump.TimeFormat(time.Kitchen))
-have := dump.New(cfg).DumpAny(val)
+have := dump.New(cfg).Any(val)
 
 fmt.Println(have)
 // Output:
@@ -110,7 +110,7 @@ val := map[string]any{
 }
 
 cfg := NewConfig(PtrAddr)
-have := New(cfg).DumpAny(val)
+have := New(cfg).Any(val)
 
 fmt.Println(have)
 // Output:
@@ -144,7 +144,7 @@ customIntDumper := func(dmp Dump, lvl int, val reflect.Value) string {
 }
 
 cfg := NewConfig(Flat, Compact, WithDumper(i, customIntDumper))
-have := New(cfg).DumpAny(42)
+have := New(cfg).Any(42)
 
 fmt.Println(have)
 // Output:
@@ -174,7 +174,7 @@ val := &Node{
     },
 }
 
-have := dump.DefaultDump().DumpAny(val)
+have := dump.Default().Any(val)
 fmt.Println(have)
 // Output:
 // {
@@ -211,7 +211,7 @@ val := &Node{
     },
 }
 
-have := dump.DefaultDump().DumpAny(val)
+have := dump.Default().Any(val)
 fmt.Println(have)
 // Output:
 // {

pkg/dump/config.go

@@ -15,6 +15,9 @@ const (
 
 	// DefaultDepth is default depth when dumping values recursively.
 	DefaultDepth = 6
+
+	// DefaultIndent is default additional indent when dumping values.
+	DefaultIndent = 0
 )
 
 // Package wide configuration.
@@ -24,6 +27,9 @@ var (
 
 	// Depth is configurable depth when dumping values recursively.
 	Depth = DefaultDepth
+
+	// Indent is configurable additional indent when dumping values.
+	Indent = DefaultIndent
 )
 
 // Option represents [NewConfig] option.
@@ -47,18 +53,21 @@ func WithTimeFormat(format string) func(cfg *Config) {
 	return func(cfg *Config) { cfg.TimeFormat = format }
 }
 
-// WithPrintType is option for [NewConfig] which makes [Dump] print types.
-func WithPrintType(cfg *Config) { cfg.PrintType = true }
-
 // WithDumper adds custom [Dumper] to the config.
 func WithDumper(typ any, dumper Dumper) func(cfg *Config) {
 	return func(cfg *Config) { cfg.Dumpers[reflect.TypeOf(typ)] = dumper }
 }
 
-// WithDepth is option for [NewConfig] which controls maximum nesting when bumping
-// recursive types.
-func WithDepth(maximum int) func(cfg *Config) {
-	return func(cfg *Config) { cfg.Depth = maximum }
+// WithMaxDepth is option for [NewConfig] which controls maximum nesting when
+// bumping recursive types.
+func WithMaxDepth(maximum int) func(cfg *Config) {
+	return func(cfg *Config) { cfg.MaxDepth = maximum }
+}
+
+// WithIndent is option for [NewConfig] which how much additional indentation
+// to apply to dumped values.
+func WithIndent(n int) func(cfg *Config) {
+	return func(cfg *Config) { cfg.Indent = n }
 }
 
 // Config represents [Dump] configuration.
@@ -107,7 +116,11 @@ type Config struct {
 	Dumpers map[reflect.Type]Dumper
 
 	// Controls maximum nesting when dumping recursive types.
-	Depth int
+	// The depth is also used to properly indent values being dumped.
+	MaxDepth int
+
+	// How much additional indentation to apply to values being dumped.
+	Indent int
 }
 
 // NewConfig returns new instance of [Config] with default values.
@@ -117,7 +130,8 @@ func NewConfig(opts ...Option) Config {
 		PrintType:  true,
 		UseAny:     true,
 		Dumpers:    make(map[reflect.Type]Dumper),
-		Depth:      Depth,
+		MaxDepth:   Depth,
+		Indent:     Indent,
 	}
 	for _, opt := range opts {
 		opt(&cfg)

pkg/dump/config_test.go

@@ -56,27 +56,28 @@ func Test_WithTimeFormat(t *testing.T) {
 	affirm.Equal(t, TimeAsUnix, cfg.TimeFormat)
 }
 
-func Test_WithDepth(t *testing.T) {
+func Test_WithMaxDepth(t *testing.T) {
 	// --- Given ---
 	cfg := &Config{}
 
 	// --- When ---
-	opt := WithDepth(10)
+	opt := WithMaxDepth(10)
 
 	// --- Then ---
 	opt(cfg)
-	affirm.Equal(t, 10, cfg.Depth)
+	affirm.Equal(t, 10, cfg.MaxDepth)
 }
 
-func Test_WithPrintType(t *testing.T) {
+func Test_WithIndent(t *testing.T) {
 	// --- Given ---
 	cfg := &Config{}
 
 	// --- When ---
-	WithPrintType(cfg)
+	opt := WithIndent(10)
 
 	// --- Then ---
-	affirm.True(t, cfg.PrintType)
+	opt(cfg)
+	affirm.Equal(t, 10, cfg.Indent)
 }
 
 func Test_WithDumper(t *testing.T) {
@@ -87,7 +88,7 @@ func Test_WithDumper(t *testing.T) {
 	WithDumper(time.Time{}, GetTimeDumper(time.Kitchen))(&cfg)
 
 	// --- Then ---
-	dmp := New(cfg).DumpAny(time.Date(2020, 1, 2, 3, 4, 5, 0, time.UTC))
+	dmp := New(cfg).Any(time.Date(2020, 1, 2, 3, 4, 5, 0, time.UTC))
 	affirm.Equal(t, `"3:04AM"`, dmp)
 }
 
@@ -103,7 +104,8 @@ func Test_NewConfig(t *testing.T) {
 	affirm.False(t, have.PtrAddr)
 	affirm.True(t, have.UseAny)
 	affirm.True(t, len(have.Dumpers) == 3)
-	affirm.Equal(t, DefaultDepth, have.Depth)
+	affirm.Equal(t, DefaultDepth, have.MaxDepth)
+	affirm.Equal(t, DefaultIndent, have.Indent)
 
 	val, ok := have.Dumpers[typDur]
 	affirm.True(t, ok)