feat(UrlService): (UrlRouter) improve perf of registering Url Rules and sorting Url Rules

1) The `UrlRouter.rule` function was re-sorting all the rules each time a new one was registered.
Now, the rules are sorted only just before they are used (by either `.match()` or `.rules()`).

2) The UrlMatcher.compare function was slow because it re-computed static information each time it ran.
Now, the static "segments" data is stored in `UrlMatcher._cache`

Closes #27
Closes angular-ui/ui-router#3274

Author: christopherthielen

src/url/urlMatcher.ts

@@ -1,11 +1,12 @@
 /**
  * @coreapi
  * @module url
- */ /** for typedoc */
+ */
+/** for typedoc */
 import {
-    map, defaults, inherit, identity, unnest, tail, find, Obj, pairs, allTrueR, unnestR, arrayTuples
+  map, defaults, inherit, identity, unnest, tail, find, Obj, pairs, allTrueR, unnestR, arrayTuples
 } from "../common/common";
-import { prop, propEq, pattern, eq, is, val } from "../common/hof";
+import { prop, propEq } from "../common/hof";
 import { isArray, isString, isDefined } from "../common/predicates";
 import { Param, DefType } from "../params/param";
 import { ParamTypes } from "../params/paramTypes";
@@ -35,11 +36,16 @@ function quoteRegExp(string: any, param?: any) {
 const memoizeTo = (obj: Obj, prop: string, fn: Function) =>
     obj[prop] = obj[prop] || fn();
 
+/** @hidden */
+const splitOnSlash = splitOnDelim('/');
+
 /** @hidden */
 interface UrlMatcherCache {
-  path: UrlMatcher[];
-  parent: UrlMatcher;
-  pattern: RegExp;
+  segments?: any[];
+  weights?: number[];
+  path?: UrlMatcher[];
+  parent?: UrlMatcher;
+  pattern?: RegExp;
 }
 
 /**
@@ -98,7 +104,7 @@ export class UrlMatcher {
   static nameValidator: RegExp = /^\w+([-.]+\w+)*(?:\[\])?$/;
 
   /** @hidden */
-  private _cache: UrlMatcherCache = { path: [this], parent: null, pattern: null };
+  private _cache: UrlMatcherCache = { path: [this] };
   /** @hidden */
   private _children: UrlMatcher[] = [];
   /** @hidden */
@@ -474,8 +480,6 @@ export class UrlMatcher {
    * The comparison function sorts static segments before dynamic ones.
    */
   static compare(a: UrlMatcher, b: UrlMatcher): number {
-    const splitOnSlash = splitOnDelim('/');
-
     /**
      * Turn a UrlMatcher and all its parent matchers into an array
      * of slash literals '/', string literals, and Param objects
@@ -484,27 +488,38 @@ export class UrlMatcher {
      * var matcher = $umf.compile("/foo").append($umf.compile("/:param")).append($umf.compile("/")).append($umf.compile("tail"));
      * var result = segments(matcher); // [ '/', 'foo', '/', Param, '/', 'tail' ]
      *
+     * Caches the result as `matcher._cache.segments`
      */
     const segments = (matcher: UrlMatcher) =>
-        matcher._cache.path.map(UrlMatcher.pathSegmentsAndParams)
-            .reduce(unnestR, [])
-            .reduce(joinNeighborsR, [])
-            .map(x => isString(x) ? splitOnSlash(x) : x)
-            .reduce(unnestR, []);
-
-    let aSegments = segments(a), bSegments = segments(b);
-    // console.table( { aSegments, bSegments });
-
-    // Sort slashes first, then static strings, the Params
-    const weight = pattern([
-      [eq("/"),   val(1)],
-      [isString,  val(2)],
-      [is(Param), val(3)]
-    ]);
-    let pairs = arrayTuples(aSegments.map(weight), bSegments.map(weight));
-    // console.table(pairs);
-
-    return pairs.reduce((cmp, weightPair) => cmp !== 0 ? cmp : weightPair[0] - weightPair[1], 0);
+        matcher._cache.segments = matcher._cache.segments ||
+            matcher._cache.path.map(UrlMatcher.pathSegmentsAndParams)
+                .reduce(unnestR, [])
+                .reduce(joinNeighborsR, [])
+                .map(x => isString(x) ? splitOnSlash(x) : x)
+                .reduce(unnestR, []);
+
+    /**
+     * Gets the sort weight for each segment of a UrlMatcher
+     *
+     * Caches the result as `matcher._cache.weights`
+     */
+    const weights = (matcher: UrlMatcher) =>
+        matcher._cache.weights = matcher._cache.weights ||
+            segments(matcher).map(segment => {
+              // Sort slashes first, then static strings, the Params
+              if (segment === '/') return 1;
+              if (isString(segment)) return 2;
+              if (segment instanceof Param) return 3;
+            });
+
+    let cmp, i, pairs = arrayTuples(weights(a), weights(b));
+
+    for (i = 0; i < pairs.length; i++) {
+      cmp = pairs[i][0] - pairs[i][1];
+      if (cmp !== 0) return cmp;
+    }
+
+    return 0;
   }
 }
 

src/url/urlRouter.ts

@@ -26,8 +26,6 @@ function appendBasePath(url: string, isHtml5: boolean, absolute: boolean, baseHr
 /** @hidden */
 const getMatcher = prop("urlMatcher");
 
-
-
 /**
  * Default rule priority sorting function.
  *
@@ -71,6 +69,7 @@ export class UrlRouter implements UrlRulesApi, UrlSyncApi, Disposable {
   /** @hidden */ private _otherwiseFn: UrlRule;
   /** @hidden */ interceptDeferred = false;
   /** @hidden */ private _id = 0;
+  /** @hidden */ private _sorted = false;
 
   /** @hidden */
   constructor(router: UIRouter) {
@@ -89,6 +88,11 @@ export class UrlRouter implements UrlRulesApi, UrlSyncApi, Disposable {
   /** @inheritdoc */
   sort(compareFn?: (a: UrlRule, b: UrlRule) => number) {
     this._rules.sort(this._sortFn = compareFn || this._sortFn);
+    this._sorted = true;
+  }
+
+  private ensureSorted() {
+    this._sorted || this.sort();
   }
 
   /**
@@ -97,6 +101,8 @@ export class UrlRouter implements UrlRulesApi, UrlSyncApi, Disposable {
    * @returns {MatchResult}
    */
   match(url: UrlParts): MatchResult {
+    this.ensureSorted();
+
     url = extend({path: '', search: {}, hash: '' }, url);
     let rules = this.rules();
     if (this._otherwiseFn) rules.push(this._otherwiseFn);
@@ -247,19 +253,23 @@ export class UrlRouter implements UrlRulesApi, UrlSyncApi, Disposable {
     if (!UrlRuleFactory.isUrlRule(rule)) throw new Error("invalid rule");
     rule.$id = this._id++;
     rule.priority = rule.priority || 0;
+
     this._rules.push(rule);
-    this.sort();
+    this._sorted = false;
+
     return () => this.removeRule(rule);
   }
 
   /** @inheritdoc */
   removeRule(rule): void {
     removeFrom(this._rules, rule);
-    this.sort();
   }
 
   /** @inheritdoc */
-  rules(): UrlRule[] { return this._rules.slice(); }
+  rules(): UrlRule[] {
+    this.ensureSorted();
+    return this._rules.slice();
+  }
 
   /** @inheritdoc */
   otherwise(handler: string|UrlRuleHandlerFn|TargetState|TargetStateDef) {
@@ -269,7 +279,7 @@ export class UrlRouter implements UrlRulesApi, UrlSyncApi, Disposable {
 
     let handlerFn: UrlRuleHandlerFn = isFunction(handler) ? handler as UrlRuleHandlerFn : val(handler);
     this._otherwiseFn = this.urlRuleFactory.create(val(true), handlerFn);
-    this.sort();
+    this._sorted = false;
   };
 
   /** @inheritdoc */