feat(pipes): add limitTo pipe

Author: piloopin

modules/angular2/pipes.ts

@@ -12,3 +12,4 @@ export {ObservablePipe} from './src/change_detection/pipes/observable_pipe';
 export {JsonPipe} from './src/change_detection/pipes/json_pipe';
 export {IterableChanges} from './src/change_detection/pipes/iterable_changes';
 export {KeyValueChanges} from './src/change_detection/pipes/keyvalue_changes';
+export {LimitToPipe} from './src/change_detection/pipes/limit_to_pipe';

modules/angular2/src/change_detection/change_detection.ts

@@ -10,6 +10,7 @@ import {PromisePipeFactory} from './pipes/promise_pipe';
 import {UpperCaseFactory} from './pipes/uppercase_pipe';
 import {LowerCaseFactory} from './pipes/lowercase_pipe';
 import {JsonPipe} from './pipes/json_pipe';
+import {LimitToPipeFactory} from './pipes/limit_to_pipe';
 import {NullPipeFactory} from './pipes/null_pipe';
 import {ChangeDetection, ProtoChangeDetector, ChangeDetectorDefinition} from './interfaces';
 import {Inject, Injectable, OpaqueToken, Optional} from 'angular2/di';
@@ -64,16 +65,25 @@ export const lowercase: List<PipeFactory> =
  *
  * @exportedAs angular2/pipes
  */
-export const json: List<PipeFactory | Pipe> =
+export const json: List<PipeFactory> =
  CONST_EXPR([CONST_EXPR(new JsonPipe()), CONST_EXPR(new NullPipeFactory())]);
 
+/**
+ * LimitTo text transform.
+ *
+ * @exportedAs angular2/pipes
+ */
+export const limitTo: List<PipeFactory> =
+ CONST_EXPR([CONST_EXPR(new LimitToPipeFactory()), CONST_EXPR(new NullPipeFactory())]);
+
 export const defaultPipes = CONST_EXPR({
  "iterableDiff": iterableDiff,
  "keyValDiff": keyValDiff,
  "async": async,
  "uppercase": uppercase,
  "lowercase": lowercase,
- "json": json
+ "json": json,
+ "limitTo": limitTo
 });
 
 /**

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

@@ -0,0 +1,87 @@
+import {
+ isBlank,
+ isString,
+ isArray,
+ StringWrapper,
+ BaseException,
+ CONST
+} from 'angular2/src/facade/lang';
+import {ListWrapper} from 'angular2/src/facade/collection';
+import {Math} from 'angular2/src/facade/math';
+import {WrappedValue, Pipe, PipeFactory} from './pipe';
+import {ChangeDetectorRef} from '../change_detector_ref';
+
+/**
+ * Creates a new List or String containing only a prefix/suffix of the
+ * elements.
+ *
+ * The number of elements to return is specified by the `limitTo` parameter.
+ *
+ * # Usage
+ *
+ * expression | limitTo:number
+ *
+ * Where the input expression is a [List] or [String], and `limitTo` is:
+ *
+ * - **a positive integer**: return _number_ items from the beginning of the list or string
+ * expression.
+ * - **a negative integer**: return _number_ items from the end of the list or string expression.
+ * - **`|limitTo|` greater than the size of the expression**: return the entire expression.
+ *
+ * When operating on a [List], the returned list is always a copy even when all
+ * the elements are being returned.
+ *
+ * # Examples
+ *
+ * ## List Example
+ *
+ * Assuming `var collection = ['a', 'b', 'c']`, this `ng-for` directive:
+ *
+ * <li *ng-for="var i in collection | limitTo:2">{{i}}</li>
+ *
+ * produces the following:
+ *
+ * <li>a</li>
+ * <li>b</li>
+ *
+ * ## String Examples
+ *
+ * {{ 'abcdefghij' | limitTo: 4 }} // output is 'abcd'
+ * {{ 'abcdefghij' | limitTo: -4 }} // output is 'ghij'
+ * {{ 'abcdefghij' | limitTo: -100 }} // output is 'abcdefghij'
+ *
+ * @exportedAs angular2/pipes
+ */
+export class LimitToPipe implements Pipe {
+ static supportsObj(obj): boolean { return isString(obj) || isArray(obj); }
+
+ supports(obj): boolean { return LimitToPipe.supportsObj(obj); }
+
+ transform(value, args: List<any> = null): any {
+ if (isBlank(args) || args.length == 0) {
+ throw new BaseException('limitTo pipe requires one argument');
+ }
+ var limit: int = args[0];
+ var left = 0, right = Math.min(limit, value.length);
+ if (limit < 0) {
+ left = Math.max(0, value.length + limit);
+ right = value.length;
+ }
+ if (isString(value)) {
+ return StringWrapper.substring(value, left, right);
+ }
+ return ListWrapper.slice(value, left, right);
+ }
+
+ onDestroy(): void {}
+}
+
+/**
+ * @exportedAs angular2/pipes
+ */
+@CONST()
+export class LimitToPipeFactory implements PipeFactory {
+ supports(obj): boolean { return LimitToPipe.supportsObj(obj); }
+
+ create(cdRef: ChangeDetectorRef): Pipe { return new LimitToPipe(); }
+}

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

@@ -0,0 +1,57 @@
+import {ddescribe, describe, it, iit, xit, expect, beforeEach, afterEach} from 'angular2/test_lib';
+
+import {LimitToPipe} from 'angular2/src/change_detection/pipes/limit_to_pipe';
+
+export function main() {
+ describe("LimitToPipe", () => {
+ var list;
+ var str;
+ var pipe;
+
+ beforeEach(() => {
+ list = [1, 2, 3, 4, 5];
+ str = 'tuvwxyz';
+ pipe = new LimitToPipe();
+ });
+
+ describe("supports", () => {
+ it("should support strings", () => { expect(pipe.supports(str)).toBe(true); });
+ it("should support lists", () => { expect(pipe.supports(list)).toBe(true); });
+
+ it("should not support other objects", () => {
+ expect(pipe.supports(new Object())).toBe(false);
+ expect(pipe.supports(null)).toBe(false);
+ });
+ });
+
+ describe("transform", () => {
+
+ it('should return the first X items when X is positive', () => {
+ expect(pipe.transform(list, [3])).toEqual([1, 2, 3]);
+ expect(pipe.transform(str, [3])).toEqual('tuv');
+ });
+
+ it('should return the last X items when X is negative', () => {
+ expect(pipe.transform(list, [-3])).toEqual([3, 4, 5]);
+ expect(pipe.transform(str, [-3])).toEqual('xyz');
+ });
+
+ it('should return a copy of input array if X is exceeds array length', () => {
+ expect(pipe.transform(list, [20])).toEqual(list);
+ expect(pipe.transform(list, [-20])).toEqual(list);
+ });
+
+ it('should return the entire string if X exceeds input length', () => {
+ expect(pipe.transform(str, [20])).toEqual(str);
+ expect(pipe.transform(str, [-20])).toEqual(str);
+ });
+
+ it('should not modify the input list', () => {
+ expect(pipe.transform(list, [3])).toEqual([1, 2, 3]);
+ expect(list).toEqual([1, 2, 3, 4, 5]);
+ });
+
+ });
+
+ });
+}