breaking change: ContentType now follows mime package practice: Type and Subtype are not now split

Author: rickb777

echo4/echo4_test.go

@@ -79,6 +79,6 @@ func TestRenderBestMatch_should_give_JSON_response_for_ajax_requests(t *testing.
 	expect.Error(err).Not().ToHaveOccurred(t)
 	expect.Number(w.Code).ToBe(t, 201)
 	expect.Map(w.HeaderMap).ToHaveLength(t, 2)
-	expect.String(w.Header().Get(ContentType)).ToBe(t, "application/json;charset=utf-8")
+	expect.String(w.Header().Get(ContentType)).ToBe(t, "application/json")
 	expect.String(w.Header().Get(ContentLanguage)).ToBe(t, "en")
 }

example_test.go

@@ -99,7 +99,7 @@ func Example() {
 	// GET /request2 200
 	// 4 headers
 	// Content-Language: fr
-	// Content-Type: application/json;charset=utf-8
+	// Content-Type: application/json
 	// Etag: "hash1"
 	// Vary: Accept, Accept-Language
 	//

header/contenttype.go

@@ -2,11 +2,11 @@ package header
 
 import (
 	"io"
+	"mime"
 	"net/http"
 	"strings"
 
 	"github.com/rickb777/acceptable/headername"
-	"github.com/rickb777/acceptable/internal"
 )
 
 // ContentType is a media type as defined in RFC-2045, RFC-2046, RFC-2231
@@ -15,11 +15,26 @@ import (
 // There may also be parameters (e.g. "charset=utf-8") and extension values.
 type ContentType struct {
 	// Type and Subtype carry the media type, e.g. "text" and "html"
-	Type, Subtype string
+	MediaType string
 	// Params and Extensions hold optional parameter information
 	Params []KV
 }
 
+func (ct ContentType) Split() (string, string) {
+	t, s, _ := strings.Cut(ct.MediaType, "/")
+	return t, s
+}
+
+func (ct ContentType) Type() string {
+	t, _ := ct.Split()
+	return t
+}
+
+func (ct ContentType) Subtype() string {
+	_, s := ct.Split()
+	return s
+}
+
 // AsMediaRange converts this ContentType to a MediaRange.
 // The default quality should be 1.
 func (ct ContentType) AsMediaRange(quality float64) MediaRange {
@@ -44,33 +59,32 @@ func (ct ContentType) AsMediaRange(quality float64) MediaRange {
 //
 // where "*" is a wildcard.
 func (ct ContentType) IsTextual() bool {
-	if ct.Type == "text" {
+	t, s := ct.Split()
+	if t == "text" {
 		return true
 	}
 
-	if ct.Type == "application" {
-		return ct.Subtype == "json" ||
-			ct.Subtype == "xml" ||
-			strings.HasSuffix(ct.Subtype, "+xml") ||
-			strings.HasSuffix(ct.Subtype, "+json")
+	if t == "application" {
+		return s == "json" ||
+			s == "xml" ||
+			strings.HasSuffix(s, "+xml") ||
+			strings.HasSuffix(s, "+json")
 	}
 
-	if ct.Type == "model" {
-		return strings.HasSuffix(ct.Subtype, "+xml") ||
-			strings.HasSuffix(ct.Subtype, "+json")
+	if t == "model" {
+		return strings.HasSuffix(s, "+xml") ||
+			strings.HasSuffix(s, "+json")
 	}
 
-	if ct.Type == "image" || ct.Type == "message" {
-		return strings.HasSuffix(ct.Subtype, "+xml")
+	if t == "image" || t == "message" {
+		return strings.HasSuffix(s, "+xml")
 	}
 
 	return false
 }
 
 func (ct ContentType) writeTo(w io.StringWriter) {
-	w.WriteString(ct.Type)
-	w.WriteString("/")
-	w.WriteString(ct.Subtype)
+	w.WriteString(ct.MediaType)
 	for _, p := range ct.Params {
 		w.WriteString(";")
 		w.WriteString(p.Key)
@@ -85,7 +99,7 @@ func (ct ContentType) String() string {
 	return buf.String()
 }
 
-var starStar = ContentType{Type: "*", Subtype: "*"}
+var starStar = ContentType{MediaType: "*/*"}
 
 // ParseContentTypeFromHeaders gets the "Content-Type" header and returns
 // its parsed value.
@@ -103,34 +117,17 @@ func ParseContentType(ct string) ContentType {
 		return starStar
 	}
 
-	valueAndParams := Split(ct, ";").TrimSpace()
-	t, s := internal.Split1(valueAndParams[0], '/')
-	return contentTypeOf(t, s, valueAndParams[1:])
-}
-
-// contentTypeOf builds a content type value with optional parameters.
-// The parameters are passed in as literal strings, e.g. "charset=utf-8".
-func contentTypeOf(typ, subtype string, paramKV []string) ContentType {
-	if typ == "" {
+	mt, params, err := mime.ParseMediaType(ct)
+	if err != nil {
 		return starStar
 	}
 
-	if subtype == "" {
-		subtype = "*"
-	}
-
-	var params []KV
-	if len(paramKV) > 0 {
-		params = make([]KV, 0, len(paramKV))
-		for _, p := range paramKV {
-			k, v := internal.Split1(p, '=')
-			params = append(params, KV{Key: k, Value: v})
+	var paramsKV []KV
+	if len(params) > 0 {
+		paramsKV = make([]KV, 0, len(params))
+		for k, v := range params {
+			paramsKV = append(paramsKV, KV{Key: k, Value: v})
 		}
 	}
-
-	return ContentType{
-		Type:    typ,
-		Subtype: subtype,
-		Params:  params,
-	}
+	return ContentType{MediaType: mt, Params: paramsKV}
 }

header/contenttype_test.go

@@ -14,54 +14,32 @@ func TestParseContentTypeFromHeaders(t *testing.T) {
 
 	ct1 := ParseContentTypeFromHeaders(hdrs)
 
-	expect.Any(ct1).ToBe(t, ContentType{
-		Type:    "*",
-		Subtype: "*",
-	})
+	expect.Any(ct1).ToBe(t, ContentType{MediaType: "*/*"})
 
 	hdrs.Set(headername.ContentType, "text/plain")
 
 	ct2 := ParseContentTypeFromHeaders(hdrs)
 
-	expect.Any(ct2).ToBe(t, ContentType{
-		Type:    "text",
-		Subtype: "plain",
-	})
+	expect.Any(ct2).ToBe(t, ContentType{MediaType: "text/plain"})
 }
 
 func TestParseContentType(t *testing.T) {
 	// blank value is treated as star-star
-	expect.Any(ParseContentType("")).ToBe(t, ContentType{
-		Type:    "*",
-		Subtype: "*",
-	})
+	expect.Any(ParseContentType("")).ToBe(t, ContentType{MediaType: "*/*"})
 
 	// illegal value is treated as star-star
-	expect.Any(ParseContentType("/")).ToBe(t, ContentType{
-		Type:    "*",
-		Subtype: "*",
-	})
+	expect.Any(ParseContentType("/")).ToBe(t, ContentType{MediaType: "*/*"})
 
 	// illegal value is treated as star-star
-	expect.Any(ParseContentType("/plain")).ToBe(t, ContentType{
-		Type:    "*",
-		Subtype: "*",
-	})
+	expect.Any(ParseContentType("/plain")).ToBe(t, ContentType{MediaType: "*/*"})
 
 	// error case handled silently
-	expect.Any(ParseContentType("text/")).ToBe(t, ContentType{
-		Type:    "text",
-		Subtype: "*",
-	})
+	expect.Any(ParseContentType("text/")).ToBe(t, ContentType{MediaType: "*/*"})
 
-	expect.Any(ParseContentType("text/plain")).ToBe(t, ContentType{
-		Type:    "text",
-		Subtype: "plain",
-	})
+	expect.Any(ParseContentType("text/plain")).ToBe(t, ContentType{MediaType: "text/plain"})
 
 	expect.Any(ParseContentType("text/html; charset=utf-8")).ToBe(t, ContentType{
-		Type:    "text",
-		Subtype: "html",
+		MediaType: "text/html",
 		Params: []KV{{
 			Key:   "charset",
 			Value: "utf-8",
@@ -71,26 +49,25 @@ func TestParseContentType(t *testing.T) {
 
 func TestContentType_IsTextual(t *testing.T) {
 	cases := []ContentType{
-		{Type: "text", Subtype: "plain"},
-		{Type: "application", Subtype: "json"},
-		{Type: "application", Subtype: "geo+json"},
-		{Type: "application", Subtype: "xml"},
-		{Type: "application", Subtype: "xv+xml"},
-		{Type: "image", Subtype: "svg+xml"},
-		{Type: "message", Subtype: "imdn+xml"},
-		{Type: "model", Subtype: "x3d+xml"},
-		{Type: "model", Subtype: "gltf+json"},
+		{MediaType: "text/plain"},
+		{MediaType: "application/json"},
+		{MediaType: "application/geo+json"},
+		{MediaType: "application/xml"},
+		{MediaType: "application/xv+xml"},
+		{MediaType: "image/svg+xml"},
+		{MediaType: "message/imdn+xml"},
+		{MediaType: "model/x3d+xml"},
+		{MediaType: "model/gltf+json"},
 	}
 	for _, c := range cases {
 		expect.Bool(c.IsTextual()).I(c.String).ToBeTrue(t)
 	}
-	expect.Bool(ContentType{Type: "video", Subtype: "mp4"}.IsTextual()).ToBeFalse(t)
+	expect.Bool(ContentType{MediaType: "video/mp4"}.IsTextual()).ToBeFalse(t)
 }
 
 func TestContentType_String(t *testing.T) {
 	ct := ContentType{
-		Type:    "text",
-		Subtype: "html",
+		MediaType: "text/html",
 		Params: []KV{
 			{Key: "charset", Value: "utf-8"},
 			{Key: "level", Value: "1"},

header/mediarange.go

@@ -48,17 +48,19 @@ func (mr MediaRange) StrongerThan(other MediaRange) bool {
 		return false
 	}
 
-	if mr.Type != "*" {
-		if other.Type == "*" {
+	t1, s1 := mr.Split()
+	t2, s2 := other.Split()
+	if t1 != "*" {
+		if t2 == "*" {
 			return true
 		}
-		if mr.Subtype != "*" && other.Subtype == "*" {
+		if s1 != "*" && s2 == "*" {
 			return true
 		}
 	}
 
-	if mr.Type == other.Type {
-		if mr.Subtype == other.Subtype {
+	if t1 == t2 {
+		if s1 == s2 {
 			return len(mr.Params) > len(other.Params)
 		}
 	}
@@ -69,7 +71,7 @@ func (mr MediaRange) StrongerThan(other MediaRange) bool {
 // It does not include the quality value nor any of the extensions.
 func (mr MediaRange) Value() string {
 	buf := &strings.Builder{}
-	fmt.Fprintf(buf, "%s/%s", mr.Type, mr.Subtype)
+	buf.WriteString(mr.MediaType)
 	for _, p := range mr.Params {
 		fmt.Fprintf(buf, ";%s=%s", p.Key, p.Value)
 	}
@@ -91,7 +93,7 @@ func (mr MediaRange) String() string {
 // list is empty, the result holds a wildcard entry ("*/*").
 func (mrs MediaRanges) WithDefault() MediaRanges {
 	if len(mrs) == 0 {
-		return []MediaRange{{ContentType: ContentType{Type: "*", Subtype: "*"}, Quality: DefaultQuality}}
+		return []MediaRange{{ContentType: ContentType{MediaType: "*/*"}, Quality: DefaultQuality}}
 	}
 	return mrs
 }

header/parse_mediarange.go

@@ -35,8 +35,10 @@ func parseMediaRangeHeader(acceptHeader string) MediaRanges {
 	for _, part := range parts {
 		valueAndParams := Split(part, ";").TrimSpace()
 		if len(valueAndParams) == 1 {
-			t, s := internal.Split1(strings.TrimSpace(valueAndParams[0]), '/')
-			wvs = append(wvs, MediaRange{ContentType: ContentType{Type: t, Subtype: s}, Quality: DefaultQuality})
+			wvs = append(wvs, MediaRange{
+				ContentType: ContentType{MediaType: strings.TrimSpace(valueAndParams[0])},
+				Quality:     DefaultQuality,
+			})
 		} else {
 			wvs = append(wvs, handleMediaRangeWithParams(valueAndParams[0], valueAndParams[1:]))
 		}
@@ -47,7 +49,7 @@ func parseMediaRangeHeader(acceptHeader string) MediaRanges {
 
 func handleMediaRangeWithParams(value string, acceptParams []string) MediaRange {
 	wv := new(MediaRange)
-	wv.Type, wv.Subtype = internal.Split1(value, '/')
+	wv.MediaType = value
 	wv.Quality = DefaultQuality
 
 	for _, ap := range acceptParams {