util/trie: import some code from chi router

Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>

util/http/trie.go

@@ -1,239 +1,703 @@
 package http
 
+// Radix tree implementation below is a based on the original work by
+// Armon Dadgar in https://github.com/armon/go-radix/blob/master/radix.go
+// (MIT licensed). It's been heavily modified for use as a HTTP routing tree.
+// Copied from chi mux tree.go https://raw.githubusercontent.com/go-chi/chi/master/tree.go
+
 import (
+	"fmt"
+	"net/http"
 	"regexp"
+	"sort"
+	"strconv"
 	"strings"
-	"sync"
 )
 
-// TrieOptions contains search options
+type methodTyp uint
-type TrieOptions struct {
-	IgnoreCase bool
-}
-
-// TrieOption func signature
-type TrieOption func(*TrieOptions)
-
-// IgnoreCase says that search must be case insensitive
-func IgnoreCase(b bool) TrieOption {
-	return func(o *TrieOptions) {
-		o.IgnoreCase = b
-	}
-}
-
-// Tree is a trie tree.
-type Trie struct {
-	node   *node
-	rcache map[string]*regexp.Regexp
-	rmu    sync.RWMutex
-}
-
-// node is a node of tree
-type node struct {
-	actions  map[string]interface{} // key is method, val is handler interface
-	children map[string]*node       // key is label of next nodes
-	label    string
-}
 
 const (
-	pathRoot          string = "/"
+	mSTUB methodTyp = 1 << iota
-	pathDelimiter     string = "/"
+	mCONNECT
-	paramDelimiter    string = ":"
+	mDELETE
-	leftPtnDelimiter  string = "{"
+	mGET
-	rightPtnDelimiter string = "}"
+	mHEAD
-	ptnWildcard       string = "(.+)"
+	mOPTIONS
+	mPATCH
+	mPOST
+	mPUT
+	mTRACE
 )
 
-// NewTree creates a new trie tree.
+var mALL = mCONNECT | mDELETE | mGET | mHEAD |
-func NewTrie() *Trie {
+	mOPTIONS | mPATCH | mPOST | mPUT | mTRACE
-	return &Trie{
+
-		node: &node{
+var methodMap = map[string]methodTyp{
-			label:    pathRoot,
+	http.MethodConnect: mCONNECT,
-			actions:  make(map[string]interface{}),
+	http.MethodDelete:  mDELETE,
-			children: make(map[string]*node),
+	http.MethodGet:     mGET,
-		},
+	http.MethodHead:    mHEAD,
-		rcache: make(map[string]*regexp.Regexp),
+	http.MethodOptions: mOPTIONS,
+	http.MethodPatch:   mPATCH,
+	http.MethodPost:    mPOST,
+	http.MethodPut:     mPUT,
+	http.MethodTrace:   mTRACE,
+}
+
+// RegisterMethod adds support for custom HTTP method handlers, available
+// via Router#Method and Router#MethodFunc
+func RegisterMethod(method string) error {
+	if method == "" {
+		return nil
+	}
+	method = strings.ToUpper(method)
+	if _, ok := methodMap[method]; ok {
+		return nil
+	}
+	n := len(methodMap)
+	if n > strconv.IntSize-2 {
+		return fmt.Errorf("max number of methods reached (%d)", strconv.IntSize)
+	}
+	mt := methodTyp(2 << n)
+	methodMap[method] = mt
+	mALL |= mt
+
+	return nil
+}
+
+type nodeTyp uint8
+
+const (
+	ntStatic   nodeTyp = iota // /home
+	ntRegexp                  // /{id:[0-9]+}
+	ntParam                   // /{user}
+	ntCatchAll                // /api/v1/*
+)
+
+func NewTrie() *Node {
+	return &Node{typ: ntStatic}
+}
+
+type Node struct {
+	// regexp matcher for regexp nodes
+	rex *regexp.Regexp
+
+	// HTTP handler endpoints on the leaf node
+	endpoints endpoints
+
+	// prefix is the common prefix we ignore
+	prefix string
+
+	// child nodes should be stored in-order for iteration,
+	// in groups of the node type.
+	children [ntCatchAll + 1]nodes
+
+	// first byte of the child prefix
+	tail byte
+
+	// node type: static, regexp, param, catchAll
+	typ nodeTyp
+
+	// first byte of the prefix
+	label byte
+}
+
+// endpoints is a mapping of http method constants to handlers
+// for a given route.
+type endpoints map[methodTyp]*endpoint
+
+type endpoint struct {
+	// parameters keys recorded on handler nodes
+	paramKeys []string
+	// endpoint handler
+	handler interface{}
+	// pattern is the routing pattern for handler nodes
+	pattern string
+}
+
+func (s endpoints) Value(method methodTyp) *endpoint {
+	mh, ok := s[method]
+	if !ok {
+		mh = &endpoint{}
+		s[method] = mh
+	}
+
+	return mh
+}
+
+func (n *Node) Insert(methods []string, pattern string, handler interface{}) error {
+	var err error
+	for _, method := range methods {
+		if err = n.insert(methodMap[method], pattern, handler); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (n *Node) insert(method methodTyp, pattern string, handler interface{}) error {
+	var parent *Node
+	search := pattern
+
+	for {
+		// Handle key exhaustion
+		if len(search) == 0 {
+			// Insert or update the node's leaf handler
+			return n.setEndpoint(method, handler, pattern)
+		}
+
+		// We're going to be searching for a wild node next,
+		// in this case, we need to get the tail
+		label := search[0]
+		var segTail byte
+		var segEndIdx int
+		var segTyp nodeTyp
+		var segRexpat string
+		var err error
+		if label == '{' || label == '*' {
+			segTyp, _, segRexpat, segTail, _, segEndIdx, err = patNextSegment(search)
+		}
+		if err != nil {
+			return err
+		}
+
+		var prefix string
+		if segTyp == ntRegexp {
+			prefix = segRexpat
+		}
+
+		// Look for the edge to attach to
+		parent = n
+		n = n.getEdge(segTyp, label, segTail, prefix)
+
+		// No edge, create one
+		if n == nil {
+			child := &Node{typ: ntStatic, label: label, tail: segTail, prefix: search}
+			var hn *Node
+			hn, err = parent.addChild(child, search)
+			if err != nil {
+				return err
+			}
+			return hn.setEndpoint(method, handler, pattern)
+		}
+
+		// Found an edge to match the pattern
+
+		if n.typ > ntStatic {
+			// We found a param node, trim the param from the search path and continue.
+			// This param/wild pattern segment would already be on the tree from a previous
+			// call to addChild when creating a new node.
+			search = search[segEndIdx:]
+			continue
+		}
+
+		// Static nodes fall below here.
+		// Determine longest prefix of the search key on match.
+		commonPrefix := longestPrefix(search, n.prefix)
+		if commonPrefix == len(n.prefix) {
+			// the common prefix is as long as the current node's prefix we're attempting to insert.
+			// keep the search going.
+			search = search[commonPrefix:]
+			continue
+		}
+
+		// Split the node
+		child := &Node{
+			typ:    ntStatic,
+			prefix: search[:commonPrefix],
+		}
+		if err = parent.replaceChild(search[0], segTail, child); err != nil {
+			return err
+		}
+
+		// Restore the existing node
+		n.label = n.prefix[commonPrefix]
+		n.prefix = n.prefix[commonPrefix:]
+		if _, err = child.addChild(n, n.prefix); err != nil {
+			return err
+		}
+
+		// If the new key is a subset, set the method/handler on this node and finish.
+		search = search[commonPrefix:]
+		if len(search) == 0 {
+			return child.setEndpoint(method, handler, pattern)
+		}
+
+		// Create a new edge for the node
+		subchild := &Node{
+			typ:    ntStatic,
+			label:  search[0],
+			prefix: search,
+		}
+		var hn *Node
+		hn, err = child.addChild(subchild, search)
+		if err != nil {
+			return err
+		}
+		return hn.setEndpoint(method, handler, pattern)
 	}
 }
 
-// Insert inserts a route definition to tree.
+// addChild appends the new `child` node to the tree using the `pattern` as the trie key.
-func (t *Trie) Insert(methods []string, path string, handler interface{}) {
+// For a URL router like chi's, we split the static, param, regexp and wildcard segments
-	curNode := t.node
+// into different nodes. In addition, addChild will recursively call itself until every
-	if path == pathRoot {
+// pattern segment is added to the url pattern tree as individual nodes, depending on type.
-		curNode.label = path
+func (n *Node) addChild(child *Node, prefix string) (*Node, error) {
-		for _, method := range methods {
+	search := prefix
-			curNode.actions[method] = handler
+
-		}
+	// handler leaf node added to the tree is the child.
-		return
+	// this may be overridden later down the flow
+	hn := child
+
+	// Parse next segment
+	segTyp, _, segRexpat, segTail, segStartIdx, segEndIdx, err := patNextSegment(search)
+	if err != nil {
+		return nil, err
 	}
-	ep := splitPath(path)
+	// Add child depending on next up segment
-	for i, p := range ep {
+	switch segTyp {
-		nextNode, ok := curNode.children[p]
+
-		if ok {
+	case ntStatic:
-			curNode = nextNode
+		// Search prefix is all static (that is, has no params in path)
-		}
+		// noop
-		// Create a new node.
+
-		if !ok {
+	default:
-			curNode.children[p] = &node{
+		// Search prefix contains a param, regexp or wildcard
-				label:    p,
+
-				actions:  make(map[string]interface{}),
+		if segTyp == ntRegexp {
-				children: make(map[string]*node),
+			rex, err := regexp.Compile(segRexpat)
+			if err != nil {
+				return nil, fmt.Errorf("invalid regexp pattern '%s' in route param", segRexpat)
 			}
-			curNode = curNode.children[p]
+			child.prefix = segRexpat
+			child.rex = rex
 		}
-		// last loop.
+
-		// If there is already registered data, overwrite it.
+		if segStartIdx == 0 {
-		if i == len(ep)-1 {
+			// Route starts with a param
-			curNode.label = p
+			child.typ = segTyp
-			for _, method := range methods {
+
-				curNode.actions[method] = handler
+			if segTyp == ntCatchAll {
+				segStartIdx = -1
+			} else {
+				segStartIdx = segEndIdx
+			}
+			if segStartIdx < 0 {
+				segStartIdx = len(search)
+			}
+			child.tail = segTail // for params, we set the tail
+
+			if segStartIdx != len(search) {
+				// add static edge for the remaining part, split the end.
+				// its not possible to have adjacent param nodes, so its certainly
+				// going to be a static node next.
+
+				search = search[segStartIdx:] // advance search position
+
+				nn := &Node{
+					typ:    ntStatic,
+					label:  search[0],
+					prefix: search,
+				}
+				var err error
+				hn, err = child.addChild(nn, search)
+				if err != nil {
+					return nil, err
+				}
+			}
+
+		} else if segStartIdx > 0 {
+			// Route has some param
+
+			// starts with a static segment
+			child.typ = ntStatic
+			child.prefix = search[:segStartIdx]
+			child.rex = nil
+
+			// add the param edge node
+			search = search[segStartIdx:]
+
+			nn := &Node{
+				typ:   segTyp,
+				label: search[0],
+				tail:  segTail,
+			}
+			var err error
+			hn, err = child.addChild(nn, search)
+			if err != nil {
+				return nil, err
 			}
-			break
 		}
 	}
+
+	n.children[child.typ] = append(n.children[child.typ], child)
+	n.children[child.typ].Sort()
+	return hn, nil
 }
 
-// Search searches a path from a tree.
+func (n *Node) replaceChild(label, tail byte, child *Node) error {
-func (t *Trie) Search(method string, path string, opts ...TrieOption) (interface{}, map[string]string, bool) {
+	for i := 0; i < len(n.children[child.typ]); i++ {
-	params := make(map[string]string)
+		if n.children[child.typ][i].label == label && n.children[child.typ][i].tail == tail {
-
+			n.children[child.typ][i] = child
-	options := TrieOptions{}
+			n.children[child.typ][i].label = label
-	for _, o := range opts {
+			n.children[child.typ][i].tail = tail
-		o(&options)
+			return nil
-	}
-
-	curNode := t.node
-
-nodeLoop:
-	for _, p := range splitPath(path) {
-		nextNode, ok := curNode.children[p]
-		if ok {
-			curNode = nextNode
-			continue nodeLoop
-		}
-		if options.IgnoreCase {
-			// additional loop for case insensitive matching
-			for k, v := range curNode.children {
-				if literalEqual(k, p, true) {
-					curNode = v
-					continue nodeLoop
-				}
-			}
-		}
-		if len(curNode.children) == 0 {
-			if !literalEqual(curNode.label, p, options.IgnoreCase) {
-				// no matching path was found
-				return nil, nil, false
-			}
-			break
-		}
-		isParamMatch := false
-		for c := range curNode.children {
-			if string([]rune(c)[0]) == leftPtnDelimiter {
-				ptn := getPattern(c)
-				t.rmu.RLock()
-				reg, ok := t.rcache[ptn]
-				t.rmu.RUnlock()
-				if !ok {
-					var err error
-					reg, err = regexp.Compile(ptn)
-					if err != nil {
-						return nil, nil, false
-					}
-					t.rmu.Lock()
-					t.rcache[ptn] = reg
-					t.rmu.Unlock()
-				}
-				if reg.Match([]byte(p)) {
-					pn := getParamName(c)
-					params[pn] = p
-					curNode = curNode.children[c]
-					isParamMatch = true
-					break
-				}
-				// no matching param was found.
-				return nil, nil, false
-			}
-		}
-		if !isParamMatch {
-			return nil, nil, false
 		}
 	}
-	if path == pathRoot {
+	return fmt.Errorf("replacing missing child")
-		if len(curNode.actions) == 0 {
+}
-			return nil, nil, false
+
+func (n *Node) getEdge(ntyp nodeTyp, label, tail byte, prefix string) *Node {
+	nds := n.children[ntyp]
+	for i := 0; i < len(nds); i++ {
+		if nds[i].label == label && nds[i].tail == tail {
+			if ntyp == ntRegexp && nds[i].prefix != prefix {
+				continue
+			}
+			return nds[i]
 		}
 	}
+	return nil
+}
 
-	handler, ok := curNode.actions[method]
+func (n *Node) setEndpoint(method methodTyp, handler interface{}, pattern string) error {
-	if !ok || handler == nil {
+	// Set the handler for the method type on the node
+	if n.endpoints == nil {
+		n.endpoints = make(endpoints)
+	}
+
+	paramKeys, err := patParamKeys(pattern)
+	if err != nil {
+		return err
+	}
+	if method&mSTUB == mSTUB {
+		n.endpoints.Value(mSTUB).handler = handler
+	}
+	if method&mALL == mALL {
+		h := n.endpoints.Value(mALL)
+		h.handler = handler
+		h.pattern = pattern
+		h.paramKeys = paramKeys
+		for _, m := range methodMap {
+			h := n.endpoints.Value(m)
+			h.handler = handler
+			h.pattern = pattern
+			h.paramKeys = paramKeys
+		}
+	} else {
+		h := n.endpoints.Value(method)
+		h.handler = handler
+		h.pattern = pattern
+		h.paramKeys = paramKeys
+	}
+
+	return nil
+}
+
+func (n *Node) Search(method string, path string) (interface{}, map[string]string, bool) {
+	params := &routeParams{}
+	// Find the routing handlers for the path
+	rn := n.findRoute(params, methodMap[method], path)
+	if rn == nil {
 		return nil, nil, false
 	}
-	return handler, params, true
+	ep, ok := rn.endpoints[methodMap[method]]
-}
+	if !ok {
-
+		return nil, nil, false
-// getPattern gets a pattern from a label
-// {id:[^\d+$]} -> ^\d+$
-// {id}         -> (.+)
-func getPattern(label string) string {
-	leftI := strings.Index(label, leftPtnDelimiter)
-	rightI := strings.Index(label, paramDelimiter)
-	// if label doesn't have any pattern, return wild card pattern as default.
-	if leftI == -1 || rightI == -1 {
-		return ptnWildcard
 	}
-	return label[rightI+1 : len(label)-1]
+
+	eparams := make(map[string]string, len(params.keys))
+	for idx, key := range params.keys {
+		eparams[key] = params.vals[idx]
+	}
+
+	return ep.handler, eparams, true
 }
 
-// getParamName gets a parameter from a label
+type routeParams struct {
-// {id:[^\d+$]} -> id
+	keys []string
-// {id}         -> id
+	vals []string
-func getParamName(label string) string {
+}
-	leftI := strings.Index(label, leftPtnDelimiter)
-	rightI := func(l string) int {
-		r := []rune(l)
 
-		var n int
+// Recursive edge traversal by checking all nodeTyp groups along the way.
+// It's like searching through a multi-dimensional radix trie.
+func (n *Node) findRoute(params *routeParams, method methodTyp, path string) *Node {
+	nn := n
+	search := path
 
-	loop:
+	for t, nds := range nn.children {
-		for i := 0; i < len(r); i++ {
+		ntyp := nodeTyp(t)
-			n = i
+		if len(nds) == 0 {
-			switch string(r[i]) {
+			continue
-			case paramDelimiter:
+		}
-				n = i
+
-				break loop
+		var xn *Node
-			case rightPtnDelimiter:
+		xsearch := search
-				n = i
+
-				break loop
+		var label byte
+		if search != "" {
+			label = search[0]
+		}
+
+		switch ntyp {
+		case ntStatic:
+			xn = nds.findEdge(label)
+			if xn == nil || !strings.HasPrefix(xsearch, xn.prefix) {
+				continue
+			}
+			xsearch = xsearch[len(xn.prefix):]
+
+		case ntParam, ntRegexp:
+			// short-circuit and return no matching route for empty param values
+			if xsearch == "" {
+				continue
 			}
 
-			if i == len(r)-1 {
+			// serially loop through each node grouped by the tail delimiter
-				n = i + 1
+			for idx := 0; idx < len(nds); idx++ {
-				break loop
+				xn = nds[idx]
+
+				// label for param nodes is the delimiter byte
+				p := strings.IndexByte(xsearch, xn.tail)
+
+				if p < 0 {
+					if xn.tail == '/' {
+						p = len(xsearch)
+					} else {
+						continue
+					}
+				} else if ntyp == ntRegexp && p == 0 {
+					continue
+				}
+
+				if ntyp == ntRegexp && xn.rex != nil {
+					if !xn.rex.MatchString(xsearch[:p]) {
+						continue
+					}
+				} else if strings.IndexByte(xsearch[:p], '/') != -1 {
+					// avoid a match across path segments
+					continue
+				}
+
+				prevlen := len(params.vals)
+				params.vals = append(params.vals, xsearch[:p])
+				xsearch = xsearch[p:]
+
+				if len(xsearch) == 0 {
+					if xn.isLeaf() {
+						h := xn.endpoints[method]
+						if h != nil && h.handler != nil {
+							params.keys = append(params.keys, h.paramKeys...)
+							return xn
+						}
+					}
+				}
+
+				// recursively find the next node on this branch
+				fin := xn.findRoute(params, method, xsearch)
+				if fin != nil {
+					return fin
+				}
+
+				// not found on this branch, reset vars
+				params.vals = params.vals[:prevlen]
+				xsearch = search
+			}
+
+			params.vals = append(params.vals, "")
+
+		default:
+			// catch-all nodes
+			params.vals = append(params.vals, search)
+			xn = nds[0]
+			xsearch = ""
+		}
+
+		if xn == nil {
+			continue
+		}
+
+		// did we find it yet?
+		if len(xsearch) == 0 {
+			if xn.isLeaf() {
+				h := xn.endpoints[method]
+				if h != nil && h.handler != nil {
+					params.keys = append(params.keys, h.paramKeys...)
+					return xn
+				}
 			}
 		}
 
-		return n
+		// recursively find the next node..
-	}(label)
+		fin := xn.findRoute(params, method, xsearch)
+		if fin != nil {
+			return fin
+		}
 
-	return label[leftI+1 : rightI]
+		// Did not find final handler, let's remove the param here if it was set
+		if xn.typ > ntStatic {
+			if len(params.vals) > 0 {
+				params.vals = params.vals[:len(params.vals)-1]
+			}
+		}
+
+	}
+
+	return nil
 }
 
-// splitPath removes an empty value in slice.
+func (n *Node) isLeaf() bool {
-func splitPath(path string) []string {
+	return n.endpoints != nil
-	s := strings.Split(path, pathDelimiter)
+}
-	var r []string
+
-	for _, str := range s {
+// patNextSegment returns the next segment details from a pattern:
-		if str != "" {
+// node type, param key, regexp string, param tail byte, param starting index, param ending index
-			r = append(r, str)
+func patNextSegment(pattern string) (nodeTyp, string, string, byte, int, int, error) {
+	ps := strings.Index(pattern, "{")
+	ws := strings.Index(pattern, "*")
+
+	if ps < 0 && ws < 0 {
+		return ntStatic, "", "", 0, 0, len(pattern), nil // we return the entire thing
+	}
+
+	// Sanity check
+	if ps >= 0 && ws >= 0 && ws < ps {
+		return ntStatic, "", "", 0, 0, 0, fmt.Errorf("wildcard '*' must be the last pattern in a route, otherwise use a '{param}'")
+	}
+
+	var tail byte = '/' // Default endpoint tail to / byte
+
+	if ps < 0 {
+		// Wildcard pattern as finale
+		if ws < len(pattern)-1 {
+			return ntStatic, "", "", 0, 0, 0, fmt.Errorf("wildcard '*' must be the last value in a route. trim trailing text or use a '{param}' instead")
+		}
+
+		return ntCatchAll, "*", "", 0, ws, len(pattern), nil
+	}
+
+	// Param/Regexp pattern is next
+	nt := ntParam
+
+	// Read to closing } taking into account opens and closes in curl count (cc)
+	cc := 0
+	pe := ps
+	for i, c := range pattern[ps:] {
+		if c == '{' {
+			cc++
+		} else if c == '}' {
+			cc--
+			if cc == 0 {
+				pe = ps + i
+				break
+			}
 		}
 	}
-	return r
+
+	if pe == ps {
+		return ntStatic, "", "", 0, 0, 0, fmt.Errorf("route param closing delimiter '}' is missing")
+	}
+
+	key := pattern[ps+1 : pe]
+	pe++ // set end to next position
+
+	if pe < len(pattern) {
+		tail = pattern[pe]
+	}
+
+	var rexpat string
+	if idx := strings.Index(key, ":"); idx >= 0 {
+		nt = ntRegexp
+		rexpat = key[idx+1:]
+		key = key[:idx]
+	}
+
+	if len(rexpat) > 0 {
+		if rexpat[0] != '^' {
+			rexpat = "^" + rexpat
+		}
+		if rexpat[len(rexpat)-1] != '$' {
+			rexpat += "$"
+		}
+	}
+
+	return nt, key, rexpat, tail, ps, pe, nil
 }
 
-func literalEqual(component, literal string, ignoreCase bool) bool {
+func patParamKeys(pattern string) ([]string, error) {
-	if ignoreCase {
+	pat := pattern
-		return strings.EqualFold(component, literal)
+	paramKeys := []string{}
+	for {
+		ptyp, paramKey, _, _, _, e, err := patNextSegment(pat)
+		if err != nil {
+			return nil, err
+		}
+		if ptyp == ntStatic {
+			return paramKeys, nil
+		}
+		for i := 0; i < len(paramKeys); i++ {
+			if paramKeys[i] == paramKey {
+				return nil, fmt.Errorf("routing pattern '%s' contains duplicate param key, '%s'", pattern, paramKey)
+			}
+		}
+		paramKeys = append(paramKeys, paramKey)
+		pat = pat[e:]
 	}
-	return component == literal
+}
+
+// longestPrefix finds the length of the shared prefix
+// of two strings
+func longestPrefix(k1, k2 string) int {
+	max := len(k1)
+	if l := len(k2); l < max {
+		max = l
+	}
+	var i int
+	for i = 0; i < max; i++ {
+		if k1[i] != k2[i] {
+			break
+		}
+	}
+	return i
+}
+
+type nodes []*Node
+
+// Sort the list of nodes by label
+func (ns nodes) Sort()              { sort.Sort(ns); ns.tailSort() }
+func (ns nodes) Len() int           { return len(ns) }
+func (ns nodes) Swap(i, j int)      { ns[i], ns[j] = ns[j], ns[i] }
+func (ns nodes) Less(i, j int) bool { return ns[i].label < ns[j].label }
+
+// tailSort pushes nodes with '/' as the tail to the end of the list for param nodes.
+// The list order determines the traversal order.
+func (ns nodes) tailSort() {
+	for i := len(ns) - 1; i >= 0; i-- {
+		if ns[i].typ > ntStatic && ns[i].tail == '/' {
+			ns.Swap(i, len(ns)-1)
+			return
+		}
+	}
+}
+
+func (ns nodes) findEdge(label byte) *Node {
+	num := len(ns)
+	idx := 0
+	i, j := 0, num-1
+	for i <= j {
+		idx = i + (j-i)/2
+		if label > ns[idx].label {
+			i = idx + 1
+		} else if label < ns[idx].label {
+			j = idx - 1
+		} else {
+			i = num // breaks cond
+		}
+	}
+
+	if ns[idx].label != label {
+		return nil
+	}
+
+	return ns[idx]
 }

util/http/trie_test.go

@@ -5,14 +5,66 @@ import (
 	"testing"
 )
 
+func TestTrieWildcardPathPrefix(t *testing.T) {
+	var err error
+	type handler struct {
+		name string
+	}
+	tr := NewTrie()
+	if err = tr.Insert([]string{http.MethodPost}, "/v1/update", &handler{name: "post_update"}); err != nil {
+		t.Fatal(err)
+	}
+	if err = tr.Insert([]string{http.MethodPost}, "/v1/*", &handler{name: "post_create"}); err != nil {
+		t.Fatal(err)
+	}
+	h, _, ok := tr.Search(http.MethodPost, "/v1/test/one")
+	if !ok {
+		t.Fatalf("unexpected error handler not found")
+	}
+	if h.(*handler).name != "post_create" {
+		t.Fatalf("invalid handler %v", h)
+	}
+	h, _, ok = tr.Search(http.MethodPost, "/v1/update")
+	if !ok {
+		t.Fatalf("unexpected error")
+	}
+	if h.(*handler).name != "post_update" {
+		t.Fatalf("invalid handler %v", h)
+	}
+	h, _, ok = tr.Search(http.MethodPost, "/v1/update/some/{x}")
+	if !ok {
+		t.Fatalf("unexpected error")
+	}
+	if h.(*handler).name != "post_create" {
+		t.Fatalf("invalid handler %v", h)
+	}
+}
+
+func TestTriePathPrefix(t *testing.T) {
+	type handler struct {
+		name string
+	}
+	tr := NewTrie()
+	_ = tr.Insert([]string{http.MethodPost}, "/v1/create/{id}", &handler{name: "post_create"})
+	_ = tr.Insert([]string{http.MethodPost}, "/v1/update/{id}", &handler{name: "post_update"})
+	_ = tr.Insert([]string{http.MethodPost}, "/", &handler{name: "post_wildcard"})
+	h, _, ok := tr.Search(http.MethodPost, "/")
+	if !ok {
+		t.Fatalf("unexpected error")
+	}
+	if h.(*handler).name != "post_wildcard" {
+		t.Fatalf("invalid handler %v", h)
+	}
+}
+
 func TestTrieFixedPattern(t *testing.T) {
 	type handler struct {
 		name string
 	}
 	tr := NewTrie()
-	tr.Insert([]string{http.MethodPut}, "/v1/create/{id}", &handler{name: "pattern"})
+	_ = tr.Insert([]string{http.MethodPut}, "/v1/create/{id}", &handler{name: "pattern"})
-	tr.Insert([]string{http.MethodPut}, "/v1/create/12", &handler{name: "fixed"})
+	_ = tr.Insert([]string{http.MethodPut}, "/v1/create/12", &handler{name: "fixed"})
-	h, _, ok := tr.Search(http.MethodPut, "/v1/create/12", IgnoreCase(false))
+	h, _, ok := tr.Search(http.MethodPut, "/v1/create/12")
 	if !ok {
 		t.Fatalf("unexpected error")
 	}
@@ -21,43 +73,9 @@ func TestTrieFixedPattern(t *testing.T) {
 	}
 }
 
-func TestTrieIgnoreCase(t *testing.T) {
-	type handler struct {
-		name string
-	}
-	tr := NewTrie()
-	tr.Insert([]string{http.MethodPut}, "/v1/create/{id}", &handler{name: "test"})
-
-	_, _, ok := tr.Search(http.MethodPut, "/v1/CREATE/12", IgnoreCase(true))
-	if !ok {
-		t.Fatalf("unexpected error")
-	}
-}
-
-func TestTrieContentType(t *testing.T) {
-	type handler struct {
-		name string
-	}
-	tr := NewTrie()
-	tr.Insert([]string{"application/json"}, "/v1/create/{id}", &handler{name: "test"})
-
-	h, _, ok := tr.Search("application/json", "/v1/create/12")
-	if !ok {
-		t.Fatalf("must be found error")
-	}
-	if h.(*handler).name != "test" {
-		t.Fatalf("invalid handler %v", h)
-	}
-	_, _, ok = tr.Search("text/xml", "/v1/create/12")
-	if ok {
-		t.Fatalf("must be not found error")
-	}
-}
-
 func TestTrieNoMatchMethod(t *testing.T) {
 	tr := NewTrie()
-	tr.Insert([]string{http.MethodPut}, "/v1/create/{id}", nil)
+	_ = tr.Insert([]string{http.MethodPut}, "/v1/create/{id}", nil)
-
 	_, _, ok := tr.Search(http.MethodPost, "/v1/create")
 	if ok {
 		t.Fatalf("must be not found error")
@@ -67,8 +85,7 @@ func TestTrieNoMatchMethod(t *testing.T) {
 func TestTrieMatchRegexp(t *testing.T) {
 	type handler struct{}
 	tr := NewTrie()
-	tr.Insert([]string{http.MethodPut}, "/v1/create/{category}/{id:[0-9]+}", &handler{})
+	_ = tr.Insert([]string{http.MethodPut}, "/v1/create/{category}/{id:[0-9]+}", &handler{})
-
 	_, params, ok := tr.Search(http.MethodPut, "/v1/create/test_cat/12345")
 	switch {
 	case !ok:
@@ -83,8 +100,7 @@ func TestTrieMatchRegexp(t *testing.T) {
 func TestTrieMatchRegexpFail(t *testing.T) {
 	type handler struct{}
 	tr := NewTrie()
-	tr.Insert([]string{http.MethodPut}, "/v1/create/{id:[a-z]+}", &handler{})
+	_ = tr.Insert([]string{http.MethodPut}, "/v1/create/{id:[a-z]+}", &handler{})
-
 	_, _, ok := tr.Search(http.MethodPut, "/v1/create/12345")
 	if ok {
 		t.Fatalf("route must not be not found")
@@ -96,8 +112,8 @@ func TestTrieMatchLongest(t *testing.T) {
 		name string
 	}
 	tr := NewTrie()
-	tr.Insert([]string{http.MethodPut}, "/v1/create", &handler{name: "first"})
+	_ = tr.Insert([]string{http.MethodPut}, "/v1/create", &handler{name: "first"})
-	tr.Insert([]string{http.MethodPut}, "/v1/create/{id:[0-9]+}", &handler{name: "second"})
+	_ = tr.Insert([]string{http.MethodPut}, "/v1/create/{id:[0-9]+}", &handler{name: "second"})
 	if h, _, ok := tr.Search(http.MethodPut, "/v1/create/12345"); !ok {
 		t.Fatalf("route must be found")
 	} else if h.(*handler).name != "second" {