refactor: add a symbol to distinguish Tree instances

instanceof is fickle and does not work very well here.

Author: hansl

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

@@ -8,52 +8,63 @@
 import { BaseException } from '@angular-devkit/core';
 import { Observable } from 'rxjs/Observable';
 import { Rule, SchematicContext, Source } from '../engine/interface';
-import { Tree } from '../tree/interface';
-import { VirtualTree } from '../tree/virtual';
+import { Tree, TreeSymbol } from '../tree/interface';
 
 
 declare const Symbol: Symbol & {
   readonly observable: symbol;
 };
 
 
+function _getTypeOfResult(value?: {}): string {
+  if (value === undefined) {
+    return 'undefined';
+  } else if (value === null) {
+    return 'null';
+  } else if (typeof value == 'function') {
+    return `Function()`;
+  } else if (typeof value != 'object') {
+    return `${typeof value}(${JSON.stringify(value)})`;
+  } else {
+    if (Object.getPrototypeOf(value) == Object) {
+      return `Object(${JSON.stringify(value)})`;
+    } else if (value.constructor) {
+      return `Instance of class ${value.constructor.name}`;
+    } else {
+      return 'Unknown Object';
+    }
+  }
+}
+
+
 /**
  * When a rule or source returns an invalid value.
  */
 export class InvalidRuleResultException extends BaseException {
   constructor(value?: {}) {
-    let v = 'Unknown Type';
-    if (value === undefined) {
-      v = 'undefined';
-    } else if (value === null) {
-      v = 'null';
-    } else if (typeof value == 'function') {
-      v = `Function()`;
-    } else if (typeof value != 'object') {
-      v = `${typeof value}(${JSON.stringify(value)})`;
-    } else {
-      if (Object.getPrototypeOf(value) == Object) {
-        v = `Object(${JSON.stringify(value)})`;
-      } else if (value.constructor) {
-        v = `Instance of class ${value.constructor.name}`;
-      } else {
-        v = 'Unknown Object';
-      }
-    }
-    super(`Invalid rule or source result: ${v}.`);
+    super(`Invalid rule result: ${_getTypeOfResult(value)}.`);
+  }
+}
+
+
+export class InvalidSourceResultException extends BaseException {
+  constructor(value?: {}) {
+    super(`Invalid source result: ${_getTypeOfResult(value)}.`);
   }
 }
 
 
 export function callSource(source: Source, context: SchematicContext): Observable<Tree> {
-  const result = source(context);
+  const result = source(context) as object;
 
-  if (result instanceof VirtualTree) {
-    return Observable.of(result);
+  if (result === undefined) {
+    throw new InvalidSourceResultException(result);
+  } else if (TreeSymbol in result) {
+    return Observable.of(result as Tree);
   } else if (Symbol.observable in result) {
     return result as Observable<Tree>;
   } else {
-    throw new InvalidRuleResultException(result);
+    throw new InvalidSourceResultException(result);
   }
 }
 
@@ -64,7 +75,9 @@ export function callRule(rule: Rule,
   return input.mergeMap(inputTree => {
     const result = rule(inputTree, context) as object;
 
-    if (result instanceof VirtualTree) {
+    if (result === undefined) {
+      return Observable.of(inputTree);
+    } else if (TreeSymbol in result) {
       return Observable.of(result as Tree);
     } else if (Symbol.observable in result) {
       return result as Observable<Tree>;

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

@@ -55,6 +55,27 @@ export const FileVisitorCancelToken = Symbol();
 export type FileVisitor = FilePredicate<void>;
 
 
+declare const window: { Symbol: { schematicTree: symbol }, window: {} };
+declare const self: { Symbol: { schematicTree: symbol }, self: {} };
+declare const global: { Symbol: { schematicTree: symbol }, global: {} };
+
+export const TreeSymbol: symbol = (function() {
+  const globalSymbol = (typeof window == 'object' && window.window === window && window.Symbol)
+                    || (typeof self == 'object' && self.self === self && self.Symbol)
+                    || (typeof global == 'object' && global.global === global && global.Symbol);
+
+  if (!globalSymbol) {
+    return Symbol('schematic-tree');
+  }
+
+  if (!globalSymbol.schematicTree) {
+    globalSymbol.schematicTree = Symbol('schematic-tree');
+  }
+
+  return globalSymbol.schematicTree;
+})();
+
+
 export interface Tree {
   branch(): Tree;
   merge(other: Tree, strategy?: MergeStrategy): void;

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

@@ -15,7 +15,7 @@ import {
 } from '@angular-devkit/core';
 import { FileDoesNotExistException } from '../exception/exception';
 import { Action } from './action';
-import { DirEntry, MergeStrategy, Tree, UpdateRecorder } from './interface';
+import { DirEntry, MergeStrategy, Tree, TreeSymbol, UpdateRecorder } from './interface';
 import { UpdateRecorderBase } from './recorder';
 
 
@@ -42,6 +42,10 @@ export class NullTreeDirEntry implements DirEntry {
 
 
 export class NullTree implements Tree {
+  [TreeSymbol]() {
+    return this;
+  }
+
   branch(): Tree {
     return new NullTree();
   }

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

@@ -30,6 +30,7 @@ import {
   FileVisitorCancelToken,
   MergeStrategy,
   Tree,
+  TreeSymbol,
   UpdateRecorder,
 } from './interface';
 import { UpdateRecorderBase } from './recorder';
@@ -93,6 +94,10 @@ export class VirtualTree implements Tree {
   protected get tree(): ReadonlyMap<Path, FileEntry> { return this._tree; }
   get staging(): ReadonlyMap<Path, FileEntry> { return this._cacheMap; }
 
+  [TreeSymbol]() {
+    return this;
+  }
+
   /**
    * A list of file names contained by this Tree.
    * @returns {[string]} File paths.