anchor.diff:  
   /**
    * Dispatch a request.
  - * 
  + *
    * This method is intended to be used in unit tests, where you
    * can create new requests with [MockRequest]
    */
  -Future<HttpResponse> dispatch(UnparsedRequest request) => 
  +Future<HttpResponse> dispatch(UnparsedRequest request) =>
       _dispatchRequest(request);
   
   
   /**
    * Allows to programmatically create routes, interceptors, error handlers,
    * parameter providers and response processors.
  - * 
  + *
    * To access a [Manager] instance, you need to create and register a [RedstonePlugin].
    */
   abstract class Manager {
  -  
  +
     /**
      * The server metadata, which contains all routes, interceptors,
      * error handlers and groups that composes this application.
  -   */ 
  +   */
     ServerMetadata get serverMetadata;
  -  
  +
     /**
      * Create a new route.
      */
     void addRoute(Route conf, String name, RouteHandler route, {String bodyType});
  -  
  +
     /**
      * Create a new interceptor.
      */
     void addInterceptor(Interceptor conf, String name, Handler interceptor);
  -  
  +
     /**
      * Create a new error handler.
      */
     void addErrorHandler(ErrorHandler conf, String name, Handler errorHandler);
  -  
  +
     /**
      * Create a new parameter provider.
  -   * 
  -   * [metadataType] is the annotation type that will trigger the provider. 
  +   *
  +   * [metadataType] is the annotation type that will trigger the provider.
      * [parameterProvider] is the function which will be invoked to create
      * the parameter's value. [handlerTypes] are the handler types that can use
      * this provider, and defaults to ROUTE.
      */
  -  void addParameterProvider(Type metadataType, ParamProvider parameterProvider, 
  +  void addParameterProvider(Type metadataType, ParamProvider parameterProvider,
                               {List<String> handlerTypes: const [ROUTE]});
  -  
  +
     /**
      * Create a new response processor.
  -   * 
  +   *
      * [metadataType] is the annotation type that will trigger the processor.
      * [processor] is the function which will be invoked to transform the returned
      * value. If [includeGroups] is true and the annotation is used on a group, then
      * all group's routes will use the processor.
      */
  -  void addResponseProcessor(Type metadataType, ResponseProcessor processor, 
  +  void addResponseProcessor(Type metadataType, ResponseProcessor processor,
                               {bool includeGroups: false});
  -  
  +
     /**
      * Create a new route wrapper.
  -   * 
  +   *
      * Wrap all routes that are annotated with [metadataType].
      * If [includeGroups] is true and the annotation is used on a group,
      * then all group's routes will be wrapped as well.
  -   * 
  +   *
      * Usage:
  -   * 
  +   *
      *      //wrap all routes annotated with @MyAnnotation()
      *      manager.addRouteWrapper(MyAnnotation, (myAnnotation, pathSegments, injector, request, route) {
  -   *        
  +   *
      *        //here you can prevent the route from executing, or inspect and modify
      *        //the returned value
  -   * 
  +   *
      *        return route(pathSegments, injector, request);
  -   * 
  +   *
      *      });
      */
  -  void addRouteWrapper(Type metadataType, RouteWrapper wrapper, 
  +  void addRouteWrapper(Type metadataType, RouteWrapper wrapper,
                          {bool includeGroups: false});
  -  
  +
   }
   
   abstract class HandlerMetadata<T, M> {
  -  
  +
     T get conf;
  -  
  +
     M get mirror;
  -  
  +
     List get metadata;
  -  
  +
   }
   
   /**
    * Allow access to all installed routes, interceptors,
    * error handlers and groups that composes an application.
  - */ 
  + */
   abstract class ServerMetadata {
  -  
  +
     /**
      * Returns the installed routes.
  -   * 
  +   *
      * This list contains routes which are bound to top level
      * functions. For routes that belongs to a group, see [groups];
  -   */ 
  +   */
     List<RouteMetadata> get routes;
  -  
  +
     /**
      * Returns the installed interceptors.
  -   * 
  +   *
      * This list contains interceptors which are bound to top level
      * functions. For interceptors that belongs to a group, see [groups];
      */
     List<InterceptorMetadata> get interceptors;
  -  
  +
     /**
      * Returns the installed error handlers.
  -   * 
  +   *
      * This list contains error handlers which are bound to top level
      * functions. For error handlers that belongs to a group, see [groups];
      */
     List<ErrorHandlerMetadata> get errorHandlers;
  -  
  +
     ///Returns all installed groups.
     List<GroupMetadata> get groups;
  -  
  -}
  -
  -abstract class RouteMetadata implements 
  -    HandlerMetadata<Route, MethodMirror> { 
  -  
  +
  +}
  +
  +abstract class RouteMetadata implements
  +    HandlerMetadata<Route, MethodMirror> {
  +
     ///The url pattern of this route
     String get urlRegex;
  -  
  -}
  -
  -abstract class InterceptorMetadata implements 
  +
  +}
  +
  +abstract class InterceptorMetadata implements
       HandlerMetadata<Interceptor, MethodMirror> { }
   
   abstract class ErrorHandlerMetadata implements
       HandlerMetadata<ErrorHandler, MethodMirror> { }
   
  -abstract class GroupMetadata implements ServerMetadata, 
  +abstract class GroupMetadata implements ServerMetadata,
                                           HandlerMetadata<Group, ClassMirror> { }
   
   /**
  
positive.code: 
  /**
   * Remove all modules, plugins, routes, interceptors and error handlers.
   * 
   * This method is intended to be used in unit tests.
   */
  void tearDown() {
  
negative.code: 
    ///The body type, such as 'JSON', 'TEXT' or 'FORM'
    String get bodyType;
  
    ///Indicate if this request is multipart
    bool get isMultipart;
  
  