fix(@angular-devkit/schematics): support filtering a HostTree

Author: clydin

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

@@ -8,7 +8,7 @@
 import { Observable, of as observableOf } from 'rxjs';
 import { concatMap, last, map } from 'rxjs/operators';
 import { FileOperator, Rule, SchematicContext, Source } from '../engine/interface';
-import { FilteredTree } from '../tree/filtered';
+import { FilterTree, FilteredTree } from '../tree/filtered';
 import { FileEntry, FilePredicate, MergeStrategy, Tree } from '../tree/interface';
 import {
   branch,
@@ -92,7 +92,13 @@ export function noop(): Rule {
 
 
 export function filter(predicate: FilePredicate<boolean>): Rule {
-  return (tree: Tree) => new FilteredTree(tree, predicate);
+  return ((tree: Tree) => {
+    if (tree instanceof VirtualTree) {
+      return new FilteredTree(tree, predicate);
+    } else {
+      return new FilterTree(tree, predicate);
+    }
+  });
 }
 
 

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

@@ -9,7 +9,7 @@
 // tslint:disable:non-null-operator
 import { Path, virtualFs } from '@angular-devkit/core';
 import {
-  FileSystemTree,
+  HostTree,
   MergeStrategy,
   partitionApplyMerge,
 } from '@angular-devkit/schematics';
@@ -138,7 +138,7 @@ describe('partitionApplyMerge', () => {
       '/test1': '',
       '/test2': '',
     });
-    const tree = new FileSystemTree(host);
+    const tree = new HostTree(host);
     const predicate = (path: Path) => path.indexOf('1') != -1;
 
     const ruleYes: Rule = (tree: Tree) => {

packages/angular_devkit/schematics/src/tree/filtered.ts

@@ -5,6 +5,7 @@
  * 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 { DelegateTree } from './delegate';
 import { FilePredicate, Tree } from './interface';
 import { VirtualTree } from './virtual';
 
@@ -38,3 +39,15 @@ export class FilteredTree extends VirtualTree {
     });
   }
 }
+
+export class FilterTree extends DelegateTree {
+  constructor(tree: Tree, filter: FilePredicate<boolean> = () => true) {
+    super(tree.branch());
+
+    tree.visit(path => {
+      if (!filter(path)) {
+        this.delete(path);
+      }
+    });
+  }
+}

packages/angular_devkit/schematics/src/tree/filtered_spec.ts

@@ -6,7 +6,8 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { normalize } from '@angular-devkit/core';
-import { FilteredTree } from './filtered';
+import { FilterTree, FilteredTree } from './filtered';
+import { HostTree } from './host-tree';
 import { VirtualTree } from './virtual';
 
 
@@ -21,3 +22,30 @@ describe('FilteredTree', () => {
     expect(filtered.files.sort()).toEqual(['/file1', '/file3'].map(normalize));
   });
 });
+
+describe('FilterTree', () => {
+  it('works', () => {
+    const tree = new HostTree();
+    tree.create('/file1', '');
+    tree.create('/file2', '');
+    tree.create('/file3', '');
+
+    const filtered = new FilterTree(tree, p => p != '/file2');
+    const filteredFiles: string[] = [];
+    filtered.visit(path => filteredFiles.push(path));
+    expect(filteredFiles.sort()).toEqual(['/file1', '/file3'].map(normalize));
+  });
+
+  it('works with two filters', () => {
+    const tree = new HostTree();
+    tree.create('/file1', '');
+    tree.create('/file2', '');
+    tree.create('/file3', '');
+
+    const filtered = new FilterTree(tree, p => p != '/file2');
+    const filtered2 = new FilterTree(filtered, p => p != '/file3');
+    const filteredFiles: string[] = [];
+    filtered2.visit(path => filteredFiles.push(path));
+    expect(filteredFiles.sort()).toEqual(['/file1'].map(normalize));
+  });
+});

packages/angular_devkit/schematics/src/tree/static.ts

@@ -5,7 +5,7 @@
  * 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 { FilteredTree } from './filtered';
+import { FilterTree, FilteredTree } from './filtered';
 import { HostTree } from './host-tree';
 import { FilePredicate, MergeStrategy, Tree } from './interface';
 import { VirtualTree } from './virtual';
@@ -16,34 +16,45 @@ export function empty() {
 }
 
 export function branch(tree: Tree) {
-  if (tree instanceof HostTree) {
-    return tree.branch();
+  // TODO: Remove VirtualTree usage in 7.0
+  if (tree instanceof VirtualTree) {
+    return VirtualTree.branch(tree);
   }
 
-  return VirtualTree.branch(tree);
+  return tree.branch();
 }
 
 export function merge(tree: Tree, other: Tree, strategy: MergeStrategy = MergeStrategy.Default) {
-  if (tree instanceof HostTree) {
-    tree.merge(other, strategy);
-
-    return tree;
+  // TODO: Remove VirtualTree usage in 7.0
+  if (tree instanceof VirtualTree) {
+    return VirtualTree.merge(tree, other, strategy);
   }
 
-  return VirtualTree.merge(tree, other, strategy);
+  tree.merge(other, strategy);
+
+  return tree;
 }
 
 export function partition(tree: Tree, predicate: FilePredicate<boolean>): [Tree, Tree] {
-  return [
-    new FilteredTree(tree, predicate),
-    new FilteredTree(tree, (path, entry) => !predicate(path, entry)),
-  ];
+  // TODO: Remove VirtualTree usage in 7.0
+  if (tree instanceof VirtualTree) {
+    return [
+      new FilteredTree(tree, predicate),
+      new FilteredTree(tree, (path, entry) => !predicate(path, entry)),
+    ];
+  } else {
+    return [
+      new FilterTree(tree, predicate),
+      new FilterTree(tree, (path, entry) => !predicate(path, entry)),
+    ];
+  }
 }
 
 export function optimize(tree: Tree) {
-  if (tree instanceof HostTree) {
-    return tree;
+  // TODO: Remove VirtualTree usage in 7.0
+  if (tree instanceof VirtualTree) {
+    return VirtualTree.optimize(tree);
   }
 
-  return VirtualTree.optimize(tree);
+  return tree;
 }