Initial commit

Author: mgechev

.gitignore

@@ -0,0 +1,23 @@
+node_modules
+.tmp
+.sass-cache
+app/bower_components
+.DS_Store
+.bash_history
+*.swp
+*.swo
+
+*.classpath
+*.project
+*.settings/
+*.classpath
+*.project
+*.settings/
+
+.vim/bundle
+nvim/autoload
+nvim/plugged
+nvim/doc
+nvim/swaps
+nvim/colors
+

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "editor.formatOnSave": true
+}

deploy/actions.spec.ts

@@ -0,0 +1,92 @@
+import { JsonObject, logging } from '@angular-devkit/core';
+import {
+  BuilderContext,
+  BuilderRun,
+  ScheduleOptions,
+  Target
+} from '@angular-devkit/architect/src/index';
+import deploy from './actions';
+
+let context: BuilderContext;
+
+const PROJECT = 'pirojok-project';
+
+describe('Deploy Angular apps', () => {
+  beforeEach(() => initMocks());
+
+  it('should invoke the builder', async () => {
+    const spy = spyOn(context, 'scheduleTarget').and.callThrough();
+    await deploy(
+      {
+        publish() {}
+      },
+      context,
+      'host'
+    );
+    expect(spy).toHaveBeenCalled();
+    expect(spy).toHaveBeenCalledWith({
+      target: 'build',
+      configuration: 'production',
+      project: PROJECT
+    });
+  });
+
+  it('should invoke ghpages.publish', async () => {
+    const mock = {
+      publish() {}
+    };
+    const spy = spyOn(mock, 'publish').and.callThrough();
+    await deploy(mock, context, 'host');
+    expect(spy).toHaveBeenCalled();
+    expect(spy).toHaveBeenCalledWith('host', {}, expect.any(Function));
+  });
+
+  describe('error handling', () => {
+    it('throws if there is no target project', async () => {
+      context.target = undefined;
+      try {
+        await deploy(
+          {
+            publish() {}
+          },
+          context,
+          'host'
+        );
+        fail();
+      } catch (e) {
+        expect(e.message).toMatch(/Cannot execute the build target/);
+      }
+    });
+  });
+});
+
+const initMocks = () => {
+  context = {
+    target: {
+      configuration: 'production',
+      project: PROJECT,
+      target: 'foo'
+    },
+    builder: {
+      builderName: 'mock',
+      description: 'mock',
+      optionSchema: false
+    },
+    currentDirectory: 'cwd',
+    id: 1,
+    logger: new logging.NullLogger() as any,
+    workspaceRoot: 'cwd',
+    addTeardown: _ => {},
+    validateOptions: _ => Promise.resolve({} as any),
+    getBuilderNameForTarget: () => Promise.resolve(''),
+    analytics: null as any,
+    getTargetOptions: (_: Target) => Promise.resolve({}),
+    reportProgress: (_: number, __?: number, ___?: string) => {},
+    reportStatus: (_: string) => {},
+    reportRunning: () => {},
+    scheduleBuilder: (_: string, __?: JsonObject, ___?: ScheduleOptions) =>
+      Promise.resolve({} as BuilderRun),
+    scheduleTarget: (_: Target, __?: JsonObject, ___?: ScheduleOptions) =>
+      Promise.resolve({} as BuilderRun)
+  };
+};

deploy/actions.ts

@@ -0,0 +1,38 @@
+import { BuilderContext } from '@angular-devkit/architect';
+import { GHPages } from '../interfaces';
+
+export default async function deploy(
+  ghPages: GHPages,
+  context: BuilderContext,
+  projectRoot: string
+) {
+  if (!context.target) {
+    throw new Error('Cannot execute the build target');
+  }
+
+  context.logger.info(`📦 Building "${context.target.project}"`);
+
+  const run = await context.scheduleTarget({
+    target: 'build',
+    project: context.target.project,
+    configuration: 'production'
+  });
+  await run.result;
+
+  try {
+    const success = ghPages.publish(projectRoot, {}, err => {
+      if (err) {
+        context.logger.error(err);
+        return;
+      }
+      console.log(arguments);
+      context.logger.info(
+        `🚀 Your application is now available at https://${
+          success.hosting.split('/')[1]
+        }.firebaseapp.com/`
+      );
+    });
+  } catch (e) {
+    context.logger.error(e);
+  }
+}

deploy/builder.ts

@@ -0,0 +1,41 @@
+import {
+  BuilderContext,
+  BuilderOutput,
+  createBuilder
+} from '@angular-devkit/architect';
+import { NodeJsSyncHost } from '@angular-devkit/core/node';
+import deploy from './actions';
+import { experimental, join, normalize } from '@angular-devkit/core';
+const ghpages = require('gh-pages');
+
+// Call the createBuilder() function to create a builder. This mirrors
+// createJobHandler() but add typings specific to Architect Builders.
+export default createBuilder<any>(
+  async (_: any, context: BuilderContext): Promise<BuilderOutput> => {
+    // The project root is added to a BuilderContext.
+    const root = normalize(context.workspaceRoot);
+    const workspace = new experimental.workspace.Workspace(
+      root,
+      new NodeJsSyncHost()
+    );
+    await workspace
+      .loadWorkspaceFromHost(normalize('angular.json'))
+      .toPromise();
+
+    if (!context.target) {
+      throw new Error('Cannot deploy the application without a target');
+    }
+
+    const project = workspace.getProject(context.target.project);
+
+    try {
+      await deploy(ghpages, context, join(workspace.root, project.root));
+    } catch (e) {
+      console.error('Error when trying to deploy: ');
+      console.error(e.message);
+      return { success: false };
+    }
+
+    return { success: true };
+  }
+);

deploy/schema.json

@@ -0,0 +1,6 @@
+{
+  "id": "GHPagesDeploySchema",
+  "title": "GH pages deploy",
+  "description": "TBD",
+  "properties": {}
+}

index.spec.ts

@@ -0,0 +1,2 @@
+import './ng-add.spec';
+import './deploy/actions.spec'; 

index.ts

@@ -0,0 +1 @@
+export * from './public_api';

interfaces.ts

@@ -0,0 +1,8 @@
+export interface GHPages {
+  publish(dir: string, options: any, callback: any);
+}
+
+export interface Project {
+  name: string;
+  id: string;
+}