Merge remote-tracking branch 'mgechev/ng-deploy' into ng-deploy

# Conflicts:
#	.gitignore
#	LICENSE
#	README.md
#	package.json

Author: JohannesHoppe

.gitignore

@@ -1,3 +1,24 @@
-.DS_Store
 node_modules
-npm-debug.log
+.tmp
+.sass-cache
+app/bower_components
+.DS_Store
+.bash_history
+*.swp
+*.swo
+*.d.ts
+
+*.classpath
+*.project
+*.settings/
+*.classpath
+*.project
+*.settings/
+
+.vim/bundle
+nvim/autoload
+nvim/plugged
+nvim/doc
+nvim/swaps
+nvim/colors
+dist

LICENSE

@@ -1,6 +1,7 @@
 The MIT License (MIT)
 
-Copyright (c) 2017 Johannes Hoppe, https://angular.schule/
+Copyright (c) 2017-2019 Johannes Hoppe
+Copyright (c) 2019 Minko Gechev
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

builders.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "@angular-devkit/architect/src/builders-schema.json",
+  "builders": {
+    "deploy": {
+      "implementation": "./deploy/builder",
+      "schema": "./deploy/schema.json",
+      "description": "Deploy builder"
+    }
+  }
+}

collection.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "@angular-devkit/schematics/collection-schema.json",
+  "schematics": {
+    "ng-add": {
+      "description": "Add GitHub pages deploy schematic",
+      "factory": "./ng-add#ngAdd"
+    }
+  }
+}

deploy/actions.spec.ts

@@ -0,0 +1,97 @@
+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: (_: string, __: any) => Promise.resolve()
+      },
+      context,
+      'host',
+      {}
+    );
+    expect(spy).toHaveBeenCalled();
+    expect(spy).toHaveBeenCalledWith(
+      {
+        target: 'build',
+        configuration: 'production',
+        project: PROJECT
+      },
+      {}
+    );
+  });
+
+  it('should invoke ghpages.publish', async () => {
+    const mock = {
+      publish: (_: string, __: any) => Promise.resolve()
+    };
+    const spy = spyOn(mock, 'publish').and.callThrough();
+    await deploy(mock, context, 'host', {});
+    expect(spy).toHaveBeenCalled();
+    expect(spy).toHaveBeenCalledWith('host', {});
+  });
+
+  describe('error handling', () => {
+    it('throws if there is no target project', async () => {
+      context.target = undefined;
+      try {
+        await deploy(
+          {
+            publish: (_: string, __: any) => Promise.resolve()
+          },
+          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,41 @@
+import { BuilderContext } from '@angular-devkit/architect';
+import { GHPages } from '../interfaces';
+import { Schema as RealDeployOptions } from './schema';
+import { json } from '@angular-devkit/core';
+type DeployOptions = RealDeployOptions & json.JsonObject;
+
+export default async function deploy(
+  ghPages: GHPages,
+  context: BuilderContext,
+  projectRoot: string,
+  options: DeployOptions
+) {
+  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'
+    },
+    options
+  );
+  await run.result;
+
+  try {
+    await ghPages.publish(projectRoot, {});
+    if (options.deployUrl) {
+      context.logger.info(
+        `🚀 Your application is now available at ${options.deployUrl}`
+      );
+    } else {
+      context.logger.info(`🚀 Your application is now on GitHub pages!`);
+    }
+  } catch (e) {
+    context.logger.error(e);
+  }
+}

deploy/builder.ts

@@ -0,0 +1,60 @@
+import {
+  BuilderContext,
+  BuilderOutput,
+  createBuilder
+} from '@angular-devkit/architect';
+import { NodeJsSyncHost } from '@angular-devkit/core/node';
+import deploy from './actions';
+import { experimental, join, normalize, json } from '@angular-devkit/core';
+import { Schema as RealDeployOptions } from './schema';
+type DeployOptions = RealDeployOptions & json.JsonObject;
+
+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 (
+    options: DeployOptions,
+    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 targets = workspace.getProjectTargets(context.target.project);
+
+    if (
+      !targets ||
+      !targets.build ||
+      !targets.build.options ||
+      !targets.build.options.outputPath
+    ) {
+      throw new Error('Cannot find the project output directory');
+    }
+
+    try {
+      await deploy(
+        ghpages,
+        context,
+        join(workspace.root, targets.build.options.outputPath),
+        options
+      );
+    } catch (e) {
+      context.logger.error('Error when trying to deploy: ', e.message);
+      return { success: false };
+    }
+
+    return { success: true };
+  }
+);

deploy/schema.json

@@ -0,0 +1,15 @@
+{
+  "id": "Schema",
+  "title": "schema",
+  "description": "Deployment of Angular CLI applications to GitHub pages",
+  "properties": {
+    "baseHref": {
+      "type": "string",
+      "description": "Base url for the application being built."
+    },
+    "deployUrl": {
+      "type": "string",
+      "description": "URL where files will be deployed."
+    }
+  }
+}

index.spec.ts

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

index.ts

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