initial import for Open Source 🎉

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

@@ -0,0 +1,53 @@
+import { RouteBuilder } from './route-builder.service';
+import { Injectable, Inject } from 'ng-metadata/core';
+import { PageService, QuayPage, QuayPageProfile } from '../page/page.service';
+
+
+@Injectable(RouteBuilder.name)
+export class RouteBuilderImpl implements RouteBuilder {
+
+  public currentProfile: string = 'layout';
+  public profiles: QuayPageProfile[] = [
+    // Start with the old pages (if we asked for it).
+    {id: 'old-layout', templatePath: '/static/partials/'},
+    // Fallback back combined new/existing pages.
+    {id: 'layout', templatePath: '/static/partials/'}
+  ];
+
+
+  constructor(@Inject('routeProvider') private routeProvider: ng.route.IRouteProvider,
+              @Inject('pages') private pages: PageService) {
+    for (let i = 0; i < this.profiles.length; ++i) {
+      if (this.profiles[i].id == this.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,118 @@
+import { RouteBuilderImpl } from './route-builder.service.impl';
+import { PageService } from '../page/page.service';
+
+
+describe("Service: RouteBuilderImpl", () => {
+  var routeProviderMock: any;
+  var pagesMock: any;
+  var profiles: any[];
+
+  beforeEach((() => {
+    profiles = [
+      {id: 'old-layout', templatePath: '/static/partials/'},
+      {id: 'layout', templatePath: '/static/partials/'}
+    ];
+    routeProviderMock = jasmine.createSpyObj('routeProvider', ['otherwise', 'when']);
+    pagesMock = jasmine.createSpyObj('pagesMock', ['get', 'create']);
+  }));
+
+  describe("constructor", () => {
+
+    it("returns a RouteBuilder object", () => {
+      var routeBuilder: RouteBuilderImpl = new RouteBuilderImpl(routeProviderMock, pagesMock);
+
+      expect(routeBuilder).toBeDefined();
+    });
+
+    it("initializes current profile to 'layout'", () => {
+      var routeBuilder: RouteBuilderImpl = new RouteBuilderImpl(routeProviderMock, pagesMock);
+
+      expect(routeBuilder.currentProfile).toEqual('layout');
+    });
+
+    it("initializes available profiles", () => {
+      var routeBuilder: RouteBuilderImpl = new RouteBuilderImpl(routeProviderMock, pagesMock);
+      var matchingRoutes: any[] = routeBuilder.profiles.filter((profile) => {
+        return profiles.indexOf(profile) == -1;
+      });
+      expect(matchingRoutes).toEqual(routeBuilder.profiles);
+    });
+
+    it("sets 'profiles' to the first given profile with id matching given current profile", () => {
+      var routeBuilder: RouteBuilderImpl = new RouteBuilderImpl(routeProviderMock, pagesMock);
+
+      expect(routeBuilder.profiles).toEqual([profiles[1]]);
+    });
+  });
+
+  describe("otherwise", () => {
+    var routeBuilder: RouteBuilderImpl;
+
+    beforeEach(() => {
+      routeBuilder = new RouteBuilderImpl(routeProviderMock, pagesMock);
+    });
+
+    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: RouteBuilderImpl;
+    var path: string;
+    var pagename: string;
+    var page: any;
+
+    beforeEach(() => {
+      path = '/repository/:namespace/:name';
+      pagename = 'repo-view';
+      page = {
+        templateName: 'repository.html',
+        reloadOnSearch: false,
+        controller: jasmine.createSpy('pageController'),
+        flags: {},
+      };
+      routeBuilder = new RouteBuilderImpl(routeProviderMock, pagesMock);
+    });
+
+    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: any = {
+        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,18 @@
+/**
+ * Constructs client-side routes.
+ */
+export abstract class RouteBuilder {
+
+  /**
+   * Configure the redirect route.
+   * @param options Configuration options.
+   */
+  public abstract otherwise(options: any): void;
+
+  /**
+   * Register a route.
+   * @param path The URL of the route.
+   * @param pagename The name of the page to associate with this route.
+   */
+  public abstract route(path: string, pagename: string): RouteBuilder;
+}