import "github.com/bmizerany/pat"
Package pat implements a simple URL pattern muxer
func Tail(pat, path string) string
Tail returns the trailing string in path after the final slash for a pat ending with a slash.
Examples:
Tail("/hello/:title/", "/hello/mr/mizerany") == "mizerany"
Tail("/:a/", "/x/y/z") == "y/z"
type PatternServeMux struct {
// contains filtered or unexported fields
}PatternServeMux is an HTTP request multiplexer. It matches the URL of each incoming request against a list of registered patterns with their associated methods and calls the handler for the pattern that most closely matches the URL.
Pattern matching attempts each pattern in the order in which they were registered.
Patterns may contain literals or captures. Capture names start with a colon and consist of letters A-Z, a-z, _, and 0-9. The rest of the pattern matches literally. The portion of the URL matching each name ends with an occurrence of the character in the pattern immediately following the name, or a /, whichever comes first. It is possible for a name to match the empty string.
Example pattern with one capture:
/hello/:name
Will match:
/hello/blake /hello/keith
Will not match:
/hello/blake/ /hello/blake/foo /foo /foo/bar
Example 2:
/hello/:name/
Will match:
/hello/blake/ /hello/keith/foo /hello/blake /hello/keith
Will not match:
/foo /foo/bar
A pattern ending with a slash will get an implicit redirect to it's non-slash version. For example: Get("/foo/", handler) will implicitly register Get("/foo", handler). You may override it by registering Get("/foo", anotherhandler) before the slash version.
Retrieve the capture from the r.URL.Query().Get(":name") in a handler (note the colon). If a capture name appears more than once, the additional values are appended to the previous values (see http://golang.org/pkg/net/url/#Values)
A trivial example server is:
package main
import (
"io"
"net/http"
"github.com/bmizerany/pat"
"log"
)
// hello world, the web server
func HelloServer(w http.ResponseWriter, req *http.Request) {
io.WriteString(w, "hello, "+req.URL.Query().Get(":name")+"!\n")
}
func main() {
m := pat.New()
m.Get("/hello/:name", http.HandlerFunc(HelloServer))
// Register this pat with the default serve mux so that other packages
// may also be exported. (i.e. /debug/pprof/*)
http.Handle("/", m)
err := http.ListenAndServe(":12345", nil)
if err != nil {
log.Fatal("ListenAndServe: ", err)
}
}
When "Method Not Allowed":
Pat knows what methods are allowed given a pattern and a URI. For convenience, PatternServeMux will add the Allow header for requests that match a pattern for a method other than the method requested and set the Status to "405 Method Not Allowed".
func New() *PatternServeMux
New returns a new PatternServeMux.
func (p *PatternServeMux) Add(meth, pat string, h http.Handler)
Add will register a pattern with a handler for meth requests.
func (p *PatternServeMux) Del(pat string, h http.Handler)
Del will register a pattern with a handler for DELETE requests.
func (p *PatternServeMux) Get(pat string, h http.Handler)
Get will register a pattern with a handler for GET requests. It also registers pat for HEAD requests. If this needs to be overridden, use Head before Get with pat.
func (p *PatternServeMux) Head(pat string, h http.Handler)
Head will register a pattern with a handler for HEAD requests.
func (p *PatternServeMux) Options(pat string, h http.Handler)
Options will register a pattern with a handler for OPTIONS requests.
func (p *PatternServeMux) Post(pat string, h http.Handler)
Post will register a pattern with a handler for POST requests.
func (p *PatternServeMux) Put(pat string, h http.Handler)
Put will register a pattern with a handler for PUT requests.
func (p *PatternServeMux) ServeHTTP(w http.ResponseWriter, r *http.Request)
ServeHTTP matches r.URL.Path against its routing table using the rules described above.