feat(@angular-devkit/schematics): rules return values are optional now

This simplifies writing simple rules that only change the tree.

Author: hansl

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

@@ -166,4 +166,4 @@ export type AsyncFileOperator = (tree: FileEntry) => Observable<FileEntry | null
  * know which types is the schematic or collection metadata, as they are both tooling specific.
  */
 export type Source = (context: SchematicContext) => Tree | Observable<Tree>;
-export type Rule = (tree: Tree, context: SchematicContext) => Tree | Observable<Tree>;
+export type Rule = (tree: Tree, context: SchematicContext) => Tree | Observable<Tree> | void;

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

@@ -55,6 +55,8 @@ export class SchematicImpl<CollectionT extends object, SchematicT extends object
       const result = this._factory(transformedOptions)(tree, context);
       if (result instanceof Observable) {
         return result;
+      } else if (result === undefined) {
+        return Observable.of(tree);
       } else {
         return Observable.of(result);
       }

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

@@ -35,7 +35,7 @@ const engine: Engine<CollectionT, SchematicT> = {
   createContext: (schematic: Schematic<{}, {}>) => ({ engine, schematic, ...context }),
   transformOptions: (_: {}, options: {}) => options,
   defaultMergeStrategy: MergeStrategy.Default,
-} as Engine<CollectionT, SchematicT>;
+} as {} as Engine<CollectionT, SchematicT>;
 const collection = {
   name: 'collection',
   description: 'description',

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

@@ -16,7 +16,7 @@ import { VirtualTree } from '../tree/virtual';
  * When a rule or source returns an invalid value.
  */
 export class InvalidRuleResultException extends BaseException {
-  constructor(value: {}) {
+  constructor(value?: {}) {
     let v = 'Unknown Type';
     if (value === undefined) {
       v = 'undefined';
@@ -56,13 +56,15 @@ export function callSource(source: Source, context: SchematicContext): Observabl
 export function callRule(rule: Rule,
                          input: Observable<Tree>,
                          context: SchematicContext): Observable<Tree> {
-  return input.mergeMap(i => {
-    const result = rule(i, context);
+  return input.mergeMap(inputTree => {
+    const result = rule(inputTree, context);
 
     if (result instanceof VirtualTree) {
       return Observable.of(result as Tree);
     } else if (result instanceof Observable) {
       return result;
+    } else if (result === undefined) {
+      return Observable.of(inputTree);
     } else {
       throw new InvalidRuleResultException(result);
     }