important hotfix: golang's strings.ToLower is not backward compatible

Author: Sergio Andres Virviescas Santana

.travis.yml

@@ -4,6 +4,7 @@ go:
   - 1.9.x
   - 1.10.x
   - 1.11.x
+  - 1.12.x
   - tip
 
 os:

tolower.go

@@ -0,0 +1,9 @@
+//+build !go1.12
+
+package router
+
+import "strings"
+
+func toLower(s string) string {
+	return strings.ToLower(s)
+}

tolower_go112.go

@@ -0,0 +1,105 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the "third_party_licenses/Go (golang)" file.
+
+//+build go1.12
+
+package router
+
+import (
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
+
+// toLower returns a copy of the string s with all Unicode letters mapped to their lower case.
+func toLower(s string) string {
+	isASCII, hasUpper := true, false
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		if c >= utf8.RuneSelf {
+			isASCII = false
+			break
+		}
+		hasUpper = hasUpper || (c >= 'A' && c <= 'Z')
+	}
+
+	if isASCII { // optimize for ASCII-only strings.
+		if !hasUpper {
+			return s
+		}
+		var b strings.Builder
+		b.Grow(len(s))
+		for i := 0; i < len(s); i++ {
+			c := s[i]
+			if c >= 'A' && c <= 'Z' {
+				c += 'a' - 'A'
+			}
+			b.WriteByte(c)
+		}
+		return b.String()
+	}
+	return stringsMap(unicode.ToLower, s)
+}
+
+// Map returns a copy of the string s with all its characters modified
+// according to the mapping function. If mapping returns a negative value, the character is
+// dropped from the string with no replacement.
+func stringsMap(mapping func(rune) rune, s string) string {
+	// In the worst case, the string can grow when mapped, making
+	// things unpleasant. But it's so rare we barge in assuming it's
+	// fine. It could also shrink but that falls out naturally.
+
+	// The output buffer b is initialized on demand, the first
+	// time a character differs.
+	var b strings.Builder
+
+	for i, c := range s {
+		r := mapping(c)
+		if r == c {
+			continue
+		}
+
+		b.Grow(len(s) + utf8.UTFMax)
+		b.WriteString(s[:i])
+		if r >= 0 {
+			b.WriteRune(r)
+		}
+
+		if c == utf8.RuneError {
+			// RuneError is the result of either decoding
+			// an invalid sequence or '\uFFFD'. Determine
+			// the correct number of bytes we need to advance.
+			_, w := utf8.DecodeRuneInString(s[i:])
+			i += w
+		} else {
+			i += utf8.RuneLen(c)
+		}
+
+		s = s[i:]
+		break
+	}
+
+	// Fast path for unchanged input
+	if b.Cap() == 0 { // didn't call b.Grow above
+		return s
+	}
+
+	for _, c := range s {
+		r := mapping(c)
+
+		if r >= 0 {
+			// common case
+			// Due to inlining, it is more performant to determine if WriteByte should be
+			// invoked rather than always call WriteRune
+			if r < utf8.RuneSelf {
+				b.WriteByte(byte(r))
+			} else {
+				// r is not a ASCII rune.
+				b.WriteRune(r)
+			}
+		}
+	}
+
+	return b.String()
+}

tree.go

@@ -471,7 +471,7 @@ func (n *node) findCaseInsensitivePath(path string, fixTrailingSlash bool) ([]by
 
 	fixedPath, found := n.findCaseInsensitivePathRec(
 		path,
-		strings.ToLower(path),
+		toLower(path),
 		buff.b[:0],
 		[4]byte{}, // empty rune buffer
 		fixTrailingSlash,
@@ -500,7 +500,7 @@ func shiftNRuneBytes(rb [4]byte, n int) [4]byte {
 
 // recursive case-insensitive lookup function used by n.findCaseInsensitivePath
 func (n *node) findCaseInsensitivePathRec(path, loPath string, ciPath []byte, rb [4]byte, fixTrailingSlash bool) ([]byte, bool) {
-	loNPath := strings.ToLower(n.path)
+	loNPath := toLower(n.path)
 
 walk: // outer loop for walking the tree
 	for len(loPath) >= len(loNPath) && (len(loNPath) == 0 || loPath[1:len(loNPath)] == loNPath[1:]) {
@@ -524,7 +524,7 @@ walk: // outer loop for walking the tree
 						if n.indices[i] == rb[0] {
 							// continue with child node
 							n = n.children[i]
-							loNPath = strings.ToLower(n.path)
+							loNPath = toLower(n.path)
 							continue walk
 						}
 					}
@@ -574,7 +574,7 @@ walk: // outer loop for walking the tree
 							if n.indices[i] == rb[0] {
 								// continue with child node
 								n = n.children[i]
-								loNPath = strings.ToLower(n.path)
+								loNPath = toLower(n.path)
 								continue walk
 							}
 						}
@@ -603,7 +603,7 @@ walk: // outer loop for walking the tree
 					if len(n.children) > 0 {
 						// continue with child node
 						n = n.children[0]
-						loNPath = strings.ToLower(n.path)
+						loNPath = toLower(n.path)
 						loPath = loPath[k:]
 						path = path[k:]
 						continue