@@ -1,6 +1,9 @@
 # restify Changelog
 
-## 2.3.5 (not yet released)
+## 2.4.0 (not yet released)
+
+- GH-193 support `next('name_of_route')`
+
 
 ## 2.3.4
 
 
@@ -206,6 +206,37 @@ You can pass in  `false` to not error, but to stop the handler
 chain.  This is useful if you had a `res.send` in an early filter, which is
 not an error, and you possibly have one later you want to short-circuit.
 
+Lastly, you can pass in a string `name` to `next()`, and restify will lookup
+that route, and assuming it exists will run the chain *from where you left
+off*.  So for example:
+
+    var count = 0;
+
+    server.use(function foo(req, res, next) {
+        count++;
+        next();
+    });
+
+    server.get('/foo/:id', function (req, res, next) {
+       next('foo2');
+    });
+
+    server.get({
+        name: 'foo2',
+        path: '/foo/:id'
+    }, function (req, res, next) {
+       assert.equal(count, 1);
+       res.send(200);
+       next();
+    });
+
+Note that `foo` only gets run once in that example.  A few caveats:
+
+- If you provide a name that doesn't exist, restify will 500 that request.
+- Don't be silly and call this in cycles.  restify won't check that.
+- Lastly, you cannot "chain" `next('route')` calls; you can only delegate the
+  routing chain once (this is a limitation of the way routes are stored
+  internally, and may be revisited someday).
 
 ### Versioned Routes
 
 
@@ -1,4 +1,4 @@
-var server = require('restify').createServer();
+var server = require('../../lib').createServer();
 //var server = require('express')();
 
 server.get('/echo/:name', function (req, res, next) {
 
@@ -23,6 +23,7 @@ var DEF_CT = 'application/octet-stream';
 var maxSatisfying = semver.maxSatisfying;
 
 var BadRequestError = errors.BadRequestError;
+var InternalError = errors.InternalError;
 var InvalidArgumentError = errors.InvalidArgumentError;
 var InvalidVersionError = errors.InvalidVersionError;
 var MethodNotAllowedError = errors.MethodNotAllowedError;
@@ -258,9 +259,31 @@ Router.prototype.unmount = function unmount(name) {
 };
 
 
+Router.prototype.get = function get(name, req, cb) {
+        var params;
+        var route = false;
+        var routes = this.routes[req.method] || [];
+
+        for (var i = 0; i < routes.length; i++) {
+                if (routes[i].name === name) {
+                        route = routes[i];
+                        try {
+                                params = matchURL(route.path, req);
+                        } catch (e) {}
+                        break;
+                }
+        }
+
+        if (route) {
+                cb(null, route, params || {});
+        } else {
+                cb(new InternalError());
+        }
+};
+
+
 Router.prototype.find = function find(req, res, callback) {
         var candidates = [];
-        // var candidateKeys = [];
         var ct = req.headers['content-type'] || DEF_CT;
         var cacheKey = req.method + req.url + req.version() + ct;
         var cacheVal;
@@ -431,7 +454,7 @@ Router.prototype.find = function find(req, res, callback) {
                         res.methods = this.reverse[urls[i]].slice();
                         res.setHeader('Allow', res.methods.join(', '));
                         if (preflight(res.methods)) {
-                                callback(null, true);
+                                callback(null, { name: 'preflight' });
                                 return;
                         }
                         var err = new MethodNotAllowedError('%s is not allowed',
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-var server = require('restify').createServer();`
	`1`	`+var server = require('../../lib').createServer();`
`2`	`2`	`//var server = require('express')();`
`3`	`3`
`4`	`4`	`server.get('/echo/:name', function (req, res, next) {`