feat: support for RFC 9651

Author: dunglas

bareitem.go

@@ -5,15 +5,16 @@ import (
 	"fmt"
 	"reflect"
 	"strings"
+	"time"
 )
 
 // ErrInvalidBareItem is returned when a bare item is invalid.
 var ErrInvalidBareItem = errors.New(
-	"invalid bare item type (allowed types are bool, string, int64, float64, []byte and Token)",
+	"invalid bare item type (allowed types are bool, string, int64, float64, []byte, time.Time and Token)",
 )
 
 // assertBareItem asserts that v is a valid bare item
-// according to https://httpwg.org/specs/rfc8941.html#item.
+// according to https://httpwg.org/specs/rfc9651.html#item.
 //
 // v can be either:
 //
@@ -23,6 +24,7 @@ var ErrInvalidBareItem = errors.New(
 // * a token (Section 3.3.4.)
 // * a byte sequence (Section 3.3.5.)
 // * a boolean (Section 3.3.6.)
+// * a date (Section 3.3.7.)
 func assertBareItem(v interface{}) {
 	switch v.(type) {
 	case bool,
@@ -40,7 +42,9 @@ func assertBareItem(v interface{}) {
 		float32,
 		float64,
 		[]byte,
-		Token:
+		time.Time,
+		Token,
+		DisplayString:
 		return
 	default:
 		panic(fmt.Errorf("%w: got %s", ErrInvalidBareItem, reflect.TypeOf(v)))
@@ -66,8 +70,12 @@ func marshalBareItem(b *strings.Builder, v interface{}) error {
 		return marshalDecimal(b, v.(float64))
 	case []byte:
 		return marshalBinary(b, v)
+	case time.Time:
+		return marshalDate(b, v)
 	case Token:
 		return v.marshalSFV(b)
+	case DisplayString:
+		return v.marshalSFV(b)
 	default:
 		panic(ErrInvalidBareItem)
 	}
@@ -92,6 +100,10 @@ func parseBareItem(s *scanner) (interface{}, error) {
 		return parseBinary(s)
 	case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
 		return parseNumber(s)
+	case '@':
+		return parseDate(s)
+	case '%':
+		return parseDisplayString(s)
 	default:
 		if isAlpha(c) {
 			return parseToken(s)

bareitem_test.go

@@ -23,6 +23,7 @@ func TestParseBareItem(t *testing.T) {
 		{"abc", Token("abc"), false},
 		{"*abc", Token("*abc"), false},
 		{":YWJj:", []byte("abc"), false},
+		{"@1659578233", time.Unix(1659578233, 0), false},
 		{"", nil, true},
 		{"~", nil, true},
 	}

binary_test.go

@@ -6,7 +6,7 @@ import (
 	"testing"
 )
 
-func TestBinary(t *testing.T) {
+func TestMarshalBinary(t *testing.T) {
 	t.Parallel()
 
 	var bd strings.Builder

boolean_test.go

@@ -5,7 +5,7 @@ import (
 	"testing"
 )
 
-func TestBooleanMarshalSFV(t *testing.T) {
+func TestMarshalBoolean(t *testing.T) {
 	t.Parallel()
 
 	var b strings.Builder

date.go

@@ -0,0 +1,41 @@
+package httpsfv
+
+import (
+	"errors"
+	"io"
+	"time"
+)
+
+var ErrInvalidDateFormat = errors.New("invalid date format")
+
+// marshalDate serializes as defined in
+// https://httpwg.org/specs/rfc9651.html#ser-date.
+func marshalDate(b io.StringWriter, i time.Time) error {
+	_, err := b.WriteString("@")
+	if err != nil {
+		return err
+	}
+
+	return marshalInteger(b, i.Unix())
+}
+
+// parseDate parses as defined in
+// https://httpwg.org/specs/rfc9651.html#parse-date.
+func parseDate(s *scanner) (time.Time, error) {
+	if s.eof() || s.data[s.off] != '@' {
+		return time.Time{}, &UnmarshalError{s.off, ErrInvalidDateFormat}
+	}
+	s.off++
+
+	n, err := parseNumber(s)
+	if err != nil {
+		return time.Time{}, &UnmarshalError{s.off, ErrInvalidDateFormat}
+	}
+
+	i, ok := n.(int64)
+	if !ok {
+		return time.Time{}, &UnmarshalError{s.off, ErrInvalidDateFormat}
+	}
+
+	return time.Unix(i, 0), nil
+}

date_test.go

@@ -0,0 +1,63 @@
+package httpsfv
+
+import (
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestMarshalDate(t *testing.T) {
+	t.Parallel()
+
+	data := []struct {
+		in       time.Time
+		expected string
+		valid    bool
+	}{
+		{time.Unix(1659578233, 0), "@1659578233", true},
+		{time.Unix(9999999999999999, 0), "@", false},
+	}
+
+	var b strings.Builder
+
+	for _, d := range data {
+		b.Reset()
+
+		err := marshalDate(&b, d.in)
+		if d.valid && err != nil {
+			t.Errorf("error not expected for %v, got %v", d.in, err)
+		} else if !d.valid && err == nil {
+			t.Errorf("error expected for %v, got %v", d.in, err)
+		}
+
+		if b.String() != d.expected {
+			t.Errorf("got %v; want %v", b.String(), d.expected)
+		}
+	}
+}
+
+func TestParseDate(t *testing.T) {
+	t.Parallel()
+
+	data := []struct {
+		in  string
+		out time.Time
+		err bool
+	}{
+		{"@1659578233", time.Unix(1659578233, 0), false},
+		{"invalid", time.Time{}, true},
+	}
+
+	for _, d := range data {
+		s := &scanner{data: d.in}
+
+		i, err := parseDate(s)
+		if d.err && err == nil {
+			t.Errorf("parse%s): error expected", d.in)
+		}
+
+		if !d.err && d.out != i {
+			t.Errorf("parse%s) = %v, %v; %v, <nil> expected", d.in, i, err, d.out)
+		}
+	}
+}

decimal_test.go

@@ -5,7 +5,7 @@ import (
 	"testing"
 )
 
-func TestDecimalMarshalSFV(t *testing.T) {
+func TestMarshalDecimal(t *testing.T) {
 	t.Parallel()
 
 	data := []struct {

dictionary_test.go

@@ -6,7 +6,7 @@ import (
 	"testing"
 )
 
-func TestDictionnary(t *testing.T) {
+func TestMarshalDictionnary(t *testing.T) {
 	t.Parallel()
 
 	dict := NewDictionary()

displaystring.go

@@ -0,0 +1,105 @@
+package httpsfv
+
+import (
+	"encoding/hex"
+	"errors"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
+
+type DisplayString string
+
+var ErrInvalidDisplayString = errors.New("invalid display string type")
+
+var notVcharOrSp = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		{0x0000, 0x001f, 1},
+		{0x007f, 0x00ff, 1},
+	},
+	LatinOffset: 2,
+}
+
+// marshalSFV serializes as defined in
+// https://httpwg.org/specs/rfc8941.html#ser-string.
+func (s DisplayString) marshalSFV(b *strings.Builder) error {
+	if _, err := b.WriteString(`%"`); err != nil {
+		return err
+	}
+
+	for i := 0; i < len(s); i++ {
+		if s[i] == '%' || s[i] == '"' || unicode.Is(notVcharOrSp, rune(s[i])) {
+			b.WriteRune('%')
+			b.WriteString(hex.EncodeToString([]byte{s[i]}))
+
+			continue
+		}
+
+		b.WriteByte(s[i])
+	}
+
+	b.WriteByte('"')
+
+	return nil
+}
+
+// parseDisplayString parses as defined in
+// https://httpwg.org/specs/rfc9651.html#parse-display.
+func parseDisplayString(s *scanner) (DisplayString, error) {
+	if s.eof() || len(s.data[s.off:]) < 2 || s.data[s.off:2] != `%"` {
+		return "", &UnmarshalError{s.off, ErrInvalidDisplayString}
+	}
+	s.off += 2
+
+	var b strings.Builder
+	for !s.eof() {
+		c := s.data[s.off]
+		s.off++
+
+		switch c {
+		case '%':
+			if len(s.data[s.off:]) < 2 {
+				return "", &UnmarshalError{s.off, ErrInvalidDisplayString}
+			}
+			c0 := unhex(s.data[s.off])
+			if c0 == 0 {
+				return "", &UnmarshalError{s.off, ErrInvalidDisplayString}
+			}
+
+			c1 := unhex(s.data[s.off+1])
+			if c1 == 0 {
+				return "", &UnmarshalError{s.off, ErrInvalidDisplayString}
+			}
+
+			b.WriteByte(c0<<4 | c1)
+			s.off += 2
+		case '"':
+			r := b.String()
+			if !utf8.ValidString(r) {
+				return "", ErrInvalidDisplayString
+			}
+
+			return DisplayString(r), nil
+
+		default:
+			if unicode.Is(notVcharOrSp, rune(c)) {
+				return "", &UnmarshalError{s.off, ErrInvalidDisplayString}
+			}
+
+			b.WriteByte(c)
+		}
+	}
+
+	return "", &UnmarshalError{s.off, ErrInvalidDisplayString}
+}
+
+func unhex(c byte) byte {
+	switch {
+	case '0' <= c && c <= '9':
+		return c - '0'
+	case 'a' <= c && c <= 'f':
+		return c - 'a' + 10
+	default:
+		return 0
+	}
+}

displaystring_test.go

@@ -0,0 +1,69 @@
+package httpsfv
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestMarshalDisplayString(t *testing.T) {
+	t.Parallel()
+
+	data := []struct {
+		in       string
+		expected string
+		valid    bool
+	}{
+		{"foo", `%"foo"`, true},
+		{"Kévin", `%"K%c3%a9vin"`, true},
+	}
+
+	var b strings.Builder
+
+	for _, d := range data {
+		b.Reset()
+
+		err := DisplayString(d.in).marshalSFV(&b)
+		if d.valid && err != nil {
+			t.Errorf("error not expected for %v, got %v", d.in, err)
+		} else if !d.valid && err == nil {
+			t.Errorf("error expected for %v, got %v", d.in, err)
+		}
+
+		if b.String() != d.expected {
+			t.Errorf("got %v; want %v", b.String(), d.expected)
+		}
+	}
+}
+
+func TestParseDisplayString(t *testing.T) {
+	t.Parallel()
+
+	data := []struct {
+		in  string
+		out string
+		err bool
+	}{
+		{`%"foo"`, "foo", false},
+		{`%"K%c3%a9vin"`, "Kévin", false},
+		{`%"K%00vin"`, "", true},
+		{`"K%e9vin"`, "", true},
+		{`%K%e9vin"`, "", true},
+		{`%"K%e9vin`, "", true},
+	}
+
+	for _, d := range data {
+		s := &scanner{data: d.in}
+
+		i, err := parseDisplayString(s)
+		if d.err && err == nil {
+			t.Errorf("parse(%s): error expected", d.in)
+		}
+
+		if !d.err && d.out != string(i) {
+			fmt.Printf("%q\n", i)
+			fmt.Printf("%q\n", d.out)
+			t.Errorf("parse(%s) = %v, %v; %v, <nil> expected", d.in, i, err, d.out)
+		}
+	}
+}