- Kind
- Pure package
- Name
- v0
- Namespace
- nt / mux
- Exported functions
- n/a — not supported for pure packages by the node (vm/qfuncs)
- Module
- gno.land/p/nt/mux/v0
- gno
- 0.9
router.gnogno
1package mux23import (4 "net/url"5 "strings"6)78
not supported for pure packages by the node (vm/qfuncs)
Signatures reconstructed verbatim from vm/qfuncs — interface params keep their inline definitions.
// Router handles the routing and rendering logic.
9type Router struct {
10 routes []Handler
11 NotFoundHandler NotFoundHandler
12}
13
14// NewRouter creates a new Router instance.
15func NewRouter() *Router {
16 return &Router{
17 routes: make([]Handler, 0),
18 NotFoundHandler: defaultNotFoundHandler,
19 }
20}
21
22// Render renders the output for the given path using the registered route handler.
23func (r *Router) Render(reqPath string) string {
24 clearPath, rawQuery, _ := strings.Cut(reqPath, "?")
25 query, _ := url.ParseQuery(rawQuery)
26 reqParts := strings.Split(clearPath, "/")
27
28 for _, route := range r.routes {
29 patParts := strings.Split(route.Pattern, "/")
30 wildcard := false
31 for _, part := range patParts {
32 if part == "*" {
33 wildcard = true
34 break
35 }
36 }
37 if !wildcard && len(patParts) != len(reqParts) {
38 continue
39 }
40
41 match := true
42 for i := 0; i < len(patParts); i++ {
43 patPart := patParts[i]
44 reqPart := reqParts[i]
45
46 if patPart == "*" {
47 break
48 }
49 if strings.HasPrefix(patPart, "{") && strings.HasSuffix(patPart, "}") {
50 continue
51 }
52 if patPart != reqPart {
53 match = false
54 break
55 }
56 }
57 if match {
58 req := &Request{
59 Path: clearPath,
60 RawPath: reqPath,
61 HandlerPath: route.Pattern,
62 Query: query,
63 }
64 res := &ResponseWriter{}
65 if route.Fn == nil {
66 panic("Router.Render: route " + route.Pattern + " was registered via HandleFuncRlm; use RenderRlm to dispatch")
67 }
68 route.Fn(res, req)
69 return res.Output()
70 }
71 }
72
73 // not found
74 req := &Request{Path: reqPath, Query: query}
75 res := &ResponseWriter{}
76 r.NotFoundHandler(res, req)
77 return res.Output()
78}
79
80// RenderRlm is the rlm-aware counterpart of Render. Dispatches matched
81// routes registered via HandleFuncRlm with the supplied rlm; routes
82// registered via the legacy HandleFunc still work — rlm is ignored.
83// Use this when the router carries any rlm-aware handlers.
84func (r *Router) RenderRlm(_ int, rlm realm, reqPath string) string {
85 clearPath, rawQuery, _ := strings.Cut(reqPath, "?")
86 query, _ := url.ParseQuery(rawQuery)
87 reqParts := strings.Split(clearPath, "/")
88
89 for _, route := range r.routes {
90 patParts := strings.Split(route.Pattern, "/")
91 wildcard := false
92 for _, part := range patParts {
93 if part == "*" {
94 wildcard = true
95 break
96 }
97 }
98 if !wildcard && len(patParts) != len(reqParts) {
99 continue
100 }
101
102 match := true
103 for i := 0; i < len(patParts); i++ {
104 patPart := patParts[i]
105 reqPart := reqParts[i]
106
107 if patPart == "*" {
108 break
109 }
110 if strings.HasPrefix(patPart, "{") && strings.HasSuffix(patPart, "}") {
111 continue
112 }
113 if patPart != reqPart {
114 match = false
115 break
116 }
117 }
118 if match {
119 req := &Request{
120 Path: clearPath,
121 RawPath: reqPath,
122 HandlerPath: route.Pattern,
123 Query: query,
124 }
125 res := &ResponseWriter{}
126 if route.FnRlm != nil {
127 route.FnRlm(0, rlm, res, req)
128 } else {
129 route.Fn(res, req)
130 }
131 return res.Output()
132 }
133 }
134
135 // not found
136 req := &Request{Path: reqPath, Query: query}
137 res := &ResponseWriter{}
138 r.NotFoundHandler(res, req)
139 return res.Output()
140}
141
142// HandleFunc registers a route and its handler function.
143func (r *Router) HandleFunc(pattern string, fn HandlerFunc) {
144 route := Handler{Pattern: pattern, Fn: fn}
145 r.routes = append(r.routes, route)
146}
147
148// HandleFuncRlm registers a route with a rlm-aware handler. Dispatch
149// must use Router.RenderRlm — calling Router.Render on a route registered
150// via HandleFuncRlm panics (no rlm to supply).
151func (r *Router) HandleFuncRlm(pattern string, fn HandlerFuncRlm) {
152 route := Handler{Pattern: pattern, FnRlm: fn}
153 r.routes = append(r.routes, route)
154}
155
156// HandleErrFunc registers a route and its error handler function.
157func (r *Router) HandleErrFunc(pattern string, fn ErrHandlerFunc) {
158 // Convert ErrHandlerFunc to regular HandlerFunc
159 handler := func(res *ResponseWriter, req *Request) {
160 if err := fn(res, req); err != nil {
161 res.Write("Error: " + err.Error())
162 }
163 }
164
165 r.HandleFunc(pattern, handler)
166}
167
168// SetNotFoundHandler sets custom message for 404 defaultNotFoundHandler.
169func (r *Router) SetNotFoundHandler(handler NotFoundHandler) {
170 r.NotFoundHandler = handler
171}
172