feat(rules): Added NoneOf rule

Author: ricardogobbosouza

README.md

@@ -109,6 +109,7 @@ The library can be loaded either as a standalone script, or through an [AMD](htt
 - [Negative](docs/negative.md)
 - [NfeAccessKey](docs/nfe-access-key.md)
 - [No](docs/no.md)
+- [NoneOf](docs/none-of.md)
 - [Not](docs/not.md)
 - [NotEmpty](docs/not-empty.md)
 - [NullType](docs/null-type.md)

awesome-validator.min.js

@@ -0,0 +1,21 @@
+# None Of
+
+Will validate if none internal validator is validate.
+
+Valid values:
+
+```js
+validator.noneOf(
+    validator.alwaysInvalid(),
+    validator.alwaysInvalid()
+).validate(null);
+```
+
+Invalid values:
+
+```js
+validator.noneOf(
+    validator.alwaysInvalid(),
+    validator.alwaysValid()
+).validate(null);
+```

docs/none-of.md

@@ -30,6 +30,7 @@ export * from './multiple';
 export * from './negative';
 export * from './nfe-access-key';
 export * from './no';
+export * from './none-of';
 export * from './not';
 export * from './not-empty';
 export * from './null-type';

src/rules/index.ts

@@ -0,0 +1,20 @@
+import { Validatable } from './../validatable';
+import { AbstractComposite } from './abstract-composite';
+
+export class NoneOf extends AbstractComposite {
+
+    /**
+     * Validate.
+     */
+    public validate(input: any): boolean {
+        const rules: Validatable[] = this.getRules();
+
+        for (const rule of rules) {
+            if (rule.validate(input)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

src/rules/none-of.ts

@@ -37,6 +37,7 @@ export class Validator extends AllOf {
     public static negative = (): Validator => new Validator(new rules.Negative());
     public static nfeAccessKey  = (): Validator => new Validator(new rules.NfeAccessKey());
     public static no = (): Validator => new Validator(new rules.No());
+    public static noneOf = (...args: Validatable[]): Validator => new Validator(new rules.NoneOf(...args));
     public static not = (rule: Validatable): Validator => new Validator(new rules.Not(rule));
     public static notEmpty = (): Validator => new Validator(new rules.NotEmpty());
     public static nullType = (): Validator => new Validator(new rules.NullType());
@@ -110,6 +111,7 @@ export class Validator extends AllOf {
     public negative = (): this => this.addRule(new rules.Negative());
     public nfeAccessKey  = (): this => this.addRule(new rules.NfeAccessKey());
     public no = (): this => this.addRule(new rules.No());
+    public noneOf = (...args: Validatable[]): this => this.addRule(new rules.NoneOf(...args));
     public not = (rule: Validatable): this => this.addRule(new rules.Not(rule));
     public notEmpty = (): this => this.addRule(new rules.NotEmpty());
     public nullType = (): this => this.addRule(new rules.NullType());

src/validator.ts

@@ -0,0 +1,22 @@
+import { assert } from 'chai';
+
+import { AbstractRule } from '../../src/rules/abstract-rule';
+import { AlwaysInvalid } from '../../src/rules/always-invalid';
+import { AlwaysValid } from '../../src/rules/always-valid';
+import { NoneOf } from '../../src/rules/none-of';
+
+describe('NoneOf', () => {
+
+    it('is rule', () => {
+        assert.instanceOf(new NoneOf(), AbstractRule);
+    });
+
+    it('values is valid', () => {
+        assert.isTrue(new NoneOf(new AlwaysInvalid(), new AlwaysInvalid()).validate(null));
+    });
+
+    it('values is not valid', () => {
+        assert.isFalse(new NoneOf(new AlwaysInvalid(), new AlwaysValid()).validate(null));
+    });
+
+});

test/rules/none-of.ts

@@ -47,6 +47,7 @@ describe('Validator', () => {
         assert.instanceOf(V.negative(), V);
         assert.instanceOf(V.nfeAccessKey(), V);
         assert.instanceOf(V.no(), V);
+        assert.instanceOf(V.noneOf(), V);
         assert.instanceOf(V.not(V.alwaysInvalid()), V);
         assert.instanceOf(V.notEmpty(), V);
         assert.instanceOf(V.nullType(), V);
@@ -125,6 +126,7 @@ describe('Validator', () => {
         assert.instanceOf(v.negative(), V);
         assert.instanceOf(v.nfeAccessKey(), V);
         assert.instanceOf(v.no(), V);
+        assert.instanceOf(v.noneOf(), V);
         assert.instanceOf(v.not(v.alwaysInvalid()), V);
         assert.instanceOf(v.notEmpty(), V);
         assert.instanceOf(v.nullType(), V);