feat(rules): Added NotOptional rule

Author: ricardogobbosouza

README.md

@@ -113,6 +113,7 @@ The library can be loaded either as a standalone script, or through an [AMD](htt
 - [NoneOf](docs/none-of.md)
 - [Not](docs/not.md)
 - [NotEmpty](docs/not-empty.md)
+- [NotOptional](docs/not-optional.md)
 - [NullType](docs/null-type.md)
 - [NumberInstance](docs/number-instance.md)
 - [NumberType](docs/number-type.md)

awesome-validator.min.js

@@ -0,0 +1,23 @@
+# Not Optional
+
+Validates if the given input is not optional.
+
+Valid values:
+
+```js
+validator.notOptional().validate(' ');
+validator.notOptional().validate('foo');
+validator.notOptional().validate(true);
+validator.notOptional().validate(false);
+validator.notOptional().validate(0);
+validator.notOptional().validate(1);
+validator.notOptional().validate([]);
+validator.notOptional().validate({});
+```
+
+Invalid values:
+
+```js
+validator.notOptional().validate('');
+validator.notOptional().validate(null);
+```

docs/not-optional.md

@@ -34,6 +34,7 @@ export * from './no';
 export * from './none-of';
 export * from './not';
 export * from './not-empty';
+export * from './not-optional';
 export * from './null-type';
 export * from './number-instance';
 export * from './number-type';

src/rules/index.ts

@@ -0,0 +1,12 @@
+import { AbstractRule } from './abstract-rule';
+import { In } from './in';
+
+export class NotOptional extends AbstractRule {
+
+    /**
+     * Validate.
+     */
+    public validate(input: any): boolean {
+        return !new In([null, ''], false).validate(input);
+    }
+}

src/rules/not-optional.ts

@@ -1,12 +1,13 @@
+
 import { AbstractWrapper } from './abstract-wrapper';
-import { In } from './in';
+import { NotOptional } from './not-optional';
 
 export class Optional extends AbstractWrapper {
 
     /**
      * Validate.
      */
     public validate(input: any): boolean {
-        return new In([null, ''], false).validate(input) || super.validate(input);
+        return !new NotOptional().validate(input) || super.validate(input);
     }
 }

src/rules/optional.ts

@@ -43,6 +43,7 @@ export class Validator extends AllOf {
     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 notOptional = (): Validator => new Validator(new rules.NotOptional());
     public static nullType = (): Validator => new Validator(new rules.NullType());
     public static numberInstance = (): Validator => new Validator(new rules.NumberInstance());
     public static numberType = (): Validator => new Validator(new rules.NumberType());
@@ -124,6 +125,7 @@ export class Validator extends AllOf {
     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 notOptional = (): this => this.addRule(new rules.NotOptional());
     public nullType = (): this => this.addRule(new rules.NullType());
     public numberInstance = (): this => this.addRule(new rules.NumberInstance());
     public numberType = (): this => this.addRule(new rules.NumberType());

src/validator.ts

@@ -0,0 +1,64 @@
+import { assert } from 'chai';
+
+import { AbstractRule } from '../../src/rules/abstract-rule';
+import { NotOptional } from '../../src/rules/not-optional';
+
+describe('NotOptional', () => {
+
+    let notOptional: NotOptional;
+
+    beforeEach(() => {
+        notOptional = new NotOptional();
+    });
+
+    it('is rule', () => {
+        assert.instanceOf(notOptional, AbstractRule);
+    });
+
+    it('values is valid', () => {
+        assert.isTrue(notOptional.validate(Boolean()));
+        assert.isTrue(notOptional.validate(Boolean(true)));
+        assert.isTrue(notOptional.validate(Boolean(false)));
+        assert.isTrue(notOptional.validate(Boolean('1')));
+        assert.isTrue(notOptional.validate(Boolean('0')));
+        assert.isTrue(notOptional.validate(true));
+        assert.isTrue(notOptional.validate(false));
+        assert.isTrue(notOptional.validate(Number()));
+        assert.isTrue(notOptional.validate(undefined));
+        assert.isTrue(notOptional.validate('true'));
+        assert.isTrue(notOptional.validate('false'));
+        assert.isTrue(notOptional.validate('-1.1'));
+        assert.isTrue(notOptional.validate('1.1'));
+        assert.isTrue(notOptional.validate('1'));
+        assert.isTrue(notOptional.validate('-1'));
+        assert.isTrue(notOptional.validate('0'));
+        assert.isTrue(notOptional.validate(' '));
+        assert.isTrue(notOptional.validate('   '));
+        assert.isTrue(notOptional.validate(0));
+        assert.isTrue(notOptional.validate(-0));
+        assert.isTrue(notOptional.validate(1));
+        assert.isTrue(notOptional.validate(-1));
+        assert.isTrue(notOptional.validate(0.0));
+        assert.isTrue(notOptional.validate(-0.0));
+        assert.isTrue(notOptional.validate(1.0));
+        assert.isTrue(notOptional.validate(-1.0));
+        assert.isTrue(notOptional.validate(0.1));
+        assert.isTrue(notOptional.validate(-0.1));
+        assert.isTrue(notOptional.validate(1.1));
+        assert.isTrue(notOptional.validate(-1.1));
+        assert.isTrue(notOptional.validate([]));
+        assert.isTrue(notOptional.validate({}));
+        assert.isTrue(notOptional.validate(new Array('foo')));
+        assert.isTrue(notOptional.validate(new Object({foo: 'bar'})));
+
+        class Foo {}
+        assert.isTrue(notOptional.validate(new Foo()));
+    });
+
+    it('values is not valid', () => {
+        assert.isFalse(notOptional.validate(''));
+        assert.isFalse(notOptional.validate(null));
+        assert.isFalse(notOptional.validate(String()));
+    });
+
+});

test/rules/not-optional.ts

@@ -59,6 +59,7 @@ describe('Validator', () => {
         assert.instanceOf(V.noneOf(V.alwaysValid()), V);
         assert.instanceOf(V.not(V.alwaysValid()), V);
         assert.instanceOf(V.notEmpty(), V);
+        assert.instanceOf(V.notOptional(), V);
         assert.instanceOf(V.nullType(), V);
         assert.instanceOf(V.numberInstance(), V);
         assert.instanceOf(V.numberType(), V);
@@ -163,6 +164,7 @@ describe('Validator', () => {
         assert.instanceOf(v.noneOf(V.alwaysValid()), V);
         assert.instanceOf(v.not(V.alwaysValid()), V);
         assert.instanceOf(v.notEmpty(), V);
+        assert.instanceOf(v.notOptional(), V);
         assert.instanceOf(v.nullType(), V);
         assert.instanceOf(v.numberInstance(), V);
         assert.instanceOf(v.numberType(), V);