[pull] master from fasthttp:master

.github/workflows/test.yml

@@ -0,0 +1,31 @@
+name: Test
+on: [push, pull_request]
+jobs:
+  test:
+    strategy:
+      matrix:
+        go-version: [1.21.x, 1.22.x, 1.23.x]
+        os: [ubuntu-latest, macos-latest, windows-latest, macos-14]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version: ${{ matrix.go-version }}
+      - run: go version
+      - run: go test -v -cover -shuffle=on ./...
+      - run: go test -v -cover -shuffle=on -race ./...
+
+      - name: Send coverage
+        uses: shogo82148/actions-goveralls@v1
+        with:
+          flag-name: Go-${{ matrix.os }}-${{ matrix.go-version }}
+          parallel: true
+
+  finish:
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: shogo82148/actions-goveralls@v1
+        with:
+          parallel-finished: true

.gitignore

@@ -1,10 +1,19 @@
-.vscode/
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
 
-*.swp
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+.coverprofile
 
-coverage.out
-examples/basic/basic
-examples/hosts/hosts
-examples/auth/auth
+# Dependency directories (remove the comment below to include it)
+vendor/
 
-**/vendor/
+# IDE
+.vscode/

README.md

@@ -1,6 +1,6 @@
 # Router
 
-[![Build Status](https://travis-ci.org/fasthttp/router.svg?branch=master)](https://travis-ci.org/fasthttp/router)
+[![Test status](https://github.com/fasthttp/router/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/fasthttp/router/actions?workflow=test)
 [![Coverage Status](https://coveralls.io/repos/fasthttp/router/badge.svg?branch=master&service=github)](https://coveralls.io/github/fasthttp/router?branch=master)
 [![Go Report Card](https://goreportcard.com/badge/github.com/fasthttp/router)](https://goreportcard.com/report/github.com/fasthttp/router)
 [![GoDev](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white)](https://pkg.go.dev/github.com/fasthttp/router)
@@ -132,7 +132,7 @@ If you need define an optional parameters, add `?` at the end of param name. `{n
 
 If you need define a validation, you could use a custom regex for the paramater value, add `:<regex>` after the name. For example: `{name:[a-zA-Z]{5}}`.
 
-**_Optional paramters and regex validation are compatibles, only add `?` between the name and the regex. For example: `{name?:[a-zA-Z]{5}}`._**
+**_Optional parameters and regex validation are compatibles, only add `?` between the name and the regex. For example: `{name?:[a-zA-Z]{5}}`._**
 
 ### Catch-All parameters
 
@@ -168,7 +168,8 @@ Priority   Path             Handle
 
 Every `*<num>` represents the memory address of a handler function (a pointer). If you follow a path trough the tree from the root to the leaf, you get the complete route path, e.g `\blog\{post}\`, where `{post}` is just a placeholder ([_parameter_](#named-parameters)) for an actual post name. Unlike hash-maps, a tree structure also allows us to use dynamic parts like the `{post}` parameter, since we actually match against the routing patterns instead of just comparing hashes. [As benchmarks show][benchmark], this works very well and efficient.
 
-Since URL paths have a hierarchical structure and make use only of a limited set of characters (byte values), it is very likely that there are a lot of common prefixes. This allows us to easily reduce the routing into ever smaller problems.
+Since URL paths have a hierarchical structure and make use only of a limited set of characters (byte values), it is very likely that there are a lot of common prefixes. This allows us to easily reduce the routing into ever smaller problems. Moreover the router manages a separate tree for every request method. For one thing it is more space efficient than holding a method->handle map in every single node, for another thing is also allows us to greatly reduce the routing problem before even starting the look-up in the prefix-tree.
+
 
 For even better scalability, the child nodes on each tree level are ordered by priority, where the priority is just the number of handles registered in sub nodes (children, grandchildren, and so on..). This helps in two ways:
 
@@ -199,8 +200,8 @@ This package just provides a very efficient request router with a few extra feat
 
 Have a look at these middleware examples:
 
-- [Auth Middleware](examples/auth)
-- [Multi Hosts Middleware](examples/hosts)
+- [Auth Middleware](_examples/auth)
+- [Multi Hosts Middleware](_examples/hosts)
 
 ## Chaining with the NotFound handler
 

go.mod

@@ -1,9 +1,16 @@
 module github.com/fasthttp/router
 
-go 1.11
+go 1.21
+
+toolchain go1.23.4
 
 require (
-	github.com/savsgio/gotils v0.0.0-20200413113635-8c468ce75cca
+	github.com/savsgio/gotils v0.0.0-20240704082632-aef3928b8a38
 	github.com/valyala/bytebufferpool v1.0.0
-	github.com/valyala/fasthttp v1.12.0
+	github.com/valyala/fasthttp v1.58.0
+)
+
+require (
+	github.com/andybalholm/brotli v1.1.1 // indirect
+	github.com/klauspost/compress v1.17.11 // indirect
 )

go.sum

@@ -1,14 +1,12 @@
-github.com/klauspost/compress v1.10.4 h1:jFzIFaf586tquEB5EhzQG0HwGNSlgAJpG53G6Ss11wc=
-github.com/klauspost/compress v1.10.4/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
-github.com/savsgio/gotils v0.0.0-20200413113635-8c468ce75cca h1:Qe7Mtuhjkk38HVpRtvWdziZJcwG3Qup1mfyvyOrcnyM=
-github.com/savsgio/gotils v0.0.0-20200413113635-8c468ce75cca/go.mod h1:TWNAOTaVzGOXq8RbEvHnhzA/A2sLZzgn0m6URjnukY8=
+github.com/andybalholm/brotli v1.1.1 h1:PR2pgnyFznKEugtsUo0xLdDop5SKXd5Qf5ysW+7XdTA=
+github.com/andybalholm/brotli v1.1.1/go.mod h1:05ib4cKhjx3OQYUY22hTVd34Bc8upXjOLL2rKwwZBoA=
+github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=
+github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=
+github.com/savsgio/gotils v0.0.0-20240704082632-aef3928b8a38 h1:D0vL7YNisV2yqE55+q0lFuGse6U8lxlg7fYTctlT5Gc=
+github.com/savsgio/gotils v0.0.0-20240704082632-aef3928b8a38/go.mod h1:sM7Mt7uEoCeFSCBM+qBrqvEo+/9vdmj19wzp3yzUhmg=
 github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
-github.com/valyala/fasthttp v1.12.0 h1:TsB9qkSeiMXB40ELWWSRMjlsE+8IkqXHcs01y2d9aw0=
-github.com/valyala/fasthttp v1.12.0/go.mod h1:229t1eWu9UXTPmoUkbpN/fctKPBY4IJoFXQnxHGXy6E=
-github.com/valyala/tcplisten v0.0.0-20161114210144-ceec8f93295a/go.mod h1:v3UYOV9WzVtRmSR+PDvWpU/qWl4Wa5LApYYX4ZtKbio=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+github.com/valyala/fasthttp v1.58.0 h1:GGB2dWxSbEprU9j0iMJHgdKYJVDyjrOwF9RE59PbRuE=
+github.com/valyala/fasthttp v1.58.0/go.mod h1:SYXvHHaFp7QZHGKSHmoMipInhrI5StHrhDTYVEjK/Kw=
+github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU=
+github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E=

group.go

@@ -0,0 +1,151 @@
+package router
+
+import (
+	"io/fs"
+
+	"github.com/valyala/fasthttp"
+)
+
+// Group returns a new group.
+// Path auto-correction, including trailing slashes, is enabled by default.
+func (g *Group) Group(path string) *Group {
+	validatePath(path)
+
+	if len(g.prefix) > 0 && path == "/" {
+		return g
+	}
+
+	return g.router.Group(g.prefix + path)
+}
+
+// GET is a shortcut for group.Handle(fasthttp.MethodGet, path, handler)
+func (g *Group) GET(path string, handler fasthttp.RequestHandler) {
+	validatePath(path)
+
+	g.router.GET(g.prefix+path, handler)
+}
+
+// HEAD is a shortcut for group.Handle(fasthttp.MethodHead, path, handler)
+func (g *Group) HEAD(path string, handler fasthttp.RequestHandler) {
+	validatePath(path)
+
+	g.router.HEAD(g.prefix+path, handler)
+}
+
+// POST is a shortcut for group.Handle(fasthttp.MethodPost, path, handler)
+func (g *Group) POST(path string, handler fasthttp.RequestHandler) {
+	validatePath(path)
+
+	g.router.POST(g.prefix+path, handler)
+}
+
+// PUT is a shortcut for group.Handle(fasthttp.MethodPut, path, handler)
+func (g *Group) PUT(path string, handler fasthttp.RequestHandler) {
+	validatePath(path)
+
+	g.router.PUT(g.prefix+path, handler)
+}
+
+// PATCH is a shortcut for group.Handle(fasthttp.MethodPatch, path, handler)
+func (g *Group) PATCH(path string, handler fasthttp.RequestHandler) {
+	validatePath(path)
+
+	g.router.PATCH(g.prefix+path, handler)
+}
+
+// DELETE is a shortcut for group.Handle(fasthttp.MethodDelete, path, handler)
+func (g *Group) DELETE(path string, handler fasthttp.RequestHandler) {
+	validatePath(path)
+
+	g.router.DELETE(g.prefix+path, handler)
+}
+
+// OPTIONS is a shortcut for group.Handle(fasthttp.MethodOptions, path, handler)
+func (g *Group) CONNECT(path string, handler fasthttp.RequestHandler) {
+	validatePath(path)
+
+	g.router.CONNECT(g.prefix+path, handler)
+}
+
+// OPTIONS is a shortcut for group.Handle(fasthttp.MethodOptions, path, handler)
+func (g *Group) OPTIONS(path string, handler fasthttp.RequestHandler) {
+	validatePath(path)
+
+	g.router.OPTIONS(g.prefix+path, handler)
+}
+
+// OPTIONS is a shortcut for group.Handle(fasthttp.MethodOptions, path, handler)
+func (g *Group) TRACE(path string, handler fasthttp.RequestHandler) {
+	validatePath(path)
+
+	g.router.TRACE(g.prefix+path, handler)
+}
+
+// ANY is a shortcut for group.Handle(router.MethodWild, path, handler)
+//
+// WARNING: Use only for routes where the request method is not important
+func (g *Group) ANY(path string, handler fasthttp.RequestHandler) {
+	validatePath(path)
+
+	g.router.ANY(g.prefix+path, handler)
+}
+
+// ServeFiles serves files from the given file system root path.
+// The path must end with "/{filepath:*}", files are then served from the local
+// path /defined/root/dir/{filepath:*}.
+// For example if root is "/etc" and {filepath:*} is "passwd", the local file
+// "/etc/passwd" would be served.
+// Internally a fasthttp.FSHandler is used, therefore http.NotFound is used instead
+// Use:
+//
+//	router.ServeFiles("/src/{filepath:*}", "./")
+func (g *Group) ServeFiles(path string, rootPath string) {
+	validatePath(path)
+
+	g.router.ServeFiles(g.prefix+path, rootPath)
+}
+
+// ServeFS serves files from the given file system.
+// The path must end with "/{filepath:*}", files are then served from the local
+// path /defined/root/dir/{filepath:*}.
+// For example if root is "/etc" and {filepath:*} is "passwd", the local file
+// "/etc/passwd" would be served.
+// Internally a fasthttp.FSHandler is used, therefore http.NotFound is used instead
+// Use:
+//
+//	router.ServeFS("/src/{filepath:*}", myFilesystem)
+func (g *Group) ServeFS(path string, filesystem fs.FS) {
+	validatePath(path)
+
+	g.router.ServeFS(g.prefix+path, filesystem)
+}
+
+// ServeFilesCustom serves files from the given file system settings.
+// The path must end with "/{filepath:*}", files are then served from the local
+// path /defined/root/dir/{filepath:*}.
+// For example if root is "/etc" and {filepath:*} is "passwd", the local file
+// "/etc/passwd" would be served.
+// Internally a fasthttp.FSHandler is used, therefore http.NotFound is used instead
+// of the Router's NotFound handler.
+// Use:
+//
+//	router.ServeFilesCustom("/src/{filepath:*}", *customFS)
+func (g *Group) ServeFilesCustom(path string, fs *fasthttp.FS) {
+	validatePath(path)
+
+	g.router.ServeFilesCustom(g.prefix+path, fs)
+}
+
+// Handle registers a new request handler with the given path and method.
+//
+// For GET, POST, PUT, PATCH and DELETE requests the respective shortcut
+// functions can be used.
+//
+// This function is intended for bulk loading and to allow the usage of less
+// frequently used, non-standardized or custom methods (e.g. for internal
+// communication with a proxy).
+func (g *Group) Handle(method, path string, handler fasthttp.RequestHandler) {
+	validatePath(path)
+
+	g.router.Handle(method, g.prefix+path, handler)
+}