feat(@angular-devkit/schematics): allow schematic rules to control interactivity

Author: clydin

packages/angular_devkit/schematics/src/engine/engine.ts

@@ -18,6 +18,7 @@ import {
   CollectionDescription,
   Engine,
   EngineHost,
+  ExecutionOptions,
   Schematic,
   SchematicContext,
   SchematicDescription,
@@ -215,12 +216,20 @@ export class SchematicEngine<CollectionT extends object, SchematicT extends obje
   createContext(
     schematic: Schematic<CollectionT, SchematicT>,
     parent?: Partial<TypedSchematicContext<CollectionT, SchematicT>>,
+    executionOptions?: Partial<ExecutionOptions>,
   ): TypedSchematicContext<CollectionT, SchematicT> {
     // Check for inconsistencies.
     if (parent && parent.engine && parent.engine !== this) {
       throw new SchematicEngineConflictingException();
     }
 
+    let interactive = true;
+    if (executionOptions && executionOptions.interactive != undefined) {
+      interactive = executionOptions.interactive;
+    } else if (parent && parent.interactive != undefined) {
+      interactive = parent.interactive;
+    }
+
     let context: TypedSchematicContext<CollectionT, SchematicT> = {
       debug: parent && parent.debug || false,
       engine: this,
@@ -229,6 +238,7 @@ export class SchematicEngine<CollectionT extends object, SchematicT extends obje
       schematic,
       strategy: (parent && parent.strategy !== undefined)
         ? parent.strategy : this.defaultMergeStrategy,
+      interactive,
       addTask,
     };
 
@@ -325,8 +335,9 @@ export class SchematicEngine<CollectionT extends object, SchematicT extends obje
   transformOptions<OptionT extends object, ResultT extends object>(
     schematic: Schematic<CollectionT, SchematicT>,
     options: OptionT,
+    context?: TypedSchematicContext<CollectionT, SchematicT>,
   ): Observable<ResultT> {
-    return this._host.transformOptions<OptionT, ResultT>(schematic.description, options);
+    return this._host.transformOptions<OptionT, ResultT>(schematic.description, options, context);
   }
 
   createSourceFromUrl(url: Url, context: TypedSchematicContext<CollectionT, SchematicT>): Source {

packages/angular_devkit/schematics/src/engine/interface.ts

@@ -41,6 +41,10 @@ export interface TaskInfo {
   readonly context: SchematicContext;
 }
 
+export interface ExecutionOptions {
+  interactive: boolean;
+}
+
 /**
  * The description (metadata) of a collection. This type contains every information the engine
  * needs to run. The CollectionMetadataT type parameter contains additional metadata that you
@@ -92,6 +96,7 @@ export interface EngineHost<CollectionMetadataT extends object, SchematicMetadat
   transformOptions<OptionT extends object, ResultT extends object>(
     schematic: SchematicDescription<CollectionMetadataT, SchematicMetadataT>,
     options: OptionT,
+    context?: TypedSchematicContext<CollectionMetadataT, SchematicMetadataT>,
   ): Observable<ResultT>;
   transformContext(
     context: TypedSchematicContext<CollectionMetadataT, SchematicMetadataT>,
@@ -118,6 +123,7 @@ export interface Engine<CollectionMetadataT extends object, SchematicMetadataT e
   createContext(
     schematic: Schematic<CollectionMetadataT, SchematicMetadataT>,
     parent?: Partial<TypedSchematicContext<CollectionMetadataT, SchematicMetadataT>>,
+    executionOptions?: Partial<ExecutionOptions>,
   ): TypedSchematicContext<CollectionMetadataT, SchematicMetadataT>;
   createSchematic(
       name: string,
@@ -130,6 +136,7 @@ export interface Engine<CollectionMetadataT extends object, SchematicMetadataT e
   transformOptions<OptionT extends object, ResultT extends object>(
       schematic: Schematic<CollectionMetadataT, SchematicMetadataT>,
       options: OptionT,
+      context?: TypedSchematicContext<CollectionMetadataT, SchematicMetadataT>,
   ): Observable<ResultT>;
   executePostTasks(): Observable<void>;
 
@@ -166,6 +173,7 @@ export interface Schematic<CollectionMetadataT extends object, SchematicMetadata
     options: OptionT,
     host: Observable<Tree>,
     parentContext?: Partial<TypedSchematicContext<CollectionMetadataT, SchematicMetadataT>>,
+    executionOptions?: Partial<ExecutionOptions>,
   ): Observable<Tree>;
 }
 
@@ -181,6 +189,7 @@ export interface TypedSchematicContext<CollectionMetadataT extends object,
   readonly logger: logging.LoggerApi;
   readonly schematic: Schematic<CollectionMetadataT, SchematicMetadataT>;
   readonly strategy: MergeStrategy;
+  readonly interactive: boolean;
   addTask<T>(task: TaskConfigurationGenerator<T>, dependencies?: Array<TaskId>): TaskId;
 }
 

packages/angular_devkit/schematics/src/engine/schematic.ts

@@ -13,6 +13,7 @@ import { Tree } from '../tree/interface';
 import {
   Collection,
   Engine,
+  ExecutionOptions,
   RuleFactory,
   Schematic,
   SchematicDescription,
@@ -46,13 +47,14 @@ export class SchematicImpl<CollectionT extends object, SchematicT extends object
     options: OptionT,
     host: Observable<Tree>,
     parentContext?: Partial<TypedSchematicContext<CollectionT, SchematicT>>,
+    executionOptions?: Partial<ExecutionOptions>,
   ): Observable<Tree> {
-    const context = this._engine.createContext(this, parentContext);
+    const context = this._engine.createContext(this, parentContext, executionOptions);
 
     return host
       .pipe(
         first(),
-        concatMap(tree => this._engine.transformOptions(this, options).pipe(
+        concatMap(tree => this._engine.transformOptions(this, options, context).pipe(
           map(o => [tree, o]),
         )),
         concatMap(([tree, transformedOptions]: [Tree, OptionT]) => {

packages/angular_devkit/schematics/src/rules/schematic.ts

@@ -7,7 +7,7 @@
  */
 import { of as observableOf } from 'rxjs';
 import { last, map } from 'rxjs/operators';
-import { Rule, SchematicContext } from '../engine/interface';
+import { ExecutionOptions, Rule, SchematicContext } from '../engine/interface';
 import { MergeStrategy, Tree } from '../tree/interface';
 import { branch } from '../tree/static';
 
@@ -19,14 +19,17 @@ import { branch } from '../tree/static';
  * @param schematicName The name of the schematic to run.
  * @param options The options to pass as input to the RuleFactory.
  */
-export function externalSchematic<OptionT extends object>(collectionName: string,
-                                                          schematicName: string,
-                                                          options: OptionT): Rule {
+export function externalSchematic<OptionT extends object>(
+  collectionName: string,
+  schematicName: string,
+  options: OptionT,
+  executionOptions?: Partial<ExecutionOptions>,
+): Rule {
   return (input: Tree, context: SchematicContext) => {
     const collection = context.engine.createCollection(collectionName);
     const schematic = collection.createSchematic(schematicName);
 
-    return schematic.call(options, observableOf(branch(input)), context);
+    return schematic.call(options, observableOf(branch(input)), context, executionOptions);
   };
 }
 
@@ -37,12 +40,16 @@ export function externalSchematic<OptionT extends object>(collectionName: string
  * @param schematicName The name of the schematic to run.
  * @param options The options to pass as input to the RuleFactory.
  */
-export function schematic<OptionT extends object>(schematicName: string, options: OptionT): Rule {
+export function schematic<OptionT extends object>(
+  schematicName: string,
+  options: OptionT,
+  executionOptions?: Partial<ExecutionOptions>,
+): Rule {
   return (input: Tree, context: SchematicContext) => {
     const collection = context.schematic.collection;
     const schematic = collection.createSchematic(schematicName, true);
 
-    return schematic.call(options, observableOf(branch(input)), context).pipe(
+    return schematic.call(options, observableOf(branch(input)), context, executionOptions).pipe(
       last(),
       map(x => {
         // We allow overwrite conflict here because they're the only merge conflict we particularly

packages/angular_devkit/schematics/tools/fallback-engine-host.ts

@@ -31,10 +31,6 @@ export type FallbackSchematicDescription = {
 };
 export type FallbackContext =
   TypedSchematicContext<FallbackCollectionDescription, FallbackSchematicDescription>;
-export declare type OptionTransform<T extends object, R extends object> = (
-  schematic: SchematicDescription<FallbackCollectionDescription, FallbackSchematicDescription>,
-  options: T,
-) => Observable<R>;
 
 
 /**
@@ -93,9 +89,12 @@ export class FallbackEngineHost implements EngineHost<{}, {}> {
   transformOptions<OptionT extends object, ResultT extends object>(
     schematic: SchematicDescription<FallbackCollectionDescription, FallbackSchematicDescription>,
     options: OptionT,
+    context?: FallbackContext,
   ): Observable<ResultT> {
     return (observableOf(options)
-      .pipe(...this._hosts.map(host => mergeMap(opt => host.transformOptions(schematic, opt))))
+      .pipe(...this._hosts
+        .map(host => mergeMap(opt => host.transformOptions(schematic, opt, context))),
+      )
     ) as {} as Observable<ResultT>;
   }
 

packages/angular_devkit/schematics/tools/file-system-engine-host-base.ts

@@ -39,7 +39,11 @@ import { readJsonFile } from './file-system-utility';
 
 
 export declare type OptionTransform<T extends object, R extends object>
-    = (schematic: FileSystemSchematicDescription, options: T) => Observable<R>;
+    = (
+      schematic: FileSystemSchematicDescription,
+      options: T,
+      context?: FileSystemSchematicContext,
+    ) => Observable<R>;
 
 
 export class CollectionCannotBeResolvedException extends BaseException {
@@ -269,11 +273,12 @@ export abstract class FileSystemEngineHostBase implements
   transformOptions<OptionT extends object, ResultT extends object>(
     schematic: FileSystemSchematicDesc,
     options: OptionT,
+    context?: FileSystemSchematicContext,
   ): Observable<ResultT> {
     return (observableOf(options)
       .pipe(
         ...this._transforms.map(tFn => mergeMap(opt => {
-          const newOptions = tFn(schematic, opt);
+          const newOptions = tFn(schematic, opt, context);
           if (isObservable(newOptions)) {
             return newOptions;
           } else {

packages/angular_devkit/schematics/tools/schema-option-transform.ts

@@ -8,7 +8,7 @@
 import { deepCopy, schema } from '@angular-devkit/core';
 import { Observable, of as observableOf } from 'rxjs';
 import { first, map, mergeMap } from 'rxjs/operators';
-import { FileSystemSchematicDescription } from './description';
+import { FileSystemSchematicContext, FileSystemSchematicDescription } from './description';
 
 export class InvalidInputOptions<T = {}> extends schema.SchemaValidationException {
   constructor(options: T, errors: schema.SchemaValidatorError[]) {
@@ -21,16 +21,22 @@ export class InvalidInputOptions<T = {}> extends schema.SchemaValidationExceptio
 
 // This can only be used in NodeJS.
 export function validateOptionsWithSchema(registry: schema.SchemaRegistry) {
-  return <T extends {}>(schematic: FileSystemSchematicDescription, options: T): Observable<T> => {
+  return <T extends {}>(
+    schematic: FileSystemSchematicDescription,
+    options: T,
+    context?: FileSystemSchematicContext,
+  ): Observable<T> => {
     // Prevent a schematic from changing the options object by making a copy of it.
     options = deepCopy(options);
 
+    const withPrompts = context ? context.interactive : true;
+
     if (schematic.schema && schematic.schemaJson) {
       // Make a deep copy of options.
       return registry
         .compile(schematic.schemaJson)
         .pipe(
-          mergeMap(validator => validator(options)),
+          mergeMap(validator => validator(options, { withPrompts })),
           first(),
           map(result => {
             if (!result.success) {