github.com/angenalZZZ/gofunc@v0.0.0-20210507121333-48ff1be3917b/http/fast/router.go

// 🚀 Fast is an Express inspired web framework written in Go.

package fast

import (
	"log"
	"regexp"
	"strings"
	"time"

	"github.com/valyala/fasthttp"
)

// Route struct
type Route struct {
	isGet bool // allows HEAD requests if GET

	isMiddleware bool // is middleware route

	isStar  bool // path == '*'
	isSlash bool // path == '/'
	isRegex bool // needs regex parsing

	Method string         // http method
	Path   string         // original path
	Params []string       // path params
	Regexp *regexp.Regexp // regexp matcher

	Handler func(*Ctx) // ctx handler
}

func (app *Fast) nextRoute(ctx *Ctx) {
	// Keep track of head matches
	l := len(app.routes) - 1
	for ctx.index < l {
		ctx.index++
		route := app.routes[ctx.index]
		match, values := route.matchRoute(ctx.method, ctx.path)
		if match {
			ctx.route = route
			ctx.values = values
			route.Handler(ctx)
			return
		}
	}
	if len(ctx.C.Response.Body()) == 0 {
		ctx.SendStatus(404)
	}
}

func (r *Route) matchRoute(method, path string) (match bool, values []string) {
	// is route middleware? matches all http methods
	if r.isMiddleware {
		// '*' or '/' means its a valid match
		if r.isStar || r.isSlash {
			return true, values
		}
		// if midware path starts with req.path
		if strings.HasPrefix(path, r.Path) {
			return true, values
		}
		// middlewares dont support regex so bye!
		return false, values
	}
	// non-middleware route, http method must match!
	// the wildcard method is for .All() & .Use() methods
	// If route is GET, also match HEAD requests
	if r.Method == method || r.Method[0] == '*' || (r.isGet && len(method) == 4 && method == "HEAD") {
		// '*' means we match anything
		if r.isStar {
			return true, values
		}
		// simple '/' bool, so you avoid unnecessary comparison for long paths
		if r.isSlash && path == "/" {
			return true, values
		}
		// does this route need regex matching?
		// does req.path match regex pattern?
		if r.isRegex && r.Regexp.MatchString(path) {
			// do we have parameters
			if len(r.Params) > 0 {
				// get values for parameters
				matches := r.Regexp.FindAllStringSubmatch(path, -1)
				// did we get the values?
				if len(matches) > 0 && len(matches[0]) > 1 {
					values = matches[0][1:len(matches[0])]
					return true, values
				}
				return false, values
			}
			return true, values
		}
		// last thing to do is to check for a simple path match
		if len(r.Path) == len(path) && r.Path == path {
			return true, values
		}
	}
	// Nothing match
	return false, values
}

func (app *Fast) handler(fctx *fasthttp.RequestCtx) {
	// get fiber context from sync pool
	ctx := acquireCtx(fctx)
	defer releaseCtx(ctx)
	// attach app pointer and compress settings
	ctx.app = app

	// Case sensitive routing
	if !app.Settings.CaseSensitive {
		ctx.path = strings.ToLower(ctx.path)
	}
	// Strict routing
	if !app.Settings.StrictRouting && len(ctx.path) > 1 {
		ctx.path = strings.TrimRight(ctx.path, "/")
	}
	// Find route
	app.nextRoute(ctx)
}

func (app *Fast) registerMethod(method, path string, handlers ...func(*Ctx)) {
	// Route requires atleast one handler
	if len(handlers) == 0 {
		log.Fatalf("Missing handler in route")
	}
	// Cannot have an empty path
	if path == "" {
		path = "/"
	}
	// Path always start with a '/' or '*'
	if path[0] != '/' && path[0] != '*' {
		path = "/" + path
	}
	// Store original path to strip case sensitive params
	original := path
	// Case sensitive routing, all to lowercase
	if !app.Settings.CaseSensitive {
		path = strings.ToLower(path)
	}
	// Strict routing, remove last `/`
	if !app.Settings.StrictRouting && len(path) > 1 {
		path = strings.TrimRight(path, "/")
	}
	// SetHeader route booleans
	var isGet = method == "GET"
	var isMiddleware = method == "USE"
	// Middleware / All allows all HTTP methods
	if isMiddleware || method == "ALL" {
		method = "*"
	}
	var isStar = path == "*" || path == "/*"
	// Middleware containing only a `/` equals wildcard
	if isMiddleware && path == "/" {
		isStar = true
	}
	var isSlash = path == "/"
	var isRegex = false
	// Route properties
	var Params = getParams(original)
	var Regexp *regexp.Regexp
	// Params requires regex pattern
	if len(Params) > 0 {
		regex, err := getRegex(path)
		if err != nil {
			log.Fatal("Router: Invalid path pattern: " + path)
		}
		isRegex = true
		Regexp = regex
	}
	for i := range handlers {
		app.routes = append(app.routes, &Route{
			isGet:        isGet,
			isMiddleware: isMiddleware,
			isStar:       isStar,
			isSlash:      isSlash,
			isRegex:      isRegex,
			Method:       method,
			Path:         path,
			Params:       Params,
			Regexp:       Regexp,
			Handler:      handlers[i],
		})
	}
}

func (app *Fast) registerStatic(prefix, root string, config ...Static) {
	// Cannot have an empty prefix
	if prefix == "" {
		prefix = "/"
	}
	// Prefix always start with a '/' or '*'
	if prefix[0] != '/' && prefix[0] != '*' {
		prefix = "/" + prefix
	}
	// Match anything
	var wildcard = false
	if prefix == "*" || prefix == "/*" {
		wildcard = true
		prefix = "/"
	}
	// Case sensitive routing, all to lowercase
	if !app.Settings.CaseSensitive {
		prefix = strings.ToLower(prefix)
	}
	// For security we want to restrict to the current work directory.
	if len(root) == 0 {
		root = "."
	}
	// Strip trailing slashes from the root path
	if len(root) > 0 && root[len(root)-1] == '/' {
		root = root[:len(root)-1]
	}
	// isSlash ?
	var isSlash = prefix == "/"
	if strings.Contains(prefix, "*") {
		wildcard = true
		prefix = strings.Split(prefix, "*")[0]
	}
	var stripper = len(prefix)
	if isSlash {
		stripper = 0
	}
	// File server settings
	fs := &fasthttp.FS{
		Root:                 root,
		GenerateIndexPages:   false,
		AcceptByteRange:      false,
		Compress:             false,
		CompressedFileSuffix: ".gz",
		CacheDuration:        10 * time.Second,
		IndexNames:           []string{"index.html"},
		PathRewrite:          fasthttp.NewPathPrefixStripper(stripper),
		PathNotFound: func(ctx *fasthttp.RequestCtx) {
			ctx.Response.SetStatusCode(404)
			ctx.Response.SetBodyString("Not Found")
		},
	}
	// SetHeader config if provided
	if len(config) > 0 {
		fs.Compress = config[0].Compress
		fs.AcceptByteRange = config[0].ByteRange
		fs.GenerateIndexPages = config[0].Browse
		if config[0].Index != "" {
			fs.IndexNames = []string{config[0].Index}
		}
	}
	fileHandler := fs.NewRequestHandler()
	app.routes = append(app.routes, &Route{
		isMiddleware: true,
		isSlash:      isSlash,
		Method:       "*",
		Path:         prefix,
		Handler: func(c *Ctx) {
			// Only handle GET & HEAD methods
			if c.method == "GET" || c.method == "HEAD" {
				// Do stuff
				if wildcard {
					c.C.Request.SetRequestURI(prefix)
				}
				// Serve file
				fileHandler(c.C)
				// End response when file is found
				if c.C.Response.StatusCode() != 404 {
					return
				}
			}
			c.Next()
		},
	})
}