Merge branch 'release-0.2.0'

Author: takama

README.md

@@ -8,7 +8,7 @@ A simple, compact and fast router package for use with Go services to process HT
 
 ### Examples
 
-Simplest example (serve static route): 
+- Simplest example (serve static route): 
 ```go
 package main
 
@@ -29,7 +29,7 @@ func main() {
 }
 ```
 
-Check it:
+- Check it:
 ```sh
 curl -i http://localhost:8888/hello/
 
@@ -41,7 +41,7 @@ Content-Length: 11
 Hello world
 ```
 
-Serve dynamic route with parameter:
+- Serve dynamic route with parameter:
 ```go
 func main() {
 	r := router.New()
@@ -54,7 +54,7 @@ func main() {
 }
 ```
 
-Check it:
+- Check it:
 ```sh
 curl -i http://localhost:8888/hello/John
 
@@ -66,7 +66,7 @@ Content-Length: 10
 Hello John
 ```
 
-Checks JSON Content-Type automatically:
+- Checks JSON Content-Type automatically:
 ```go
 func main() {
 	r := router.New()
@@ -85,7 +85,7 @@ func main() {
 }
 ```
 
-Check it:
+- Check it:
 ```sh
 curl -i http://localhost:8888/api/v1/settings/database/testdb
 
@@ -103,6 +103,47 @@ Content-Length: 102
 }
 ```
 
+- Use timer to calculate the elapsed time of request handling:
+```go
+func main() {
+	r := router.New()
+	r.GET("/api/v1/settings/database/:db", func(c *router.Control) {
+		data := map[string]map[string]string{
+			"Database settings": {
+				"database": c.Get(":db"),
+				"host":     "localhost",
+				"port":     "3306",
+			},
+		}
+		c.UseTimer()
+		c.Code(200).Body(data)
+	})
+	// Listen and serve on 0.0.0.0:8888
+	r.Listen(":8888")
+}
+```
+
+- Check it:
+```sh
+curl -i http://localhost:8888/api/v1/settings/database/testdb
+
+HTTP/1.1 200 OK
+Content-Type: application/json
+Date: Sun, 17 Aug 2014 13:26:05 GMT
+Content-Length: 143
+
+{
+  "took": 422,
+  "data": {
+    "Database settings": {
+      "database": "testdb",
+      "host": "localhost",
+      "port": "3306"
+    }
+  }
+}
+```
+
 ## Author
 
 [Igor Dolzhikov](https://github.com/takama)

control.go

@@ -7,20 +7,34 @@ package router
 import (
 	"encoding/json"
 	"net/http"
+	"time"
 )
 
 const (
+	// MIMEJSON - "Content-type" for JSON
 	MIMEJSON = "application/json"
+	// MIMETEXT - "Content-type" for TEXT
 	MIMETEXT = "text/plain"
 )
 
 // Control allows us to pass variables between middleware,
 // assign Http codes and render a Body.
 type Control struct {
+
+	// Request is an adapter which allows the usage of a http.Request as standard request
 	Request *http.Request
-	Writer  http.ResponseWriter
-	code    int
-	Params  []Param
+
+	// Writer is an adapter which allows the usage of a http.ResponseWriter as standard writer
+	Writer http.ResponseWriter
+
+	// Code of HTTP status
+	code int
+
+	// Params is set of parameters
+	Params []Param
+
+	// timer used to calculate a elapsed time for handler and writing it in a response
+	timer time.Time
 }
 
 // Param is a URL parameter which represents as key and value.
@@ -29,6 +43,12 @@ type Param struct {
 	Value string
 }
 
+// Header used if non-zero Control.timer initialized by UserTimer() method
+type Header struct {
+	Took time.Duration `json:"took"`
+	Data interface{}   `json:"data"`
+}
+
 // Get returns the first value associated with the given name.
 // If there are no values associated with the key, an empty string is returned.
 func (c *Control) Get(name string) string {
@@ -54,19 +74,28 @@ func (c *Control) Code(code int) *Control {
 	return c
 }
 
+// UseTimer allow caalculate elapsed time of request handling
+func (c *Control) UseTimer() {
+	c.timer = time.Now()
+}
+
 // Body renders the given data into the response body
 func (c *Control) Body(data interface{}) {
 	var content []byte
 	if str, ok := data.(string); ok {
-		c.Writer.Header().Set("Content-type", MIMETEXT)
+		c.Writer.Header().Add("Content-type", MIMETEXT)
 		content = []byte(str)
 	} else {
+		if !c.timer.IsZero() {
+			took := time.Now()
+			data = &Header{Took: took.Sub(c.timer), Data: data}
+		}
 		jsn, err := json.MarshalIndent(data, "", "  ")
 		if err != nil {
 			c.Writer.WriteHeader(http.StatusInternalServerError)
 			return
 		}
-		c.Writer.Header().Set("Content-type", MIMEJSON)
+		c.Writer.Header().Add("Content-type", MIMEJSON)
 		content = jsn
 	}
 	if c.code > 0 {

control_test.go

@@ -9,7 +9,7 @@ import (
 	"testing"
 )
 
-var parameters []Param = []Param{
+var parameters = []Param{
 	{"name", "John"},
 	{"age", "32"},
 	{"gender", "M"},

example/example.go

@@ -18,6 +18,7 @@ func main() {
 				"port":     "3306",
 			},
 		}
+		c.UseTimer()
 		c.Code(200).Body(data)
 	})
 	// Listen and serve on 0.0.0.0:8888

router.go

@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.
 
 /*
-Package router 0.1.1 provides fast HTTP request router.
+Package router 0.2.0 provides fast HTTP request router.
 
 The router matches incoming requests by the request method and the path.
 If a handle is registered for this path and method, the router delegates the
@@ -71,15 +71,26 @@ package router
 import (
 	"log"
 	"net/http"
+	"strings"
 )
 
 // Router represents a multiplexer for HTTP requests.
 type Router struct {
+	// List of handlers which accociated with known http methods (GET, POST ...)
 	handlers map[string]*parser
+
 	// NotFound is called when unknown HTTP method or a handler not found.
 	// If it is not set, http.NotFound is used.
 	// Please overwrite this if need your own NotFound handler.
 	NotFound http.HandlerFunc
+
+	// PanicHandler is called when panic happen.
+	// The handler prevents your server from crashing and should be used to return
+	// http status code http.StatusInternalServerError (500)
+	PanicHandler func(c *Control)
+
+	// Logger activates logging for each requests
+	Logger bool
 }
 
 // Handle type is aliased to type of handler function.
@@ -158,6 +169,19 @@ func (r *Router) Listen(hostPort string) {
 
 // ServeHTTP implements http.Handler interface.
 func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+	defer func() {
+		if recovery := recover(); recovery != nil {
+			c := &Control{Request: req, Writer: w}
+			if r.PanicHandler != nil {
+				r.PanicHandler(c)
+			} else {
+				log.Println("Recovered in handler:", req.Method, req.URL.Path)
+			}
+		}
+	}()
+	if r.Logger {
+		log.Println(req.Method, req.URL.Path)
+	}
 	if handle, params, ok := r.handlers[req.Method].get(req.URL.Path); ok {
 		c := &Control{Request: req, Writer: w}
 		if len(params) > 0 {
@@ -166,11 +190,22 @@ func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) {
 		handle(c)
 		return
 	}
+	allowed := make([]string, 0, len(r.handlers))
+	for method, parser := range r.handlers {
+		if _, _, ok := parser.get(req.URL.Path); ok {
+			allowed = append(allowed, method)
+		}
+	}
 
-	if r.NotFound != nil {
-		r.NotFound(w, req)
-	} else {
-		http.NotFound(w, req)
+	if len(allowed) == 0 {
+		if r.NotFound != nil {
+			r.NotFound(w, req)
+		} else {
+			http.NotFound(w, req)
+		}
+		return
 	}
-	return
+
+	w.Header().Add("Allow", strings.Join(allowed, ", "))
+	http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
 }