From 450b1f0e8e03c738174ff967f688b9a6373290f4 Mon Sep 17 00:00:00 2001
From: Nate Abele <nate.abele@gmail.com>
Date: Wed, 26 Mar 2014 09:59:04 -0400
Subject: [PATCH] feat($urlMatcherFactory): implement type support

---
 src/urlMatcherFactory.js      | 171 +++++++++++++++++++++-------
 test/urlMatcherFactorySpec.js | 206 ++++++++++++++++++++--------------
 2 files changed, 249 insertions(+), 128 deletions(-)

diff --git a/src/urlMatcherFactory.js b/src/urlMatcherFactory.js
index 542c75a03..0a272e501 100644
--- a/src/urlMatcherFactory.js
+++ b/src/urlMatcherFactory.js
@@ -72,15 +72,14 @@ function UrlMatcher(pattern, caseInsensitiveMatch) {
   //    \\.                       - a backslash escape
   //    \{(?:[^{}\\]+|\\.)*\}     - a matched set of curly braces containing other atoms
   var placeholder = /([:*])(\w+)|\{(\w+)(?:\:((?:[^{}\\]+|\\.|\{(?:[^{}\\]+|\\.)*\})+))?\}/g,
-      names = {}, compiled = '^', last = 0, m,
+      compiled = '^', last = 0, m,
       segments = this.segments = [],
-      params = this.params = [];
+      params = this.params = {};
 
-  function addParameter(id) {
+  function addParameter(id, type) {
     if (!/^\w+(-+\w+)*$/.test(id)) throw new Error("Invalid parameter name '" + id + "' in pattern '" + pattern + "'");
-    if (names[id]) throw new Error("Duplicate parameter name '" + id + "' in pattern '" + pattern + "'");
-    names[id] = true;
-    params.push(id);
+    if (params[id]) throw new Error("Duplicate parameter name '" + id + "' in pattern '" + pattern + "'");
+    params[id] = type;
   }
 
   function quoteRegExp(string) {
@@ -91,14 +90,18 @@ function UrlMatcher(pattern, caseInsensitiveMatch) {
 
   // Split into static segments separated by path parameter placeholders.
   // The number of segments is always 1 more than the number of parameters.
-  var id, regexp, segment;
+  var id, regexp, segment, type;
+
   while ((m = placeholder.exec(pattern))) {
-    id = m[2] || m[3]; // IE[78] returns '' for unmatched groups instead of null
-    regexp = m[4] || (m[1] == '*' ? '.*' : '[^/]*');
+    id      = m[2] || m[3]; // IE[78] returns '' for unmatched groups instead of null
+    regexp  = m[4] || (m[1] == '*' ? '.*' : '[^/]*');
     segment = pattern.substring(last, m.index);
+    type    = this.$types[regexp] || new Type({ pattern: new RegExp(regexp) });
+
     if (segment.indexOf('?') >= 0) break; // we're into the search part
-    compiled += quoteRegExp(segment) + '(' + regexp + ')';
-    addParameter(id);
+
+    compiled += quoteRegExp(segment) + '(' + type.$subPattern() + ')';
+    addParameter(id, type);
     segments.push(segment);
     last = placeholder.lastIndex;
   }
@@ -106,10 +109,11 @@ function UrlMatcher(pattern, caseInsensitiveMatch) {
 
   // Find any search parameter names and remove them from the last segment
   var i = segment.indexOf('?');
+
   if (i >= 0) {
     var search = this.sourceSearch = segment.substring(i);
     segment = segment.substring(0, i);
-    this.sourcePath = pattern.substring(0, last+i);
+    this.sourcePath = pattern.substring(0, last + i);
 
     // Allow parameters to be separated by '?' as well as '&' to make concat() easier
     forEach(search.substring(1).split(/[&?]/), addParameter);
@@ -120,12 +124,8 @@ function UrlMatcher(pattern, caseInsensitiveMatch) {
 
   compiled += quoteRegExp(segment) + '$';
   segments.push(segment);
-  if(caseInsensitiveMatch){
-    this.regexp = new RegExp(compiled, 'i');
-  }else{
-    this.regexp = new RegExp(compiled);	
-  }
-  
+
+  this.regexp = (caseInsensitiveMatch) ? new RegExp(compiled, 'i') : new RegExp(compiled);
   this.prefix = segments[0];
 }
 
@@ -187,14 +187,18 @@ UrlMatcher.prototype.exec = function (path, searchParams) {
   var m = this.regexp.exec(path);
   if (!m) return null;
 
-  var params = this.params, nTotal = params.length,
-    nPath = this.segments.length-1,
-    values = {}, i;
+  var params = this.parameters(), nTotal = params.length,
+    nPath = this.segments.length - 1,
+    values = {}, i, type, param;
 
   if (nPath !== m.length - 1) throw new Error("Unbalanced capture group in route '" + this.source + "'");
 
-  for (i=0; i<nPath; i++) values[params[i]] = m[i+1];
-  for (/**/; i<nTotal; i++) values[params[i]] = searchParams[params[i]];
+  for (i = 0; i < nPath; i++) {
+    param = params[i];
+    type = this.params[param];
+    values[param] = type.decode(m[i + 1]);
+  }
+  for (/**/; i < nTotal; i++) values[params[i]] = searchParams[params[i]];
 
   return values;
 };
@@ -211,7 +215,7 @@ UrlMatcher.prototype.exec = function (path, searchParams) {
  *    pattern has no parameters, an empty array is returned.
  */
 UrlMatcher.prototype.parameters = function () {
-  return this.params;
+  return keys(this.params);
 };
 
 /**
@@ -234,30 +238,59 @@ UrlMatcher.prototype.parameters = function () {
  * @returns {string}  the formatted URL (path and optionally search part).
  */
 UrlMatcher.prototype.format = function (values) {
-  var segments = this.segments, params = this.params;
+  var segments = this.segments, params = this.parameters();
   if (!values) return segments.join('');
 
-  var nPath = segments.length-1, nTotal = params.length,
-    result = segments[0], i, search, value;
+  var nPath = segments.length - 1, nTotal = params.length,
+    result = segments[0], i, search, value, param, type;
 
-  for (i=0; i<nPath; i++) {
-    value = values[params[i]];
-    // TODO: Maybe we should throw on null here? It's not really good style to use '' and null interchangeabley
-    if (value != null) result += encodeURIComponent(value);
-    result += segments[i+1];
-  }
-  for (/**/; i<nTotal; i++) {
-    value = values[params[i]];
-    if (value != null) {
-      result += (search ? '&' : '?') + params[i] + '=' + encodeURIComponent(value);
-      search = true;
-    }
+  for (i = 0; i < nPath; i++) {
+    param = params[i];
+    value = values[param];
+    type  = this.params[param];
+    // TODO: Maybe we should throw on null here? It's not really good style
+    // to use '' and null interchangeabley
+    if (value != null) result += encodeURIComponent(type.encode(value));
+    result += segments[i + 1];
   }
 
+  for (/**/; i < nTotal; i++) {
+    param = params[i]
+    if (values[param] == null) continue;
+    result += (search ? '&' : '?') + param + '=' + encodeURIComponent(values[param]);
+    search = true;
+  }
   return result;
 };
 
+UrlMatcher.prototype.$types = {};
+
+function Type(options) {
+  extend(this, options);
+}
+
+Type.prototype.is = function(val, key) {
+  return angular.toJson(this.decode(this.encode(val))) === angular.toJson(val);
+};
+
+Type.prototype.encode = function(val, key) {
+  return String(val);
+};
 
+Type.prototype.decode = function(val, key) {
+  return val;
+}
+
+Type.prototype.equals = function(a, b) {
+  return a == b;
+};
+
+Type.prototype.$subPattern = function() {
+  var sub = this.pattern.toString();
+  return sub.substr(1, sub.length - 2);
+};
+
+Type.prototype.pattern = /.*/;
 
 /**
  * @ngdoc object
@@ -271,6 +304,33 @@ function $UrlMatcherFactory() {
 
   var useCaseInsensitiveMatch = false;
 
+  var enqueue = true, typeQueue = [], injector, defaultTypes = {
+    int: {
+      decode: function(val) {
+        return parseInt(val, 10);
+      },
+      is: function(val) {
+        return this.decode(val.toString()) === val;
+      },
+      pattern: /\d+/
+    },
+    bool: {
+      encode: function(val) {
+        return val ? 1 : 0;
+      },
+      decode: function(val) {
+        return parseInt(val, 10) === 0 ? false : true;
+      },
+      is: function(val) {
+        return val === true || val === false;
+      },
+      pattern: /0|1/
+    },
+    string: {
+      pattern: /.*/
+    }
+  };
+
   /**
    * @ngdoc function
    * @name ui.router.util.$urlMatcherFactory#caseInsensitiveMatch
@@ -281,7 +341,7 @@ function $UrlMatcherFactory() {
    *   
    * @param {bool} value false to match URL in a case sensitive manner; otherwise true;
    */
-  this.caseInsensitiveMatch = function(value){
+  this.caseInsensitiveMatch = function(value) {
     useCaseInsensitiveMatch = value;
   };
 
@@ -314,11 +374,36 @@ function $UrlMatcherFactory() {
   this.isMatcher = function (o) {
     return isObject(o) && isFunction(o.exec) && isFunction(o.format) && isFunction(o.concat);
   };
-  
-  /* No need to document $get, since it returns this */
-  this.$get = function () {
+
+  this.type = function (name, def) {
+    if (!isDefined(def)) return UrlMatcher.prototype.$types[name];
+    typeQueue.push({ name: name, def: def });
+    if (!enqueue) flushTypeQueue();
     return this;
   };
+
+  /* No need to document $get, since it returns this */
+  this.$get = ['$injector', function ($injector) {
+    injector = $injector;
+    enqueue = false;
+    UrlMatcher.prototype.$types = {};
+    flushTypeQueue();
+
+    forEach(defaultTypes, function(type, name) {
+      if (!UrlMatcher.prototype.$types[name]) UrlMatcher.prototype.$types[name] = new Type(type);
+    });
+    return this;
+  }];
+
+  function flushTypeQueue() {
+    forEach(typeQueue, function(type) {
+      if (UrlMatcher.prototype.$types[type.name]) {
+        throw new Error("A type named '" + type.name + "' has already been defined.");
+      }
+      var def = new Type(isFunction(type.def) ? injector.invoke(type.def) : type.def);
+      UrlMatcher.prototype.$types[type.name] = def;
+    });
+  }
 }
 
 // Register as a provider so it's available to other providers
diff --git a/test/urlMatcherFactorySpec.js b/test/urlMatcherFactorySpec.js
index 67dbae3e1..68c75fc96 100644
--- a/test/urlMatcherFactorySpec.js
+++ b/test/urlMatcherFactorySpec.js
@@ -1,19 +1,20 @@
 describe("UrlMatcher", function () {
-  it("matches static URLs", function () {
+
+  it("shoudl match static URLs", function () {
     expect(new UrlMatcher('/hello/world').exec('/hello/world')).toEqual({});
   });
 
-  it("matches static case insensitive URLs", function () {
+  it("should match static case insensitive URLs", function () {
     expect(new UrlMatcher('/hello/world', true).exec('/heLLo/World')).toEqual({});
   });
 
-  it("matches against the entire path", function () {
+  it("should match against the entire path", function () {
     var matcher = new UrlMatcher('/hello/world');
     expect(matcher.exec('/hello/world/')).toBeNull();
     expect(matcher.exec('/hello/world/suffix')).toBeNull();
   });
 
-  it("parses parameter placeholders", function () {
+  it("shoudl parse parameter placeholders", function () {
     var matcher = new UrlMatcher('/users/:id/details/{type}/{repeat:[0-9]+}?from&to');
     var params = matcher.parameters();
     expect(params.length).toBe(5);
@@ -24,105 +25,107 @@ describe("UrlMatcher", function () {
     expect(params).toContain('to');
   });
 
-  it("handles proper snake case parameter names", function(){
-    var matcher = new UrlMatcher('/users/?from&to&snake-case&snake-case-triple');
-    var params = matcher.parameters();
-    expect(params.length).toBe(4);
-    expect(params).toContain('from');
-    expect(params).toContain('to');
-    expect(params).toContain('snake-case');
-    expect(params).toContain('snake-case-triple');
-  });
+  describe("snake-case parameters", function() {
+    it("should match if properly formatted", function() {
+      var matcher = new UrlMatcher('/users/?from&to&snake-case&snake-case-triple');
+      var params = matcher.parameters();
 
-    it("handles invalid snake case parameter names", function(){
-        expect(function() { new UrlMatcher('/users/?from&to&-snake'); }).toThrow(
-            "Invalid parameter name '-snake' in pattern '/users/?from&to&-snake'"
-        );
-
-        expect(function() { new UrlMatcher('/users/?from&to&snake-'); }).toThrow(
-            "Invalid parameter name 'snake-' in pattern '/users/?from&to&snake-'"
-        );
+      expect(params.length).toBe(4);
+      expect(params).toContain('from');
+      expect(params).toContain('to');
+      expect(params).toContain('snake-case');
+      expect(params).toContain('snake-case-triple');
     });
 
-  it(".exec() captures parameter values", function () {
-    expect(
-      new UrlMatcher('/users/:id/details/{type}/{repeat:[0-9]+}?from&to')
-        .exec('/users/123/details//0', {}))
-      .toEqual({ id:'123', type:'', repeat:'0' });
-  });
+    it("should not match if invalid", function() {
+      var err = "Invalid parameter name '-snake' in pattern '/users/?from&to&-snake'";
+      expect(function() { new UrlMatcher('/users/?from&to&-snake'); }).toThrow(err);
 
-  it(".exec() captures catch-all parameters", function () {
-    var m = new UrlMatcher('/document/*path');
-    expect(m.exec('/document/a/b/c', {})).toEqual({ path: 'a/b/c' });
-    expect(m.exec('/document/', {})).toEqual({ path: '' });
+      err = "Invalid parameter name 'snake-' in pattern '/users/?from&to&snake-'";
+      expect(function() { new UrlMatcher('/users/?from&to&snake-'); }).toThrow(err);
+    });
   });
 
-  it(".exec() uses the optional regexp with curly brace placeholders", function () {
-    expect(
-      new UrlMatcher('/users/:id/details/{type}/{repeat:[0-9]+}?from&to')
-        .exec('/users/123/details/what/thisShouldBeDigits', {}))
-      .toBeNull();
-  });
+  describe(".exec()", function() {
+    it("should capture parameter values", function () {
+      var m = new UrlMatcher('/users/:id/details/{type}/{repeat:[0-9]+}?from&to');
+      expect(m.exec('/users/123/details//0', {})).toEqual({ id:'123', type:'', repeat:'0' });
+    });
 
-  it(".exec() treats the URL as already decoded and does not decode it further", function () {
-    expect(new UrlMatcher('/users/:id').exec('/users/100%25', {})).toEqual({ id: '100%25'});
-  });
+    it("should capture catch-all parameters", function () {
+      var m = new UrlMatcher('/document/*path');
+      expect(m.exec('/document/a/b/c', {})).toEqual({ path: 'a/b/c' });
+      expect(m.exec('/document/', {})).toEqual({ path: '' });
+    });
 
-  it('.exec() throws on unbalanced capture list', function () {
-    var shouldThrow = {
-      "/url/{matchedParam:([a-z]+)}/child/{childParam}": '/url/someword/child/childParam',
-      "/url/{matchedParam:([a-z]+)}/child/{childParam}?foo": '/url/someword/child/childParam'
-    };
+    it("should use the optional regexp with curly brace placeholders", function () {
+      var m = new UrlMatcher('/users/:id/details/{type}/{repeat:[0-9]+}?from&to');
+      expect(m.exec('/users/123/details/what/thisShouldBeDigits', {})).toBeNull();
+    });
 
-    angular.forEach(shouldThrow, function(url, route) {
-      expect(function() { new UrlMatcher(route).exec(url, {}); }).toThrow(
-        "Unbalanced capture group in route '" + route + "'"
-      );
+    it("should treat the URL as already decoded and does not decode it further", function () {
+      expect(new UrlMatcher('/users/:id').exec('/users/100%25', {})).toEqual({ id: '100%25'});
     });
 
-    var shouldPass = {
-      "/url/{matchedParam:[a-z]+}/child/{childParam}": '/url/someword/child/childParam',
-      "/url/{matchedParam:[a-z]+}/child/{childParam}?foo": '/url/someword/child/childParam'
-    };
+    it('should throw on unbalanced capture list', function () {
+      var shouldThrow = {
+        "/url/{matchedParam:([a-z]+)}/child/{childParam}": '/url/someword/child/childParam',
+        "/url/{matchedParam:([a-z]+)}/child/{childParam}?foo": '/url/someword/child/childParam'
+      };
+
+      angular.forEach(shouldThrow, function(url, route) {
+        expect(function() { new UrlMatcher(route).exec(url, {}); }).toThrow(
+          "Unbalanced capture group in route '" + route + "'"
+        );
+      });
+
+      var shouldPass = {
+        "/url/{matchedParam:[a-z]+}/child/{childParam}": '/url/someword/child/childParam',
+        "/url/{matchedParam:[a-z]+}/child/{childParam}?foo": '/url/someword/child/childParam'
+      };
 
-    angular.forEach(shouldPass, function(url, route) {
-      expect(function() { new UrlMatcher(route).exec(url, {}); }).not.toThrow();
+      angular.forEach(shouldPass, function(url, route) {
+        expect(function() { new UrlMatcher(route).exec(url, {}); }).not.toThrow();
+      });
     });
   });
 
-  it(".format() reconstitutes the URL", function () {
-    expect(
-      new UrlMatcher('/users/:id/details/{type}/{repeat:[0-9]+}?from')
-        .format({ id:'123', type:'default', repeat:444, ignored:'value', from:'1970' }))
-      .toEqual('/users/123/details/default/444?from=1970');
-  });
+  describe(".format()", function() {
+    it("should reconstitute the URL", function () {
+      var m = new UrlMatcher('/users/:id/details/{type}/{repeat:[0-9]+}?from'),
+          params = { id:'123', type:'default', repeat:444, ignored:'value', from:'1970' };
 
-  it(".format() encodes URL parameters", function () {
-    expect(new UrlMatcher('/users/:id').format({ id:'100%'})).toEqual('/users/100%25');
-  });
+      expect(m.format(params)).toEqual('/users/123/details/default/444?from=1970');
+    });
 
-  it(".format() encodes URL parameters with hashes", function () {
-    expect(
-      new UrlMatcher('/users/:id#:section')
-        .format({ id: 'bob', section: 'contact-details' }))
-    .toEqual('/users/bob#contact-details');
-  });
+    it("should encode URL parameters", function () {
+      expect(new UrlMatcher('/users/:id').format({ id:'100%'})).toEqual('/users/100%25');
+    });
 
-  it(".concat() concatenates matchers", function () {
-    var matcher = new UrlMatcher('/users/:id/details/{type}?from').concat('/{repeat:[0-9]+}?to');
-    var params = matcher.parameters();
-    expect(params.length).toBe(5);
-    expect(params).toContain('id');
-    expect(params).toContain('type');
-    expect(params).toContain('repeat');
-    expect(params).toContain('from');
-    expect(params).toContain('to');
+    it("encodes URL parameters with hashes", function () {
+      var m = new UrlMatcher('/users/:id#:section'),
+          params = { id: 'bob', section: 'contact-details' };
+      expect(m.format(params)).toEqual('/users/bob#contact-details');
+    });
   });
 
-  it(".concat() returns a new matcher", function () {
-    var base = new UrlMatcher('/users/:id/details/{type}?from');
-    var matcher = base.concat('/{repeat:[0-9]+}?to');
-    expect(matcher).toNotBe(base);
+  describe(".concat()", function() {
+    it("should concatenate matchers", function () {
+      var matcher = new UrlMatcher('/users/:id/details/{type}?from').concat('/{repeat:[0-9]+}?to');
+      var params = matcher.parameters();
+      expect(params.length).toBe(5);
+      expect(params).toContain('id');
+      expect(params).toContain('type');
+      expect(params).toContain('repeat');
+      expect(params).toContain('from');
+      expect(params).toContain('to');
+    });
+
+    it("should return a new matcher", function () {
+      var base = new UrlMatcher('/users/:id/details/{type}?from');
+      var matcher = base.concat('/{repeat:[0-9]+}?to');
+      expect(matcher).toNotBe(base);
+    });
   });
 });
 
@@ -142,14 +145,47 @@ describe("urlMatcherFactory", function () {
 
   it("recognizes matchers", function () {
     expect($umf.isMatcher(new UrlMatcher('/'))).toBe(true);
+
+    var custom = { format: angular.noop, exec: angular.noop, concat: angular.noop };
+    expect($umf.isMatcher(custom)).toBe(true);
   });
 
-  it("should handle case sensistive URL by default", function () {
+  it("should handle case sensitive URL by default", function () {
     expect($umf.compile('/hello/world').exec('/heLLo/WORLD')).toBeNull();
   });
 
   it("should handle case insensistive URL", function () {
-  	$umf.caseInsensitiveMatch(true);
+    $umf.caseInsensitiveMatch(true);
     expect($umf.compile('/hello/world').exec('/heLLo/WORLD')).toEqual({});
   });
+
+  describe("typed parameters", function() {
+    it("should accept object definitions", function() {
+      var type = { encode: function() {}, decode: function() {} };
+      $umf.type("myType", type);
+      expect($umf.type("myType").encode).toBe(type.encode);
+    });
+
+    it("should reject duplicate definitions", function() {
+      $umf.type("myType", { encode: function() {}, decode: function() {} });
+      expect(function() { $umf.type("myType", {}); }).toThrow("A type named 'myType' has already been defined.");
+    });
+
+    it("should accept injected function definitions", inject(function($stateParams) {
+      $umf.type("myType", function($stateParams) {
+        return {
+          decode: function() {
+            return $stateParams;
+          }
+        };
+      });
+      expect($umf.type("myType").decode()).toBe($stateParams);
+    }));
+
+    it("should match built-in types", function() {
+      var m = new UrlMatcher("/{foo:int}/{flag:bool}");
+      expect(m.exec("/1138/1")).toEqual({ foo: 1138, flag: true });
+      expect(m.format({ foo: 5, flag: true })).toBe("/5/1");
+    });
+  });
 });