Encode using identity function by default, and remove

Author: guoyao

README.md

@@ -53,8 +53,8 @@ import pathToRegexp "github.com/soongo/path-to-regexp"
   - **Delimiter** The default delimiter for segments. (default: `'/'`)
   - **EndsWith** Optional character, or list of characters, to treat as "end" characters.
   - **Whitelist** List of characters to consider delimiters when parsing. (default: `nil`, any character)
-  - **Encode** How to encode uri. (default: `pathToRegexp.EncodeURIComponent`)
-  - **Decode** How to decode uri. (default: `pathToRegexp.DecodeURIComponent`)
+  - **Encode** How to encode uri. (default: `func (uri string, token interface{}) string { return uri }`)
+  - **Decode** How to decode uri. (default: `func (uri string, token interface{}) string { return uri }`)
 
 ```go
 var tokens []pathToRegexp.Token
@@ -221,27 +221,19 @@ fmt.Println(match)
 The `match` function will return a function for transforming paths into parameters:
 
 ```go
-match := pathToRegexp.MustMatch("/user/:id")
+match := pathToRegexp.MustMatch("/user/:id", &pathToRegexp.Options{Decode: func(str string, token interface{}) string {
+    return pathToRegexp.DecodeURIComponent(str)
+}})
 
-fmt.Printf("%#v\n", match("/user/123"))
+match("/user/123")
 //=> &pathtoregexp.MatchResult{Path:"/user/123", Index:0, Params:map[interface {}]interface {}{"id":"123"}}
 
 match("/invalid") //=> nil
-```
-
-### Normalize Pathname
 
-The `NormalizePathname` function will return a normalized string for matching with `PathToRegexp`.
-
-```js
-re := pathToRegexp.Must(pathToRegexp.PathToRegexp("/caf\u00E9", nil, nil))
-input := pathToRegexp.EncodeURI("/caf\u00E9");
-re.MatchString(input) //=> false, nil
-re.MatchString(pathToRegexp.NormalizePathname(input)); //=> true, nil
+match("/user/caf%C3%A9")
+//=> &pathtoregexp.MatchResult{Path:"/user/caf%C3%A9", Index:0, Params:map[interface {}]interface {}{"id":"café"}}
 ```
 
-**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:
@@ -266,32 +258,35 @@ fmt.Printf("%#v\n", tokens[2])
 The `Compile` function will return a function for transforming parameters into a valid path:
 
 ```go
-falseValue := false
-toPath := pathToRegexp.MustCompile("/user/:id", nil)
+toPath := pathToRegexp.MustCompile("/user/:id", &pathToRegexp.Options{Encode: func(str string, token interface{}) string {
+    return pathToRegexp.EncodeURIComponent(str)
+}})
+
+toPath(map[string]int{"id": 123}) //=> "/user/123"
+toPath(map[string]string{"id": "café"}) //=> "/user/caf%C3%A9"
+toPath(map[string]string{"id": "/"}) //=> "/user/%2F"
 
-toPath(map[string]int{"id": 123}, nil) //=> "/user/123"
-toPath(map[string]string{"id": "café"}, nil) //=> "/user/caf%C3%A9"
-toPath(map[string]string{"id": "/"}, nil) //=> "/user/%2F"
+toPath(map[string]string{"id": ":/"}) //=> "/user/%3A%2F"
 
-toPath(map[string]string{"id": ":/"}, nil) //=> "/user/%3A%2F"
-toPath(map[string]string{"id": ":/"}, &Options{
-    Encode: func(value string, token interface{}) string {
-        return value
-    },
-    Validate: &falseValue,
-}) //=> "/user/:/"
+// Without `encode`, you need to make sure inputs are encoded correctly.
+falseValue := false
+toPathRaw := pathToRegexp.MustCompile("/user/:id", &pathToRegexp.Options{Validate: &falseValue})
+toPathRaw(map[string]string{"id": "%3A%2F"}); //=> "/user/%3A%2F"
+toPathRaw(map[string]string{"id": ":/"}); //=> "/user/:/"
 
 toPathRepeated := pathToRegexp.MustCompile("/:segment+", nil)
 
-toPathRepeated(map[string]string{"segment": "foo"}, nil) //=> "/foo"
-toPathRepeated(map[string][]string{"segment": {"a", "b", "c"}}, nil) //=> "/a/b/c"
+toPathRepeated(map[string]string{"segment": "foo"}) //=> "/foo"
+toPathRepeated(map[string][]string{"segment": {"a", "b", "c"}}) //=> "/a/b/c"
+
+toPathRegexp := pathToRegexp.MustCompile("/user/:id(\\d+)", &pathToRegexp.Options{Validate: &falseValue})
 
-toPathRegexp := pathToRegexp.MustCompile("/user/:id(\\d+)", nil)
+toPathRegexp(map[string]int{"id": 123}) //=> "/user/123"
+toPathRegexp(map[string]string{"id": "123"}) //=> "/user/123"
+toPathRegexp(map[string]string{"id": "abc"}) //=> "/user/abc"
 
-toPathRegexp(map[string]int{"id": 123}, nil) //=> "/user/123"
-toPathRegexp(map[string]string{"id": "123"}, nil) //=> "/user/123"
-toPathRegexp(map[string]string{"id": "abc"}, nil) //=> panic
-toPathRegexp(map[string]string{"id": "abc"}, &Options{Validate: &falseValue}) //=> "/user/abc"
+toPathRegexp = pathToRegexp.MustCompile("/user/:id(\\d+)", nil)
+toPathRegexp(map[string]string{"id": "abc"}) //=> panic
 ```
 
 **Note:** The generated function will panic on invalid input. It will do all necessary checks to ensure the generated path is valid. This method only works with strings.

go.mod

@@ -2,7 +2,4 @@ module github.com/soongo/path-to-regexp
 
 go 1.13
 
-require (
-	github.com/dlclark/regexp2 v1.2.0
-	golang.org/x/text v0.3.2
-)
+require github.com/dlclark/regexp2 v1.2.0

go.sum

@@ -1,5 +1,2 @@
 github.com/dlclark/regexp2 v1.2.0 h1:8sAhBGEM0dRWogWqWyQeIJnxjWO6oIjl8FKqREDsGfk=
 github.com/dlclark/regexp2 v1.2.0/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc=
-golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
-golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

path_to_regexp.go

@@ -11,14 +11,9 @@ import (
 	"reflect"
 	"strconv"
 	"strings"
-	"unicode"
 	"unsafe"
 
-	"golang.org/x/text/runes"
-
 	"github.com/dlclark/regexp2"
-	"golang.org/x/text/transform"
-	"golang.org/x/text/unicode/norm"
 )
 
 // Token is parsed from path. For example, using `/user/:id`, `tokens` will
@@ -93,6 +88,10 @@ const defaultDelimiter = "/"
 var escapeRegexp = regexp2.MustCompile("([.+*?=^!:${}()[\\]|/\\\\])", regexp2.None)
 var tokenRegexp = regexp2.MustCompile("\\((?!\\?)", regexp2.None)
 
+func identity(uri string, token interface{}) string {
+	return uri
+}
+
 // EncodeURIComponent encodes a text string as a valid component of a Uniform
 // Resource Identifier (URI).
 func EncodeURIComponent(str string) string {
@@ -150,33 +149,6 @@ func decodeURI(str string) string {
 	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
-}
-
-// NormalizePathname normalizes a pathname for matching, replaces multiple slashes
-// 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)
-	pathname, err := r.Replace(pathname, "/", -1, -1)
-	if err != nil {
-		panic(err)
-	}
-	return pathname
-}
-
 // Balanced bracket helper function.
 func balanced(open string, close string, str string, index int) int {
 	count, i, arr := 0, index, strings.Split(str, "")
@@ -431,7 +403,7 @@ func tokensToFunction(tokens []interface{}, o *Options) (
 		o = &Options{}
 	}
 	reFlags := flags(o)
-	encode, validate := encodeURIComponent, true
+	encode, validate := identity, true
 	if o.Encode != nil {
 		encode = o.Encode
 	}
@@ -690,13 +662,16 @@ func tokensToRegExp(rawTokens []interface{}, tokens *[]Token, o *Options) (*rege
 		o = &Options{}
 	}
 
-	strict, start, end, route := o.Strict, true, true, ""
+	strict, start, end, route, encode := o.Strict, true, true, "", identity
 	if o.Start != nil {
 		start = *o.Start
 	}
 	if o.End != nil {
 		end = *o.End
 	}
+	if o.Encode != nil {
+		encode = o.Encode
+	}
 
 	var ends []string
 	if o.EndsWith != nil {
@@ -731,7 +706,7 @@ func tokensToRegExp(rawTokens []interface{}, tokens *[]Token, o *Options) (*rege
 	// Iterate over the tokens and create our regexp string.
 	for _, token := range rawTokens {
 		if str, ok := token.(string); ok {
-			route += escapeString(str)
+			route += escapeString(encode(str, nil))
 		} else if token, ok := token.(Token); ok {
 			capture := token.Pattern
 			if token.Repeat {

path_to_regexp_test.go

@@ -217,15 +217,7 @@ var tests = []a{
 		a{
 			a{m{}, nil},
 			a{m{"test": "abc"}, "/abc"},
-			a{
-				m{"test": "a+b"},
-				"/a+b",
-				&Options{
-					Encode: func(uri string, token interface{}) string {
-						return uri
-					},
-				},
-			},
+			a{m{"test": "a+b"}, "/a+b"},
 			a{
 				m{"test": "a+b"},
 				"/test",
@@ -238,7 +230,7 @@ var tests = []a{
 					},
 				},
 			},
-			a{m{"test": "a+b"}, "/a%2Bb"},
+			a{m{"test": "a+b"}, "/a%2Bb", &Options{Encode: encodeURIComponent}},
 		},
 	},
 	{
@@ -346,15 +338,7 @@ var tests = []a{
 		a{
 			a{m{}, nil},
 			a{m{"test": "abc"}, "/abc"},
-			a{
-				m{"test": "a+b"},
-				"/a+b",
-				&Options{
-					Encode: func(uri string, token interface{}) string {
-						return uri
-					},
-				},
-			},
+			a{m{"test": "a+b"}, "/a+b"},
 			a{
 				m{"test": "a+b"},
 				"/test",
@@ -367,7 +351,7 @@ var tests = []a{
 					},
 				},
 			},
-			a{m{"test": "a+b"}, "/a%2Bb"},
+			a{m{"test": "a+b"}, "/a%2Bb", &Options{Encode: encodeURIComponent}},
 		},
 	},
 	{
@@ -690,8 +674,16 @@ var tests = []a{
 		},
 		a{
 			a{m{"test": "route"}, "/route"},
-			a{m{"test": "something/else"}, "/something%2Felse"},
-			a{m{"test": "something/else/more"}, "/something%2Felse%2Fmore"},
+			a{
+				m{"test": "something/else"},
+				"/something%2Felse",
+				&Options{Encode: encodeURIComponent},
+			},
+			a{
+				m{"test": "something/else/more"},
+				"/something%2Felse%2Fmore",
+				&Options{Encode: encodeURIComponent},
+			},
 		},
 	},
 	{
@@ -1175,8 +1167,8 @@ var tests = []a{
 		a{
 			a{m{"test": ""}, "/"},
 			a{m{"test": "abc"}, "/abc"},
-			a{m{"test": "abc/123"}, "/abc%2F123"},
-			a{m{"test": "abc/123/456"}, "/abc%2F123%2F456"},
+			a{m{"test": "abc/123"}, "/abc%2F123", &Options{Encode: encodeURIComponent}},
+			a{m{"test": "abc/123/456"}, "/abc%2F123%2F456", &Options{Encode: encodeURIComponent}},
 		},
 	},
 	{
@@ -2240,7 +2232,7 @@ var tests = []a{
 		},
 		a{
 			a{m{"foo": "foo"}, "/foobaz"},
-			a{m{"foo": "foo/bar"}, "/foo%2Fbarbaz"},
+			a{m{"foo": "foo/bar"}, "/foo%2Fbarbaz", &Options{Encode: encodeURIComponent}},
 			a{m{"foo": a{"foo", "bar"}}, "/foo/barbaz"},
 		},
 	},
@@ -2420,7 +2412,8 @@ var tests = []a{
 			a{"/café", a{"/café", "café"}},
 		},
 		a{
-			a{m{"foo": "café"}, "/caf%C3%A9"},
+			a{m{"foo": "café"}, "/café"},
+			a{m{"foo": "café"}, "/caf%C3%A9", &Options{Encode: encodeURIComponent}},
 		},
 	},
 	{
@@ -2436,6 +2429,21 @@ var tests = []a{
 			a{nil, "/café"},
 		},
 	},
+	{
+		"/café",
+		&Options{Encode: func(uri string, token interface{}) string {
+			return encodeURI(uri)
+		}},
+		a{
+			"/café",
+		},
+		a{
+			a{"/caf%C3%A9", a{"/caf%C3%A9"}},
+		},
+		a{
+			a{nil, "/café"},
+		},
+	},
 	{
 		"packages/",
 		nil,
@@ -3163,40 +3171,6 @@ 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")
-
-			result := exec(re, input)
-			if result != nil {
-				t.Errorf("got %v want %v", result, nil)
-			}
-
-			want := []string{"/caf\u00E9"}
-			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) {
 		_, err := PathToRegexp(123, nil, nil)
 		if err == nil {