96 lines
2.3 KiB
Go
96 lines
2.3 KiB
Go
package http
|
|
|
|
import (
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
type ServeMux struct {
|
|
routes []route
|
|
}
|
|
|
|
func (mux *ServeMux) Handle(pattern string, handler http.Handler, pathParams ...any) {
|
|
mux.routes = append(mux.routes, newRoute(pattern, handler, pathParams...))
|
|
}
|
|
|
|
func (mux *ServeMux) HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request), pathParams ...any) {
|
|
mux.routes = append(mux.routes, newRoute(pattern, http.HandlerFunc(handler), pathParams...))
|
|
}
|
|
|
|
func (mux *ServeMux) Handler(r *http.Request) (h http.Handler, pattern string) {
|
|
for _, rte := range mux.routes {
|
|
switch {
|
|
case rte.matcher(r):
|
|
return rte.handler, rte.pattern
|
|
}
|
|
}
|
|
return http.HandlerFunc(http.NotFound), ""
|
|
}
|
|
|
|
func (mux *ServeMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
if r.RequestURI == "*" {
|
|
if r.ProtoAtLeast(1, 1) {
|
|
w.Header().Set("Connection", "close")
|
|
}
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
h, _ := mux.Handler(r)
|
|
h.ServeHTTP(w, r)
|
|
}
|
|
|
|
type route struct {
|
|
pattern string
|
|
matcher func(r *http.Request) bool
|
|
handler http.HandlerFunc
|
|
}
|
|
|
|
func newRoute(pattern string, handler http.Handler, vars ...interface{}) route {
|
|
return route{
|
|
pattern,
|
|
func(r *http.Request) bool {
|
|
return match(r.URL.Path, pattern, vars...)
|
|
},
|
|
handler.ServeHTTP,
|
|
}
|
|
}
|
|
|
|
// match reports whether path matches the given pattern, which is a
|
|
// path with '+' wildcards wherever you want to use a parameter. Path
|
|
// parameters are assigned to the pointers in vars (len(vars) must be
|
|
// the number of wildcards), which must be of type *string or *int.
|
|
func match(path, pattern string, vars ...interface{}) bool {
|
|
for ; pattern != "" && path != ""; pattern = pattern[1:] {
|
|
switch pattern[0] {
|
|
case '+':
|
|
// '+' matches till next slash in path
|
|
slash := strings.IndexByte(path, '/')
|
|
if slash < 0 {
|
|
slash = len(path)
|
|
}
|
|
segment := path[:slash]
|
|
path = path[slash:]
|
|
switch p := vars[0].(type) {
|
|
case *string:
|
|
*p = segment
|
|
case *int:
|
|
n, err := strconv.Atoi(segment)
|
|
if err != nil || n < 0 {
|
|
return false
|
|
}
|
|
*p = n
|
|
default:
|
|
panic("vars must be *string or *int")
|
|
}
|
|
vars = vars[1:]
|
|
case path[0]:
|
|
// non-'+' pattern byte must match path byte
|
|
path = path[1:]
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
return path == "" && pattern == ""
|
|
}
|