file type registry

Author: pjdufour

pkg/http/Ext.go

@@ -0,0 +1,36 @@
+// =================================================================
+//
+// Copyright (C) 2019 Spatial Current, Inc. - All Rights Reserved
+// Released as open source under the MIT License.  See LICENSE file.
+//
+// =================================================================
+
+package http
+
+import (
+	"net/http"
+	"path/filepath"
+
+	"github.com/pkg/errors"
+)
+
+var (
+	ErrMissingURL = errors.New("missing URL")
+)
+
+// Ext returns the file name extension in the URL path.
+// The extension begins after the last period in the file element of the path.
+// If no period is in the last element or a period is the last character, then returns a blank string.
+func Ext(r *http.Request) (string, error) {
+	if r.URL == nil {
+		return "", ErrMissingURL
+	}
+	ext := filepath.Ext(r.URL.Path)
+	if len(ext) == 0 {
+		return "", nil
+	}
+	if ext == "." {
+		return "", nil
+	}
+	return ext[1:], nil
+}

pkg/http/NegotiateFormat.go

@@ -8,28 +8,35 @@
 package http
 
 import (
-	"github.com/pkg/errors"
-	"github.com/spatialcurrent/go-simple-serializer/pkg/serializer"
 	"net/http"
 	"sort"
 	"strconv"
 	"strings"
+
+	"github.com/pkg/errors"
+
+	"github.com/spatialcurrent/go-simple-serializer/pkg/registry"
 )
 
 var (
 	ErrMissingAcceptHeader = errors.New("missing accept header")
+	ErrMissingRegistry     = errors.New("missing file type registry")
 )
 
-// NegotiateFormat negotitates the format for the response based on the incoming request.
+// NegotiateFormat negotitates the format for the response based on the incoming request and the given file type registry.
 // Returns the matching content type, followed by the format known to GSS, and then an error if any.
-func NegotiateFormat(r *http.Request) (string, string, error) {
+func NegotiateFormat(r *http.Request, reg *registry.Registry) (string, string, error) {
 
 	accept := strings.TrimSpace(r.Header.Get(HeaderAccept))
 
 	if len(accept) == 0 {
 		return "", "", ErrMissingAcceptHeader
 	}
 
+	if reg == nil {
+		return "", "", ErrMissingRegistry
+	}
+
 	// Parse accept header into map of weights to accepted values
 	values := map[float64][]string{}
 	for _, str := range strings.SplitN(accept, ",", -1) {
@@ -67,19 +74,8 @@ func NegotiateFormat(r *http.Request) (string, string, error) {
 	// Iterate through accepted values in order of highest weight first
 	for _, w := range weights {
 		for _, contentType := range values[w] {
-			switch contentType {
-			case "application/ubjson":
-				return contentType, serializer.FormatBSON, nil
-			case "application/json":
-				return contentType, serializer.FormatJSON, nil
-			case "application/toml":
-				return contentType, serializer.FormatTOML, nil
-			case "text/csv":
-				return contentType, serializer.FormatCSV, nil
-			case "text/tab-separated-values":
-				return contentType, serializer.FormatTSV, nil
-			case "text/yaml":
-				return contentType, serializer.FormatYAML, nil
+			if item, ok := reg.LookupContentType(contentType); ok {
+				return contentType, item.Format, nil
 			}
 		}
 	}

pkg/http/NegotiateFormat_test.go

@@ -11,32 +11,36 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"github.com/spatialcurrent/go-simple-serializer/pkg/serializer"
 	"github.com/stretchr/testify/assert"
+
+	"github.com/spatialcurrent/go-simple-serializer/pkg/serializer"
 )
 
 func TestNegotiateFormatJSON(t *testing.T) {
+	reg := NewDefaultRegistry()
 	r := httptest.NewRequest("GET", "https://example.com/foo/bar", nil)
 	r.Header.Set("Accept", "application/json")
-	c, f, err := NegotiateFormat(r)
+	c, f, err := NegotiateFormat(r, reg)
 	assert.NoError(t, err)
 	assert.Equal(t, "application/json", c)
 	assert.Equal(t, serializer.FormatJSON, f)
 }
 
 func TestNegotiateFormatBSON(t *testing.T) {
+	reg := NewDefaultRegistry()
 	r := httptest.NewRequest("GET", "https://example.com/foo/bar", nil)
 	r.Header.Set("Accept", "application/ubjson, application/json")
-	c, f, err := NegotiateFormat(r)
+	c, f, err := NegotiateFormat(r, reg)
 	assert.NoError(t, err)
 	assert.Equal(t, "application/ubjson", c)
 	assert.Equal(t, serializer.FormatBSON, f)
 }
 
 func TestNegotiateFormatWeight(t *testing.T) {
+	reg := NewDefaultRegistry()
 	r := httptest.NewRequest("GET", "https://example.com/foo/bar", nil)
 	r.Header.Set("Accept", "text/csv;q=0.8, application/json;q=0.9")
-	c, f, err := NegotiateFormat(r)
+	c, f, err := NegotiateFormat(r, reg)
 	assert.NoError(t, err)
 	assert.Equal(t, "application/json", c)
 	assert.Equal(t, serializer.FormatJSON, f)

pkg/http/Respond.go

@@ -8,18 +8,30 @@
 package http
 
 import (
+	"net/http"
+
 	"github.com/pkg/errors"
+
+	"github.com/spatialcurrent/go-simple-serializer/pkg/registry"
 	"github.com/spatialcurrent/go-simple-serializer/pkg/serializer"
-	"net/http"
 )
 
 // Respond writes the given data to the respond writer, and returns an error if any.
 // If filename is not empty, then the "Content-Disposition" header is set to "attachment; filename=<FILENAME>".
-func Respond(w http.ResponseWriter, r *http.Request, data interface{}, status int, filename string) error {
+func Respond(w http.ResponseWriter, r *http.Request, reg *registry.Registry, data interface{}, status int, filename string) error {
 
-	contentType, format, err := NegotiateFormat(r)
+	contentType, format, err := NegotiateFormat(r, reg)
 	if err != nil {
-		return err
+		ext, err := Ext(r)
+		if err != nil || len(ext) == 0 {
+			return errors.Errorf("could not negotiate format or parse file extension from %#v", r)
+		}
+		if item, ok := reg.LookupExtension(ext); ok {
+			contentType = item.ContentTypes[0]
+			format = item.Format
+		} else {
+			return errors.Errorf("could not negotiate format or parse file extension from %#v", r)
+		}
 	}
 
 	s := serializer.New(format)

pkg/http/RespondWithContent.go

@@ -9,11 +9,12 @@ package http
 
 import (
 	"fmt"
-	"github.com/pkg/errors"
 	"net/http"
+
+	"github.com/pkg/errors"
 )
 
-// RespondWithContent writes the given content to the respond writer, and returns an error if any.
+// RespondWithContent writes the given content to the response writer, and returns an error if any.
 // If filename is not empty, then the "Content-Disposition" header is set to "attachment; filename=<FILENAME>".
 func RespondWithContent(w http.ResponseWriter, body []byte, contentType string, status int, filename string) error {
 

pkg/http/Respond_test.go

@@ -12,17 +12,39 @@ import (
 	"net/http/httptest"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
 	"io/ioutil"
+
+	"github.com/stretchr/testify/assert"
 )
 
-func TestRespondJSON(t *testing.T) {
+func TestRespondAcceptCSV(t *testing.T) {
+	reg := NewDefaultRegistry()
+	w := httptest.NewRecorder()
+	r := httptest.NewRequest("GET", "https://example.com/foo/bar", nil)
+	r.Header.Set("Accept", "text/csv")
+	data := map[string]interface{}{"foo": "bar"}
+	status := http.StatusOK
+	err := Respond(w, r, reg, data, status, "")
+	if !assert.NoError(t, err) {
+		return
+	}
+	resp := w.Result()
+	assert.Equal(t, http.StatusOK, resp.StatusCode)
+	body, err := ioutil.ReadAll(resp.Body)
+	if !assert.NoError(t, err) {
+		return
+	}
+	assert.Equal(t, "foo\nbar\n", string(body))
+}
+
+func TestRespondAcceptJSON(t *testing.T) {
+	reg := NewDefaultRegistry()
 	w := httptest.NewRecorder()
 	r := httptest.NewRequest("GET", "https://example.com/foo/bar", nil)
 	r.Header.Set("Accept", "application/json")
 	data := map[string]interface{}{"foo": "bar"}
 	status := http.StatusOK
-	err := Respond(w, r, data, status, "")
+	err := Respond(w, r, reg, data, status, "")
 	if !assert.NoError(t, err) {
 		return
 	}
@@ -35,13 +57,71 @@ func TestRespondJSON(t *testing.T) {
 	assert.Equal(t, "{\"foo\":\"bar\"}", string(body))
 }
 
-func TestRespondYAML(t *testing.T) {
+func TestRespondAcceptYAML(t *testing.T) {
+	reg := NewDefaultRegistry()
 	w := httptest.NewRecorder()
 	r := httptest.NewRequest("GET", "https://example.com/foo/bar", nil)
 	r.Header.Set("Accept", "application/json;q=0.8, text/yaml;q=0.9")
 	data := map[string]interface{}{"foo": "bar"}
 	status := http.StatusOK
-	err := Respond(w, r, data, status, "")
+	err := Respond(w, r, reg, data, status, "")
+	if !assert.NoError(t, err) {
+		return
+	}
+	resp := w.Result()
+	assert.Equal(t, http.StatusOK, resp.StatusCode)
+	body, err := ioutil.ReadAll(resp.Body)
+	if !assert.NoError(t, err) {
+		return
+	}
+	assert.Equal(t, "foo: bar\n", string(body))
+}
+
+func TestRespondExtensionCSV(t *testing.T) {
+	reg := NewDefaultRegistry()
+	w := httptest.NewRecorder()
+	r := httptest.NewRequest("GET", "https://example.com/foo/bar.csv", nil)
+	data := map[string]interface{}{"foo": "bar"}
+	status := http.StatusOK
+	err := Respond(w, r, reg, data, status, "")
+	if !assert.NoError(t, err) {
+		return
+	}
+	resp := w.Result()
+	assert.Equal(t, http.StatusOK, resp.StatusCode)
+	body, err := ioutil.ReadAll(resp.Body)
+	if !assert.NoError(t, err) {
+		return
+	}
+	assert.Equal(t, "foo\nbar\n", string(body))
+}
+
+func TestRespondExtensionJSON(t *testing.T) {
+	reg := NewDefaultRegistry()
+	w := httptest.NewRecorder()
+	r := httptest.NewRequest("GET", "https://example.com/foo/bar.json", nil)
+	data := map[string]interface{}{"foo": "bar"}
+	status := http.StatusOK
+	err := Respond(w, r, reg, data, status, "")
+	if !assert.NoError(t, err) {
+		return
+	}
+	resp := w.Result()
+	assert.Equal(t, http.StatusOK, resp.StatusCode)
+	body, err := ioutil.ReadAll(resp.Body)
+	if !assert.NoError(t, err) {
+		return
+	}
+	assert.Equal(t, "{\"foo\":\"bar\"}", string(body))
+}
+
+func TestRespondExtensionYAML(t *testing.T) {
+	reg := NewDefaultRegistry()
+	w := httptest.NewRecorder()
+	r := httptest.NewRequest("GET", "https://example.com/foo/bar.yml", nil)
+	data := map[string]interface{}{"foo": "bar"}
+	status := http.StatusOK
+	err := Respond(w, r, reg, data, status, "")
 	if !assert.NoError(t, err) {
 		return
 	}

pkg/http/http.go

@@ -31,8 +31,10 @@ var (
 
 var (
 	ContentTypeBSON  = "application/ubjson"
+	ContentTypeCSV   = "text/csv"
 	ContentTypeJSON  = "application/json"
 	ContentTypeTOML  = "application/toml"
+	ContentTypeTSV   = "text/tab-separated-values"
 	ContentTypeYAML  = "text/yaml"
 	ContentTypePlain = "text/plain; charset=utf-8"
 )

pkg/http/http_test.go

@@ -0,0 +1,38 @@
+// =================================================================
+//
+// Copyright (C) 2019 Spatial Current, Inc. - All Rights Reserved
+// Released as open source under the MIT License.  See LICENSE file.
+//
+// =================================================================
+
+package http
+
+import (
+	"github.com/spatialcurrent/go-simple-serializer/pkg/registry"
+	"github.com/spatialcurrent/go-simple-serializer/pkg/serializer"
+)
+
+func NewDefaultRegistry() *registry.Registry {
+	r := registry.New()
+	r.Add(registry.Item{
+		Format:       serializer.FormatBSON,
+		ContentTypes: []string{"application/ubjson"},
+		Extensions:   []string{},
+	})
+	r.Add(registry.Item{
+		Format:       serializer.FormatJSON,
+		ContentTypes: []string{"application/json", "text/json"},
+		Extensions:   []string{"json"},
+	})
+	r.Add(registry.Item{
+		Format:       serializer.FormatCSV,
+		ContentTypes: []string{"text/csv"},
+		Extensions:   []string{"csv"},
+	})
+	r.Add(registry.Item{
+		Format:       serializer.FormatYAML,
+		ContentTypes: []string{"text/yaml"},
+		Extensions:   []string{"yaml", "yml"},
+	})
+	return r
+}