Add a Mime() method on the ContentType to be able to get the MIME only part without the parameters for simpler comparison against other MIME-types in for example switch statements.

Partially closes #3

This PR is a refactor to split out the parsing part of the logic for each of Content-Type and Accept into a separate function from the "get the header from the request" part, making it possible to parse MIME type and Accept header values that came from somewhere other than the usual-named headers of an http.Request.

This fixes #1 (or at least works around it), but it also widens the usefulness of this library to parse values from other places such as the Content-Type of a multipart.Part (I appreciate this part is already possible with NewMediaType but that doesn't do the same error handling and reporting as GetMediaType). My particular use case is writing a default backend to handle HTTP error codes for the ingress-nginx Kubernetes ingress controller, where the original request's Accept header is passed to the error handler endpoint as a different header name X-Format.

Currently, there is no neat way to compare MediaTypes. E.g. when you need to handle multiple different media types, you have to add this ugly if else chain, with checks for type & subtype, because MediaType itself isn't comparable (because of the usage of map[..].. for the parameters):

var MediaTypeEventStream contenttype.MediaType = contenttype.NewMediaType("application/vnd.my-product.v1+stream")
var MediaTypeEventJSON contenttype.MediaType = contenttype.NewMediaType("application/vnd.my-product.v1+json")
var MediaTypeEventXML contenttype.MediaType = contenttype.NewMediaType("application/xml")

func HandleCall(rw http.ResponseWriter, r *http.Request) {
	mediaType, _, err := contenttype.GetAcceptableMediaType(ctx.Request(), []contenttype.MediaType{
		MediaTypeEventStream,
		MediaTypeEventJSON,
		MediaTypeEventXML,
	})
	// handle err

	if mediaType.Type == MediaTypeEventStream.Type && mediaType.Subtype == MediaTypeEventStream.Subtype {
		// write stream to rw
	} else if mediaType.Type == MediaTypeEventJSON.Type && mediaType.Subtype == MediaTypeEventJSON.Subtype {
		// write json to rw
	} else {
		// write xml to rw
	}
}

It would be cool, if a EqualIgnoreParameters method could be added to the media type. Another even better solution would be to remove the parameter map from the MediaType, then it would be possible to use the media type in a switch case like this:

var MediaTypeStream MyMediaType = MyMediaType{Type: "application", SubType: "application/vnd.my-product.v1+stream"}
var MediaTypeJson MyMediaType = MyMediaType{Type: "application", SubType: "application/vnd.my-product.v1+json"}
var MediaTypeXML MyMediaType = MyMediaType{Type: "application", SubType: "application/vnd.my-product.v1+xml"}

func something(r *http.Request()) {
	mt, parameters, err := parseMyMediaType(r, []MyMediaType{..})
	switch mt {
	case MediaTypeJson:
		// write as json to response writer
	case MediaTypeXML:
		// write as xml to response writer
	case MediaTypeStream:
		// write as stream to response writer
	}
}

Thanks for your package and have a great day!

Add a selection of commutative utility comparison methods.

These additional methods further close of the material requested in #3

The internally used compareMediaTypes is not commutative in that the code assumes the wildcard will only come as the MediaType compared to (checkMediaType), but not in the MediaType being compared against (mediaType). Secondly this same method only checks the parameters ins a single direction, such that the parameters in the checkMediaType argument only need to be a subset of those in mediaType. Didn't want to touch this in case it was intentional.

Ended up using reflect.DeepEqual since it is the quicker way of comparing two maps, but it can be resolved by iterating over the map, comparing one to the other, and making sure they both have the same keys in each map (same length of keys) is a simple fix.

The go.mod references go version 1.13 https://github.com/elnormous/contenttype/blob/dcd30b18c159a48185c2fa84cf30d0194fbfc67c/go.mod#L3

and the code uses net/http.Header.Values, which was added in go 1.14 https://github.com/elnormous/contenttype/blob/dcd30b18c159a48185c2fa84cf30d0194fbfc67c/contenttype.go#L318-L323

Attempting to use the code or test it will result in:

$ go version
go version go1.13 linux/amd64

$ go test ./...
# github.com/elnormous/contenttype
./contenttype.go:355:38: request.Header.Values undefined (type http.Header has no field or method Values)
./contenttype.go:404:33: request.Header.Values undefined (type http.Header has no field or method Values)
FAIL    github.com/elnormous/contenttype [build failed]
FAIL

The minimal upgrade needed would be to increase it to go1.14.

Hi elnormous/contenttype!

This is a one-off automatically generated pull request from LGTM.com :robot:. You might have heard that we’ve integrated LGTM’s underlying CodeQL analysis engine natively into GitHub. The result is GitHub code scanning!

With LGTM fully integrated into code scanning, we are focused on improving CodeQL within the native GitHub code scanning experience. In order to take advantage of current and future improvements to our analysis capabilities, we suggest you enable code scanning on your repository. Please take a look at our blog post for more information.

This pull request enables code scanning by adding an auto-generated codeql.yml workflow file for GitHub Actions to your repository — take a look! We tested it before opening this pull request, so all should be working :heavy_check_mark:. In fact, you might already have seen some alerts appear on this pull request!

Where needed and if possible, we’ve adjusted the configuration to the needs of your particular repository. But of course, you should feel free to tweak it further! Check this page for detailed documentation.

Questions? Check out the FAQ below!

FAQ