net/http: add accept parserv0.5.2

2 files changed, 361 insertions, 0 deletions

diff --git a/net/http/accept.go b/net/http/accept.go
new file mode 100644
index 0000000..cabfc48
--- /dev/null
+++ b/net/http/accept.go
@@ -0,0 +1,214 @@
+package http
+
+import (
+        "fmt"
+        "mime"
+        "reflect"
+        "regexp"
+        "sort"
+        "strconv"
+        "strings"
+)
+
+type MediaType struct {
+        Type       string
+        Subtype    string
+        Parameters map[string]string
+        Weight     float64
+        originalQ  string
+}
+
+func ParseMediaType(v string) (*MediaType, error) {
+        mt, params, err := mime.ParseMediaType(v)
+        if err != nil {
+                return nil, err
+        }
+
+        majorMinor := strings.Split(mt, "/")
+        if len(majorMinor) != 2 {
+                return nil, fmt.Errorf("Invalid major/minor media type: %s", mt)
+        }
+
+        // No q should be weight 1.0, per spec
+        q := float64(1)
+        sq, ok := params["q"]
+        if ok {
+                delete(params, "q")
+                q, err = parseQ(sq)
+                if err != nil {
+                        return nil, err
+                }
+        }
+
+        return &MediaType{
+                Type:       majorMinor[0],
+                Subtype:    majorMinor[1],
+                Parameters: params,
+                Weight:     q,
+                originalQ:  sq,
+        }, nil
+}
+
+func (m MediaType) String() string {
+        b := strings.Builder{}
+        b.WriteString(m.Type + "/" + m.Subtype)
+
+        params := []string{}
+        for k, v := range m.Parameters {
+                params = append(params, fmt.Sprintf("%s=%s", k, v))
+        }
+
+        // Keep them in the same order so they're comparable
+        sort.Strings(params)
+
+        // Q should always be last per RFC9110
+        if m.originalQ != "" {
+                params = append(params, fmt.Sprintf("q=%s", m.originalQ))
+        }
+
+        if len(params) > 0 {
+                b.WriteString(";")
+                b.WriteString(strings.Join(params, ";"))
+        }
+
+        return b.String()
+}
+
+func (m MediaType) Specificity() int {
+        s := 0
+
+        if m.Type != "*" {
+                s += 1
+        }
+        if m.Subtype != "*" {
+                s += 1
+        }
+        if m.Parameters != nil {
+                s += len(m.Parameters)
+        }
+
+        return s
+}
+
+func (m MediaType) Satisfies(v MediaType) bool {
+        if m.Equal(v) {
+                return true
+        }
+
+        if m.Type != v.Type && m.Type != "*" && v.Type != "*" {
+                return false
+        }
+
+        if m.Subtype != v.Subtype && m.Subtype != "*" && v.Subtype != "*" {
+                return false
+        }
+
+        return reflect.DeepEqual(m.Parameters, v.Parameters)
+}
+
+func (m MediaType) Equal(v MediaType) bool {
+        return m.Type == v.Type &&
+                m.Subtype == v.Subtype &&
+                reflect.DeepEqual(m.Parameters, v.Parameters)
+}
+
+type AcceptableTypes []*MediaType
+
+func (a AcceptableTypes) Sorted() AcceptableTypes { sort.Stable(sort.Reverse(a)); return a }
+func (a AcceptableTypes) Len() int                { return len(a) }
+func (a AcceptableTypes) Less(i, j int) bool      { return a[i].Weight < a[j].Weight }
+func (a AcceptableTypes) Swap(i, j int)           { a[i], a[j] = a[j], a[i] }
+
+// FindMatch returns the MediaType in the set that has the best match
+// for the passed media types as well as the media type that determined
+// the match. According to the rules of RFC7231, the most specific match
+// wins in order of weight. This function assumes that both values are
+// sorted.
+func (a AcceptableTypes) FindMatch(values AcceptableTypes) (match *MediaType, matcher *MediaType) {
+        if len(a) == 0 || len(values) == 0 {
+                return nil, nil
+        }
+
+        candidates := AcceptableTypes{}
+
+        // Return the highest precedence match for the type. If there is no
+        // exact match then the most specific match with the highest precedence
+        // should win.
+        for _, matcher = range values {
+                for _, match = range a {
+                        if match.Equal(*matcher) {
+                                return match, matcher
+                        }
+
+                        if match.Satisfies(*matcher) {
+                                candidates = append(candidates, match)
+                        }
+                }
+
+                if len(candidates) != 0 {
+                        break
+                }
+        }
+
+        if len(candidates) == 0 {
+                return nil, nil
+        }
+
+        // Sort ascending by specificity
+        sort.SliceStable(candidates, func(i, j int) bool {
+                return candidates[i].Specificity() < candidates[j].Specificity()
+        })
+
+        return candidates[len(candidates)-1], matcher
+}
+
+// ParseAccept parses a set of Accept headers and scores them per the
+// rules in RFC7231, returning a slice of headers in descending order of
+// priority. If the Accept header occurs multiple times in the request
+// the result of all headers will be combined and scored together as if
+// they were all in one header line.
+//
+// See: https://tools.ietf.org/html/rfc7231#section-5.3.2
+func ParseAccept(values []string) (AcceptableTypes, error) {
+        all := AcceptableTypes{}
+
+        for _, l := range values {
+                t, err := parseAcceptLine(l)
+                if err != nil {
+                        return nil, err
+                }
+                all = append(all, t...)
+        }
+
+        return all.Sorted(), nil
+}
+
+func parseAcceptLine(l string) (AcceptableTypes, error) {
+        out := AcceptableTypes{}
+
+        for _, t := range strings.Split(l, ",") {
+                mt, err := ParseMediaType(t)
+                if err != nil {
+                        return nil, err
+                }
+                out = append(out, mt)
+        }
+
+        return out, nil
+}
+
+// https://tools.ietf.org/html/rfc7231#section-5.3.1
+var validateQ = regexp.MustCompile(`(0\.[0-9]{1,3}|1\.0{1,3})$`)
+
+func parseQ(v string) (float64, error) {
+        if !validateQ.Match([]byte(v)) {
+                return 0.0, fmt.Errorf("Invalid format for Q")
+        }
+
+        f, err := strconv.ParseFloat(v, 64)
+        if err != nil {
+                return 0.0, err
+        }
+
+        return f, nil
+}
diff --git a/net/http/accept_test.go b/net/http/accept_test.go
new file mode 100644
index 0000000..4e209c2
--- /dev/null
+++ b/net/http/accept_test.go
@@ -0,0 +1,147 @@
+package http
+
+import (
+        "testing"
+
+        "github.com/stretchr/testify/assert"
+)
+
+var rfcTestLine = "text/*;q=0.3, text/html;q=0.7, text/html;level=1, text/html;level=2;q=0.4, */*;q=0.5"
+
+func TestParseAccept(t *testing.T) {
+        values, err := ParseAccept([]string{
+                "text/*;q=0.3, text/html;q=0.7",
+                "text/html;level=1, text/html;level=2;q=0.4",
+                "*/*;q=0.5",
+        })
+
+        assert.NoError(t, err)
+        assert.Len(t, values, 5)
+
+        expected := []MediaType{
+                MediaType{Type: "text", Subtype: "html", Weight: 1, Parameters: map[string]string{"level": "1"}},
+                MediaType{Type: "text", Subtype: "html", Weight: 0.7, Parameters: map[string]string{}, originalQ: "0.7"},
+                MediaType{Type: "*", Subtype: "*", Weight: 0.5, Parameters: map[string]string{}, originalQ: "0.5"},
+                MediaType{Type: "text", Subtype: "html", Weight: 0.4, Parameters: map[string]string{"level": "2"}, originalQ: "0.4"},
+                MediaType{Type: "text", Subtype: "*", Weight: 0.3, Parameters: map[string]string{}, originalQ: "0.3"},
+        }
+
+        for i, e := range values {
+                assert.Equal(t, *e, expected[i])
+        }
+}
+
+func TestParseQ(t *testing.T) {
+        var v float64
+        var err error
+
+        _, err = parseQ("1.12")
+        assert.ErrorContains(t, err, "Invalid format for Q")
+
+        _, err = parseQ("0.1234")
+        assert.ErrorContains(t, err, "Invalid format for Q")
+
+        v, err = parseQ("1.0")
+        assert.NoError(t, err)
+        assert.Equal(t, 1.0, v)
+
+        v, err = parseQ("0.003")
+        assert.NoError(t, err)
+        assert.Equal(t, 0.003, v)
+}
+
+func TestParseMediaType(t *testing.T) {
+        mt, err := ParseMediaType("text/plain;foo=bar;q=0.3")
+        assert.NoError(t, err)
+        assert.Equal(t, "text", mt.Type)
+        assert.Equal(t, "plain", mt.Subtype)
+        assert.Equal(t, map[string]string{"foo": "bar"}, mt.Parameters)
+        assert.Equal(t, 0.3, mt.Weight)
+
+        mt, err = ParseMediaType("text/plain")
+        assert.NoError(t, err)
+        assert.Equal(t, 1.0, mt.Weight)
+
+        mt, err = ParseMediaType("foo")
+        assert.ErrorContains(t, err, "Invalid major/minor")
+
+        mt, err = ParseMediaType("foo/bar;q=11")
+        assert.ErrorContains(t, err, "Invalid format for Q")
+}
+
+func TestMediaTypeString(t *testing.T) {
+        mt, err := ParseMediaType("text/plain;foo=bar;biz=baz;q=0.3")
+        assert.NoError(t, err)
+        assert.Equal(t, "text/plain;biz=baz;foo=bar;q=0.3", mt.String())
+
+        // Default q of 1 should not leak to String()
+        mt, err = ParseMediaType("text/plain;foo=bar;biz=baz")
+        assert.NoError(t, err)
+        assert.Equal(t, "text/plain;biz=baz;foo=bar", mt.String())
+}
+
+func TestMediaTypeSpecificity(t *testing.T) {
+        mt, err := ParseMediaType("text/plain;foo=bar;biz=baz")
+        assert.NoError(t, err)
+        assert.Equal(t, 4, mt.Specificity())
+
+        mt, err = ParseMediaType("text/*;foo=bar;biz=baz")
+        assert.NoError(t, err)
+        assert.Equal(t, 3, mt.Specificity())
+
+        mt, err = ParseMediaType("text/*")
+        assert.NoError(t, err)
+        assert.Equal(t, 1, mt.Specificity())
+
+        mt, err = ParseMediaType("*/*")
+        assert.NoError(t, err)
+        assert.Equal(t, 0, mt.Specificity())
+}
+
+func TestParseAcceptLine(t *testing.T) {
+        types, err := parseAcceptLine(rfcTestLine)
+
+        assert.NoError(t, err)
+        assert.Len(t, types, 5)
+
+        for i, e := range []MediaType{
+                MediaType{Type: "text", Subtype: "*", Weight: 0.3, Parameters: map[string]string{}, originalQ: "0.3"},
+                MediaType{Type: "text", Subtype: "html", Weight: 0.7, Parameters: map[string]string{}, originalQ: "0.7"},
+                MediaType{Type: "text", Subtype: "html", Weight: 1, Parameters: map[string]string{"level": "1"}},
+                MediaType{Type: "text", Subtype: "html", Weight: 0.4, Parameters: map[string]string{"level": "2"}, originalQ: "0.4"},
+                MediaType{Type: "*", Subtype: "*", Weight: 0.5, Parameters: map[string]string{}, originalQ: "0.5"},
+        } {
+                assert.Equal(t, e, *types[i])
+        }
+}
+
+func TestFindMatch(t *testing.T) {
+        ours, err := ParseAccept([]string{
+                "text/html;level=1, text/html, text/plain, image/jpeg",
+                "text/html;level=2, text/html;level=3",
+        })
+        assert.NoError(t, err)
+
+        theirs, err := ParseAccept([]string{rfcTestLine})
+        assert.NoError(t, err)
+
+        match, matcher := ours.FindMatch(theirs)
+        assert.Equal(t, "text/html;level=1", match.String())
+        assert.Equal(t, "text/html;level=1", matcher.String())
+
+        match, matcher = ours.FindMatch(theirs[1:])
+        assert.Equal(t, "text/html", match.String())
+        assert.Equal(t, "text/html;q=0.7", matcher.String())
+
+        match, matcher = ours.FindMatch(theirs[2:])
+        assert.Equal(t, "image/jpeg", match.String())
+        assert.Equal(t, "*/*;q=0.5", matcher.String())
+
+        match, matcher = ours.FindMatch(theirs[3:])
+        assert.Equal(t, "text/html;level=2", match.String())
+        assert.Equal(t, "text/html;level=2;q=0.4", matcher.String())
+
+        match, matcher = ours.FindMatch(theirs[4:])
+        assert.Equal(t, "text/plain", match.String())
+        assert.Equal(t, "text/*;q=0.3", matcher.String())
+}