vinchent/gin
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

New Render API

Browse Source
This commit is contained in:
Manu Mtz-Almeida
2015-05-18 15:45:24 +02:00
parent 3066c35754
commit 947b53d4a2
13 changed files with 190 additions and 229 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
render/data.go
View File

@ -2,19 +2,15 @@ package render
import "net/http"
type dataRender struct{}
type Data struct {
ContentType string
Data []byte
}
func (_ dataRender) Render(w http.ResponseWriter, code int, data ...interface{}) error {
contentType := data[0].(string)
bytes := data[1].([]byte)
WriteData(w, code, contentType, bytes)
func (r Data) Write(w http.ResponseWriter) error {
if len(r.ContentType) > 0 {
w.Header().Set("Content-Type", r.ContentType)
}
w.Write(r.Data)
return nil
}
func WriteData(w http.ResponseWriter, code int, contentType string, data []byte) {
if len(contentType) > 0 {
w.Header().Set("Content-Type", contentType)
}
w.WriteHeader(code)
w.Write(data)
}

13
render/file.go Normal file
View File

@ -0,0 +1,13 @@
package render
import "net/http"
type File struct {
Path string
Request *http.Request
}
func (r File) Write(w http.ResponseWriter) error {
http.ServeFile(w, r.Request, r.Path)
return nil
}

71
render/html.go
View File

@ -1,66 +1,57 @@
package render
import (
"errors"
"fmt"
"html/template"
"net/http"
)
type (
HTMLRender struct {
HTMLRender interface {
Instance(string, interface{}) Render
}
HTMLProduction struct {
Template *template.Template
}
htmlPlainRender struct{}
HTMLDebugRender struct {
HTMLDebug struct {
Files []string
Glob string
}
HTML struct {
Template *template.Template
Name string
Data interface{}
}
)
func (html HTMLRender) Render(w http.ResponseWriter, code int, data ...interface{}) error {
writeHeader(w, code, "text/html; charset=utf-8")
file := data[0].(string)
args := data[1]
return html.Template.ExecuteTemplate(w, file, args)
}
func (r *HTMLDebugRender) Render(w http.ResponseWriter, code int, data ...interface{}) error {
writeHeader(w, code, "text/html; charset=utf-8")
file := data[0].(string)
obj := data[1]
if t, err := r.loadTemplate(); err == nil {
return t.ExecuteTemplate(w, file, obj)
} else {
return err
func (r HTMLProduction) Instance(name string, data interface{}) Render {
return HTML{
Template: r.Template,
Name: name,
Data: data,
}
}
func (r *HTMLDebugRender) loadTemplate() (*template.Template, error) {
func (r HTMLDebug) Instance(name string, data interface{}) Render {
return HTML{
Template: r.loadTemplate(),
Name: name,
Data: data,
}
}
func (r HTMLDebug) loadTemplate() *template.Template {
if len(r.Files) > 0 {
return template.ParseFiles(r.Files...)
return template.Must(template.ParseFiles(r.Files...))
}
if len(r.Glob) > 0 {
return template.ParseGlob(r.Glob)
return template.Must(template.ParseFiles(r.Files...))
}
return nil, errors.New("the HTML debug render was created without files or glob pattern")
panic("the HTML debug render was created without files or glob pattern")
}
func (_ htmlPlainRender) Render(w http.ResponseWriter, code int, data ...interface{}) error {
format := data[0].(string)
values := data[1].([]interface{})
WriteHTMLString(w, code, format, values)
return nil
}
func WriteHTMLString(w http.ResponseWriter, code int, format string, values []interface{}) {
writeHeader(w, code, "text/html; charset=utf-8")
if len(values) > 0 {
fmt.Fprintf(w, format, values...)
} else {
w.Write([]byte(format))
}
func (r HTML) Write(w http.ResponseWriter) error {
w.Header().Set("Content-Type", "text/html; charset=utf-8")
return r.Template.ExecuteTemplate(w, r.Name, r.Data)
}

32
render/json.go
View File

@ -6,30 +6,26 @@ import (
)
type (
jsonRender struct{}
JSON struct {
Data interface{}
}
indentedJSON struct{}
IndentedJSON struct {
Data interface{}
}
)
func (_ jsonRender) Render(w http.ResponseWriter, code int, data ...interface{}) error {
return WriteJSON(w, code, data[0])
func (r JSON) Write(w http.ResponseWriter) error {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
return json.NewEncoder(w).Encode(r.Data)
}
func (_ indentedJSON) Render(w http.ResponseWriter, code int, data ...interface{}) error {
return WriteIndentedJSON(w, code, data[0])
}
func WriteJSON(w http.ResponseWriter, code int, data interface{}) error {
writeHeader(w, code, "application/json; charset=utf-8")
return json.NewEncoder(w).Encode(data)
}
func WriteIndentedJSON(w http.ResponseWriter, code int, data interface{}) error {
writeHeader(w, code, "application/json; charset=utf-8")
jsonData, err := json.MarshalIndent(data, "", " ")
func (r IndentedJSON) Write(w http.ResponseWriter) error {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
jsonBytes, err := json.MarshalIndent(r.Data, "", " ")
if err != nil {
return err
}
_, err = w.Write(jsonData)
return err
w.Write(jsonBytes)
return nil
}

22
render/redirect.go
View File

@ -5,18 +5,16 @@ import (
"net/http"
)
type redirectRender struct{}
type Redirect struct {
Code int
Request *http.Request
Location string
}
func (_ redirectRender) Render(w http.ResponseWriter, code int, data ...interface{}) error {
req := data[0].(*http.Request)
location := data[1].(string)
WriteRedirect(w, code, req, location)
func (r Redirect) Write(w http.ResponseWriter) error {
if r.Code < 300 || r.Code > 308 {
panic(fmt.Sprintf("Cannot redirect with status code %d", r.Code))
}
http.Redirect(w, r.Request, r.Location, r.Code)
return nil
}
func WriteRedirect(w http.ResponseWriter, code int, req *http.Request, location string) {
if code < 300 || code > 308 {
panic(fmt.Sprintf("Cannot redirect with status code %d", code))
}
http.Redirect(w, req, location, code)
}

26
render/render.go
View File

@ -7,22 +7,18 @@ package render
import "net/http"
type Render interface {
Render(http.ResponseWriter, int, ...interface{}) error
Write(http.ResponseWriter) error
}
var (
JSON Render = jsonRender{}
IndentedJSON Render = indentedJSON{}
XML Render = xmlRender{}
HTMLPlain Render = htmlPlainRender{}
Plain Render = plainTextRender{}
Redirect Render = redirectRender{}
Data Render = dataRender{}
_ Render = HTMLRender{}
_ Render = &HTMLDebugRender{}
_ Render = JSON{}
_ Render = IndentedJSON{}
_ Render = XML{}
_ Render = String{}
_ Render = Redirect{}
_ Render = Data{}
_ Render = HTML{}
_ Render = File{}
_ HTMLRender = HTMLDebug{}
_ HTMLRender = HTMLProduction{}
)
func writeHeader(w http.ResponseWriter, code int, contentType string) {
w.Header().Set("Content-Type", contentType)
w.WriteHeader(code)
}

57
render/render_test.go
View File

@ -18,30 +18,27 @@ import (
func TestRenderJSON(t *testing.T) {
w := httptest.NewRecorder()
w2 := httptest.NewRecorder()
data := map[string]interface{}{
"foo": "bar",
}
err := JSON.Render(w, 201, data)
WriteJSON(w2, 201, data)
err := (JSON{data}).Write(w)
assert.Equal(t, w, w2)
assert.NoError(t, err)
assert.Equal(t, w.Code, 201)
assert.Equal(t, w.Body.String(), "{\"foo\":\"bar\"}\n")
assert.Equal(t, w.Header().Get("Content-Type"), "application/json; charset=utf-8")
}
func TestRenderIndentedJSON(t *testing.T) {
w := httptest.NewRecorder()
err := IndentedJSON.Render(w, 202, map[string]interface{}{
data := map[string]interface{}{
"foo": "bar",
"bar": "foo",
})
}
err := (IndentedJSON{data}).Write(w)
assert.NoError(t, err)
assert.Equal(t, w.Code, 202)
assert.Equal(t, w.Body.String(), "{\n \"bar\": \"foo\",\n \"foo\": \"bar\"\n}")
assert.Equal(t, w.Header().Get("Content-Type"), "application/json; charset=utf-8")
}
@ -74,17 +71,13 @@ func (h xmlmap) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
func TestRenderXML(t *testing.T) {
w := httptest.NewRecorder()
w2 := httptest.NewRecorder()
data := xmlmap{
"foo": "bar",
}
err := XML.Render(w, 200, data)
WriteXML(w2, 200, data)
err := (XML{data}).Write(w)
assert.Equal(t, w, w2)
assert.NoError(t, err)
assert.Equal(t, w.Code, 200)
assert.Equal(t, w.Body.String(), "<map><foo>bar</foo></map>")
assert.Equal(t, w.Header().Get("Content-Type"), "application/xml; charset=utf-8")
}
@ -95,53 +88,43 @@ func TestRenderRedirect(t *testing.T) {
func TestRenderData(t *testing.T) {
w := httptest.NewRecorder()
w2 := httptest.NewRecorder()
data := []byte("#!PNG some raw data")
err := Data.Render(w, 400, "image/png", data)
WriteData(w2, 400, "image/png", data)
err := (Data{
ContentType: "image/png",
Data: data,
}).Write(w)
assert.Equal(t, w, w2)
assert.NoError(t, err)
assert.Equal(t, w.Code, 400)
assert.Equal(t, w.Body.String(), "#!PNG some raw data")
assert.Equal(t, w.Header().Get("Content-Type"), "image/png")
}
func TestRenderPlain(t *testing.T) {
func TestRenderString(t *testing.T) {
w := httptest.NewRecorder()
w2 := httptest.NewRecorder()
err := Plain.Render(w, 400, "hola %s %d", []interface{}{"manu", 2})
WritePlainText(w2, 400, "hola %s %d", []interface{}{"manu", 2})
err := (String{
Format: "hola %s %d",
Data: []interface{}{"manu", 2},
}).Write(w)
assert.Equal(t, w, w2)
assert.NoError(t, err)
assert.Equal(t, w.Code, 400)
assert.Equal(t, w.Body.String(), "hola manu 2")
assert.Equal(t, w.Header().Get("Content-Type"), "text/plain; charset=utf-8")
}
func TestRenderPlainHTML(t *testing.T) {
w := httptest.NewRecorder()
err := HTMLPlain.Render(w, 401, "hola %s %d", []interface{}{"manu", 2})
assert.NoError(t, err)
assert.Equal(t, w.Code, 401)
assert.Equal(t, w.Body.String(), "hola manu 2")
assert.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8")
}
func TestRenderHTMLTemplate(t *testing.T) {
w := httptest.NewRecorder()
templ := template.Must(template.New("t").Parse(`Hello {{.name}}`))
htmlRender := HTMLRender{Template: templ}
err := htmlRender.Render(w, 402, "t", map[string]interface{}{
htmlRender := HTMLProduction{Template: templ}
instance := htmlRender.Instance("t", map[string]interface{}{
"name": "alexandernyquist",
})
err := instance.Write(w)
assert.NoError(t, err)
assert.Equal(t, w.Code, 402)
assert.Equal(t, w.Body.String(), "Hello alexandernyquist")
assert.Equal(t, w.Header().Get("Content-Type"), "text/html; charset=utf-8")
}

31
render/ssevent.go
View File

@ -1,31 +0,0 @@
package render
import (
"net/http"
"github.com/manucorporat/sse"
)
type sseRender struct{}
var SSEvent Render = sseRender{}
func (_ sseRender) Render(w http.ResponseWriter, code int, data ...interface{}) error {
eventName := data[0].(string)
obj := data[1]
return WriteSSEvent(w, eventName, obj)
}
func WriteSSEvent(w http.ResponseWriter, eventName string, data interface{}) error {
header := w.Header()
if len(header.Get("Content-Type")) == 0 {
header.Set("Content-Type", sse.ContentType)
}
if len(header.Get("Cache-Control")) == 0 {
header.Set("Cache-Control", "no-cache")
}
return sse.Encode(w, sse.Event{
Event: eventName,
Data: data,
})
}

29
render/text.go
View File

@ -5,21 +5,20 @@ import (
"net/http"
)
type plainTextRender struct{}
type String struct {
Format string
Data []interface{}
}
func (_ plainTextRender) Render(w http.ResponseWriter, code int, data ...interface{}) error {
format := data[0].(string)
values := data[1].([]interface{})
WritePlainText(w, code, format, values)
func (r String) Write(w http.ResponseWriter) error {
header := w.Header()
if _, exist := header["Content-Type"]; !exist {
header.Set("Content-Type", "text/plain; charset=utf-8")
}
if len(r.Data) > 0 {
fmt.Fprintf(w, r.Format, r.Data...)
} else {
w.Write([]byte(r.Format))
}
return nil
}
func WritePlainText(w http.ResponseWriter, code int, format string, values []interface{}) {
writeHeader(w, code, "text/plain; charset=utf-8")
// we assume w.Write can not fail, is that right?
if len(values) > 0 {
fmt.Fprintf(w, format, values...)
} else {
w.Write([]byte(format))
}
}

12
render/xml.go
View File

@ -5,13 +5,11 @@ import (
"net/http"
)
type xmlRender struct{}
func (_ xmlRender) Render(w http.ResponseWriter, code int, data ...interface{}) error {
return WriteXML(w, code, data[0])
type XML struct {
Data interface{}
}
func WriteXML(w http.ResponseWriter, code int, data interface{}) error {
writeHeader(w, code, "application/xml; charset=utf-8")
return xml.NewEncoder(w).Encode(data)
func (r XML) Write(w http.ResponseWriter) error {
w.Header().Set("Content-Type", "application/xml; charset=utf-8")
return xml.NewEncoder(w).Encode(r.Data)
}