issue #10: none operator

Author: André Schreck

README.md

@@ -57,6 +57,8 @@ Gets a function that takes an element and returns a boolean. If an element is ev
 Some works similar to the `first`-operator except that not the element is returned, but the value `true` as soon as the passed function evaluates to true.
 * __every__<br />
 `every` also applies the passed function to each element. As soon as one element does not evaluate to `true` the pipe immediately returns `false`. 
+* __none__<br />
+`none` also applies the passed function to each element. As soon as one element evaluates to `true` the pipe immediately returns `false`. 
 
 ## When is it usefull?
 

src/index.spec.ts

@@ -1,5 +1,5 @@
 import './index';
-import { filter, map, flatMap, distinct, find, some, every } from './operators';
+import { filter, map, flatMap, distinct, find, some, every, none } from './operators';
 
 describe('pipe', () => {
 
@@ -111,6 +111,26 @@ describe('pipe', () => {
             expect(result).toBe(false);
         });
 
+        it('should pipe and return true because all elements do not match criteria', () => {
+            const result: number = ['3', '5', '7', '9', '11', '13', '15', '17', '19', '21']
+                .pipe(
+                    map((n: string) => parseInt(n)),
+                    none((n: number) => n%2 === 0)
+                );
+            
+            expect(result).toBeTruthy();
+        });
+    
+        it('should pipe and return false because not all elements match criteria', () => {
+            const result: number = ['3', '5', '7', '9', '12', '13', '15', '17', '19', '21']
+                .pipe(
+                    map((n: string) => parseInt(n)),
+                    none((n: number) => n%2 === 0)
+                );
+            
+            expect(result).toBe(false);
+        });
+    
         it('should pipe undefined and null values', () => {
             const undefinedMapper = (s: string) => {
                 if (s === undefined || s === null) {

src/none.spec.ts

@@ -0,0 +1,32 @@
+import { TerminalOperator, none } from './operators';
+
+describe('none', () => {
+
+    it('should be terminal', () => {
+        const operator: TerminalOperator<any, any> = none((n: number) => n%2 === 0);
+        expect(operator.isTerminal()).toBeTruthy();
+    });
+
+    it('should have a fallback value', () => {
+        const operator: TerminalOperator<any, any> = none((n: number) => n%2 === 0);
+        expect(operator.getFallbackValue()).toBeTruthy();
+    });
+
+    it('should not match', () => {
+        const operator: TerminalOperator<any, any> = none((n: number) => n%2 === 0);
+        expect(operator.perform(4)).toEqual({
+            value: false,
+            skip: false,
+            needsFlattening: false
+        });
+    });
+
+    it('should match', () => {
+        const operator: TerminalOperator<any, any> = none((n: number) => n%2 === 0);
+        expect(operator.perform(5)).toEqual({
+            value: null,
+            skip: true,
+            needsFlattening: false
+        });
+    });
+});

src/operators.ts

@@ -90,6 +90,32 @@ class EveryOperator<T> extends TerminalOperator<T, boolean> {
     }
 }
 
+class NoneOperator<T> extends TerminalOperator<T, boolean> {
+
+    constructor(private tester: Predicate<T>) {
+        super();
+    }
+
+    public getFallbackValue(): boolean {
+        return true;
+    }
+
+    public perform(from: T): OperatorResult<boolean> {
+        if (this.tester(from)) {
+            return {
+                value: false,
+                skip: false,
+                needsFlattening: false
+            };
+        }
+        return {
+            value: null,
+            skip: true,
+            needsFlattening: false
+        };
+    }
+}
+
 class FilterOperator<T> extends IntermediateOperator<T, T> {
 
     constructor(private tester: Predicate<T>) {
@@ -205,3 +231,7 @@ export function some<T>(tester: Predicate<T>): TerminalOperator<T, boolean> {
 export function every<T>(tester: Predicate<T>): TerminalOperator<T, boolean> {
     return new EveryOperator<T>(tester);
 }
+
+export function none<T>(tester: Predicate<T>): TerminalOperator<T, boolean> {
+    return new NoneOperator<T>(tester);
+}