Merge with master

Author: itsmontoya

adoptResponse.go

@@ -0,0 +1,30 @@
+package httpserve
+
+import (
+	"io"
+)
+
+// NewAdoptResponse will return a new adopt response
+func NewAdoptResponse() *AdoptResponse {
+	var t AdoptResponse
+	return &t
+}
+
+// AdoptResponse is a basic adopt response
+type AdoptResponse struct {
+}
+
+// ContentType returns the content type
+func (t *AdoptResponse) ContentType() (contentType string) {
+	return "text/plain"
+}
+
+// StatusCode returns the status code
+func (t *AdoptResponse) StatusCode() (code int) {
+	return 200
+}
+
+// WriteTo will write the internal reader to a provided io.Writer
+func (t *AdoptResponse) WriteTo(w io.Writer) (n int64, err error) {
+	return
+}

context.go

@@ -1,6 +1,7 @@
 package httpserve
 
 import (
+	"encoding/json"
 	"fmt"
 	"net/http"
 	"os"
@@ -22,7 +23,10 @@ func newContext(w http.ResponseWriter, r *http.Request, p Params) *Context {
 
 // Context is the request context
 type Context struct {
+	// Internal context storage, used by Context.Get and Context.Put
 	s Storage
+	// hooks are a list of hook functions added during the lifespam of the context
+	hooks []Hook
 
 	Writer  http.ResponseWriter
 	Request *http.Request
@@ -47,15 +51,49 @@ func (c *Context) respond(resp Response) {
 	if resp == nil {
 		return
 	}
+
+	if c.redirect(resp) {
+		return
+	}
+
+	// Write content type!
+	c.Writer.Header().Set("Content-Type", resp.ContentType())
+
 	// Write status code to header
 	c.Writer.WriteHeader(resp.StatusCode())
+
 	// Write response to http.ResponseWriter
 	if _, err := resp.WriteTo(c.Writer); err != nil {
 		// Write error to stderr
 		fmt.Fprintf(os.Stderr, "Error writing to http.ResponseWriter: %v\n", err)
 	}
 }
 
+func (c *Context) redirect(resp Response) (ok bool) {
+	var redirect *RedirectResponse
+	if redirect, ok = resp.(*RedirectResponse); !ok {
+		return
+	}
+
+	c.Writer.Header().Add("Location", redirect.url)
+	c.Writer.WriteHeader(redirect.code)
+	return
+}
+
+func (c *Context) wasAdopted(resp Response) (ok bool) {
+	if _, ok = resp.(*AdoptResponse); !ok {
+		return
+	}
+
+	return
+}
+
+func (c *Context) processHooks(statusCode int) {
+	for i := len(c.hooks) - 1; i > -1; i-- {
+		c.hooks[i](statusCode, c.s)
+	}
+}
+
 // Write will write a byteslice
 func (c *Context) Write(bs []byte) (n int, err error) {
 	return c.Writer.Write(bs)
@@ -68,7 +106,7 @@ func (c *Context) WriteString(str string) (n int, err error) {
 
 // Param will return the associated parameter value with the provided key
 func (c *Context) Param(key string) (value string) {
-	return c.Param(key)
+	return c.Params.ByName(key)
 }
 
 // Get will retrieve a value for a provided key from the Context's internal storage
@@ -77,6 +115,17 @@ func (c *Context) Get(key string) (value string) {
 }
 
 // Put will set a value for a provided key into the Context's internal storage
-func (c *Context) Put(key string) (value string) {
-	return c.s[key]
+func (c *Context) Put(key, value string) {
+	c.s[key] = value
+}
+
+// BindJSON is a helper function which binds the request body to a provided value to be parsed as JSON
+func (c *Context) BindJSON(value interface{}) (err error) {
+	defer c.Request.Body.Close()
+	return json.NewDecoder(c.Request.Body).Decode(value)
+}
+
+// AddHook will add a hook function to be ran after the context has completed
+func (c *Context) AddHook(fn Hook) {
+	c.hooks = append(c.hooks, fn)
 }

group.go

@@ -69,6 +69,19 @@ func (g *Group) DELETE(route string, hs ...Handler) {
 	g.r.DELETE(route, newHandler(hs))
 }
 
+// OPTIONS will set a OPTIONS endpoint
+func (g *Group) OPTIONS(route string, hs ...Handler) {
+	if g.route != "" {
+		route = path.Join(g.route, route)
+	}
+
+	if len(g.hs) > 0 {
+		hs = append(g.hs, hs...)
+	}
+
+	g.r.OPTIONS(route, newHandler(hs))
+}
+
 // Group will return a new group
 func (g *Group) Group(route string, hs ...Handler) *Group {
 	if g.route != "" {

htmlResponse.go

@@ -0,0 +1,35 @@
+package httpserve
+
+import (
+	"bytes"
+	"io"
+)
+
+// NewHTMLResponse will return a new text response
+func NewHTMLResponse(code int, body []byte) *HTMLResponse {
+	var h HTMLResponse
+	h.code = code
+	h.r = bytes.NewReader(body)
+	return &h
+}
+
+// HTMLResponse is a basic text response
+type HTMLResponse struct {
+	code int
+	r    io.Reader
+}
+
+// ContentType returns the content type
+func (h *HTMLResponse) ContentType() (contentType string) {
+	return "text/html"
+}
+
+// StatusCode returns the status code
+func (h *HTMLResponse) StatusCode() (code int) {
+	return h.code
+}
+
+// WriteTo will write the internal reader to a provided io.Writer
+func (h *HTMLResponse) WriteTo(w io.Writer) (n int64, err error) {
+	return io.Copy(w, h.r)
+}

htmlResponse_test.go

@@ -0,0 +1,17 @@
+package httpserve
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestHTMLResponse(t *testing.T) {
+	value := "<html><head></head><body><p>hello world<p></body>"
+	resp := NewHTMLResponse(200, []byte(value))
+	buf := bytes.NewBuffer(nil)
+	resp.WriteTo(buf)
+
+	if buf.String() != value {
+		t.Fatalf("invalid value, expected %#v and received %#v", buf.String(), value)
+	}
+}

httpserve.go

@@ -12,10 +12,6 @@ import (
 	"github.com/bradfitz/http2"
 )
 
-const (
-	invalidTLSFmt = "invalid tls certification pair, neither key nor cert can be empty (%s): %#v"
-)
-
 var (
 	// ErrNotInitialized is returned when an action is performed on an uninitialized instance of Serve
 	ErrNotInitialized = errors.New("cannot perform action on uninitialized Serve")
@@ -60,6 +56,11 @@ func (s *Serve) DELETE(route string, hs ...Handler) {
 	s.g.DELETE(route, hs...)
 }
 
+// OPTIONS will set a OPTIONS endpoint
+func (s *Serve) OPTIONS(route string, hs ...Handler) {
+	s.g.OPTIONS(route, hs...)
+}
+
 // Group will return a new group for a given route and handlers
 func (s *Serve) Group(route string, hs ...Handler) *Group {
 	return s.g.Group(route, hs...)
@@ -101,6 +102,8 @@ func (s *Serve) ListenTLSWithConfig(port uint16, certificateDir string, c Config
 		return
 	}
 
+	cfg.PreferServerCipherSuites = true
+	cfg.MinVersion = tls.VersionTLS12
 	cfg.RootCAs = x509.NewCertPool()
 	cfg.BuildNameToCertificate()
 	s.s = newHTTPServer(s.g.r, port, c)

httpserve_test.go

@@ -5,8 +5,6 @@ import (
 	"net/http"
 	"testing"
 	"time"
-
-	"fmt"
 )
 
 func TestServeText(t *testing.T) {
@@ -35,7 +33,6 @@ func TestServeText(t *testing.T) {
 	// Listen within a new goroutine
 	go func() {
 		if err := serve.Listen(8080); err != nil && err != http.ErrServerClosed {
-			fmt.Println("Uhh ", err.Error())
 			t.Fatal(err)
 		}
 	}()

jsonResponse.go

@@ -36,14 +36,15 @@ func (j *JSONResponse) newValue() (value JSONValue, err error) {
 		value.Data = j.val
 		return
 	}
+
 	// Switch on associated value's type
 	switch v := j.val.(type) {
 	case error:
 		// Type is a single error value, create new error slice with error as only item
-		value.Errors = []error{v}
+		value.Errors.Push(v)
 	case []error:
 		// Type is an error slice, set errors as the value
-		value.Errors = v
+		value.Errors.Copy(v)
 	default:
 		// Invalid error value, return error
 		err = fmt.Errorf("invalid type for an error response: %#v", v)
@@ -60,6 +61,7 @@ func (j *JSONResponse) WriteTo(w io.Writer) (n int64, err error) {
 		// Error encountered while initializing responder, return early
 		return
 	}
+
 	// Initialize a new JSON encoder
 	enc := json.NewEncoder(w)
 	// Encode the responder

jsonValue.go

@@ -27,7 +27,11 @@ func UnmarshalJSONValue(bs []byte, val interface{}) (err error) {
 		return
 	}
 
-	return jv.Errors.Err()
+	if err = jv.Errors.Err(); err != nil {
+		return
+	}
+
+	return
 }
 
 // JSONValue represents a basic JSON value

noContentResponse.go

@@ -0,0 +1,30 @@
+package httpserve
+
+import (
+	"io"
+)
+
+// NewNoContentResponse will return a new text response
+func NewNoContentResponse() *NoContentResponse {
+	var t NoContentResponse
+	return &t
+}
+
+// NoContentResponse is a basic text response
+type NoContentResponse struct {
+}
+
+// ContentType returns the content type
+func (t *NoContentResponse) ContentType() (contentType string) {
+	return "text/plain"
+}
+
+// StatusCode returns the status code
+func (t *NoContentResponse) StatusCode() (code int) {
+	return 204
+}
+
+// WriteTo will write the internal reader to a provided io.Writer
+func (t *NoContentResponse) WriteTo(w io.Writer) (n int64, err error) {
+	return
+}