group use with options, add contextParams pointer

add forest custom hostMatcher

Author: honmaple

README.org

@@ -17,7 +17,7 @@
              return c.HTML(http.StatusOK, "<h1>Hello Forest</h1>")
          })
 
-         v1 := r.Group("/v1")
+         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")})
@@ -35,14 +35,14 @@
              })
          }
 
-         v2 := forest.NewHost("v2.localhost:8000")
+         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.Mount(v2)
          r.Start("127.0.0.1:8000")
      }
    #+end_src
@@ -122,8 +122,8 @@
 *** Named Route
     #+begin_src go
       r := forest.New()
-      g1 := r.Group("/api").Named("g1")
-      g2 := g1.Group("/v1").Named("g2")
+      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
@@ -184,7 +184,7 @@
       // with root
       router.Use(MyMiddleware)
       // with group
-      group := router.Group("/api/v1", MyMiddleware)
+      group := router.Group(forest.WithPrefix("/api/v1"), forest.WithMiddlewares(MyMiddleware))
       // with special handler
       group.GET("/", MyMiddleware, func(c forest.Context) error {
           return nil
@@ -201,13 +201,13 @@
           ...
           })
 
-      group := router.Group("/api/v1")
+      group := router.Group(forest.WithPrefix("/api/v1"))
       group.GET("/posts", func(c forest.Context) error {
           // c.Logger() == Logger1
           ...
           })
 
-      group := router.Group("/api/v2")
+      group := router.Group(forest.WithPrefix("/api/v2"))
       group.Logger = Logger2
       group.GET("/posts", func(c forest.Context) error {
           // c.Logger() == Logger2
@@ -229,7 +229,7 @@
       router.ErrorHandler = func(err error, c Context) {
           c.String(500, err.Error())
       }
-      group := router.Group("/api/v1")
+      group := router.Group(forest.WithPrefix("/api/v1"))
       // group only
       group.ErrorHandler = func(err error, c Context) {
           c.String(501, err.Error())
@@ -252,6 +252,16 @@
       }
     #+end_src
 
+*** Custom Host Matcher
+    #+begin_src go
+      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))
+    #+end_src
+
 *** Custom URL Param
     #+begin_src go
       import (
@@ -279,7 +289,7 @@
           return 18, true
       }
 
-      func NewUUIDMatcher(pname string, ptype string) forest.Matcher {
+      func NewUUIDMatcher(rule string) forest.Matcher {
           return &UUIDMatcher{}
       }
 

context.go

@@ -65,7 +65,7 @@ type Context interface {
 type context struct {
 	response  *Response
 	request   *http.Request
-	pvalues   []string
+	params    *contextParams
 	storeLock sync.RWMutex
 	store     map[string]interface{}
 	query     url.Values
@@ -108,8 +108,8 @@ func (c *context) Get(key string) interface{} {
 
 func (c *context) Param(name string) string {
 	for i, p := range c.route.pnames {
-		if i < len(c.pvalues) && p.name == name {
-			return c.pvalues[i]
+		if i < len(c.params.pvalues) && p.name == name {
+			return c.params.pvalues[i]
 		}
 	}
 	return ""
@@ -121,8 +121,8 @@ func (c *context) Params() map[string]string {
 	}
 	params := make(map[string]string)
 	for i, p := range c.route.pnames {
-		if i < len(c.pvalues) {
-			params[p.name] = c.pvalues[i]
+		if i < len(c.params.pvalues) {
+			params[p.name] = c.params.pvalues[i]
 		}
 	}
 	return params
@@ -323,8 +323,18 @@ func (c *context) reset(r *http.Request, w http.ResponseWriter) {
 	c.request = r
 	c.store = nil
 	c.index = -1
-	for i := 0; i < len(c.pvalues); i++ {
-		c.pvalues[i] = ""
+	c.params.reset(0)
+}
+
+type contextParams struct {
+	pindex  int
+	pvalues []string
+}
+
+func (m *contextParams) reset(pindex int) {
+	m.pindex = pindex
+	for ; pindex < len(m.pvalues); pindex++ {
+		m.pvalues[pindex] = ""
 	}
 }
 

examples/helloworld/main.go

@@ -9,31 +9,40 @@ import (
 
 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>")
+	r.Use(middleware.Recover())
+
+	r.NotFound(func(c forest.Context) error {
+		return c.JSON(444, forest.H{"message": "not found"})
 	})
 
-	v1 := r.Group("/v1")
+	// r.Use(middleware.BasicAuth(nil))
+	r.GET("/*", func(c forest.Context) error {
+		return c.HTML(http.StatusOK, "<h1>Hello Forest</h1>")
+
+	})
+	v1 := r.Group(forest.WithPrefix("/v1"), forest.WithName("v1"))
 	{
 		v1.GET("/posts/{title}", func(c forest.Context) error {
 			return c.JSON(http.StatusOK, forest.H{"title": c.Param("title")})
-		})
+		}).Named("vv")
 		v1.GET("/posts/{titleId:int}", func(c forest.Context) error {
 			return c.JSON(http.StatusOK, forest.H{"title": c.Param("titleId")})
 		})
 	}
 
-	v2 := r.Host("v2.localhost:8000", "")
+	v2 := r.Group(forest.WithHost("v2.localhost:8000"))
 	{
 		v2.GET("/posts/{title:^test-\\w+}", func(c forest.Context) error {
 			return c.JSON(http.StatusOK, forest.H{"title": c.Param("title")})
 		})
 	}
 
 	v3 := newGroup()
-	r.MountGroup("/v3", v3)
+	r.MountGroup(v3, forest.WithPrefix("/v3"))
+
+	v2.Mount(v3, forest.WithPrefix("/v3"))
 
 	r.Start("127.0.0.1:8000")
 }

examples/pprof/main.go

@@ -17,6 +17,14 @@ func profile() *forest.Forest {
 	return r
 }
 
+func profile1() *forest.Group {
+	r := forest.NewGroup()
+	r.GET("/pprof/", forest.WrapHandlerFunc(pprof.Index))
+	r.GET("/pprof/*", forest.WrapHandler(http.DefaultServeMux))
+	r.POST("/pprof/symbol", forest.WrapHandlerFunc(pprof.Symbol))
+	return r
+}
+
 func main() {
 	r := forest.New(forest.Debug())
 	r.Use(middleware.Recover())
@@ -25,6 +33,7 @@ func main() {
 		return c.HTML(http.StatusOK, "<h1>PPROF</h1>")
 
 	})
-	r.Mount("/debug", profile())
+	r.Mount(profile(), forest.WithPrefix("/debug"))
+	r.MountGroup(profile1(), forest.WithPrefix("/debug1"))
 	r.Start("127.0.0.1:8000")
 }

forest.go

@@ -8,6 +8,7 @@ import (
 	"reflect"
 	"runtime"
 	"sort"
+	"strings"
 	"sync"
 )
 
@@ -26,6 +27,7 @@ type (
 		methodNotAllowedRoute *Route
 		maxParam              int
 		debug                 bool
+		hostMatch             func(string, string) bool
 		Server                *http.Server
 	}
 	HandlerFunc      func(Context) error
@@ -86,14 +88,32 @@ func debugPrint(msg string, args ...interface{}) {
 	fmt.Fprint(os.Stdout, sprintf(msg, args...))
 }
 
-type Option func(e *Forest)
+type Option func(*Forest)
+
+func (opt Option) Group() GroupOption {
+	return func(g *Group) {
+		opt(g.forest)
+	}
+}
 
 func Debug() Option {
 	return func(e *Forest) {
 		e.debug = true
 	}
 }
 
+func HostMatch(matcher func(string, string) bool) Option {
+	return func(e *Forest) {
+		e.hostMatch = matcher
+	}
+}
+
+func Middlewares(handlers ...HandlerFunc) Option {
+	return func(e *Forest) {
+		e.middlewares = handlers
+	}
+}
+
 func New(opts ...Option) *Forest {
 	e := &Forest{
 		node:   &node{},
@@ -116,6 +136,18 @@ func New(opts ...Option) *Forest {
 	return e
 }
 
+func HostMatcher(host, dst string) bool {
+	c := len(host) - len(dst)
+	if c < 0 {
+		return false
+	}
+	index := strings.IndexRune(dst, '*')
+	if index < 0 {
+		return false
+	}
+	return dst[:index] == host[:index] && dst[index+1:] == host[c+index+1:]
+}
+
 func WrapHandler(h http.Handler) HandlerFunc {
 	return func(c Context) error {
 		h.ServeHTTP(c.Response(), c.Request())
@@ -165,22 +197,32 @@ func (e *Forest) addRoute(host, method, path string) *Route {
 	return route
 }
 
-func (e *Forest) findRoute(host, method, path string, pvalues []string) *Route {
-	root := e.node
-	if host != "" {
-		if h, ok := e.nodes[host]; ok {
-			root = h
+func (e *Forest) findHost(host string) *node {
+	if host != "" && len(e.nodes) > 0 {
+		if node, ok := e.nodes[host]; ok {
+			return node
+		}
+		if e.hostMatch == nil {
+			return e.node
+		}
+		for h, node := range e.nodes {
+			if e.hostMatch(host, h) {
+				return node
+			}
 		}
 	}
-	n := root.find(path, 0, pvalues)
-	if n == nil || n.routes == nil {
-		return e.notFoundRoute
-	}
-	if len(n.routes) == 0 {
+	return e.node
+}
+
+func (e *Forest) findRoute(host, method, path string, params *contextParams) *Route {
+	n := e.findHost(host).find(path, params)
+	if n == nil || n.routes == nil || len(n.routes) == 0 {
 		return e.notFoundRoute
 	}
-	if result := n.routes.find(method); result != nil {
-		return result
+	for _, route := range n.routes {
+		if route.Method() == method {
+			return route
+		}
 	}
 	return e.methodNotAllowedRoute
 }
@@ -237,17 +279,19 @@ func (e *Forest) Use(middlewares ...HandlerFunc) *Forest {
 	return e
 }
 
-func (e *Forest) Mount(prefix string, child *Forest) {
-	e.rootGroup.Mount(prefix, child.rootGroup)
+func (e *Forest) Mount(child *Forest, opts ...GroupOption) {
+	e.rootGroup.Mount(child.rootGroup, opts...)
 }
 
-func (e *Forest) MountGroup(prefix string, child *Group) {
-	e.rootGroup.Mount(prefix, child)
+func (e *Forest) MountGroup(child *Group, opts ...GroupOption) {
+	e.rootGroup.Mount(child, opts...)
 }
 
 func (e *Forest) NewContext(w http.ResponseWriter, r *http.Request) *context {
 	c := &context{
-		pvalues:  make([]string, e.maxParam),
+		params: &contextParams{
+			pvalues: make([]string, e.maxParam),
+		},
 		response: NewResponse(w),
 	}
 	return c
@@ -263,7 +307,7 @@ func (e *Forest) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		path = r.URL.Path
 	}
 	// pass []string is faster than *context than *([]string)
-	c.route = e.findRoute(r.Host, r.Method, path, c.pvalues)
+	c.route = e.findRoute(r.Host, r.Method, path, c.params)
 	c.Next()
 }