README.md

# Alice 

`Alice` provides a convenient way to chain 
your HTTP middleware functions and the app handler.

In short, it transforms `Middleware1(Middleware2(Middleware3(App)))`
to `alice.New(Middleware1, Middleware, Middleware3).Then(App)`.

### Why?

None of the other middleware chaining solutions
behaves exactly like Alice.
Alice is as minimal as a chaining solution gets.
In its essence, it's just a for loop that does the wrapping for you.

### Usage

Your middleware constructors should have the form of

    func (http.Handler) http.Handler

Some middleware provide this out of the box.
For ones that don't, it's trivial to write one yourself.

```go
func myStripPrefix(h http.Handler) http.Handler {
    return http.StripPrefix("/old", h)
}
```

This complete example shows the full power of Alice.

```go
package main

import (
    "net/http"
    "time"

    "github.com/PuerkitoBio/throttled"
    "github.com/justinas/alice"
    "github.com/justinas/nosurf"
)

func timeoutHandler(h http.Handler) http.Handler {
    return http.TimeoutHandler(h, 1*time.Second, "timed out")
}

func myApp(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello world!"))
}

func main() {
    th := throttled.Interval(throttled.PerSec(10), 1, &throttled.VaryBy{Path: true}, 50)
    myHandler := http.HandlerFunc(myApp)

    chain := alice.New(th.Throttle, timeoutHandler, nosurf.NewPure).Then(myHandler)
    http.ListenAndServe(":8000", chain)
}
```

Here, the request will pass [throttled](https://github.com/PuerkitoBio/throttled) first,
then an http.TimeoutHandler we've set up,
then [nosurf](https://github.com/justinas/nosurf)
and will finally reach our handler.

Note that Alice makes **no guarantees** for
how one or another piece of  middleware will behave.
It does not execute all handlers sequentially
but wraps them in one another.

If a piece of middleware were to stop the chain,
the request will not reach the inner handlers.
This is intentional behavior.

### Contributing

0. Find an issue that bugs you / open a new one.
1. Discuss.
2. Branch off the `develop` branch, commit, test.
3. Make a pull request / attach the commits to the issue.