Add implementations of encoding.MarshalText to stack.Call and stack.CallStack.

Author: ChrisHines

stack.go

@@ -10,6 +10,8 @@
 package stack
 
 import (
+	"bytes"
+	"errors"
 	"fmt"
 	"io"
 	"path/filepath"
@@ -50,6 +52,21 @@ func (c Call) String() string {
 	return fmt.Sprint(c)
 }
 
+// MarshalText implements encoding.TextMarshaler. It formats the Call the same
+// as fmt.Sprintf("%v", c).
+func (c Call) MarshalText() ([]byte, error) {
+	if c.fn == nil {
+		return nil, ErrNoFunc
+	}
+	buf := bytes.Buffer{}
+	fmt.Fprint(&buf, c)
+	return buf.Bytes(), nil
+}
+
+// ErrNoFunc means that the Call has a nil *runtime.Func. The most likely
+// cause is a Call with the zero value.
+var ErrNoFunc = errors.New("no call stack information")
+
 // Format implements fmt.Formatter with support for the following verbs.
 //
 //    %s    source file
@@ -181,18 +198,42 @@ func (cs CallStack) String() string {
 	return fmt.Sprint(cs)
 }
 
+var (
+	openBracketBytes  = []byte("[")
+	closeBracketBytes = []byte("]")
+	spaceBytes        = []byte(" ")
+)
+
+// MarshalText implements encoding.TextMarshaler. It formats the CallStack the
+// same as fmt.Sprintf("%v", cs).
+func (cs CallStack) MarshalText() ([]byte, error) {
+	buf := bytes.Buffer{}
+	buf.Write(openBracketBytes)
+	for i, pc := range cs {
+		if pc.fn == nil {
+			return nil, ErrNoFunc
+		}
+		if i > 0 {
+			buf.Write(spaceBytes)
+		}
+		fmt.Fprint(&buf, pc)
+	}
+	buf.Write(closeBracketBytes)
+	return buf.Bytes(), nil
+}
+
 // Format implements fmt.Formatter by printing the CallStack as square brackes
 // ([, ]) surrounding a space separated list of Calls each formatted with the
 // supplied verb and options.
 func (cs CallStack) Format(s fmt.State, verb rune) {
-	s.Write([]byte("["))
+	s.Write(openBracketBytes)
 	for i, pc := range cs {
 		if i > 0 {
-			s.Write([]byte(" "))
+			s.Write(spaceBytes)
 		}
 		pc.Format(s, verb)
 	}
-	s.Write([]byte("]"))
+	s.Write(closeBracketBytes)
 }
 
 // findSigpanic intentially executes faulting code to generate a stack trace

stack_test.go

@@ -5,6 +5,7 @@ import (
 	"io/ioutil"
 	"path"
 	"path/filepath"
+	"reflect"
 	"runtime"
 	"strings"
 	"testing"
@@ -110,6 +111,43 @@ func TestCallString(t *testing.T) {
 	}
 }
 
+func TestCallMarshalText(t *testing.T) {
+	t.Parallel()
+
+	c := stack.Caller(0)
+	_, file, line, ok := runtime.Caller(0)
+	line--
+	if !ok {
+		t.Fatal("runtime.Caller(0) failed")
+	}
+
+	c2, _, file2, line2, ok2 := testType{}.testMethod()
+	if !ok2 {
+		t.Fatal("runtime.Caller(0) failed")
+	}
+
+	data := []struct {
+		c    stack.Call
+		desc string
+		out  []byte
+		err  error
+	}{
+		{stack.Call{}, "error", nil, stack.ErrNoFunc},
+		{c, "func", []byte(fmt.Sprint(path.Base(file), ":", line)), nil},
+		{c2, "meth", []byte(fmt.Sprint(path.Base(file2), ":", line2)), nil},
+	}
+
+	for _, d := range data {
+		text, err := d.c.MarshalText()
+		if got, want := err, d.err; got != want {
+			t.Errorf("%s: got err %v, want err %v", d.desc, got, want)
+		}
+		if got, want := text, d.out; !reflect.DeepEqual(got, want) {
+			t.Errorf("%s: got %s, want %s", d.desc, got, want)
+		}
+	}
+}
+
 func TestCallStackString(t *testing.T) {
 	cs, line0 := getTrace(t)
 	_, file, line1, ok := runtime.Caller(0)
@@ -123,6 +161,19 @@ func TestCallStackString(t *testing.T) {
 	}
 }
 
+func TestCallStackMarshalText(t *testing.T) {
+	cs, line0 := getTrace(t)
+	_, file, line1, ok := runtime.Caller(0)
+	line1--
+	if !ok {
+		t.Fatal("runtime.Caller(0) failed")
+	}
+	file = path.Base(file)
+	text, _ := cs.MarshalText()
+	if got, want := text, []byte(fmt.Sprintf("[%s:%d %s:%d]", file, line0, file, line1)); !reflect.DeepEqual(got, want) {
+		t.Errorf("\n got %v\nwant %v", got, want)
+	}
+}
 func getTrace(t *testing.T) (stack.CallStack, int) {
 	cs := stack.Trace().TrimRuntime()
 	_, _, line, ok := runtime.Caller(0)