Hello,

Can you please tag and version this project?

I am the Debian Maintainer for pat and versioning would help Debian keep up with development.

Like: implements a simple URL pattern muxer

The tests still use bmizerany/assert. I haven't used or felt the need to use anything like it not longer after releasing it. :) Pat can easily live without it. If anyone wants to remove the dependency, that would be rad.

I see that it hasn't been updated in a while. Is this project still maintained, or is just so solid that it's done until a future version of Go requires it to change?

Used by backbone.js for partial object updates.

i think the pattern /:name/
should match
_localhost:12345/abc/_
and
_localhost:12345/abc_

according the example provided in the code:

// 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

What do you think?
But I found the behavior is not the same as I supposed.

The fact is that,
I wanna to the pattern /:name/ match
_localhost:12345/abc_
but when i type the URL in Chrome,
it will turn to
_localhost:12345/:name_

see the example

https://golang.org/pkg/net/http/httputil/#NewSingleHostReverseProxy

Hello,

Could you add the License file please ?

Thank you

Now that net/http supports context, I think it will be more appropriate to pass the extracted parameters via context. This will avoid confusion regarding what are actual query parameters. Obviously doing this will break backward compatibility.

go get github.com/bmizerany/pat

go: downloading github.com/bmizerany/pat v0.0.0-20170815010413-6226ea591a40
go get github.com/bmizerany/pat: github.com/bmizerany/[email protected]: verifying module: github.com/bmizerany/[email protected]: cannot authenticate record data in server response

If there is a trailing slash in a pattern then redirects don't work as expected. Take the example server from the documentation, but add a slash to the pattern:

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))

    http.Handle("/", m)
    err := http.ListenAndServe(":12345", nil)
    if err != nil {
        log.Fatal("ListenAndServe: ", err)
    }
}

If we request /hello/bob/ everything works as expected:

$ curl http://localhost:12345/hello/bob/
hello, bob!

But if we request a url without a trailing slash like /hello/bob we get a broken redirect to /hello/:name/

$ curl -si http://localhost:12345/hello/bob | grep Location
Location: /hello/:name/

It looks like the code is using the pattern as the redirect target, instead of the requested url.

The docs on this are also unclear, they say "A pattern ending with a slash will get an implicit redirect to it's non-slash version." - but the redirect appears to be from the non-slash version.