Revert revision 33053

third_party/pkg/route_hierarchical/lib/client.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.
 
 library route.client;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:html';
 
 import 'package:logging/logging.dart';
 
 import 'url_matcher.dart';
 export 'url_matcher.dart';
 import 'url_template.dart';
 
 
 final _logger = new Logger('route');
 
-typedef RoutePreEnterEventHandler(RoutePreEnterEvent path);
-typedef RouteEnterEventHandler(RouteEnterEvent path);
-typedef RouteLeaveEventHandler(RouteLeaveEvent path);
+typedef RouteEventHandler(RouteEvent path);
 
 /**
  * A helper Router handle that scopes all route event subsriptions to it's
  * instance and provides an convinience [discard] method.
  */
 class RouteHandle implements Route {
   Route _route;
-  final StreamController<RoutePreEnterEvent> _onPreEnterController;
-  final StreamController<RouteEnterEvent> _onEnterController;
-  final StreamController<RouteLeaveEvent> _onLeaveController;
-
-  @deprecated
-  Stream<RouteEnterEvent> get onRoute => onEnter;
-  Stream<RoutePreEnterEvent> get onPreEnter => _onPreEnterController.stream;
-  Stream<RouteEnterEvent> get onEnter => _onEnterController.stream;
-  Stream<RouteLeaveEvent> get onLeave => _onLeaveController.stream;
-
-  StreamSubscription _onPreEnterSubscription;
-  StreamSubscription _onEnterSubscription;
+  final StreamController<RouteEvent> _onRouteController;
+  final StreamController<RouteEvent> _onLeaveController;
+  Stream<RouteEvent> get onRoute => _onRouteController.stream;
+  Stream<RouteEvent> get onLeave => _onLeaveController.stream;
+  StreamSubscription _onRouteSubscription;
   StreamSubscription _onLeaveSubscription;
   List<RouteHandle> _childHandles = <RouteHandle>[];
 
   RouteHandle._new(Route this._route)
-      : _onEnterController =
-            new StreamController<RouteEnterEvent>.broadcast(sync: true),
-        _onPreEnterController =
-            new StreamController<RoutePreEnterEvent>.broadcast(sync: true),
+      : _onRouteController =
+            new StreamController<RouteEvent>.broadcast(sync: true),
         _onLeaveController =
-            new StreamController<RouteLeaveEvent>.broadcast(sync: true) {
-    _onEnterSubscription = _route.onEnter.listen(_onEnterController.add);
-    _onPreEnterSubscription =
-        _route.onPreEnter.listen(_onPreEnterController.add);
+            new StreamController<RouteEvent>.broadcast(sync: true) {
+    _onRouteSubscription = _route.onRoute.listen(_onRouteController.add);
     _onLeaveSubscription = _route.onLeave.listen(_onLeaveController.add);
   }
 
   /// discards this handle.
   void discard() {
     _logger.finest('discarding handle for $_route');
-    _onPreEnterSubscription.cancel();
-    _onEnterSubscription.cancel();
+    _onRouteSubscription.cancel();
     _onLeaveSubscription.cancel();
-    _onEnterController.close();
+    _onRouteController.close();
     _onLeaveController.close();
     _childHandles.forEach((RouteHandle c) => c.discard());
     _childHandles.clear();
     _route = null;
   }
 
   /// Not supported. Overridden to throw an error.
   void addRoute({String name, Pattern path, bool defaultRoute: false,
-    RouteEnterEventHandler enter, RoutePreEnterEventHandler preEnter,
-    RouteLeaveEventHandler leave, mount}) =>
+      RouteEventHandler enter, RouteEventHandler leave, mount}) =>
           throw new UnsupportedError('addRoute is not supported in handle');
 
   /// See [Route.getRoute]
   Route getRoute(String routePath) {
     Route r = _assertState(() => _getHost(_route).getRoute(routePath));
     if (r == null) return null;
     var handle = r.newHandle();
     if (handle != null) {
       _childHandles.add(handle);
     }
@@ skipping 40 matching lines @@
   /// See [Route.path]
   UrlMatcher get path => _route.path;
 
   /// See [Route.name]
   String get name => _route.name;
 
   /// See [Route.parent]
   Route get parent => _route.parent;
 }
 
-childRoute({String name, Pattern path, bool defaultRoute: false,
-    RouteEnterEventHandler enter, RoutePreEnterEventHandler preEnter,
-    RouteLeaveEventHandler leave, mount}) => (Route route) =>
-        route.addRoute(name: name, path: path, defaultRoute: defaultRoute,
-            enter: enter, preEnter: preEnter, leave: leave, mount: leave);
-
 /**
  * Route is a node in the tree of routes. The edge leading to the route is
  * defined by path.
  */
 class Route {
   final String name;
   final Map<String, Route> _routes = new LinkedHashMap<String, Route>();
   final UrlMatcher path;
-  final StreamController<RouteEnterEvent> _onEnterController;
-  final StreamController<RoutePreEnterEvent> _onPreEnterController;
-  final StreamController<RouteLeaveEvent> _onLeaveController;
+  final StreamController<RouteEvent> _onRouteController;
+  final StreamController<RouteEvent> _onLeaveController;
   final Route parent;
   Route _defaultRoute;
   Route _currentRoute;
   RouteEvent _lastEvent;
 
-  @deprecated
-  Stream<RouteEvent> get onRoute => onEnter;
-
-  Stream<RouteEvent> get onPreEnter => _onPreEnterController.stream;
+  Stream<RouteEvent> get onRoute => _onRouteController.stream;
   Stream<RouteEvent> get onLeave => _onLeaveController.stream;
-  Stream<RouteEvent> get onEnter => _onEnterController.stream;
 
   Route._new({this.name, this.path, this.parent})
-      : _onEnterController =
-            new StreamController<RouteEnterEvent>.broadcast(sync: true),
-        _onPreEnterController =
-            new StreamController<RoutePreEnterEvent>.broadcast(sync: true),
+      : _onRouteController =
+            new StreamController<RouteEvent>.broadcast(sync: true),
         _onLeaveController =
-            new StreamController<RouteLeaveEvent>.broadcast(sync: true);
+            new StreamController<RouteEvent>.broadcast(sync: true);
 
   void addRoute({String name, Pattern path, bool defaultRoute: false,
-      RouteEnterEventHandler enter, RoutePreEnterEventHandler preEnter,
-      RouteLeaveEventHandler leave, mount}) {
+      RouteEventHandler enter, RouteEventHandler leave, mount}) {
     if (name == null) {
       throw new ArgumentError('name is required for all routes');
     }
     if (_routes.containsKey(name)) {
       throw new ArgumentError('Route $name already exists');
     }
 
     var matcher;
     if (!(path is UrlMatcher)) {
       matcher = new UrlTemplate(path.toString());
     } else {
       matcher = path;
     }
     var route = new Route._new(name: name, path: matcher, parent: this);
 
-    if (preEnter != null) {
-      route.onPreEnter.listen(preEnter);
-    }
     if (enter != null) {
-      route.onEnter.listen(enter);
+      route.onRoute.listen(enter);
     }
     if (leave != null) {
       route.onLeave.listen(leave);
     }
 
     if (mount != null) {
       if (mount is Function) {
         mount(route);
       } else if (mount is Routable) {
         mount.configureRoute(route);
@@ skipping 113 matching lines @@
       if (_lastEvent == null) return {};
       return new Map.from(_lastEvent.parameters);
     }
     return null;
   }
 }
 
 /**
  * Route enter or leave event.
  */
-abstract class RouteEvent {
+class RouteEvent {
   final String path;
   final Map parameters;
   final Route route;
+  var _allowLeaveFutures = <Future<bool>>[];
 
   RouteEvent(this.path, this.parameters, this.route);
-}
-
-class RoutePreEnterEvent extends RouteEvent {
-
-  var _allowEnterFutures = <Future<bool>>[];
-
-  RoutePreEnterEvent(path, parameters, route)  : super(path, parameters, route);
 
   /**
-   * Can be called on enter with the future which will complete with a boolean
-   * value allowing (true) or disallowing (false) the current navigation.
-   */
-  void allowEnter(Future<bool> allow) {
-    _allowEnterFutures.add(allow);
-  }
-}
-
-class RouteEnterEvent extends RouteEvent {
-
-  RouteEnterEvent(path, parameters, route)  : super(path, parameters, route);
-}
-
-class RouteLeaveEvent extends RouteEvent {
-
-  var _allowLeaveFutures = <Future<bool>>[];
-
-  RouteLeaveEvent(path, parameters, route)  : super(path, parameters, route);
-
-  /**
-   * Can be called on enter with the future which will complete with a boolean
+   * Can be called on leave with the future which will complete with a boolean
    * value allowing (true) or disallowing (false) the current navigation.
    */
   void allowLeave(Future<bool> allow) {
     _allowLeaveFutures.add(allow);
   }
 
-  RouteLeaveEvent _clone() => new RouteLeaveEvent(path, parameters, route);
+  RouteEvent _clone() => new RouteEvent(path, parameters, route);
 }
 
 /**
  * Event emitted when routing starts.
  */
 class RouteStartEvent {
 
   /**
    * URI that was passed to [Router.route].
    */
@@ skipping 49 matching lines @@
 
   /**
    * Finds a matching [Route] added with [addRoute], parses the path
    * and invokes the associated callback.
    *
    * This method does not perform any navigation, [go] should be used for that.
    * This method is used to invoke a handler after some other code navigates the
    * window, such as [listen].
    */
   Future<bool> route(String path, {Route startingFrom}) {
-    var future = _route(path, startingFrom);
+    var future = _route(path, startingFrom: startingFrom);
     _onRouteStart.add(new RouteStartEvent._new(path, future));
     return future;
   }
 
-  Future<bool> _route(String path, Route startingFrom) {
-    var baseRoute = startingFrom == null ? root : _dehandle(startingFrom);
+  Future<bool> _route(String path, {Route startingFrom}) {
+    var baseRoute = startingFrom == null ? this.root : _dehandle(startingFrom);
     _logger.finest('route $path $baseRoute');
-    var treePath = _matchingTreePath(path, baseRoute);
-    Route cmpBase = baseRoute;
-    var tail = path;
-    // Skip all routes that are unaffected by this path.
-    treePath = treePath.skipWhile((_Match matchedRoute) {
-      var skip = cmpBase._currentRoute == matchedRoute.route &&
-          !_paramsChanged(cmpBase, matchedRoute.urlMatch);
-      if (skip) {
-        cmpBase = matchedRoute.route;
-        tail = matchedRoute.urlMatch.tail;
+    Route matchedRoute;
+    List matchingRoutes = baseRoute._routes.values.where(
+        (r) => r.path.match(path) != null).toList();
+    if (!matchingRoutes.isEmpty) {
+      if (matchingRoutes.length > 1) {
+        _logger.warning("More than one route matches $path $matchingRoutes");
       }
-      return skip;
-    });
-    // TODO(pavelgj): weird things happen without this line...
-    treePath = treePath.toList();
-    if (treePath.isEmpty) {
-      return new Future.value(true);
+      matchedRoute = matchingRoutes.first;
+    } else {
+      if (baseRoute._defaultRoute != null) {
+        matchedRoute = baseRoute._defaultRoute;
+      }
     }
-    var preEnterFutures = _preEnter(tail, treePath);
-    return Future.wait(preEnterFutures).then((List<bool> results) {
-      if (results.fold(true, (a, b) => a && b)) {
-        return _processNewRoute(cmpBase, treePath, tail);
+    if (matchedRoute != null) {
+      var match = _getMatch(matchedRoute, path);
+      if (matchedRoute != baseRoute._currentRoute ||
+          _paramsChanged(baseRoute, match)) {
+        return _processNewRoute(baseRoute, path, match, matchedRoute);
+      } else {
+        baseRoute._currentRoute._lastEvent =
+            new RouteEvent(match.match, match.parameters,
+                baseRoute._currentRoute);
+        return _route(match.tail, startingFrom: matchedRoute);
       }
-      return false;
-    });
-  }
-
-  List<Future<bool>> _preEnter(String tail, Iterable<_Match> treePath) {
-    List<Future<bool>> preEnterFutures = <Future<bool>>[];
-    treePath.forEach((_Match matchedRoute) {
-      tail = matchedRoute.urlMatch.tail;
-      var preEnterEvent = new RoutePreEnterEvent(tail, matchedRoute.urlMatch.parameters, matchedRoute.route);
-      matchedRoute.route._onPreEnterController.add(preEnterEvent);
-      preEnterFutures.addAll(preEnterEvent._allowEnterFutures);
-    });
-    return preEnterFutures;
-  }
-
-  Future<bool> _processNewRoute(Route startingFrom, Iterable<_Match> treePath, String path) {
-    return _leaveOldRoutes(startingFrom, treePath).then((bool allowed) {
-      if (allowed) {
-        var base = startingFrom;
-        var tail = path;
-        treePath.forEach((_Match matchedRoute) {
-          tail = matchedRoute.urlMatch.tail;
-          var event = new RouteEnterEvent(matchedRoute.urlMatch.match,
-              matchedRoute.urlMatch.parameters, matchedRoute.route);
-          _unsetAllCurrentRoutes(base);
-          base._currentRoute = matchedRoute.route;
-          base._currentRoute._lastEvent = event;
-          matchedRoute.route._onEnterController.add(event);
-          base = matchedRoute.route;
-        });
-        return true;
-      }
-      return false;
-    });
-  }
-
-  Future<bool> _leaveOldRoutes(Route startingFrom, Iterable<_Match> treePath) {
-    if (treePath.isEmpty) {
-      return new Future.value(true);
+    } else if (baseRoute._currentRoute != null) {
+      var event = new RouteEvent('', {}, baseRoute);
+      return _leaveCurrentRoute(baseRoute, event).then((success) {
+        if (success) {
+          baseRoute._currentRoute = null;
+        }
+        return success;
+      });
     }
-    var event = new RouteLeaveEvent('', {}, startingFrom);
-    return _leaveCurrentRoute(startingFrom, event);
-  }
-
-  Iterable<_Match> _matchingTreePath(String path, Route baseRoute) {
-    List<_Match> treePath = <_Match>[];
-    Route matchedRoute;
-    do {
-      matchedRoute = null;
-      List matchingRoutes = baseRoute._routes.values.where(
-          (r) => r.path.match(path) != null).toList();
-      if (!matchingRoutes.isEmpty) {
-        if (matchingRoutes.length > 1) {
-          _logger.warning("More than one route matches $path $matchingRoutes");
-        }
-        matchedRoute = matchingRoutes.first;
-      } else {
-        if (baseRoute._defaultRoute != null) {
-          matchedRoute = baseRoute._defaultRoute;
-        }
-      }
-      if (matchedRoute != null) {
-        var match = _getMatch(matchedRoute, path);
-        treePath.add(new _Match(matchedRoute, match));
-        baseRoute = matchedRoute;
-        path = match.tail;
-      }
-    } while (matchedRoute != null);
-    return treePath;
+    return new Future.value(true);
   }
 
   bool _paramsChanged(Route baseRoute, UrlMatch match) {
     return baseRoute._currentRoute._lastEvent.path != match.match ||
         !_mapsEqual(baseRoute._currentRoute._lastEvent.parameters,
             match.parameters);
   }
 
   bool _mapsEqual(Map a, Map b) {
     if (a.keys.length != b.keys.length) {
@@ skipping 36 matching lines @@
 
   String _buildQuery(Map queryParams) {
     var query = queryParams.keys.map((key) =>
         '$key=${Uri.encodeComponent(queryParams[key])}').join('&');
     if (query.isEmpty) {
       return '';
     }
     return '?$query';
   }
 
-  Route _dehandle(Route r) => r is RouteHandle ? r._getHost(r): r;
+  Route _dehandle(Route r) {
+    if (r is RouteHandle) {
+      return (r as RouteHandle)._getHost(r);
+    }
+    return r;
+  }
 
   UrlMatch _getMatch(Route route, String path) {
     var match = route.path.match(path);
     if (match == null) { // default route
       return new UrlMatch('', '', {});
     }
     _parseQuery(route, path).forEach((k, v) { match.parameters[k] = v; });
     return match;
   }
 
@@ skipping 20 matching lines @@
       return ['', ''];
     }
     var splitPoint = keyValPair.indexOf('=') == -1 ?
         keyValPair.length : keyValPair.indexOf('=') + 1;
     var key = keyValPair.substring(0, splitPoint +
         (keyValPair.indexOf('=') == -1 ? 0 : -1));
     var value = keyValPair.substring(splitPoint);
     return [key, value];
   }
 
+  Future<bool> _processNewRoute(Route base, String path, UrlMatch match,
+      Route newRoute) {
+    _logger.finest('_processNewRoute $path');
+    var event = new RouteEvent(match.match, match.parameters, newRoute);
+    // before we make this a new current route, leave the old
+    return _leaveCurrentRoute(base, event).then((bool allowNavigation) {
+      if (allowNavigation) {
+        _unsetAllCurrentRoutes(base);
+        base._currentRoute = newRoute;
+        base._currentRoute._lastEvent = event;
+        newRoute._onRouteController.add(event);
+        return _route(match.tail, startingFrom: newRoute);
+      }
+      return false;
+    });
+  }
+
   void _unsetAllCurrentRoutes(Route r) {
     if (r._currentRoute != null) {
       _unsetAllCurrentRoutes(r._currentRoute);
       r._currentRoute = null;
     }
   }
 
-  Future<bool> _leaveCurrentRoute(Route base, RouteLeaveEvent e) =>
+  Future<bool> _leaveCurrentRoute(Route base, RouteEvent e) =>
       Future.wait(_leaveCurrentRouteHelper(base, e))
           .then((values) => values.fold(true, (c, v) => c && v));
 
-  List<Future<bool>> _leaveCurrentRouteHelper(Route base, RouteLeaveEvent e) {
+  List<Future<bool>> _leaveCurrentRouteHelper(Route base, RouteEvent e) {
     var futures = [];
     if (base._currentRoute != null) {
       List<Future<bool>> pendingResponses = <Future<bool>>[];
       // We create a copy of the route event
       var event = e._clone();
       base._currentRoute._onLeaveController.add(event);
       futures.addAll(event._allowLeaveFutures);
       futures.addAll(_leaveCurrentRouteHelper(base._currentRoute, event));
     }
     return futures;
   }
 
   /**
    * Listens for window history events and invokes the router. On older
    * browsers the hashChange event is used instead.
    */
-  void listen({bool ignoreClick: false, Element appRoot}) {
+  void listen({bool ignoreClick: false}) {
     _logger.finest('listen ignoreClick=$ignoreClick');
     if (_listen) {
       throw new StateError('listen can only be called once');
     }
     _listen = true;
     if (_useFragment) {
       _window.onHashChange.listen((_) {
         route(_normalizeHash(_window.location.hash)).then((allowed) {
           // if not allowed, we need to restore the browser location
           if (!allowed) {
             _window.history.back();
           }
         });
       });
       route(_normalizeHash(_window.location.hash));
     } else {
       _window.onPopState.listen((_) {
         var path = '${_window.location.pathname}${_window.location.hash}';
         route(path).then((allowed) {
           // if not allowed, we need to restore the browser location
           if (!allowed) {
             _window.history.back();
           }
         });
       });
     }
     if (!ignoreClick) {
-      if (appRoot == null) {
-        appRoot = _window.document.documentElement;
-      }
       _logger.finest('listen on win');
-      appRoot.onClick.listen((MouseEvent e) {
-        if (!e.ctrlKey && !e.metaKey && !e.shiftKey && e.target is AnchorElement) {
+      _window.onClick.listen((Event e) {
+        if (e.target is AnchorElement) {
           AnchorElement anchor = e.target;
           if (anchor.host == _window.location.host) {
             _logger.finest('clicked ${anchor.pathname}${anchor.hash}');
             e.preventDefault();
             var path;
             if (_useFragment) {
               path = _normalizeHash(anchor.hash);
             } else {
               path = '${anchor.pathname}';
             }
@@ skipping 55 matching lines @@
   List<Route> get activePath {
     var res = <Route>[];
     var current = root;
     while (current._currentRoute != null) {
       current = current._currentRoute;
       res.add(current);
     }
     return res;
   }
 }
-
-class _Match {
-  final Route route;
-  final UrlMatch urlMatch;
-
-  _Match(this.route, this.urlMatch);
-}