feat(router): added vetoable preLeave event

BREAKING CHANGE

Previously, vetoing was allowed on leave (RouteLeaveEvent) which caused
issues because routes had no way to recover from other route vetoing a leave
event.

Now, similar to preEnter and enter, leave event was split into vetoable
preLeave (RoutePreLeaveEvent) and non-vetoable leave (RouteLeaveEvent).

    views.configure({
      'foo': ngRoute(
          path: '/foo',
          preLeave: (RoutePreLeaveEvent e) {
            e.allowLeave(new Future.value(false));
          })
    });

Author: pavelgj

Diff for: lib/routing/routing.dart

@@ -55,6 +55,11 @@ class RouteViewFactory {
               cfg.preEnter(e);
             }
           },
+          preLeave: (RoutePreLeaveEvent e) {
+            if (cfg.preLeave != null) {
+              cfg.preLeave(e);
+            }
+          },
           leave: cfg.leave,
           mount: (Route mountRoute) {
             if (cfg.mount != null) {
@@ -68,10 +73,10 @@ class RouteViewFactory {
 NgRouteCfg ngRoute({String path, String view, String viewHtml,
     Map<String, NgRouteCfg> mount, modules(), bool defaultRoute: false,
     RoutePreEnterEventHandler preEnter, RouteEnterEventHandler enter,
-    RouteLeaveEventHandler leave}) =>
+    RoutePreLeaveEventHandler preLeave, RouteLeaveEventHandler leave}) =>
         new NgRouteCfg(path: path, view: view, viewHtml: viewHtml, mount: mount,
             modules: modules, defaultRoute: defaultRoute, preEnter: preEnter,
-            enter: enter, leave: leave);
+            preLeave: preLeave, enter: enter, leave: leave);
 
 class NgRouteCfg {
   final String path;
@@ -82,10 +87,11 @@ class NgRouteCfg {
   final bool defaultRoute;
   final RouteEnterEventHandler enter;
   final RoutePreEnterEventHandler preEnter;
+  final RoutePreLeaveEventHandler preLeave;
   final RouteLeaveEventHandler leave;
 
   NgRouteCfg({this.view, this.viewHtml, this.path, this.mount, this.modules,
-      this.defaultRoute, this.enter, this.preEnter, this.leave});
+      this.defaultRoute, this.enter, this.preEnter, this.preLeave, this.leave});
 }
 
 /**

Diff for: test/angular_spec.dart

@@ -266,6 +266,8 @@ main() {
         "route.client.RouteLeaveEventHandler",
         "route.client.RoutePreEnterEvent",
         "route.client.RoutePreEnterEventHandler",
+        "route.client.RoutePreLeaveEvent",
+        "route.client.RoutePreLeaveEventHandler",
         "route.client.Router",
         "route.client.RouteStartEvent",
         "url_matcher.UrlMatch",

Diff for: test/routing/routing_spec.dart

@@ -169,6 +169,66 @@ main() {
     }));
 
 
+    it('should call preEnter callback and be able to veto', async(() {
+      int preEnterCount = 0;
+      initRouter((Router router, RouteViewFactory views) {
+        views.configure({
+          'foo': ngRoute(
+              path: '/foo',
+              preEnter: (RoutePreEnterEvent e) {
+                preEnterCount++;
+                e.allowEnter(new Future.value(false));
+              },
+              view: 'foo.html'
+          ),
+        });
+      });
+
+      Element root = _.compile('<ng-view></ng-view>');
+      expect(root.text).toEqual('');
+
+      router.route('/foo');
+      microLeap();
+
+      expect(preEnterCount).toBe(1);
+      expect(root.text).toEqual(''); // didn't enter.
+    }));
+
+
+    it('should call preLeave callback and be able to veto', async(() {
+      int preLeaveCount = 0;
+      initRouter((Router router, RouteViewFactory views) {
+        views.configure({
+          'foo': ngRoute(
+              path: '/foo',
+              preLeave: (RoutePreLeaveEvent e) {
+                preLeaveCount++;
+                e.allowLeave(new Future.value(false));
+              },
+              view: 'foo.html'
+          ),
+        });
+      });
+      _.injector.get(TemplateCache)
+          .put('foo.html', new HttpResponse(200, '<h1>Foo</h1>'));
+
+      Element root = _.compile('<ng-view></ng-view>');
+      expect(root.text).toEqual('');
+
+      router.route('/foo');
+      microLeap();
+
+      expect(preLeaveCount).toBe(0);
+      expect(root.text).toEqual('Foo');
+
+      router.route('');
+      microLeap();
+
+      expect(preLeaveCount).toBe(1);
+      expect(root.text).toEqual('Foo'); // didn't leave.
+    }));
+
+
     it('should call preEnter callback and load modules', async(() {
       int preEnterCount = 0;
       int modulesCount = 0;