Change normalize behavior

guoyao · guoyao · commit 790ebc19783b · 2020-01-31T11:56:51.000+08:00
diff --git a/README.md b/README.md
@@ -32,9 +32,8 @@ import pathToRegexp "github.com/soongo/path-to-regexp"
 // pathToRegexp.Match(path, options) // options can be nil
 // pathToRegexp.MustMatch(path, options) // like Match but panics if the error is non-nil
 // pathToRegexp.Must(regexp, err) // wraps a call to a function returning (*regexp2.Regexp, error) and panics if the error is non-nil
-// pathToRegexp.EncodeURI(str) // encodes characters in URI, like javascript's encodeURI
-// pathToRegexp.EncodeURIComponent(str) // encodes characters in URI except `;/?:@&=+$,#`, like javascript's encodeURIComponent
-// pathToRegexp.NormalizePathname(str) // return a normalized string
+// pathToRegexp.EncodeURI(str) // encodes characters in URI except `;/?:@&=+$,#`, like javascript's encodeURI
+// pathToRegexp.EncodeURIComponent(str) // encodes characters in URI, like javascript's encodeURIComponent
 ```
 
 - **path** A string, array or slice of strings, or a regular expression with type *github.com/dlclark/regexp2.Regexp.
@@ -236,10 +235,13 @@ The `NormalizePathname` function will return a normalized string for matching wi
 
 ```js
 re := pathToRegexp.Must(pathToRegexp.PathToRegexp("/caf\u00E9", nil, nil))
-input := pathToRegexp.EncodeURI("/cafe\u0301");
+input := pathToRegexp.EncodeURI("/caf\u00E9");
+re.MatchString(input) //=> false, nil
 re.MatchString(pathToRegexp.NormalizePathname(input)); //=> true, nil
 ```
 
+**Note:** It may be preferable to implement something in your own library that normalizes the pathname for matching. E.g. [`URL`](https://developer.mozilla.org/en-US/docs/Web/API/URL) automatically URI encodes paths for you, which would result in a consistent match.
+
 ### Parse
 
 The `Parse` function will return a list of strings and tokens from a path string:
diff --git a/path_to_regexp.go b/path_to_regexp.go
@@ -93,8 +93,73 @@ const defaultDelimiter = "/"
 var escapeRegexp = regexp2.MustCompile("([.+*?=^!:${}()[\\]|/\\\\])", regexp2.None)
 var tokenRegexp = regexp2.MustCompile("\\((?!\\?)", regexp2.None)
 
-func normalize(str string) string {
-	t := transform.Chain(norm.NFC, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
+// EncodeURIComponent encodes a text string as a valid component of a Uniform
+// Resource Identifier (URI).
+func EncodeURIComponent(str string) string {
+	r := url.QueryEscape(str)
+	r = strings.Replace(r, "+", "%20", -1)
+	return r
+}
+
+// Gets the unencoded version of an encoded component of a Uniform Resource
+// Identifier (URI).
+func DecodeURIComponent(str string) string {
+	r, err := url.QueryUnescape(str)
+	if err != nil {
+		panic(err)
+	}
+	return r
+}
+
+// Encodes a text string as a valid Uniform Resource Identifier (URI)
+func encodeURI(str string) string {
+	excludes := ";/?:@&=+$,#"
+	arr := strings.Split(str, "")
+	result := ""
+	for _, v := range arr {
+		if strings.Contains(excludes, v) {
+			result += v
+		} else {
+			result += EncodeURIComponent(v)
+		}
+	}
+	return result
+}
+
+// Gets the unencoded version of an encoded Uniform Resource Identifier (URI).
+func decodeURI(str string) string {
+	magicWords := "1@X#y!Z" // not a good idea
+	excludes := []string{"%3B", "%2F", "%3F", "%3A", "%40", "%26", "%3D", "%2B", "%24", "%2C", "%23"}
+	r := regexp2.MustCompile(strings.Join(excludes, "|"), regexp2.None)
+
+	str, _ = r.ReplaceFunc(str, func(m regexp2.Match) string {
+		return strings.Replace(m.String(), "%", magicWords, -1)
+	}, -1, -1)
+
+	str = decodeURIComponent(str, nil)
+
+	for i, v := range excludes {
+		excludes[i] = magicWords + strings.TrimPrefix(v, "%")
+	}
+	r = regexp2.MustCompile(strings.Join(excludes, "|"), regexp2.None)
+
+	str, _ = r.ReplaceFunc(str, func(m regexp2.Match) string {
+		return strings.Replace(m.String(), magicWords, "%", -1)
+	}, -1, -1)
+
+	return str
+}
+
+// Returns the String value result of normalizing the string into the normalization form
+// named by form as specified in Unicode Standard Annex #15, Unicode Normalization Forms.
+// param form Applicable values: "NFC", "NFD", "NFKC", or "NFKD", If not specified default
+// is "NFC"
+func normalize(str string, form ...norm.Form) string {
+	f := norm.NFC
+	if len(form) > 0 {
+		f = form[0]
+	}
+	t := transform.Chain(f, runes.Remove(runes.In(unicode.Mn)), f)
 	normStr, _, _ := transform.String(t, str)
 	return normStr
 }
@@ -103,13 +168,13 @@ func normalize(str string) string {
 // with a single slash and normalizes unicode characters to "NFC". When using this method,
 // `decode` should be an identity function so you don't decode strings twice.
 func NormalizePathname(pathname string) string {
+	pathname = decodeURI(pathname)
 	r := regexp2.MustCompile("\\/+", regexp2.None)
-	str, err := r.Replace(DecodeURIComponent(pathname, nil),
-		"/", -1, -1)
+	pathname, err := r.Replace(pathname, "/", -1, -1)
 	if err != nil {
 		panic(err)
 	}
-	return normalize(str)
+	return pathname
 }
 
 // Balanced bracket helper function.
@@ -146,7 +211,7 @@ func Parse(str string, o *Options) []interface{} {
 	if o == nil {
 		o = &Options{}
 	}
-	defaultDelimiter := orString(o.Delimiter, defaultDelimiter)
+	defaultDelimiter := anyString(o.Delimiter, defaultDelimiter)
 	whitelist := o.Whitelist
 
 	// use list to deal with unicode in str
@@ -240,7 +305,7 @@ func Parse(str string, o *Options) []interface{} {
 
 		repeat := index < length && (arr[index] == "+" || arr[index] == "*")
 		optional := index < length && (arr[index] == "?" || arr[index] == "*")
-		delimiter := orString(prefix, defaultDelimiter)
+		delimiter := anyString(prefix, defaultDelimiter)
 
 		// Increment `i` past modifier token.
 		if repeat || optional {
@@ -366,7 +431,7 @@ func tokensToFunction(tokens []interface{}, o *Options) (
 		o = &Options{}
 	}
 	reFlags := flags(o)
-	encode, validate := EncodeURIComponent, true
+	encode, validate := encodeURIComponent, true
 	if o.Encode != nil {
 		encode = o.Encode
 	}
@@ -484,14 +549,8 @@ func tokensToFunction(tokens []interface{}, o *Options) (
 	}, nil
 }
 
-func min(x, y int) int {
-	if x < y {
-		return x
-	}
-	return y
-}
-
-func orString(str ...string) string {
+// Returns the first non empty string
+func anyString(str ...string) string {
 	for _, v := range str {
 		if v != "" {
 			return v
@@ -500,26 +559,7 @@ func orString(str ...string) string {
 	return ""
 }
 
-func indexOf(in interface{}, elem interface{}) int {
-	inValue := reflect.ValueOf(in)
-	elemValue := reflect.ValueOf(elem)
-	inType := inValue.Type()
-
-	if inType.Kind() == reflect.String {
-		return strings.Index(inValue.String(), elemValue.String())
-	}
-
-	if inType.Kind() == reflect.Slice {
-		for i := 0; i < inValue.Len(); i++ {
-			if reflect.DeepEqual(inValue.Index(i).Interface(), elem) {
-				return i
-			}
-		}
-	}
-
-	return -1
-}
-
+// Returns the index of str in string slice
 func stringIndexOf(arr []string, str string) int {
 	for i, v := range arr {
 		if v == str {
@@ -529,6 +569,7 @@ func stringIndexOf(arr []string, str string) int {
 	return -1
 }
 
+// Transform data which is reflect.Slice, reflect.Array to slice
 func toSlice(data interface{}) []interface{} {
 	v := reflect.ValueOf(data)
 	length := v.Len()
@@ -539,6 +580,7 @@ func toSlice(data interface{}) []interface{} {
 	return arr
 }
 
+// Transform data which is reflect.Map to map
 func toMap(data interface{}) map[interface{}]interface{} {
 	v, m := reflect.ValueOf(data), make(map[interface{}]interface{})
 	for _, k := range v.MapKeys() {
@@ -548,32 +590,12 @@ func toMap(data interface{}) map[interface{}]interface{} {
 	return m
 }
 
-func EncodeURI(str string) string {
-	excludes := ";/?:@&=+$,#"
-	arr := strings.Split(str, "")
-	result := ""
-	for _, v := range arr {
-		if strings.Contains(excludes, v) {
-			result += v
-		} else {
-			result += EncodeURIComponent(v, nil)
-		}
-	}
-	return result
-}
-
-func EncodeURIComponent(str string, token interface{}) string {
-	r := url.QueryEscape(str)
-	r = strings.Replace(r, "+", "%20", -1)
-	return r
+func encodeURIComponent(str string, token interface{}) string {
+	return EncodeURIComponent(str)
 }
 
-func DecodeURIComponent(str string, token interface{}) string {
-	r, err := url.QueryUnescape(str)
-	if err != nil {
-		panic(err)
-	}
-	return r
+func decodeURIComponent(str string, token interface{}) string {
+	return DecodeURIComponent(str)
 }
 
 // Escape a regular expression string.
@@ -687,7 +709,7 @@ func tokensToRegExp(rawTokens []interface{}, tokens *[]Token, o *Options) (*rege
 		}
 	}
 
-	delimiter := orString(o.Delimiter, defaultDelimiter)
+	delimiter := anyString(o.Delimiter, defaultDelimiter)
 	arr := make([]string, len(ends)+1)
 	for i, v := range ends {
 		v = escapeString(v)
diff --git a/path_to_regexp_test.go b/path_to_regexp_test.go
@@ -211,7 +211,7 @@ var tests = []a{
 				"/caf%C3%A9",
 				a{"/caf%C3%A9", "caf%C3%A9"},
 				&MatchResult{Path: "/caf%C3%A9", Index: 0, Params: m{"test": "café"}},
-				&Options{Decode: DecodeURIComponent},
+				&Options{Decode: decodeURIComponent},
 			},
 		},
 		a{
@@ -3166,19 +3166,35 @@ func TestPathToRegexp(t *testing.T) {
 	t.Run("normalize pathname", func(t *testing.T) {
 		t.Run("should match normalized pathnames", func(t *testing.T) {
 			re := Must(PathToRegexp("/caf\u00E9", nil, nil))
-			input := EncodeURI("/cafe\u0301")
+			input := encodeURI("/cafe\u0301")
 
 			result := exec(re, input)
 			if result != nil {
 				t.Errorf("got %v want %v", result, nil)
 			}
 
 			want := []string{"/caf\u00E9"}
-			result = exec(re, NormalizePathname(input))
+			result = exec(re, normalize(NormalizePathname(input)))
 			if !reflect.DeepEqual(result, want) {
 				t.Errorf("got %v want %v", result, want)
 			}
 		})
+
+		t.Run("should not normalize encoded slash", func(t *testing.T) {
+			input, want := "/test/route%2F", "/test/route%2F"
+			result := NormalizePathname(input)
+			if result != want {
+				t.Errorf("got %s want %s", result, want)
+			}
+		})
+
+		t.Run("should fix repeated slashes", func(t *testing.T) {
+			input, want := encodeURI("/test///route"), "/test/route"
+			result := NormalizePathname(input)
+			if result != want {
+				t.Errorf("got %s want %s", result, want)
+			}
+		})
 	})
 
 	t.Run("path should be string, or strings, or a regular expression", func(t *testing.T) {
