Moved to goware org

Author: Peter Kieltyka

README.md

@@ -0,0 +1,111 @@
+# JSONP Go http middleware
+
+JSONP is a common technique used to communicate with a JSON-serving Web Service with a
+Web browser over cross-domains, in place of a XHR request. There is a lot written about
+JSONP out there, but the tl;dr on it is a Javascript http client requesting JSONP
+will write a `<script>` tag to the head of a page, with the `src` to an API endpoint,
+with the addition of a `callback` (or `jsonp`) query parameter that represents a
+randomly-named listener function that will parse the request when it comes back from
+the server.
+
+This middleware will work with anything that supports standard `http.Handler`. The code
+is small, so go read it, but it just buffers the response from the rest of the chain,
+and if its a JSON request with a callback, then it will wrap the response in the callback
+function before writing it to the actual response writer.
+
+Any feedback is welcome and appreciated!
+
+Written by [@pkieltyka](https://github.com/pkieltyka)
+
+## Example
+
+```go
+// JSONP example using Goji framework.. but anything that accepts
+// a http.Handler middleware chain will work
+package main
+
+import (
+  "log"
+  "net/http"
+
+  "github.com/goware/jsonp"
+  "github.com/unrolled/render"
+  "github.com/zenazn/goji/web"
+  "github.com/zenazn/goji/web/middleware"
+)
+
+func main() {
+  mux := web.New()
+  render := render.New(render.Options{})
+
+  mux.Use(middleware.Logger)
+  mux.Use(jsonp.Handler)
+
+  mux.Get("/", func(w http.ResponseWriter, r *http.Request) {
+    data := &SomeObj{"superman"}
+    render.JSON(w, 200, data)
+  })
+
+  err := http.ListenAndServe(":4444", mux)
+  if err != nil {
+    log.Fatal(err)
+  }
+}
+
+type SomeObj struct {
+  Name string `json:"name"`
+}
+
+```
+
+*Output:*
+```
+curl -v "http://localhost:4444/"
+> GET / HTTP/1.1
+> User-Agent: curl/7.37.1
+> Host: localhost:4444
+> Accept: */*
+>
+< HTTP/1.1 200 OK
+< Content-Type: application/json; charset=UTF-8
+< Date: Sat, 08 Nov 2014 16:05:04 GMT
+< Content-Length: 19
+<
+* Connection #0 to host localhost left intact
+{"name":"superman"}
+```
+
+```
+curl -v "http://localhost:4444/?callback=X"
+> GET /?callback=X HTTP/1.1
+> User-Agent: curl/7.37.1
+> Host: localhost:4444
+> Accept: */*
+>
+< HTTP/1.1 200 OK
+< Content-Length: 22
+< Content-Type: application/javascript
+< Date: Sat, 08 Nov 2014 16:05:23 GMT
+<
+* Connection #0 to host localhost left intact
+X({"name":"superman"})
+```
+
+
+## Also
+
+Since JSONP must always respond with a 200, as thats what the browser `<script>`
+tag expects, a nice pattern that is also used in the GitHub API is to put the HTTP
+response headers in a `"meta"` hash, and the HTTP response body in `"data"`. Like so..
+
+```json
+JsonpCallbackFn_abc123etc({
+  "meta": {
+    "Status": 200,
+    "Content-Type": "application/json",
+    "Content-Length": "19",
+    "etc": "etc"
+  },
+  "data": { "name": "yummy" }
+})
+```

example/main.go

@@ -0,0 +1,35 @@
+// JSONP example using Goji framework.. but anything that accepts
+// a http.Handler middleware chain will work
+package main
+
+import (
+	"log"
+	"net/http"
+
+	"github.com/goware/jsonp"
+	"github.com/unrolled/render"
+	"github.com/zenazn/goji/web"
+	"github.com/zenazn/goji/web/middleware"
+)
+
+func main() {
+	mux := web.New()
+	render := render.New(render.Options{})
+
+	mux.Use(middleware.Logger)
+	mux.Use(jsonp.Handler)
+
+	mux.Get("/", func(w http.ResponseWriter, r *http.Request) {
+		data := &SomeObj{"superman"}
+		render.JSON(w, 200, data)
+	})
+
+	err := http.ListenAndServe(":4444", mux)
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+type SomeObj struct {
+	Name string `json:"name"`
+}

jsonp.go

@@ -0,0 +1,111 @@
+package jsonp
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strconv"
+	"strings"
+)
+
+func Handler(next http.Handler) http.Handler {
+	fn := func(w http.ResponseWriter, r *http.Request) {
+		callback := r.URL.Query().Get("callback")
+		if callback == "" {
+			callback = r.URL.Query().Get("jsonp")
+		}
+		if callback == "" {
+			next.ServeHTTP(w, r)
+			return
+		}
+
+		wb := NewResponseBuffer(w)
+		next.ServeHTTP(wb, r)
+
+		if strings.Index(wb.Header().Get("Content-Type"), "/json") >= 0 {
+			status := wb.Status
+			data := wb.Body.Bytes()
+			wb.Body.Reset()
+
+			resp := &jsonpResponse{
+				Meta: map[string]interface{}{"status": status},
+				Data: data,
+			}
+			for k, v := range wb.Header() {
+				resp.Meta[strings.ToLower(k)] = v[0]
+			}
+			resp.Meta["content-length"] = len(data)
+
+			body, err := json.Marshal(resp)
+			if err != nil {
+				panic(err.Error())
+			}
+
+			wb.Body.Write([]byte(callback + "("))
+			wb.Body.Write(body)
+			wb.Body.Write([]byte(")"))
+
+			wb.Header().Set("Content-Type", "application/javascript")
+			wb.Header().Set("Content-Length", strconv.Itoa(wb.Body.Len()))
+		}
+
+		wb.Flush()
+	}
+	return http.HandlerFunc(fn)
+}
+
+type jsonpResponse struct {
+	Meta map[string]interface{}
+	Data interface{}
+}
+
+func (j *jsonpResponse) MarshalJSON() ([]byte, error) {
+	meta, err := json.Marshal(j.Meta)
+	if err != nil {
+		return nil, err
+	}
+	b := fmt.Sprintf("{\"meta\":%s,\"data\":%s}", meta, j.Data)
+	return []byte(b), nil
+}
+
+type responseBuffer struct {
+	Response http.ResponseWriter // the actual ResponseWriter to flush to
+	Status   int                 // the HTTP response code from WriteHeader
+	Body     *bytes.Buffer       // the response content body
+	Flushed  bool
+}
+
+func NewResponseBuffer(w http.ResponseWriter) *responseBuffer {
+	return &responseBuffer{
+		Response: w, Status: 200, Body: &bytes.Buffer{},
+	}
+}
+
+func (w *responseBuffer) Header() http.Header {
+	return w.Response.Header() // use the actual response header
+}
+
+func (w *responseBuffer) Write(buf []byte) (int, error) {
+	w.Body.Write(buf)
+	return len(buf), nil
+}
+
+func (w *responseBuffer) WriteHeader(status int) {
+	w.Status = status
+}
+
+func (w *responseBuffer) Flush() {
+	if w.Flushed {
+		return
+	}
+	w.Response.WriteHeader(w.Status)
+	if w.Body.Len() > 0 {
+		_, err := w.Response.Write(w.Body.Bytes())
+		if err != nil {
+			panic(err)
+		}
+		w.Body.Reset()
+	}
+	w.Flushed = true
+}