.

Author: hansl

packages/schematics/README.md

@@ -31,6 +31,11 @@ The tooling is responsible for the following tasks:
 1. Create a Sink and commit the result of the schematics to the Sink. Many sinks are provided by the library; FileSystemSink and DryRunSink are examples.
 1. Output any logs propagated by the library, including debugging information.
 
+The tooling API is composed of the following pieces:
+
+## Engine
+The `SchematicEngine` is responsible for loading and constructing `Collection`s and `Schematics`'. When creating an engine, the tooling provides an `EngineHost` interface that understands how to create a `CollectionDescription` from a name, and how to create a `Schematic
+
 # Examples
 
 ## Simple
@@ -50,7 +55,7 @@ export default function MySchematic(options: any) {
 A few things from this example:
 
 1. The function receives the list of options from the tooling.
-2. It returns a [`Rule`](src/engine/interface.ts#L73), which is a transformation from a `Tree` to another `Tree`.
+1. It returns a [`Rule`](src/engine/interface.ts#L73), which is a transformation from a `Tree` to another `Tree`.
 
 
 

packages/schematics/src/engine/engine.ts

@@ -32,7 +32,7 @@ export class UnknownUrlSourceProtocol extends BaseException {
 export class SchematicEngine implements Engine {
   private _protocolMap = new Map<string, ProtocolHandler>();
 
-  constructor(private _options: EngineHost) {
+  constructor(private _host: EngineHost) {
     // Default implementations.
     this._protocolMap.set('null', () => {
       return () => empty();
@@ -46,7 +46,7 @@ export class SchematicEngine implements Engine {
   }
 
   createCollection(name: string): Collection | null {
-    const description = this._options.loadCollection(name);
+    const description = this._host.loadCollection(name);
     if (!description) {
       return null;
     }
@@ -55,7 +55,7 @@ export class SchematicEngine implements Engine {
   }
 
   createSchematic<T>(name: string, collection: Collection, options: T): Schematic | null {
-    const description = this._options.loadSchematic<T>(name, collection, options);
+    const description = this._host.loadSchematic<T>(name, collection, options);
     if (!description) {
       return null;
     }

packages/schematics/src/engine/interface.ts

@@ -12,20 +12,25 @@ import {Url} from 'url';
 
 
 export interface EngineHost {
-  loadCollection(name: string): CollectionDescription | null;
-  loadSchematic<T>(name: string,
-                   collection: Collection,
-                   options: T): ResolvedSchematicDescription | null;
+  loadCollection<T>(name: string): CollectionDescription<T> | null;
+  loadSchematic<CT, ST>(name: string,
+                        collection: CollectionDescription<CT>): SchematicDescription<ST> | null;
 }
 
 
-export interface Schematic {
-  readonly name: string;
-  readonly description: string;
-  readonly path: string;
-  readonly collection: Collection;
+export interface Engine {
+  createCollection<T>(name: string): Collection<T> | null;
+  createSchematic<CT, ST>(name: string, collection: Collection<CT>): Schematic<CT, ST> | null;
+  registerUrlProtocolHandler(protocol: string, handler: ProtocolHandler): void;
+  createSourceFromUrl(url: Url): Source;
+}
+
 
-  call(host: Observable<Tree>, parentContext: Partial<SchematicContext>): Observable<Tree>;
+export interface Schematic<CT, ST> {
+  readonly description: SchematicDescription<ST>;
+  readonly collection: Collection<CT>;
+
+  call(host: Observable<Tree>, parentContext: SchematicContext | null): Observable<Tree>;
 }
 
 
@@ -35,22 +40,13 @@ export interface ProtocolHandler {
 
 
 
-export interface Engine {
-  createCollection(name: string): Collection | null;
-  createSchematic<T>(name: string, collection: Collection, options: T): Schematic | null;
-  registerUrlProtocolHandler(protocol: string, handler: ProtocolHandler): void;
-  createSourceFromUrl(url: Url): Source;
-}
-
-
-export interface Collection {
-  readonly engine: Engine;
+export interface Collection<T> {
   readonly name: string;
-  readonly path: string;
+  readonly description: CollectionDescription<T>;
 
   listSchematicNames(): string[];
-  getSchematicDescription(name: string): SchematicDescription | null;
-  createSchematic<T>(name: string, options: T): Schematic;
+  getSchematicDescription<T>(name: string): SchematicDescription<T> | null;
+  createSchematic(name: string): Schematic;
 }
 
 
@@ -62,25 +58,14 @@ export interface SchematicContext {
 }
 
 
-export interface CollectionDescription {
-  readonly path: string;
-  readonly name?: string;
-  readonly version?: string;
-  readonly schematics: { [name: string]: SchematicDescription };
-}
-
-export interface SchematicDescription {
-  readonly factory: string;
-  readonly description: string;
-  readonly schema?: string;
-}
-
-
-export interface ResolvedSchematicDescription extends SchematicDescription {
+export type CollectionDescription<T> = T & {
   readonly name: string;
-  readonly path: string;
-  readonly rule: Rule;
-}
+};
+export type SchematicDescription<T, OT> = T & {
+  readonly name: string;
+  readonly factory: RuleFactory<OT>;
+};
+
 
 export type RuleFactory<T> = (options: T) => Rule;
 

packages/schematics_cli/src/simple-cli-engine.ts

@@ -6,11 +6,28 @@ import {
   Collection,
   CollectionDescription,
   EngineHost,
-  ResolvedSchematicDescription,
+  SchematicDescription,
   RuleFactory,
 } from '@angular/schematics';
 
 
+export interface CliCollectionDescription extends CollectionDescription {
+  readonly path: string;
+  readonly name?: string;
+  readonly version?: string;
+  readonly schematics: { [name: string]: CliSchematicDescription };
+}
+
+
+export interface CliSchematicDescription {
+  readonly factory: string;
+  readonly description: string;
+  readonly schema?: string;
+}
+
+
+
+
 /**
  * A simple EngineHost used by the CLI. When loading for a collection, it looks through the
  */
@@ -35,7 +52,7 @@ export class SimpleCliEngineHost implements EngineHost {
 
   loadSchematic<T>(name: string,
                    collection: Collection,
-                   options: T): ResolvedSchematicDescription | null {
+                   options: T): SchematicDescription<T> | null {
     const collectionPath = dirname(collection.path);
     const description = collection.getSchematicDescription(name);