Added support for http methods when mounting routes.

lib/server.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * This library provides a simple API for routing HttpRequests based on thier
  * URL.
  */
 library route.server;
 
@@ skipping 33 matching lines @@
  *       var router = new Router(server);
  *       router.filter(matchesAny(['/foo', '/bar']), authFilter);
  *       router.serve('/foo').listen(fooHandler);
  *       router.serve('/bar').listen(barHandler);
  *       router.defaultStream.listen(send404);
  *     });
  */
 class Router {
   final Stream<HttpRequest> _incoming;
   
-  final Map<Pattern, StreamController> _controllers = 
-      new LinkedHashMap<Pattern, StreamController>();
-      
+  final Map<RequestPattern, StreamController> _controllers = 

[justinfagnani, 2013/04/19 19:20:51]

Make _controllers a List. See comment below.

[adambender, 2013/04/19 19:43:11]

Done.

+      new LinkedHashMap<RequestPattern, StreamController>();
+  
   final Map<Pattern, Filter> _filters = new LinkedHashMap<Pattern, Filter>();
   
   final StreamController<HttpRequest> _defaultController = 
       new StreamController<HttpRequest>();
   
   /**
    * Create a new Router that listens to the [incoming] stream, usually an
    * instance of [HttpServer].
    */
   Router(Stream<HttpRequest> incoming) : _incoming = incoming {
     _incoming.listen(_handleRequest);
   }
 
   /**
    * Request whose URI matches [url] are sent to the stream created by this
    * method, and not sent to any other router streams.

[justinfagnani, 2013/04/19 19:20:51]

Add docs for [method]

[adambender, 2013/04/19 19:43:11]

Done.

    */
-  Stream<HttpRequest> serve(Pattern url) {
+  Stream<HttpRequest> serve(Pattern url, {String method}) {
     var controller = new StreamController<HttpRequest>();
-    _controllers[url] = controller;
+    _controllers[new RequestPattern(url, method:method)] = controller;
     return controller.stream;
   }
-
+  
   /**
    * A [Filter] returns a [Future<bool>] that tells the router whether to apply
    * the remaining filters and send requests to the streams created by [serve].
    *
    * If the filter returns true, the request is passed to the next filter, and
    * then to the first matching server stream. If the filter returns false, it's
    * assumed that the filter is handling the request and it's not forwarded.
    */
   void filter(Pattern url, Filter filter) {
     _filters[url] = filter;
   }
 
   Stream<HttpRequest> get defaultStream => _defaultController.stream;
   
   void _handleRequest(HttpRequest req) {
     bool cont = true;
     doWhile(_filters.keys, (Pattern pattern) {
       if (matchesFull(pattern, req.uri.path)) {
         return _filters[pattern](req).then((c) {
           cont = c;
           return c;
         });
       }
       return new Future.value(true);
     }).then((_) {
       if (cont) {
         bool handled = false;
-        for (Pattern pattern in _controllers.keys) {
-          if (matchesFull(pattern, req.uri.path)) {
-            _controllers[pattern].add(req);
+        for (RequestPattern reqPattern in _controllers.keys) {

[justinfagnani, 2013/04/19 19:20:51]

if we want to be even more Darty, we can use Iterable.where (once _controllers
is a List):

var matches = _controllers.where((r) => r.matches(req))
if (!matches.isEmpty) {
  matches.first.controller.add(req);
}

[adambender, 2013/04/19 19:43:11]

Done.

+          if (reqPattern.matches(req)) {
+            _controllers[reqPattern].add(req);
             handled = true;
             break;
           }
         }
         if (!handled) {
           if (_defaultController.hasListener) {
             _defaultController.add(req);
           } else {
             send404(req);
           }
         }
       }
     });
   }
 }
 
 void send404(HttpRequest req) {
   req.response.statusCode = HttpStatus.NOT_FOUND;
   req.response.write("Not Found");
   req.response.close();
 }
+
+class RequestPattern{

[justinfagnani, 2013/04/19 19:20:51]

On the client-side I have a similar class called Route, might make sense to use
the same name. The only difference is that Route includes the handler. Here
Route could include the StreamController. I don't think the Map _controllers is
actually doing much as a Map, so it could be replaced by a list.

[adambender, 2013/04/19 19:43:11]

Done.

+  final Pattern url;
+  final String method;
+  RequestPattern(this.url, {this.method});
+  
+  bool matches(HttpRequest request){

[justinfagnani, 2013/04/19 19:20:51]

space before {

[justinfagnani, 2013/04/19 19:20:51]

you can use the "fat arrow syntax" here

[adambender, 2013/04/19 19:43:11]

Done.

[adambender, 2013/04/19 19:43:11]

Done.

+    return  matchesFull(url, request.uri.path) && (method == null || request.method.toUpperCase() == method);

[justinfagnani, 2013/04/19 19:20:51]

we're using an 80 col limit

[adambender, 2013/04/19 19:43:11]

Done.

+  }
+}