capstan/routergroup.go

package capstan

import (
	"net/http"
	pth "path"

	"git.destrealm.org/go/capstan/render"
	"github.com/go-chi/chi"
)

type RouterGroup struct {
	name       string
	basePath   string
	parent     *Router
	mux        chi.Router
	middleware chi.Middlewares
	headers    http.Header
	options    *RouterOptions
	renderer   render.Renderer
	bindFuncs  []func(*Router)
	router     *Router
}

func NewRouterGroup(path string, parent *Router) *RouterGroup {
	rg := &RouterGroup{
		headers:   http.Header{},
		parent:    parent,
		bindFuncs: make([]func(*Router), 0),
	}

	if path == "" {
		path = "/"
	}

	router := NewEmptyRouter()
	router.app = parent.app
	router.dependencies = rg.parent.dependencies
	router.urls = rg.parent.urls
	router.mux = chi.NewRouter()
	router.group = rg
	router.routes = rg.parent.routes
	router.name = rg.name
	router.renderer = rg.parent.renderer
	router.afterResponse = make([]func(Context, error) error,
		len(rg.parent.afterResponse))
	router.beforeResponse = make([]func(Context, *Route) error,
		len(rg.parent.beforeResponse))
	router.reserved = rg.parent.reserved

	copy(router.afterResponse, parent.afterResponse)
	copy(router.beforeResponse, parent.beforeResponse)
	rg.router = router
	rg.basePath = pth.Join(parent.basePath, path)

	return rg
}

func (rg *RouterGroup) Add(fn func(*Router)) {
	rg.bindFuncs = append(rg.bindFuncs, fn)

	// Before and after response funcs are always copied from the parent.

	if len(rg.middleware) > 0 {
		rg.mux.Use(rg.middleware...)
	}

	fn(rg.router)

	rg.parent.mux.Mount(rg.basePath, rg.router.mux)
}

func (rg *RouterGroup) Header() http.Header {
	return rg.headers
}

func (rg *RouterGroup) Middleware(middleware chi.Middlewares) {
	rg.middleware = middleware
}

func (rg *RouterGroup) Name(name string) *RouterGroup {
	rg.name = name
	return rg
}

func (rg *RouterGroup) Options() *RouterOptions {
	rg.options = &RouterOptions{}
	return rg.options
}

func (rg *RouterGroup) Rebase(path string) {
	rg.basePath = pth.Join(rg.parent.basePath, path)
}

func (rg *RouterGroup) Rebind() chi.Router {
	return nil
}

func (rg *RouterGroup) RebindSelf() {
	rg.mux = chi.NewRouter()
	rg.mux.Use(rg.middleware...)
	for _, fn := range rg.bindFuncs {
		fn(rg.router)
	}

	rg.parent.mux.Mount(rg.basePath, rg.router.mux)
}

func (rg *RouterGroup) ReplacePath(from, to string) {

}

func (rg *RouterGroup) WithRenderer(renderer render.Renderer) *RouterGroup {
	rg.renderer = renderer
	return rg
}