Bind and render functions

Signed-off-by: Vishal Rana <vr@labstack.com>

README.md

@@ -1,2 +1,2 @@
 # Bolt
-Coming soon...
+Modern REST library with goodies!

bolt.go

@@ -8,30 +8,25 @@ import (
 
 type (
 	Bolt struct {
-		Router                  *router
+		Router                     *router
-		handlers                []HandlerFunc
+		handlers                   []HandlerFunc
-		maxParam                byte
+		maxParam                   byte
-		notFoundHandler         HandlerFunc
+		notFoundHandler            HandlerFunc
-		methodNotAllowedHandler HandlerFunc
+		methodNotAllowedHandler    HandlerFunc
-		pool                    sync.Pool
+		internalServerErrorHandler HandlerFunc
+		pool                       sync.Pool
 	}
 	HandlerFunc func(*Context)
-	Format      byte
-)
-
-const (
-	FmtJSON Format = 1 + iota
-	FmtMsgPack
 )
 
 const (
 	MIME_JSON = "application/json"
 	MIME_MP   = "application/x-msgpack"
 
-	HdrAccept             = "Accept"
+	HeaderAccept             = "Accept"
-	HdrContentDisposition = "Content-Disposition"
+	HeaderContentDisposition = "Content-Disposition"
-	HdrContentLength      = "Content-Length"
+	HeaderContentLength      = "Content-Length"
-	HdrContentType        = "Content-Type"
+	HeaderContentType        = "Content-Type"
 )
 
 var MethodMap = map[string]uint8{
@@ -50,19 +45,22 @@ func New(opts ...func(*Bolt)) (b *Bolt) {
 	b = &Bolt{
 		maxParam: 5,
 		notFoundHandler: func(c *Context) {
-			http.Error(c.Writer, http.StatusText(http.StatusNotFound), http.StatusNotFound)
+			http.Error(c.Response, http.StatusText(http.StatusNotFound), http.StatusNotFound)
 		},
 		methodNotAllowedHandler: func(c *Context) {
-			http.Error(c.Writer, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
+			http.Error(c.Response, http.StatusText(http.StatusMethodNotAllowed), http.StatusMethodNotAllowed)
+		},
+		internalServerErrorHandler: func(c *Context) {
+			http.Error(c.Response, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
 		},
 	}
 	b.Router = NewRouter(b)
 	b.pool.New = func() interface{} {
 		return &Context{
-			Writer: NewResponse(nil),
+			Response: &response{},
-			params: make(Params, b.maxParam),
+			params:   make(Params, b.maxParam),
-			store:  make(store),
+			store:    make(store),
-			i:      -1,
+			i:        -1,
 		}
 	}
 
@@ -92,6 +90,12 @@ func MethodNotAllowedHandler(h HandlerFunc) func(*Bolt) {
 	}
 }
 
+func InternalServerErrorHandler(h HandlerFunc) func(*Bolt) {
+	return func(b *Bolt) {
+		b.internalServerErrorHandler = h
+	}
+}
+
 // Use adds middleware(s) in the chain.
 func (b *Bolt) Use(h ...HandlerFunc) {
 	b.handlers = append(b.handlers, h...)
@@ -148,7 +152,7 @@ func (b *Bolt) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
 	// Find and execute handler
 	h, c, s := b.Router.Find(r.Method, r.URL.Path)
 	if h != nil {
-		c.Writer.ResponseWriter = rw
+		c.Response.ResponseWriter = rw
 		c.Request = r
 		h(c)
 	} else {
@@ -164,3 +168,7 @@ func (b *Bolt) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
 func (b *Bolt) Run(addr string) {
 	log.Fatal(http.ListenAndServe(addr, b))
 }
+
+func (b *Bolt) Stop(addr string) {
+	panic("implement it")
+}

context.go

@@ -2,21 +2,19 @@ package bolt
 
 import (
 	"encoding/json"
-	"fmt"
-	"log"
 	"net/http"
 )
 
 type (
 	Context struct {
 		Request  *http.Request
-		Writer   *response
+		Response *response
-		Response *http.Response
 		params   Params
 		handlers []HandlerFunc
 		store    map[string]interface{}
 		l        int // Handlers' length
 		i        int // Current handler index
+		bolt     *Bolt
 	}
 	store map[string]interface{}
 )
@@ -29,31 +27,25 @@ func (c *Context) Param(n string) string {
 	return c.params.Get(n)
 }
 
-func (c *Context) Bind(f Format, i interface{}) (err error) {
+//**********
-	switch f {
+//   Bind
-	case FmtJSON:
+//**********
-		dec := json.NewDecoder(c.Request.Body)
+func (c *Context) BindJSON(i interface{}) {
-		if err = dec.Decode(i); err != nil {
+	dec := json.NewDecoder(c.Request.Body)
-			log.Printf("bolt: %s", err)
+	if err := dec.Decode(i); err != nil {
-		}
+		c.bolt.internalServerErrorHandler(c)
 	}
-	return
 }
 
-// TODO: return error, streaming?
+//************
-func (c *Context) Render(n int, f Format, i interface{}) (err error) {
+//   Render
-	var body []byte
+//************
-	switch f {
+func (c *Context) RenderJSON(n int, i interface{}) {
-	case FmtJSON:
+	enc := json.NewEncoder(c.Response)
-		body, err = json.Marshal(i)
+	c.Response.WriteHeader(n)
+	if err := enc.Encode(i); err != nil {
+		c.bolt.internalServerErrorHandler(c)
 	}
-	if err != nil {
-		return fmt.Errorf("bolt: %s", err)
-	}
-	// c.Writer.Header().Set(HEADER_CONTENT_TYPE, MIME_JSON)
-	c.Writer.WriteHeader(n)
-	_, err = c.Writer.Write(body)
-	return
 }
 
 // Next executes the next handler in the chain.
@@ -71,3 +63,7 @@ func (c *Context) Get(key string) interface{} {
 func (c *Context) Set(key string, val interface{}) {
 	c.store[key] = val
 }
+
+func (c *Context) Redirect(n int, url string) {
+	http.Redirect(c.Response, c.Request, url, n)
+}

example/main.go

@@ -26,18 +26,16 @@ func createUser(c *bolt.Context) {
 }
 
 func getUsers(c *bolt.Context) {
-	c.Render(http.StatusOK, bolt.FMT_JSON, users)
+	c.RenderJSON(http.StatusOK, users)
 }
 
 func getUser(c *bolt.Context) {
-	c.Render(http.StatusOK, bolt.FMT_JSON, users[c.P(0)])
+	c.RenderJSON(http.StatusOK, users[c.P(0)])
 }
 
 func main() {
 	b := bolt.New()
 	b.Get("/users", getUsers)
 	b.Get("/users/:id", getUser)
-	// go b.RunHttp(":8080")
+	b.Run(":8080")
-	// go b.RunWebSocket(":8081")
-	b.RunTcp(":8082")
 }

response.go

@@ -8,9 +8,6 @@ import (
 )
 
 type (
-	// ResponseWriter interface {
-	// }
-
 	response struct {
 		http.ResponseWriter
 		status int
@@ -18,13 +15,6 @@ type (
 	}
 )
 
-func NewResponse(rw http.ResponseWriter) *response {
-	return &response{
-		ResponseWriter: rw,
-		status:         http.StatusOK,
-	}
-}
-
 func (r *response) WriteHeader(c int) {
 	r.status = c
 	r.ResponseWriter.WriteHeader(c)

router.go

@@ -255,7 +255,7 @@ func lcp(a, b string) (i int) {
 
 func (r *router) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
 	h, c, rep := r.Find(req.Method, req.URL.Path)
-	c.Writer.ResponseWriter = rw
+	c.Response.ResponseWriter = rw
 	if h != nil {
 		h(c)
 	} else {