add option to automatically handle OPTIONS requests, SetAutomaticallyHandleOPTIONS

Author: joeybloggs

README.md

@@ -188,6 +188,10 @@ l.SetRedirectTrailingSlash(true)
 // Handle 405 ( Method Not allowed ), default is false
 l.SetHandle405MethodNotAllowed(false)
 
+// automatically handle OPTION requests; manually configured
+// OPTION handlers take precedence. default true
+l.SetAutomaticallyHandleOPTIONS(set bool)
+
 // register custom context
 l.RegisterContext(ContextFunc)
 
@@ -225,34 +229,34 @@ NOTICE: lars uses a custom version of [httprouter](https://github.com/julienschm
 ```go
 go test -bench=. -benchmem=true
 #GithubAPI Routes: 203
-   LARS: 49016 Bytes
+   LARS: 49040 Bytes
 
 #GPlusAPI Routes: 13
-   LARS: 3624 Bytes
+   LARS: 3648 Bytes
 
 #ParseAPI Routes: 26
-   LARS: 6616 Bytes
+   LARS: 6640 Bytes
 
 #Static Routes: 157
-   LARS: 30104 Bytes
+   LARS: 30128 Bytes
 
 PASS
-BenchmarkLARS_Param       	20000000	        75.3 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_Param5      	10000000	       126 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_Param20     	 5000000	       311 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_ParamWrite  	10000000	       144 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_GithubStatic	20000000	       101 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_GithubParam 	10000000	       154 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_GithubAll   	   50000	     33295 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_GPlusStatic 	20000000	        72.4 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_GPlusParam  	20000000	        99.6 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_GPlus2Params	10000000	       124 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_GPlusAll    	 1000000	      1640 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_ParseStatic 	20000000	        73.9 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_ParseParam  	20000000	        79.9 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_Parse2Params	20000000	        97.1 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_ParseAll    	  500000	      2974 ns/op	       0 B/op	       0 allocs/op
-BenchmarkLARS_StaticAll   	   50000	     23641 ns/op	       0 B/op	       0 allocs/op
+BenchmarkLARS_Param       	20000000	        77.1 ns/op	       0 B/op	       0 allocs/op
+BenchmarkLARS_Param5      	10000000	       134 ns/op	       0 B/op	       0 allocs/op
+BenchmarkLARS_Param20     	 5000000	       320 ns/op	       0 B/op	       0 allocs/op
+BenchmarkLARS_ParamWrite  	10000000	       142 ns/op	       0 B/op	       0 allocs/op
+BenchmarkLARS_GithubStatic	20000000	        96.2 ns/op	       0 B/op	       0 allocs/op
+BenchmarkLARS_GithubParam 	10000000	       156 ns/op	       0 B/op	       0 allocs/op
+BenchmarkLARS_GithubAll   	   50000	     32952 ns/op	       0 B/op	       0 allocs/op
+BenchmarkLARS_GPlusStatic 	20000000	        72.2 ns/op	       0 B/op	       0 allocs/op
+BenchmarkLARS_GPlusParam  	20000000	        98.0 ns/op	       0 B/op	       0 allocs/op
+BenchmarkLARS_GPlus2Params	10000000	       127 ns/op	       0 B/op	       0 allocs/op
+BenchmarkLARS_GPlusAll    	 1000000	      1619 ns/op	       0 B/op	       0 allocs/op
+BenchmarkLARS_ParseStatic 	20000000	        72.8 ns/op	       0 B/op	       0 allocs/op
+BenchmarkLARS_ParseParam  	20000000	        78.6 ns/op	       0 B/op	       0 allocs/op
+BenchmarkLARS_Parse2Params	20000000	        96.9 ns/op	       0 B/op	       0 allocs/op
+BenchmarkLARS_ParseAll    	  500000	      2968 ns/op	       0 B/op	       0 allocs/op
+BenchmarkLARS_StaticAll   	  100000	     22810 ns/op	       0 B/op	       0 allocs/op
 ```
 
 Package Versioning

doc.go

@@ -171,6 +171,10 @@ misc examples and noteworthy features
 	// Handle 405 ( Method Not allowed ), default is false
 	l.SetHandle405MethodNotAllowed(false)
 
+	// automatically handle OPTION requests; manually configured
+	// OPTION handlers take precedence. default true
+	l.SetAutomaticallyHandleOPTIONS(set bool)
+
 	// register custom context
 	l.RegisterContext(ContextFunc)
 

lars.go

@@ -72,6 +72,7 @@ const (
 	WWWAuthenticate    = "WWW-Authenticate"
 	XForwardedFor      = "X-Forwarded-For"
 	XRealIP            = "X-Real-Ip"
+	Allow              = "Allow"
 
 	Gzip = "gzip"
 
@@ -126,7 +127,8 @@ type LARS struct {
 	http404 HandlersChain // 404 Not Found
 	http405 HandlersChain // 405 Method Not Allowed
 
-	notFound HandlersChain
+	automaticOPTIONS HandlersChain
+	notFound         HandlersChain
 
 	customHandlersFuncs customHandlers
 
@@ -144,6 +146,10 @@ type LARS struct {
 	// If no other Method is allowed, the request is delegated to the NotFound
 	// handler.
 	handleMethodNotAllowed bool
+
+	// if enabled automatically handles OPTION requests; manually configured OPTION
+	// handlers take precidence. default true
+	automaticallyHandleOPTIONS bool
 }
 
 // RouteMap contains a single routes full path
@@ -161,17 +167,11 @@ var (
 	}
 
 	methodNotAllowedHandler = func(c Context) {
+		c.Response().WriteHeader(http.StatusMethodNotAllowed)
+	}
 
-		mth, _ := c.Get("methods")
-		methods := mth.([]string)
-
-		res := c.Response()
-
-		for _, m := range methods {
-			res.Header().Add("Allow", m)
-		}
-
-		res.WriteHeader(http.StatusMethodNotAllowed)
+	automaticOPTIONSHandler = func(c Context) {
+		c.Response().WriteHeader(http.StatusOK)
 	}
 )
 
@@ -186,11 +186,12 @@ func New() *LARS {
 		contextFunc: func(l *LARS) Context {
 			return NewContext(l)
 		},
-		mostParams:             0,
-		http404:                []HandlerFunc{default404Handler},
-		http405:                []HandlerFunc{methodNotAllowedHandler},
-		redirectTrailingSlash:  true,
-		handleMethodNotAllowed: false,
+		mostParams:                 0,
+		http404:                    []HandlerFunc{default404Handler},
+		http405:                    []HandlerFunc{methodNotAllowedHandler},
+		redirectTrailingSlash:      true,
+		handleMethodNotAllowed:     false,
+		automaticallyHandleOPTIONS: true,
 	}
 
 	l.routeGroup.lars = l
@@ -241,6 +242,13 @@ func (l *LARS) Register404(notFound ...Handler) {
 	l.http404 = chain
 }
 
+// SetAutomaticallyHandleOPTIONS tells lars whether to
+// automatically handle OPTION requests; manually configured
+// OPTION handlers take precedence. default true
+func (l *LARS) SetAutomaticallyHandleOPTIONS(set bool) {
+	l.automaticallyHandleOPTIONS = set
+}
+
 // SetRedirectTrailingSlash tells lars whether to try
 // and fix a URL by trying to find it
 // lowercase -> with or without slash -> 404
@@ -265,6 +273,12 @@ func (l *LARS) Serve() http.Handler {
 	copy(l.notFound, l.middleware)
 	copy(l.notFound[len(l.middleware):], l.http404)
 
+	if l.automaticallyHandleOPTIONS {
+		l.automaticOPTIONS = make(HandlersChain, len(l.middleware)+1)
+		copy(l.automaticOPTIONS, l.middleware)
+		copy(l.automaticOPTIONS[len(l.middleware):], []HandlerFunc{automaticOPTIONSHandler})
+	}
+
 	return http.HandlerFunc(l.serveHTTP)
 }
 
@@ -280,85 +294,113 @@ func (l *LARS) serveHTTP(w http.ResponseWriter, r *http.Request) {
 
 			c.params = c.params[0:0]
 
-			if l.redirectTrailingSlash {
+			if l.redirectTrailingSlash && len(r.URL.Path) > 1 {
 
 				// find again all lowercase
 				lc := strings.ToLower(r.URL.Path)
 
 				if lc != r.URL.Path {
 
-					r.URL.Path = lc
-
-					if c.handlers, _, _ = root.find(r.URL.Path, c.params); c.handlers != nil {
+					if c.handlers, _, _ = root.find(lc, c.params); c.handlers != nil {
+						r.URL.Path = lc
 						c.handlers = l.redirect(r.Method)
 						goto END
 					}
 				}
 
-				if r.URL.Path[len(r.URL.Path)-1:] == basePath {
-					r.URL.Path = r.URL.Path[:len(r.URL.Path)-1]
+				if lc[len(lc)-1:] == basePath {
+					lc = lc[:len(lc)-1]
 				} else {
-					r.URL.Path = r.URL.Path + basePath
+					lc = lc + basePath
 				}
 
-				if c.handlers, _, _ = root.find(r.URL.Path, c.params); c.handlers != nil {
+				if c.handlers, _, _ = root.find(lc, c.params); c.handlers != nil {
+					r.URL.Path = lc
 					c.handlers = l.redirect(r.Method)
 					goto END
 				}
+			}
 
-				// slow, but get's the job done
-				if l.handleMethodNotAllowed {
+		} else {
+			goto END
+		}
+	}
 
-					r.URL.Path = lc
+	if l.automaticallyHandleOPTIONS && r.Method == OPTIONS {
+		l.getOptions(c)
+		goto END
+	}
 
-					if l.checkMethodNotAllowed(c) {
-						goto END
-					}
-				}
+	if l.handleMethodNotAllowed {
+
+		if l.checkMethodNotAllowed(c) {
+			goto END
+		}
+	}
+
+	// not found
+	c.handlers = l.notFound
+
+END:
+
+	c.parent.Next()
+	c.parent.RequestEnd()
+
+	l.pool.Put(c)
+}
+
+func (l *LARS) getOptions(c *Ctx) {
+
+	res := c.Response()
+
+	if c.request.URL.Path == "*" { // check server-wide OPTIONS
+
+		for m := range l.trees {
+
+			if m == OPTIONS {
+				continue
 			}
 
-			// lowercase, fix trailing 405....
-			c.handlers = l.notFound
+			res.Header().Add(Allow, m)
 		}
+
 	} else {
+		for m, tree := range l.trees {
 
-		// slow, but get's the job done
-		if l.handleMethodNotAllowed {
+			if m == c.request.Method || m == OPTIONS {
+				continue
+			}
 
-			if l.checkMethodNotAllowed(c) {
-				goto END
+			if c.handlers, _, _ = tree.find(c.request.URL.Path, c.params); c.handlers != nil {
+				res.Header().Add(Allow, m)
 			}
 		}
 
-		c.handlers = l.notFound
 	}
 
-END:
+	res.Header().Add(Allow, OPTIONS)
+	c.handlers = l.automaticOPTIONS
 
-	c.parent.Next()
-	c.parent.RequestEnd()
-
-	l.pool.Put(c)
+	return
 }
 
 func (l *LARS) checkMethodNotAllowed(c *Ctx) (found bool) {
 
-	var methods []string
+	res := c.Response()
 
 	for m, tree := range l.trees {
 
 		if m != c.request.Method {
 			if c.handlers, _, _ = tree.find(c.request.URL.Path, c.params); c.handlers != nil {
 				// add methods
-				methods = append(methods, m)
+				res.Header().Add(Allow, m)
+				found = true
 			}
 		}
 	}
 
-	if len(methods) > 0 {
-		c.Set("methods", methods)
+	if found {
 		c.handlers = l.http405
-		found = true
 	}
 
 	return

lars_test.go

@@ -894,6 +894,41 @@ func TestRedirect(t *testing.T) {
 	Equal(t, code, http.StatusNotFound)
 }
 
+func TestAutomaticallyHandleOPTIONS(t *testing.T) {
+
+	l := New()
+	l.SetAutomaticallyHandleOPTIONS(true)
+	l.Get("/home", func(c Context) {})
+	l.Post("/home", func(c Context) {})
+	l.Delete("/user", func(c Context) {})
+	l.Options("/other", func(c Context) {})
+
+	code, _ := request(GET, "/home", l)
+	Equal(t, code, http.StatusOK)
+
+	r, _ := http.NewRequest(OPTIONS, "/home", nil)
+	w := httptest.NewRecorder()
+	l.serveHTTP(w, r)
+
+	Equal(t, w.Code, http.StatusOK)
+
+	allow, ok := w.Header()["Allow"]
+
+	Equal(t, ok, true)
+	Equal(t, len(allow), 3)
+
+	r, _ = http.NewRequest(OPTIONS, "*", nil)
+	w = httptest.NewRecorder()
+	l.serveHTTP(w, r)
+
+	Equal(t, w.Code, http.StatusOK)
+
+	allow, ok = w.Header()["Allow"]
+
+	Equal(t, ok, true)
+	Equal(t, len(allow), 4)
+}
+
 type closeNotifyingRecorder struct {
 	*httptest.ResponseRecorder
 	closed chan bool