update

errors.go

@@ -2,6 +2,18 @@ package securecookie
 
 import "errors"
 
+func NewUsageError(err error) *cookieError {
+	return &cookieError{cause: err, typ: usageError}
+}
+
+func NewInternalError(err error) *cookieError {
+	return &cookieError{cause: err, typ: internalError}
+}
+
+func NewDecodeError(err error) *cookieError {
+	return &cookieError{cause: err, typ: decodeError}
+}
+
 func IsValueTooLong(err error) bool {
 	return errors.Is(err, errEncodedValueTooLong) || errors.Is(err, errValueToDecodeTooLong)
 }

setter.go

@@ -49,6 +49,8 @@ func SetSerializer(codecs []Codec, sz Serializer) {
 	for _, c := range codecs {
 		if codec, ok := c.(*SecureCookie); ok {
 			codec.SetSerializer(sz)
+		} else if codec, ok := c.(*UnsafeCodec); ok {
+			codec.SetSerializer(sz)
 		}
 	}
 }

unsafecodec.go

@@ -0,0 +1,56 @@
+package securecookie
+
+import "fmt"
+
+var _ Codec = (*UnsafeCodec)(nil)
+
+func NewUnsafeCodec() *UnsafeCodec {
+	s := &UnsafeCodec{
+		sz: GobEncoder{},
+	}
+	return s
+}
+
+// UnsafeCodec encodes and decodes
+type UnsafeCodec struct {
+	err error
+	sz  Serializer
+}
+
+// Encoding sets the encoding/serialization method for cookies.
+//
+// Default is encoding/gob.  To encode special structures using encoding/gob,
+// they must be registered first using gob.Register().
+func (s *UnsafeCodec) SetSerializer(sz Serializer) *UnsafeCodec {
+	s.sz = sz
+
+	return s
+}
+
+// Encode encodes a value.
+func (s *UnsafeCodec) Encode(name string, value interface{}) (string, error) {
+	if s.err != nil {
+		return "", s.err
+	}
+	var err error
+	var b []byte
+	// Serialize.
+	if b, err = s.sz.Serialize(value); err != nil {
+		return "", cookieError{cause: fmt.Errorf(`%w: %s`, err, name), typ: usageError}
+	}
+	// Done.
+	return string(b), nil
+}
+
+// Decode decodes a value. The dst argument must be a pointer.
+func (s *UnsafeCodec) Decode(name, value string, dst interface{}, _ ...int) error {
+	if s.err != nil {
+		return s.err
+	}
+	// Deserialize.
+	if err := s.sz.Deserialize([]byte(value), dst); err != nil {
+		return cookieError{cause: fmt.Errorf(`%w: %s`, err, name), typ: decodeError}
+	}
+	// Done.
+	return nil
+}

unsafecodec_test.go

@@ -0,0 +1,20 @@
+package securecookie
+
+import "testing"
+
+func TestUnsafeCodec(t *testing.T) {
+	c := NewUnsafeCodec()
+	str := `TestUnsafeCodec`
+	encoded, err := c.Encode(`name`, str)
+	if err != nil {
+		t.Error(err)
+	}
+	var decoded string
+	err = c.Decode(`name`, encoded, &decoded)
+	if err != nil {
+		t.Error(err)
+	}
+	if decoded != str {
+		t.Fatalf("expected %s, got: %#v", str, decoded)
+	}
+}