refactor(UrlRouter): Change UrlRuleType from enum to string

refactor(UrlRouter): Move interfaces around

Author: christopherthielen

src/url/index.ts

@@ -2,6 +2,7 @@
  * @coreapi
  * @module url
  */ /** for typedoc */
+export * from "./interface";
 export * from "./urlMatcher";
 export * from "./urlMatcherFactory";
 export * from "./urlRouter";

src/url/interface.ts

@@ -1,7 +1,5 @@
-import { LocationServices, $InjectorLike, LocationConfig } from "../common/coreservices";
-import { UrlRule } from "./urlRule";
-import { UrlMatcher } from "./urlMatcher";
-import { IInjectable } from "../common/common";
+import { LocationConfig } from "../common/coreservices";
+import { Obj } from "../common/common";
 import { ParamType } from "../params/type";
 import { Param } from "../params/param";
 
@@ -23,3 +21,73 @@ export interface UrlMatcherConfig {
   paramType(name, type?)
 }
 
+/** @return truthy or falsey */
+export interface UrlRuleMatchFn {
+  (path: string, search: Obj, hash: string): any;
+}
+
+/** Handler invoked when a rule is matched */
+export interface UrlRuleHandlerFn {
+  (matchObject: any, path?: string, search?: Obj, hash?: string): (string|boolean|void);
+}
+
+export type UrlRuleType = "STATE" | "URLMATCHER" | "STRING" | "REGEXP" | "RAW" | "OTHER";
+export interface UrlRule {
+  /** The type of the rule */
+  type: UrlRuleType;
+
+  /**
+   * This function should match the url and return match details
+   */
+  match: UrlRuleMatchFn;
+
+  /**
+   * This function is called after the rule matched the url.
+   * This function handles the rule match event.
+   */
+  handler: UrlRuleHandlerFn;
+
+  priority: number;
+}
+
+
+// export interface UrlService {
+//   // LocationServices
+//   // todo: switch back to url()
+//   setUrl(newurl: string, replace?: boolean): void;
+//   path(): string;
+//   search(): { [key: string]: any };
+//   hash(): string;
+//   onChange(callback: Function): Function;
+//
+//   config: {
+//     // LocationConfig
+//     port(): number;
+//     protocol(): string;
+//     host(): string;
+//     baseHref(): string;
+//     html5Mode(): boolean;
+//     hashPrefix(): string;
+//
+//     hashPrefix(newprefix: string): string;
+//
+//     // MatcherConfig
+//     caseInsensitive(value?: boolean): boolean;
+//     strictMode(value?: boolean): boolean;
+//     defaultSquashPolicy(value?: (boolean|string)): (boolean|string);
+//     paramType(name, type?)
+//   }
+//
+//   rules: {
+//     // UrlRouterProvider
+//     addRule(rule: UrlRule): UrlRouterProvider;
+//     otherwise(rule: string | (($injector: $InjectorLike, $location: LocationServices) => string)): UrlRouterProvider ;
+//     when(what: (RegExp|UrlMatcher|string), handler: string|IInjectable, ruleCallback?) ;
+//   }
+//
+//   deferIntercept(defer?: boolean);
+//
+//   // UrlRouter
+//   sync(evt?);
+//   listen(): Function;
+// }

src/url/urlRouter.ts

@@ -3,14 +3,15 @@
  * @module url
  */ /** for typedoc */
 import { removeFrom, createProxyFunctions, find } from "../common/common";
-import { isFunction, isString, isArray } from "../common/predicates";
+import { isFunction, isString } from "../common/predicates";
 import { UrlMatcher } from "./urlMatcher";
 import { RawParams } from "../params/interface";
 import { Disposable } from "../interface";
 import { UIRouter } from "../router";
 import { val, is, pattern } from "../common/hof";
-import { UrlRuleFactory, UrlRule, UrlRuleMatchFn, isUrlRule, UrlRuleHandlerFn } from "./urlRule";
+import { UrlRuleFactory } from "./urlRule";
 import { TargetState } from "../state/targetState";
+import { UrlRule, UrlRuleMatchFn, UrlRuleHandlerFn } from "./interface";
 
 /** @hidden */
 function appendBasePath(url: string, isHtml5: boolean, absolute: boolean, baseHref: string): string {
@@ -179,7 +180,7 @@ export class UrlRouter implements Disposable {
   }
 
   addRule(rule: UrlRule) {
-    if (!isUrlRule(rule)) throw new Error("invalid rule");
+    if (!UrlRuleFactory.isUrlRule(rule)) throw new Error("invalid rule");
     this.rules.push(rule);
     return () => this.removeRule(rule);
   }
@@ -228,12 +229,12 @@ export class UrlRouter implements Disposable {
       [isString,        (_redirectTo: string) => rf.fromMatchFn(val(_redirectTo))],
       [isFunction,      (_redirectTo: UrlRuleMatchFn) => rf.fromMatchFn(_redirectTo)],
       [is(TargetState), (target: TargetState) => ($state.go(target.name(), target.params(), target.options()), true)],
-      [val(true), invalidArgument]
+      [val(true),       error]
     ]);
 
     this.otherwiseFn = makeRule(redirectTo);
 
-    function invalidArgument() {
+    function error() {
       throw new Error("'redirectTo' must be a string, function, TargetState, or have a state: 'target' property");
     }
   };

src/url/urlRule.ts

@@ -1,12 +1,13 @@
 import { UrlMatcher } from "./urlMatcher";
 import { isString, isDefined } from "../common/predicates";
 import { UIRouter } from "../router";
-import { Obj, extend, identity } from "../common/common";
-import { RawParams } from "../params/interface";
+import { extend, identity } from "../common/common";
 import { is, pattern } from "../common/hof";
 import { State } from "../state/stateObject";
-import { UIRouterGlobals } from "../globals";
+import { RawParams } from "../params/interface";
+import { UrlRule, UrlRuleMatchFn, UrlRuleHandlerFn, UrlRuleType } from "./interface";
 import { StateService } from "../state/stateService";
+import { UIRouterGlobals } from "../globals";
 
 /**
  * Creates a [[UrlRule]]
@@ -25,6 +26,9 @@ export class UrlRuleFactory {
     return this.router.urlMatcherFactory.compile(pattern);
   }
 
+  static isUrlRule = obj =>
+      obj && ['type', 'match', 'handler', 'priority'].every(key => isDefined(obj[key]));
+
   create(what: string|State|UrlMatcher|RegExp, handler?): UrlRule {
     const makeRule = pattern([
       [isString,       () => this.fromString(what as string, handler)],
@@ -38,7 +42,7 @@ export class UrlRuleFactory {
   }
 
   fromString = (pattern: string, handler: string|UrlMatcher|UrlRuleHandlerFn) =>
-      extend(this.fromMatcher(this.compile(pattern), handler), { type: UrlRuleType.STRING });
+      extend(this.fromMatcher(this.compile(pattern), handler), { type: "STRING" });
 
   fromMatcher = (urlMatcher: UrlMatcher, handler: string|UrlMatcher|UrlRuleHandlerFn) =>
       new UrlMatcherRule(urlMatcher, (isString(handler) ? this.compile(handler) : handler));
@@ -53,38 +57,6 @@ export class UrlRuleFactory {
       new RawUrlRule(match);
 }
 
-/** @return truthy or falsey */
-export interface UrlRuleMatchFn {
-  (path: string, search: Obj, hash: string): any;
-}
-
-/** Handler invoked when a rule is matched */
-export interface UrlRuleHandlerFn {
-  (matchObject: any, path?: string, search?: Obj, hash?: string): (string|boolean|void);
-}
-
-export enum UrlRuleType { STATE, URLMATCHER, STRING, REGEXP, RAW, OTHER }
-export interface UrlRule {
-  /** The type of the rule */
-  type: UrlRuleType;
-
-  /**
-   * This function should match the url and return match details
-   */
-  match: UrlRuleMatchFn;
-
-  /**
-   * This function is called after the rule matched the url.
-   * This function handles the rule match event.
-   */
-  handler: UrlRuleHandlerFn;
-
-  priority: number;
-}
-
-export const isUrlRule = obj =>
-    obj && ['type', 'match', 'handler', 'priority'].every(key => isDefined(obj[key]));
-
 /**
  * A UrlRule which matches based on a regular expression
  *
@@ -119,7 +91,7 @@ export const isUrlRule = obj =>
  * ```
  */
 export class RegExpRule implements UrlRule {
-  type = UrlRuleType.REGEXP;
+  type: UrlRuleType = "REGEXP";
   handler: UrlRuleHandlerFn;
   priority = 0;
 
@@ -184,7 +156,7 @@ export class RegExpRule implements UrlRule {
  * ```
  */
 export class UrlMatcherRule implements UrlRule {
-  type = UrlRuleType.URLMATCHER;
+  type: UrlRuleType = "URLMATCHER";
   handler: UrlRuleHandlerFn;
   priority = 0;
 
@@ -211,7 +183,7 @@ export class UrlMatcherRule implements UrlRule {
  * ```
  */
 export class StateUrlRule implements UrlRule {
-  type = UrlRuleType.STATE;
+  type: UrlRuleType = "STATE";
   priority = 0;
   $state: StateService;
   globals: UIRouterGlobals;
@@ -248,10 +220,10 @@ export class StateUrlRule implements UrlRule {
  * The value from the `match` function is passed through as the `handler` result.
  */
 export class RawUrlRule implements UrlRule {
-  type = UrlRuleType.RAW;
+  type: UrlRuleType = "RAW";
   priority = 0;
 
   constructor(public match: UrlRuleMatchFn) { }
 
   handler = identity
-}
+}

test/urlRouterSpec.ts

@@ -2,7 +2,6 @@ import { UrlMatcher, UrlMatcherFactory, UrlRouter, StateService, UIRouter } from
 import { TestingPlugin } from "./_testingPlugin";
 import { LocationServices } from "../src/common/coreservices";
 import { UrlService } from "../src/url/urlService";
-import { UrlRuleType } from "../src/url/urlRule";
 
 declare var inject;
 
@@ -72,7 +71,7 @@ describe("UrlRouter", function () {
       match: () => count++,
       handler: match => match,
       priority: 0,
-      type: UrlRuleType.OTHER,
+      type: "OTHER",
     };
 
     let dereg = $ur.addRule(rule as any);
@@ -92,7 +91,7 @@ describe("UrlRouter", function () {
       match: () => count++,
       handler: match => match,
       priority: 0,
-      type: UrlRuleType.OTHER,
+      type: "OTHER",
     };
     $ur.addRule(rule as any);