feat(change_detection): add static append method to Pipes

This change allows creation of a new Pipes object with new pipes appended
to pipes of an inherited Pipes.

Closes angular#2901

modules/angular2/src/change_detection/pipes/pipes.ts

@@ -1,4 +1,4 @@
-import {List, ListWrapper} from 'angular2/src/facade/collection';
+import {ListWrapper, isListLikeIterable, StringMapWrapper} from 'angular2/src/facade/collection';
 import {isBlank, isPresent, BaseException, CONST} from 'angular2/src/facade/lang';
 import {Pipe, PipeFactory} from './pipe';
 import {Injectable} from 'angular2/src/di/decorators';
@@ -7,7 +7,25 @@ import {ChangeDetectorRef} from '../change_detector_ref';
 @Injectable()
 @CONST()
 export class Pipes {
-  constructor(public config) {}
+  /**
+   * Map of {@link Pipe} names to {@link PipeFactory} lists used to configure the
+   * {@link Pipes} registry.
+   *
+   * #Example
+   *
+   * ```
+   * var pipesConfig = {
+   *   'json': [jsonPipeFactory]
+   * }
+   * @Component({
+   *   viewInjector: [
+   *     bind(Pipes).toValue(new Pipes(pipesConfig))
+   *   ]
+   * })
+   * ```
+   */
+  config: StringMap<string, PipeFactory[]>;
+  constructor(config: StringMap<string, PipeFactory[]>) { this.config = config; }
 
   get(type: string, obj, cdRef?: ChangeDetectorRef, existingPipe?: Pipe): Pipe {
     if (isPresent(existingPipe) && existingPipe.supports(obj)) return existingPipe;
@@ -20,6 +38,56 @@ export class Pipes {
     return factory.create(cdRef);
   }
 
+  /**
+   * Takes a {@link Pipes} config object and returns a factory used to append the
+   * provided config with an existing {@link Pipes} instance to return a new
+   * {@link Pipes} instance.
+   *
+   * If the provided config contains a key that is not yet present in the
+   * inherited {@link Pipes}' config, a new {@link PipeFactory} list will be created
+   * for that key. Otherwise, the provided config will be merged with the inherited
+   * {@link Pipes} instance by appending pipes to their respective keys, without mutating
+   * the inherited {@link Pipes}.
+   *
+   * The following example shows how to append a new {@link PipeFactory} to the
+   * existing list of `async` factories, which will only be applied to the injector
+   * for this component and its children. This step is all that's required to make a new
+   * pipe available to this component's template.
+   *
+   * # Example
+   *
+   * ```
+   * @Component({
+   *   viewInjector: [
+   *     bind(Pipes).toFactory(Pipes.append({
+   *            async: [newAsyncPipe]
+   *     })
+   *   ]
+   * })
+   * ```
+   */
+  static append(config) {
+    return (pipes: Pipes): Pipes => {
+      var mergedConfig: StringMap<string, PipeFactory[]> = <StringMap<string, PipeFactory[]>>{};
+
+      // Manual deep copy of existing Pipes config,
+      // so that lists of PipeFactories don't get mutated.
+      StringMapWrapper.forEach(pipes.config, (v: PipeFactory[], k: string) => {
+        var localPipeList: PipeFactory[] = mergedConfig[k] = [];
+        v.forEach((p: PipeFactory) => { localPipeList.push(p); });
+      });
+
+      StringMapWrapper.forEach(config, (v: PipeFactory[], k: string) => {
+        if (isListLikeIterable(mergedConfig[k])) {
+          mergedConfig[k] = ListWrapper.concat(mergedConfig[k], config[k]);
+        } else {
+          mergedConfig[k] = config[k];
+        }
+      });
+      return new Pipes(mergedConfig);
+    };
+  }
+
   private _getListOfFactories(type: string, obj: any): PipeFactory[] {
     var listOfFactories = this.config[type];
     if (isBlank(listOfFactories)) {

modules/angular2/test/change_detection/pipes/pipes_spec.ts

@@ -12,6 +12,7 @@ import {
 } from 'angular2/test_lib';
 
 import {Pipes} from 'angular2/src/change_detection/pipes/pipes';
+import {PipeFactory} from 'angular2/src/change_detection/pipes/pipe';
 
 export function main() {
   describe("pipe registry", () => {
@@ -73,5 +74,20 @@ export function main() {
       expect(() => r.get("type", "some object"))
           .toThrowError(`Cannot find 'type' pipe supporting object 'some object'`);
     });
+
+    describe('.append()', () => {
+      it('should create a factory that appends new pipes to old', () => {
+        firstPipeFactory.spy("supports").andReturn(false);
+        secondPipeFactory.spy("supports").andReturn(true);
+        secondPipeFactory.spy("create").andReturn(secondPipe);
+        var originalPipes: Pipes = new Pipes({'async': [firstPipeFactory]});
+        var factory = Pipes.append({'async':<PipeFactory[]>[secondPipeFactory]});
+        var pipes = factory(originalPipes);
+
+        expect(pipes.config['async'].length).toBe(2);
+        expect(originalPipes.config['async'].length).toBe(1);
+        expect(pipes.get('async', 'second plz')).toBe(secondPipe);
+      });
+    });
   });
 }