Using refactored URL matcher detection in $state, fixes #154

 - Refactoring $urlRouterProvider.when() for improved composability
 - Adding tests for $urlRouterProvider

Author: nateabele

src/state.js

@@ -35,11 +35,8 @@ function $StateProvider(   $urlRouterProvider,   $urlMatcherFactory,           $
         }
         return (state.parent.navigable || root).url.concat(url);
       }
-      var isMatcher = (
-        isObject(url) && isFunction(url.exec) && isFunction(url.format) && isFunction(url.concat)
-      );
 
-      if (isMatcher || url == null) {
+      if ($urlMatcherFactory.isMatcher(url) || url == null) {
         return url;
       }
       throw new Error("Invalid url '" + url + "' in state '" + state + "'");

src/urlMatcherFactory.js

@@ -58,7 +58,7 @@ function UrlMatcher(pattern) {
   //    \{(?:[^{}\\]+|\\.)*\}     - a matched set of curly braces containing other atoms
   var placeholder = /([:*])(\w+)|\{(\w+)(?:\:((?:[^{}\\]+|\\.|\{(?:[^{}\\]+|\\.)*\})+))?\}/g,
       names = {}, compiled = '^', last = 0, m,
-      segments = this.segments = [], 
+      segments = this.segments = [],
       params = this.params = [];
 
   function addParameter(id) {
@@ -244,7 +244,7 @@ function $UrlMatcherFactory() {
    * @return {boolean}
    */
   this.isMatcher = function (o) {
-    return o instanceof UrlMatcher;
+    return isObject(o) && isFunction(o.exec) && isFunction(o.format) && isFunction(o.concat);
   };
 
   this.$get = function () {

src/urlRouter.js

@@ -44,43 +44,48 @@ function $UrlRouterProvider(  $urlMatcherFactory) {
 
   this.when =
     function (what, handler) {
-      var rule, redirect;
-      if (isString(what))
-          what = $urlMatcherFactory.compile(what);
-
-      if ($urlMatcherFactory.isMatcher(what)) {
-        if (isString(handler)) {
-          redirect = $urlMatcherFactory.compile(handler);
-          handler = ['$match', function ($match) { return redirect.format($match); }];
-        }
-        else if (!isFunction(handler) && !isArray(handler))
-          throw new Error("invalid 'handler' in when()");
+      var redirect, handlerIsString = isString(handler);
+      if (isString(what)) what = $urlMatcherFactory.compile(what);
 
-        rule = function ($injector, $location) {
-          return handleIfMatch($injector, handler, what.exec($location.path(), $location.search()));
-        };
-        rule.prefix = isString(what.prefix) ? what.prefix : '';
-      }
-      else if (what instanceof RegExp) {
-        if (isString(handler)) {
-          redirect = handler;
-          handler = ['$match', function ($match) { return interpolate(redirect, $match); }];
+      if (!handlerIsString && !isFunction(handler) && !isArray(handler))
+        throw new Error("invalid 'handler' in when()");
+
+      var strategies = {
+        matcher: function (what, handler) {
+          if (handlerIsString) {
+            redirect = $urlMatcherFactory.compile(handler);
+            handler = ['$match', function ($match) { return redirect.format($match); }];
+          }
+          return extend(function ($injector, $location) {
+            return handleIfMatch($injector, handler, what.exec($location.path(), $location.search()));
+          }, {
+            prefix: isString(what.prefix) ? what.prefix : ''
+          });
+        },
+        regex: function (what, handler) {
+          if (what.global || what.sticky) throw new Error("when() RegExp must not be global or sticky");
+
+          if (handlerIsString) {
+            redirect = handler;
+            handler = ['$match', function ($match) { return interpolate(redirect, $match); }];
+          }
+          return extend(function ($injector, $location) {
+            return handleIfMatch($injector, handler, what.exec($location.path()));
+          }, {
+            prefix: regExpPrefix(what)
+          });
         }
-        else if (!isFunction(handler) && !isArray(handler))
-          throw new Error("invalid 'handler' in when()");
+      };
 
-        if (what.global || what.sticky)
-          throw new Error("when() RegExp must not be global or sticky");
+      var check = { matcher: $urlMatcherFactory.isMatcher(what), regex: what instanceof RegExp };
 
-        rule = function ($injector, $location) {
-          return handleIfMatch($injector, handler, what.exec($location.path()));
-        };
-        rule.prefix = regExpPrefix(what);
+      for (var n in check) {
+        if (check[n]) {
+          return this.rule(strategies[n](what, handler));
+        }
       }
-      else
-        throw new Error("invalid 'what' in when()");
 
-      return this.rule(rule);
+      throw new Error("invalid 'what' in when()");
     };
 
   this.$get =

test/urlRouterSpec.js

@@ -61,6 +61,25 @@ describe("UrlRouter", function () {
       scope.$emit("$locationChangeSuccess");
       expect(location.path()).toBe("/lastrule");
     });
+
+    it("should allow custom URL matchers", function () {
+      var custom = {
+        url: { exec: function() {}, format: function() {}, concat: function() {} },
+        handler: function() {}
+      };
+
+      spyOn(custom.url, "exec").andReturn({});
+      spyOn(custom.url, "format").andReturn("/foo-bar");
+      spyOn(custom, "handler").andReturn(true);
+
+      $urp.when(custom.url, custom.handler);
+      scope.$broadcast("$locationChangeSuccess");
+      scope.$apply();
+
+      expect(custom.url.exec).toHaveBeenCalled();
+      expect(custom.url.format).not.toHaveBeenCalled();
+      expect(custom.handler).toHaveBeenCalled();
+    });
   });
 
-});
+});