feat($transition): implement is() for matching

Author: nateabele

src/transition.js

@@ -9,6 +9,19 @@ function $TransitionProvider() {
 
   var $transition = {}, events, stateMatcher = angular.noop, abstractKey = 'abstract';
 
+  function matchState(current, states) {
+    var toMatch = angular.isArray(states) ? states : [states];
+
+    for (var i = 0; i < toMatch.length; i++) {
+      var glob = GlobBuilder.fromString(toMatch[i]);
+
+      if ((glob && glob.matches(current.name)) || (!glob && toMatch[i] === current.name)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   // $transitionProvider.on({ from: "home", to: "somewhere.else" }, function($transition$, $http) {
   //   // ...
   // });
@@ -78,6 +91,7 @@ function $TransitionProvider() {
      */
     function Transition(fromState, fromParams, toState, toParams, options) {
       var transition = this; // Transition() object
+
       // grab $transition's current path
       var toPath, fromPath = _fromPath; // Path() objects
       var retained, entering, exiting; // Path() objects
@@ -89,6 +103,12 @@ function $TransitionProvider() {
       };
       toState = states.to; fromState = states.from;
 
+      if (!toState || !fromState) {
+        throw new Error("To or from state not valid for transition: " + angular.toJson({
+          to: toState, from: fromState
+        }));
+      }
+
       function isTargetStateValid() {
         var state = states.to;
 
@@ -151,12 +171,14 @@ function $TransitionProvider() {
         var exitingElements = transition.exiting().slice(0).reverse().elements;
         var enteringElements = transition.entering().elements;
         var promiseChain = $q.when(true);
+
         forEach(exitingElements, function(elem) {
           if (elem.state.onExit) {
             var nextStep = transitionStep(elem.state.onExit, fromPath.resolveContext(elem));
             promiseChain.then(nextStep);
           }
         });
+
         forEach(enteringElements, function(elem) {
           var resolveContext = toPath.resolveContext(elem);
           promiseChain.then(function() { return elem.resolve(resolveContext, { policy: "lazy" }); });
@@ -232,6 +254,17 @@ function $TransitionProvider() {
           }
         }),
 
+        is: function(compare) {
+          if (compare instanceof Transition) {
+            // TODO: Also compare parameters
+            return this.is({ to: compare.to.$state().name, from: compare.from.$state().name });
+          }
+          return !(
+            (compare.to && !matchState(this.to.$state(), compare.to)) ||
+            (compare.from && !matchState(this.from.$state(), compare.from))
+          );
+        },
+
         isValid: function() {
           return isTargetStateValid() === null && !hasBeenSuperseded();
         },
@@ -343,8 +376,8 @@ function $TransitionProvider() {
     };
 
     $transition.start = function start(state, params, options) {
-      to = { state: state, params: params };
-      return new Transition(from.state, from.params, state, params, options || {});
+      to = { state: state, params: params || {} };
+      return new Transition(from.state, from.params, state, params || {}, options || {});
     };
 
     $transition.isActive = function isActive() {

test/transitionSpec.js

@@ -1,11 +1,55 @@
-describe('$transition:', function () {
+describe('transition', function () {
+
+  var transitionProvider, root = { name: "", path: [] }, matcher, matchStates = {
+    "": root,
+    "first": { name: "first", path: [root] },
+    "second": { name: "second", path: [root] },
+    "third": { name: "third", path: [root] }
+  };
+
+  describe('provider', function() {
+
+    beforeEach(module('ui.router', function($transitionProvider) {
+      transitionProvider = $transitionProvider;
+    }));
+
+    beforeEach(inject(function($transition) {
+      matcher = new StateMatcher(matchStates);
+
+      $transition.init(root, {}, function(ref, options) {
+        return matcher.find(ref, options.relative);
+      });
+    }));
+
+    describe('events', function() {
+
+      it('should fire matching "on" events regardless of outcome', inject(function($transition) {
+        var t = null;
+
+        transitionProvider.on({ from: "first", to: "second" }, function($transition$) {
+          t = $transition$;
+        });
+
+        $transition.init(matchStates.first, {}, function(ref, options) {
+          return matcher.find(ref, options.relative);
+        });
+
+        $transition.start("third");
+        expect(t).toBeNull();
+
+        $transition.start("second");
+        expect(t).not.toBeNull();
+      }));
+
+    });
+  });
+
+
   var statesTree, statesMap = {};
   var emptyPath;
   var counts;
   var asyncCount;
 
-
-
   beforeEach(module('ui.router', function($stateProvider, $locationProvider) {
     locationProvider = $locationProvider;
     $locationProvider.html5Mode(false);
@@ -74,10 +118,42 @@ describe('$transition:', function () {
     return new Path(map(names, function(name) { return statesMap[name]; }));
   }
 
-  describe('Transition().runAsync', function () {
-    it('should resolve all resolves in a PathElement', inject(function ($q, $state) {
-      $state.go("B");
-      $q.flush();
+  describe('instance', function() {
+    beforeEach(inject(function($transition) {
+      matcher = new StateMatcher(matchStates);
+
+      $transition.init(root, {}, function(ref, options) {
+        return matcher.find(ref, options.relative);
+      });
     }));
+
+    describe('is', function() {
+      it('should match rules', inject(function($transition) {
+        var t = $transition.start("first");
+
+        expect(t.is({ to: "first" })).toBe(true);
+        expect(t.is({ from: "" })).toBe(true);
+        expect(t.is({ to: "first", from: "" })).toBe(true);
+
+        expect(t.is({ to: ["first", "second"] })).toBe(true);
+        expect(t.is({ to: ["first", "second"], from: ["", "third"] })).toBe(true);
+        expect(t.is({ to: "first", from: "**" })).toBe(true);
+
+        expect(t.is({ to: "second" })).toBe(false);
+        expect(t.is({ from: "first" })).toBe(false);
+        expect(t.is({ to: "first", from: "second" })).toBe(false);
+
+        expect(t.is({ to: ["", "third"] })).toBe(false);
+        expect(t.is({ to: "**", from: "first" })).toBe(false);
+      }));
+    });
+
+    describe('runAsync', function () {
+      it('should resolve all resolves in a PathElement', inject(function ($q, $state) {
+        $state.go("B");
+        $q.flush();
+      }));
+    });
   });
+
 });