refactor(@angular-devkit/schematics): update rxjs usage in rules

rxjs has improved over time and this updates the rules to take advantage of improvements where applicable.

Author: clydin

etc/api/angular_devkit/schematics/src/_golden-api.d.ts

@@ -67,7 +67,7 @@ export interface BaseWorkflowOptions {
 
 export declare function branchAndMerge(rule: Rule, strategy?: MergeStrategy): Rule;
 
-export declare function callRule(rule: Rule, input: Observable<Tree>, context: SchematicContext): Observable<Tree>;
+export declare function callRule(rule: Rule, input: Tree | Observable<Tree>, context: SchematicContext): Observable<Tree>;
 
 export declare function callSource(source: Source, context: SchematicContext): Observable<Tree>;
 

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

@@ -5,75 +5,65 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { Observable, of as observableOf } from 'rxjs';
-import { concatMap, last, map } from 'rxjs/operators';
-import { FileOperator, Rule, SchematicContext, Source } from '../engine/interface';
+import { Observable, concat } from 'rxjs';
+import { map, mapTo, toArray } from 'rxjs/operators';
+import { FileOperator, Rule, Source } from '../engine/interface';
 import { SchematicsException } from '../exception/exception';
 import { FilterHostTree, HostTree } from '../tree/host-tree';
 import { FileEntry, FilePredicate, MergeStrategy, Tree } from '../tree/interface';
 import { ScopedTree } from '../tree/scoped';
-import {
-  branch,
-  empty as staticEmpty,
-  merge as staticMerge,
-  partition as staticPartition,
-} from '../tree/static';
+import { empty as staticEmpty, partition } from '../tree/static';
 import { callRule, callSource } from './call';
 
-
 /**
  * A Source that returns an tree as its single value.
  */
 export function source(tree: Tree): Source {
   return () => tree;
 }
 
-
 /**
  * A source that returns an empty tree.
  */
 export function empty(): Source {
   return () => staticEmpty();
 }
 
-
 /**
  * Chain multiple rules into a single rule.
  */
 export function chain(rules: Rule[]): Rule {
-  return (tree: Tree, context: SchematicContext) => {
-    return rules.reduce((acc: Observable<Tree>, curr: Rule) => {
-      return callRule(curr, acc, context);
-    }, observableOf(tree));
+  return (tree, context) => {
+    return rules.reduce(
+      (acc: Tree | Observable<Tree>, curr: Rule) => callRule(curr, acc, context),
+      tree,
+    );
   };
 }
 
-
 /**
  * Apply multiple rules to a source, and returns the source transformed.
  */
 export function apply(source: Source, rules: Rule[]): Source {
   return context => callRule(chain(rules), callSource(source, context), context);
 }
 
-
 /**
  * Merge an input tree with the source passed in.
  */
 export function mergeWith(source: Source, strategy: MergeStrategy = MergeStrategy.Default): Rule {
-  return (tree: Tree, context: SchematicContext) => {
-    const result = callSource(source, context);
-
-    return result.pipe(map(other => staticMerge(tree, other, strategy || context.strategy)));
+  return (tree, context) => {
+    return callSource(source, context).pipe(
+      map(sourceTree => tree.merge(sourceTree, strategy || context.strategy)),
+      mapTo(tree),
+    );
   };
 }
 
-
 export function noop(): Rule {
   return () => {};
 }
 
-
 export function filter(predicate: FilePredicate<boolean>): Rule {
   return ((tree: Tree) => {
     if (HostTree.isHostTree(tree)) {
@@ -84,25 +74,19 @@ export function filter(predicate: FilePredicate<boolean>): Rule {
   });
 }
 
-
 export function asSource(rule: Rule): Source {
-  return apply(empty(), [rule]);
+  return context => callRule(rule, staticEmpty(), context);
 }
 
-
 export function branchAndMerge(rule: Rule, strategy = MergeStrategy.Default): Rule {
-  return (tree: Tree, context: SchematicContext) => {
-    const branchedTree = branch(tree);
-
-    return callRule(rule, observableOf(branchedTree), context)
-      .pipe(
-        last(),
-        map(t => staticMerge(tree, t, strategy)),
-      );
+  return (tree, context) => {
+    return callRule(rule, tree.branch(), context).pipe(
+      map(branch => tree.merge(branch, strategy || context.strategy)),
+      mapTo(tree),
+    );
   };
 }
 
-
 export function when(predicate: FilePredicate<boolean>, operator: FileOperator): FileOperator {
   return (entry: FileEntry) => {
     if (predicate(entry.path, entry)) {
@@ -113,30 +97,28 @@ export function when(predicate: FilePredicate<boolean>, operator: FileOperator):
   };
 }
 
-
 export function partitionApplyMerge(
   predicate: FilePredicate<boolean>,
   ruleYes: Rule,
   ruleNo?: Rule,
 ): Rule {
-  return (tree: Tree, context: SchematicContext) => {
-    const [yes, no] = staticPartition(tree, predicate);
+  return (tree, context) => {
+    const [yes, no] = partition(tree, predicate);
 
-    if (!ruleNo) {
-      // Shortcut.
-      return callRule(ruleYes, observableOf(staticPartition(tree, predicate)[0]), context)
-        .pipe(map(yesTree => staticMerge(yesTree, no, context.strategy)));
-    }
+    return concat(
+      callRule(ruleYes, yes, context),
+      callRule(ruleNo || noop(), no, context),
+    ).pipe(
+      toArray(),
+      map(([yesTree, noTree]) => {
+        yesTree.merge(noTree, context.strategy);
 
-    return callRule(ruleYes, observableOf(yes), context)
-      .pipe(concatMap(yesTree => {
-        return callRule(ruleNo, observableOf(no), context)
-          .pipe(map(noTree => staticMerge(yesTree, noTree, context.strategy)));
-      }));
+        return yesTree;
+      }),
+    );
   };
 }
 
-
 export function forEach(operator: FileOperator): Rule {
   return (tree: Tree) => {
     tree.visit((path, entry) => {
@@ -182,7 +164,7 @@ export function applyToSubtree(path: string, rules: Rule[]): Rule {
   return (tree, context) => {
     const scoped = new ScopedTree(tree, path);
 
-    return callRule(chain(rules), observableOf(scoped), context).pipe(
+    return callRule(chain(rules), scoped, context).pipe(
       map(result => {
         if (result === scoped) {
           return tree;

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

@@ -5,8 +5,8 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { BaseException, isObservable, isPromise } from '@angular-devkit/core';
-import { Observable, from, of as observableOf, throwError } from 'rxjs';
+import { BaseException, isPromise } from '@angular-devkit/core';
+import { Observable, from, isObservable, of as observableOf, throwError } from 'rxjs';
 import { defaultIfEmpty, last, mergeMap, tap } from 'rxjs/operators';
 import { Rule, SchematicContext, Source } from '../engine/interface';
 import { Tree, TreeSymbol } from '../tree/interface';
@@ -74,17 +74,17 @@ export function callSource(source: Source, context: SchematicContext): Observabl
 
 export function callRule(
   rule: Rule,
-  input: Observable<Tree>,
+  input: Tree | Observable<Tree>,
   context: SchematicContext,
 ): Observable<Tree> {
-  return input.pipe(mergeMap(inputTree => {
+  return (isObservable(input) ? input : observableOf(input)).pipe(mergeMap(inputTree => {
     const result = rule(inputTree, context);
 
     if (!result) {
       return observableOf(inputTree);
     } else if (typeof result == 'function') {
       // This is considered a Rule, chain the rule and return its output.
-      return callRule(result, observableOf(inputTree), context);
+      return callRule(result, inputTree, context);
     } else if (isObservable(result)) {
       // Only return the last Tree, and make sure it's a Tree.
       return result.pipe(
@@ -101,7 +101,7 @@ export function callRule(
         mergeMap(inner => {
           if (typeof inner === 'function') {
             // This is considered a Rule, chain the rule and return its output.
-            return callRule(inner, observableOf(inputTree), context);
+            return callRule(inner, inputTree, context);
           } else {
             return observableOf(inputTree);
           }