Add support for + and * parameter suffixes

* Updated readme to reflect changes
* Added edge case handling for trailing slashes in non-strict mode when the path passed in already ends in a slash
* Tests

Author: blakeembrey

Readme.md

@@ -36,19 +36,21 @@ The path has the ability to define parameters and automatically populate the key
 Named parameters are defined by prefixing a colon to the parameter name (`:foo`). By default, this parameter will match up to the next path segment.
 
 ```js
-var re = pathToRegexp('/:foo/:bar');
+var re = pathToRegexp('/:foo/:bar', keys);
 // keys = ['foo', 'bar']
 
 re.exec('/test/route');
 //=> ['/test/route', 'test', 'route']
 ```
 
-#### Optional Parameters
+#### Parameter Suffixes
 
-Optional parameters can be denoted by suffixing a question mark. This will also make any prefixed path segment optional (`/` or `.`).
+##### Optional
+
+Parameters can be suffixed with a question mark (`?`) to make the entire parameter optional. This will also make any prefixed path delimiter optional (`/` or `.`).
 
 ```js
-var re = pathToRegexp('/:foo/:bar?');
+var re = pathToRegexp('/:foo/:bar?', keys);
 // keys = ['foo', 'bar']
 
 re.exec('/test');
@@ -58,12 +60,43 @@ re.exec('/test/route');
 //=> ['/test', 'test', 'route']
 ```
 
+##### Zero or more
+
+Parameters can be suffixed with an asterisk (`*`) to denote a zero or more parameter match. The prefixed path delimiter is also taken into account for the match.
+
+```js
+var re = pathToRegexp('/:foo*', keys);
+// keys = ['foo']
+
+re.exec('/');
+//=> ['/', undefined]
+
+re.exec('/bar/baz');
+//=> ['/bar/baz', 'bar/baz']
+```
+
+##### One or more
+
+Parameters can be suffixed with a plus sign (`+`) to denote a one or more parameters match. The prefixed path delimiter is included in the match.
+
+```js
+var re = pathToRegexp('/:foo+', keys);
+// keys = ['foo']
+
+re.exec('/');
+//=> null
+
+re.exec('/bar/baz');
+//=> ['/bar/baz', 'bar/baz']
+```
+
 #### Custom Matches
 
 All parameters can be provided a custom matching regexp and override the default. Please note: Backslashes need to be escaped in strings.
 
 ```js
-var re = pathToRegexp('/:foo(\\d+)');
+var re = pathToRegexp('/:foo(\\d+)', keys);
+// keys = ['foo']
 
 re.exec('/123');
 //=> ['/123', '123']

index.js

@@ -13,7 +13,7 @@ var PATH_REGEXP = new RegExp([
   //
   // "/:test(\\d+)?" => ["/", "test", "\d+", undefined, "?"]
   // "/route(\\d+)" => [undefined, undefined, undefined, "\d+", undefined]
-  '([\\/.])?(?:\\:(\\w+)(?:\\((.+)\\))?|\\((.+)\\))([?])?',
+  '([\\/.])?(?:\\:(\\w+)(?:\\((.+)\\))?|\\((.+)\\))([+*?])?',
   // Match regexp special characters that should always be escaped.
   '([.+*?=^!:${}()[\\]|\\/])'
 ].join('|'), 'g');
@@ -24,8 +24,8 @@ var PATH_REGEXP = new RegExp([
  * @param  {String} group
  * @return {String}
  */
-function wrapGroup (group) {
-  return '(' + group.replace(/([=!:$\/()])/g, '\\$1') + ')';
+function escapeGroup (group) {
+  return group.replace(/([=!:$\/()])/g, '\\$1');
 }
 
 /**
@@ -72,7 +72,7 @@ function pathtoRegexp (path, keys, options) {
   }
 
   // Alter the path string into a usable regexp.
-  path = path.replace(PATH_REGEXP, function (match, escaped, prefix, key, capture, group, optional, escape) {
+  path = path.replace(PATH_REGEXP, function (match, escaped, prefix, key, capture, group, suffix, escape) {
     // Avoiding re-escaping escaped characters.
     if (escaped) {
       return escaped;
@@ -88,33 +88,44 @@ function pathtoRegexp (path, keys, options) {
     // Special behaviour for format params.
     var format = prefix === '.' ? '\\.' : '';
 
-    // Escape the prefix and ensure both optional matches are empty strings.
+    // Escape the prefix character.
     prefix = prefix ? '\\' + prefix : '';
-    optional = optional || '';
 
     // Match using the custom capturing group, or fallback to capturing
     // everything up to the next slash (or next period if the param was
     // prefixed with a period).
-    var regexp = wrapGroup(capture || group || '[^\\/' + format + ']+?');
+    capture = escapeGroup(capture || group || '[^\\/' + format + ']+?');
 
-    if (optional) {
-      return '(?:' + prefix + regexp + ')' + optional;
+    // More complex regexp is required for suffix support.
+    if (suffix) {
+      if (suffix === '+') {
+        return prefix + '(' + capture + '(?:' + prefix + capture + ')*)'
+      }
+
+      if (suffix === '*') {
+        return '(?:' + prefix + '(' + capture + '(?:' + prefix + capture + ')*|' + capture + '))?';
+      }
+
+      return '(?:' + prefix + '(' + capture + '))?';
     }
 
-    return prefix + regexp;
+    // Basic parameter support.
+    return prefix + '(' + capture + ')';
   });
 
-  // If we are doing a non-ending match, we need to prompt the matching groups
-  // to match as much as possible. To do this, we add a positive lookahead for
-  // the next path fragment or the end. However, if the regexp already ends
-  // in a path fragment, we'll run into problems.
-  if (!end && path[path.length - 1] !== '/') {
-    path += '(?=\\/|$)';
-  }
+  if (path[path.length - 1] !== '/') {
+    // If we are doing a non-ending match, we need to prompt the matching groups
+    // to match as much as possible. To do this, we add a positive lookahead for
+    // the next path fragment or the end. However, if the regexp already ends
+    // in a path fragment, we'll run into problems.
+    if (!end) {
+      path += '(?=\\/|$)';
+    }
 
-  // Allow trailing slashes to be matched in non-strict, ending mode.
-  if (end && !strict) {
-    path += '\\/?';
+    // Allow trailing slashes to be matched in non-strict, ending mode.
+    if (end && !strict) {
+      path += '\\/?';
+    }
   }
 
   return new RegExp('^' + path + (end ? '$' : ''), flags);

test.js

@@ -25,10 +25,13 @@ var exec = function (re, str) {
  */
 var TESTS = [
   // Simple paths.
+  ['/', [], '/', ['/']],
   ['/test', [], '/test', ['/test']],
   ['/test', [], '/route', null],
   ['/test', [], '/test/route', null],
   ['/test', [], '/test/', ['/test/']],
+  ['/test/', [], '/test/', ['/test/']],
+  ['/test/', [], '/test//', null],
 
   // Case-sensitive paths.
   ['/test', [], '/test', ['/test'], { sensitive: true }],
@@ -84,8 +87,29 @@ var TESTS = [
   ['/:test?', ['test'], '/route', ['/route', 'route'], { strict: true }],
   ['/:test?', ['test'], '/', null, { strict: true }], // Questionable behaviour.
   ['/:test?/', ['test'], '/', ['/', undefined], { strict: true }],
+  ['/:test?/', ['test'], '//', null],
   ['/:test?/', ['test'], '//', null, { strict: true }],
 
+  // Repeated once or more times parameters.
+  ['/:test+', ['test'], '/', null],
+  ['/:test+', ['test'], '/route', ['/route', 'route']],
+  ['/:test+', ['test'], '/some/basic/route', ['/some/basic/route', 'some/basic/route']],
+  ['/:test(\\d+)+', ['test'], '/abc/456/789', null],
+  ['/:test(\\d+)+', ['test'], '/123/456/789', ['/123/456/789', '123/456/789']],
+  ['/route.:ext(json|xml)+', ['ext'], '/route.json', ['/route.json', 'json']],
+  ['/route.:ext(json|xml)+', ['ext'], '/route.xml.json', ['/route.xml.json', 'xml.json']],
+  ['/route.:ext(json|xml)+', ['ext'], '/route.html', null],
+
+  // Repeated zero or more times parameters.
+  ['/:test*', ['test'], '/', ['/', undefined]],
+  ['/:test*', ['test'], '//', null],
+  ['/:test*', ['test'], '/route', ['/route', 'route']],
+  ['/:test*', ['test'], '/some/basic/route', ['/some/basic/route', 'some/basic/route']],
+  ['/route.:ext([a-z]+)*', ['ext'], '/route', ['/route', undefined]],
+  ['/route.:ext([a-z]+)*', ['ext'], '/route.json', ['/route.json', 'json']],
+  ['/route.:ext([a-z]+)*', ['ext'], '/route.xml.json', ['/route.xml.json', 'xml.json']],
+  ['/route.:ext([a-z]+)*', ['ext'], '/route.123', null],
+
   // Custom named parameters.
   ['/:test(\\d+)', ['test'], '/123', ['/123', '123']],
   ['/:test(\\d+)', ['test'], '/abc', null],