refactoring RouteBuilderFactory into service

static/js/services/route-builder/route-builder.factory.spec.ts

@@ -0,0 +1,35 @@
+import RouteBuilderFactory from './route-builder.factory';
+import { RouteBuilder } from "static/js/services/route-builder/route-builder.service";
+
+
+describe("Factory: RouteBuilderFactory", () => {
+  var routeBuilderFactory: RouteBuilderFactory;
+  var routeProviderMock;
+  var pagesMock;
+  var profiles;
+  var currentProfile;
+
+  beforeEach(() => {
+    profiles = [
+      {id: 'old-layout', templatePath: '/static/partials/'},
+      {id: 'layout', templatePath: '/static/partials/'}
+    ];
+    currentProfile = 'layout';
+    routeProviderMock = jasmine.createSpyObj('routeProvider', ['otherwise', 'when']);
+    pagesMock = jasmine.createSpyObj('pagesMock', ['get', 'create']);
+    routeBuilderFactory = new RouteBuilderFactory();
+  });
+
+  describe("constructor", () => {
+
+  });
+
+  describe("create", () => {
+
+    it("returns a RouteBuilder instance", () => {
+      var routeBuilder: RouteBuilder = routeBuilderFactory.create(routeProviderMock, pagesMock, profiles, currentProfile);
+
+      expect(routeBuilder).toBeDefined();
+    });
+  });
+});

static/js/services/route-builder/route-builder.factory.ts

@@ -0,0 +1,14 @@
+import { RouteBuilder } from './route-builder.service';
+import { RouteBuilderImpl } from './route-builder.service.impl';
+
+
+export default class RouteBuilderFactory {
+
+  constructor() {
+
+  }
+
+  public create(routeProvider, pages, profiles, currentProfile): RouteBuilder {
+    return new RouteBuilderImpl(routeProvider, pages, profiles, currentProfile);
+  }
+}

static/js/services/route-builder/route-builder.service.impl.ts

@@ -0,0 +1,47 @@
+import { RouteBuilder } from './route-builder.service';
+
+
+export function routeBuilderFactory() {
+  return (routeProvider, pages, profiles, currentProfile): RouteBuilder => {
+    return new RouteBuilderImpl(routeProvider, pages, profiles, currentProfile);
+  }
+}
+
+
+export class RouteBuilderImpl implements RouteBuilder {
+
+  constructor(private routeProvider, private pages, public profiles, currentProfile) {
+    for (let i = 0; i < this.profiles.length; ++i) {
+      if (this.profiles[i].id == currentProfile) {
+        this.profiles = this.profiles.slice(i);
+        break;
+      }
+    }
+  }
+
+  public otherwise(options: any): void {
+    this.routeProvider.otherwise(options);
+  }
+
+  public route(path: string, pagename: string): RouteBuilder {
+    // Lookup the page, matching our lists of profiles.
+    var pair = this.pages.get(pagename, this.profiles);
+    if (!pair) {
+      throw Error('Unknown page: ' + pagename);
+    }
+
+    // Create the route.
+    var foundProfile = pair[0];
+    var page = pair[1];
+    var templateUrl = foundProfile.templatePath + page.templateName;
+
+    var options = page.flags || {};
+    options['templateUrl'] = templateUrl;
+    options['reloadOnSearch'] = false;
+    options['controller'] = page.controller;
+
+    this.routeProvider.when(path, options);
+
+    return this;
+  }
+}

static/js/services/route-builder/route-builder.service.spec.ts

@@ -0,0 +1,111 @@
+import { RouteBuilderImpl } from './route-builder.service.impl';
+
+
+describe("Service: RouteBuilderImpl", () => {
+  var routeProviderMock;
+  var pagesMock;
+  var profiles;
+  var currentProfile;
+
+  beforeEach((() => {
+    profiles = [
+      {id: 'old-layout', templatePath: '/static/partials/'},
+      {id: 'layout', templatePath: '/static/partials/'}
+    ];
+    currentProfile = 'layout';
+    routeProviderMock = jasmine.createSpyObj('routeProvider', ['otherwise', 'when']);
+    pagesMock = jasmine.createSpyObj('pagesMock', ['get', 'create']);
+  }));
+
+  describe("constructor", () => {
+
+    it("returns a RouteBuilder object", () => {
+      var routeBuilder = new RouteBuilderImpl(routeProviderMock, pagesMock, profiles, currentProfile);
+
+      expect(routeBuilder).toBeDefined();
+    });
+
+    it("sets 'profiles' to all given profiles if given current profile does not match any of the given profiles' id", () => {
+      var routeBuilder = new RouteBuilderImpl(routeProviderMock, pagesMock, profiles, 'fake-profile');
+
+      expect(routeBuilder.profiles).toEqual(profiles);
+    });
+
+    it("sets 'profiles' to the first given profile with id matching given current profile", () => {
+      var routeBuilder = new RouteBuilderImpl(routeProviderMock, pagesMock, profiles, currentProfile);
+
+      expect(routeBuilder.profiles).toEqual([profiles[1]]);
+    });
+  });
+
+  describe("otherwise", () => {
+    var routeBuilder;
+
+    beforeEach(() => {
+      routeBuilder = new RouteBuilderImpl(routeProviderMock, pagesMock, profiles, currentProfile);
+    });
+
+    it("calls routeProvider to set fallback route with given options", () => {
+      var options = {1: "option"};
+      routeBuilder.otherwise(options);
+
+      expect(routeProviderMock.otherwise.calls.argsFor(0)[0]).toEqual(options);
+    });
+  });
+
+  describe("route", () => {
+    var routeBuilder;
+    var path;
+    var pagename;
+    var page;
+
+    beforeEach(() => {
+      path = '/repository/:namespace/:name';
+      pagename = 'repo-view';
+      page = {
+        templateName: 'repository.html',
+        reloadOnSearch: false,
+        controller: jasmine.createSpy('pageController'),
+        flags: {},
+      };
+      routeBuilder = new RouteBuilderImpl(routeProviderMock, pagesMock, profiles, currentProfile);
+    });
+
+    it("calls pages with given pagename and 'profiles' to get matching page and profile pair", () => {
+      pagesMock.get.and.returnValue([profiles[1], page]);
+      routeBuilder.route(path, pagename);
+
+      expect(pagesMock.get.calls.argsFor(0)[0]).toEqual(pagename);
+      expect(pagesMock.get.calls.argsFor(0)[1]).toEqual(routeBuilder.profiles);
+    });
+
+    it("throws error if no matching page/profile pair found", () => {
+      pagesMock.get.and.returnValue();
+      try {
+        routeBuilder.route(path, pagename);
+        fail();
+      } catch (error) {
+        expect(error.message).toEqual('Unknown page: ' + pagename);
+      }
+    });
+
+    it("calls routeProvider to set route for given path and options", () => {
+      pagesMock.get.and.returnValue([profiles[1], page]);
+      var expectedOptions = {
+        templateUrl: profiles[1].templatePath + page.templateName,
+        reloadOnSearch: false,
+        controller: page.controller,
+      };
+      routeBuilder.route(path, pagename);
+
+      expect(routeProviderMock.when.calls.argsFor(0)[0]).toEqual(path);
+      expect(routeProviderMock.when.calls.argsFor(0)[1]).toEqual(expectedOptions);
+    });
+
+    it("returns itself (the RouteBuilder instance)", () => {
+      pagesMock.get.and.returnValue([profiles[1], page]);
+
+      expect(routeBuilder.route(path, pagename)).toEqual(routeBuilder);
+    });
+  });
+});

static/js/services/route-builder/route-builder.service.ts

@@ -0,0 +1,6 @@
+export abstract class RouteBuilder {
+
+  public abstract otherwise(options: any): void;
+
+  public abstract route(path: string, pagename: string): RouteBuilder;
+}