Example

package main
import (
 "net/http"
 "github.com/honmaple/forest"
 "github.com/honmaple/forest/middleware"
)
func main() {
 r := forest.New(forest.Debug())
 r.Use(middleware.Recover())
 r.Use(middleware.Logger())
 r.GET("/", func(c forest.Context) error {
 return c.HTML(http.StatusOK, "<h1>Hello Forest</h1>")
 })
 v1 := r.Group(forest.WithPrefix("/api"))
 {
 v1.GET("/posts/{title}", func(c forest.Context) error {
 return c.JSON(http.StatusOK, forest.H{"title": c.Param("title")})
 })
 v1.POST("/posts", func(c forest.Context) error {
 type post struct {
 Title string `json:"title" form:"title"`
 Content string `json:"content" form:"content"`
 }
 p := post{}
 if err := c.Bind(&p); err != nil {
 return c.JSON(http.BadRequest, forest.H{"message": err.Error()})
 }
 return c.JSON(http.StatusOK, p)
 })
 }
 v2 := forest.NewGroup(forest.WithHost("v2.localhost:8000"))
 {
 v2.GET("/posts/{title}", func(c forest.Context) error {
 return c.JSON(http.StatusOK, forest.H{"title": c.Param("title")})
 })
 }
 r.Mount(v2)
 r.Start("127.0.0.1:8000")
}

Route

Single parameter in path

router := forest.New()
// /posts/1 {"var": "1"}
// /posts/test {"var": "test"}
// /posts, /posts/, /posts/1/1 not match
router.GET("/posts/:var", handler)
// /posts/ {"var": ""}
// /posts/1 {"var": "1"}
// /posts/test {"var": "test"}
// /posts, /posts/1/1 not match
router.GET("/posts/:var?", handler)
// /posts/ {"var": ""}
// /posts/1 {"var": "1"}
// /posts/1/ {"var": "1/"}
// /posts/1/test/2 {"var": "1/test/2"}
router.GET("/posts/*var", handler)
// /posts/1 {"var": "1"}
// /posts/test {"var": "test"}
// /posts, /posts/, /posts/1/1 not match
router.GET("/posts/{var}", handler)
router.GET("/posts/{var:string}", handler)
// /posts/ {"var": ""}
// /posts/1 {"var": "1"}
// /posts/test {"var": "test"}
// /posts, /posts/1/1 not match
router.GET("/posts/{var?}", handler)
// /posts/1 {"var": "1"}
// /posts/test not match
router.GET("/posts/{var:int}", handler)
// /posts/1 not match
// /posts/test not match
// /posts/.1 {"var": ".1"}
// /posts/1.1 {"var": "1.1"}
// /posts/1.10 {"var": "1.10"}
router.GET("/posts/{var:float}", handler)
// /posts/1 {"var": "1"}
// /posts/test {"var": "test"}
// /posts/test/1 {"var": "test/1"}
router.GET("/posts/{var:path}", handler)

Multi parameters in path

// /posts/1 not match
// /posts/prefixtest {"var": "test"}
router.GET("/posts/prefix:var", handler)
// /posts/prefixtest {"var:end": "test"}
router.GET("/posts/prefix:var:end", handler)
// /posts/test not match
// /posts/test/1 not match
// /posts/test/1/test {"var": "test/1"}
router.GET("/posts/*var/test", handler)
// /posts/test not match
// /posts/test-123 {"var": "test", "var1": "123"}
router.GET("/posts/{var}-{var1:int}", handler)
// /posts/123-test {"var": "123", "var1": "test"}
router.GET("/posts/{var:int}-{var1}", handler)
// /posts/123-test {"var": "123", "var1": "test"}
// /posts/123/test-test {"var": "123/test", "var1": "test"}
router.GET("/posts/{var:path}-{var1}", handler)
// /posts/1/1/test {"var": "1", "var1": "1", "var2": "test"}
// /posts/test/1/1/test {"var": "test/1", "var1": "1", "var2": "test"}
// /posts/test/1/1/s/test not match
router.GET("/posts/{var:path}/{var1:int}/{var2}", handler)
// /posts/1/1/test {"var": "1", "var1": "1", "var2": "test"}
// /posts/test/1/1/test {"var": "test", "var1": "1", "var2": "1/test"}
// /posts/test/1/1/s/test {"var": "test", "var1": "1", "var2": "1/s/test"}
router.GET("/posts/{var:path}/{var1:int}/{var2:path}", handler)

Named Route

r := forest.New()
g1 := r.Group(forest.WithPrefix("/api"), forest.WithName("g1"))
g2 := g1.Group(forest.WithPrefix("/v1"), forest.WithName("g2"))
r1 := api.GET("/posts").Named("list_posts", "some description")
r2 := api.DELETE("/posts/:pk").Named("delete_post", "delete post with pk param")
// result
r.Route("g1.g2.list_posts") == r1
r.URL("g1.g2.list_posts") == r1.URL() == "/v1/api/posts"
r.Route("g1.g2.delete_post") == r2
r.URL("g1.g2.delete_post", "12") == r2.URL("12") == "/v1/api/posts/12"

Server Static files

r := forest.New()
r.GET("/static/*", func(c forest.Context) error {
 path := filepath.Join("static", c.Param("*"))
 return c.FileFromFS(path, http.FS(staticFS))
})
r.GET("/robots.txt", func(c forest.Context) error {
 return c.FileFromFS("static/robots.txt", http.FS(staticFS))
})
r.GET("/favicon.ico", func(c forest.Context) error {
 return c.FileFromFS("static/favicon.ico", http.FS(staticFS))
})

Bind Params

type Params struct {
 Text string `query:"text" json:"text" form:"text" param:"text"`
}
p := Params{}
// bind query, method: not POST, PUT, PATCH
// bind form or json or xml, method: POST, PUT, PATCH
c.Bind(&p)
// bind params, GET /test/:text
c.BindParams(&p)
// bind other params
c.BindWith(&p, bind.Query)
c.BindWith(&p, bind.Form)
c.BindWith(&p, bind.MultipartForm)
c.BindWith(&p, bind.JSON)
c.BindWith(&p, bind.XML)
c.BindWith(&p, bind.Params)
c.BindWith(&p, bind.Header)
// custom bind tag
c.BindWith(&p, bind.FormBinder{"json"})
c.BindWith(&p, bind.QueryBinder{"json"})

Custom

Custom Middleware

func MyMiddleware(c forest.Context) error {
 // do something
 // c.Next() is required, or else your handler will not execute
 return c.Next()
}
router := forest.New()
// with root
router.Use(MyMiddleware)
// with group
group := router.Group(forest.WithPrefix("/api/v1"), forest.WithMiddlewares(MyMiddleware))
// with special handler
group.GET("/", MyMiddleware, func(c forest.Context) error {
 return nil
})

Custom Logger

router := forest.New()
router.Logger = Logger1
router.GET("/posts", func(c forest.Context) error {
 // c.Logger() == Logger1
 ...
 })
group := router.Group(forest.WithPrefix("/api/v1"))
group.GET("/posts", func(c forest.Context) error {
 // c.Logger() == Logger1
 ...
 })
group := router.Group(forest.WithPrefix("/api/v2"))
group.Logger = Logger2
group.GET("/posts", func(c forest.Context) error {
 // c.Logger() == Logger2
 ...
 })

Custom Error Handler

router := forest.New()
// engine only
router.NotFound(func(c forest.Context) error {
 return c.JSON(404, forest.H{"message": "not found"})
})
router.MethodNotAllowed(func(c forest.Context) error {
 return c.JSON(405, forest.H{"message": "method not allowed"})
})
router.ErrorHandler = func(err error, c Context) {
 c.String(500, err.Error())
}
group := router.Group(forest.WithPrefix("/api/v1"))
// group only
group.ErrorHandler = func(err error, c Context) {
 c.String(501, err.Error())
}

Custom Context

type MyContext struct {
 forest.Context
}
func (c *MyContext) Next() error {
 return c.NextWith(c)
}
func MyContextMiddleware(c forest.Context) error {
 // doing somthing
 return c.NextWith(&MyContext{c})
}

Custom Host Matcher

func matcher(host, dst string) bool {
 return host == dst
}
r := forest.New(forest.HostMatch(matcher))
// or use internal matcher
r := forest.New(forest.HostMatch(forest.HostMatcher))

Custom URL Param

import (
 "github.com/google/uuid"
)
type UUIDMatcher struct {
}
func (s *UUIDMatcher) Name() string {
 return "uuid"
}
func (s *UUIDMatcher) Match(path string, index int, next bool) (int, bool) {
 if index > 0 {
 return 0, false
 }
 if len(path) < 18 || (!next && len(path) > 18) {
 return 0, false
 }
 _, err := uuid.Parse(path[:18])
 if err != nil {
 return 0, false
 }
 return 18, true
}
func NewUUIDMatcher(rule string) forest.Matcher {
 return &UUIDMatcher{}
}
forest.RegisterRule("uuid", NewUUIDMatcher)
router := forest.New()
router.GET("/api/v1/user/{pk:uuid}", handler)