feat(rules): Added options contains an identical in search

Author: ricardogobbosouza

awesome-validator.min.js

@@ -15,6 +15,8 @@ validator.contains(1).validate(new Map().set(1, 'bar'));
 validator.contains('foo').validate(new Map().set('foo', 'bar'));
 validator.contains('foo').validate({foo: 'bar'});
 validator.contains('foo').validate(Object({foo: 'bar'}));
+validator.contains('foo', false).validate('Foo');
+validator.contains('FOO', false, true).validate('FOO');
 ```
 
 Invalid values:
@@ -31,4 +33,6 @@ validator.contains('foobar').validate(new Map().set('foo', 'bar'));
 validator.contains('bar').validate({foo: 'bar'});
 validator.contains('bar').validate(Object({foo: 'bar'}));
 validator.contains().validate(null);
+validator.contains('foo', false).validate('foobar');
+validator.contains('foo', false, true).validate('FOO');
 ```

docs/contains.md

@@ -15,6 +15,8 @@ validator.in(new Map().set(1, 'bar')).validate(1);
 validator.in(new Map().set('foo', 'bar')).validate('foo');
 validator.in({foo: 'bar'}).validate('foo');
 validator.in(Object({foo: 'bar'})).validate('foo');
+validator.in('Foo', false).validate('foo');
+validator.in('FOO', false, true).validate('FOO');
 ```
 
 Invalid values:
@@ -31,4 +33,6 @@ validator.in(new Map().set('foo', 'bar')).validate('foobar');
 validator.in({foo: 'bar'}).validate('bar');
 validator.in(Object({foo: 'bar'})).validate('bar');
 validator.in().validate(null);
+validator.in('foobar', false).validate('foo');
+validator.in('FOO', false, true).validate('foo');
 ```

docs/in.md

@@ -1,24 +1,36 @@
 import { AbstractRule } from './abstract-rule';
-import { StringType } from './string-type';
+import { Scalar } from './scalar';
 
 export abstract class AbstractSearcher extends AbstractRule {
 
     /**
      * Abstract searcher.
      */
-    public constructor(public readonly searcher?: any) {
+    public constructor(
+        public readonly searcher?: any,
+        public readonly contains: boolean = true,
+        public readonly identical: boolean = false
+    ) {
         super();
     }
 
     /**
      * Validate searcher.
      */
     protected validateSearcher(searcher: any, input: any): boolean {
-        if (new StringType().validate(searcher)) {
-            return String(searcher).indexOf(input) !== - 1;
+        if (new Scalar().validate(searcher)) {
+            return String(searcher).search(
+                RegExp(this.contains ? `${input}` : `^${input}$`, this.identical ? undefined : 'i')
+            ) !== -1;
         }
 
         if (Array.isArray(searcher)) {
+            if (!this.identical && new Scalar().validate(input)) {
+                return searcher.findIndex(
+                    (item: any) => this.validateSearcher(item, input)
+                ) !== -1;
+            }
+
             return searcher.indexOf(input) !== -1;
         }
 
@@ -30,10 +42,10 @@ export abstract class AbstractSearcher extends AbstractRule {
             return searcher.has(input);
         }
 
-        if (searcher instanceof Object) {
+        if (searcher instanceof Object && /number|string|symbol/.test(typeof input)) {
             return searcher.hasOwnProperty(input);
         }
 
-        return false;
+        return searcher === input;
     }
 }

src/rules/abstract-searcher.ts

@@ -18,7 +18,7 @@ export class Validator extends AllOf {
     public static cnh = (): Validator => new Validator(new rules.Cnh());
     public static cnpj = (): Validator => new Validator(new rules.Cnpj());
     public static consonant = (additionalChars?: string): Validator => new Validator(new rules.Consonant(additionalChars));
-    public static contains = (value?: any): Validator => new Validator(new rules.Contains(value));
+    public static contains = (value?: any, contains: boolean = true, identical: boolean = false): Validator => new Validator(new rules.Contains(value, contains, identical));
     public static cpf = (): Validator => new Validator(new rules.Cpf());
     public static empty = (): Validator => new Validator(new rules.Empty());
     public static even = (): Validator => new Validator(new rules.Even());
@@ -27,7 +27,7 @@ export class Validator extends AllOf {
     public static floatVal = (): Validator => new Validator(new rules.FloatVal());
     public static functionInstance = (): Validator => new Validator(new rules.FunctionInstance());
     public static functionType = (): Validator => new Validator(new rules.FunctionType());
-    public static in = (searcher?: any): Validator => new Validator(new rules.In(searcher));
+    public static in = (searcher?: any, contains: boolean = true, identical: boolean = false): Validator => new Validator(new rules.In(searcher, contains, identical));
     public static instanceOf = (instanceName: any): Validator => new Validator(new rules.InstanceOf(instanceName));
     public static intType = (): Validator => new Validator(new rules.IntType());
     public static intVal = (): Validator => new Validator(new rules.IntVal());
@@ -95,7 +95,7 @@ export class Validator extends AllOf {
     public cnh = (): this => this.addRule(new rules.Cnh());
     public cnpj = (): this => this.addRule(new rules.Cnpj());
     public consonant = (additionalChars?: string): this => this.addRule(new rules.Consonant(additionalChars));
-    public contains = (value?: any): this => this.addRule(new rules.Contains(value));
+    public contains = (value?: any, contains: boolean = true, identical: boolean = false): this => this.addRule(new rules.Contains(value, contains, identical));
     public cpf = (): this => this.addRule(new rules.Cpf());
     public empty = (): this => this.addRule(new rules.Empty());
     public even = (): this => this.addRule(new rules.Even());
@@ -104,7 +104,7 @@ export class Validator extends AllOf {
     public floatVal = (): this => this.addRule(new rules.FloatVal());
     public functionInstance = (): this => this.addRule(new rules.FunctionInstance());
     public functionType = (): this => this.addRule(new rules.FunctionType());
-    public in = (searcher?: any): this => this.addRule(new rules.In(searcher));
+    public in = (searcher?: any, contains: boolean = true, identical: boolean = false): this => this.addRule(new rules.In(searcher, contains, identical));
     public instanceOf = (instanceName: any): this => this.addRule(new rules.InstanceOf(instanceName));
     public intType = (): this => this.addRule(new rules.IntType());
     public intVal = (): this => this.addRule(new rules.IntVal());

src/validator.ts

@@ -4,22 +4,39 @@ import { AbstractRule } from '../../src/rules/abstract-rule';
 import { Contains } from '../../src/rules/contains';
 
 describe('Contains', () => {
+    class Foo {
+        /**
+         * bar
+         */
+        public bar: string = 'foobar';
+    }
 
     it('is rule', () => {
         assert.instanceOf(new Contains(), AbstractRule);
     });
 
     it('values is valid', () => {
+        assert.isTrue(new Contains('foo').validate('FOO'));
+        assert.isTrue(new Contains('FOO').validate('foo'));
+        assert.isTrue(new Contains('foo').validate(['FOO']));
         assert.isTrue(new Contains('foo').validate('foobar'));
         assert.isTrue(new Contains('foo').validate(String('foobar')));
         assert.isTrue(new Contains(1).validate([1, 2, 3]));
+        assert.isTrue(new Contains('1').validate([1, 2, 3]));
         assert.isTrue(new Contains('foo').validate(new Array('foo', 'bar', 'foobar')));
         assert.isTrue(new Contains(1).validate(new Set([1, 2, 3])));
         assert.isTrue(new Contains('foo').validate(new Set(['foo', 'bar', 'foobar'])));
         assert.isTrue(new Contains(1).validate(new Map().set(1, 'bar')));
         assert.isTrue(new Contains('foo').validate(new Map().set('foo', 'bar')));
         assert.isTrue(new Contains('foo').validate({foo: 'bar'}));
         assert.isTrue(new Contains('foo').validate(Object({foo: 'bar'})));
+        assert.isTrue(new Contains('foo', false).validate('Foo'));
+        assert.isTrue(new Contains('FOO', false, true).validate('FOO'));
+        assert.isTrue(new Contains(null).validate(null));
+
+        const foo: Foo = new Foo();
+        assert.isTrue(new Contains(foo).validate(foo));
+        assert.isTrue(new Contains('bar').validate(foo));
     });
 
     it('values is not valid', () => {
@@ -34,6 +51,11 @@ describe('Contains', () => {
         assert.isFalse(new Contains('bar').validate({foo: 'bar'}));
         assert.isFalse(new Contains('bar').validate(Object({foo: 'bar'})));
         assert.isFalse(new Contains().validate(null));
+        assert.isFalse(new Contains('foo', false).validate('foobar'));
+        assert.isFalse(new Contains('foo', false, true).validate('FOO'));
+        assert.isFalse(new Contains().validate(null));
+        assert.isFalse(new Contains(new Foo()).validate(new Foo()));
+        assert.isFalse(new Contains('foobar').validate(new Foo()));
     });
 
 });

test/rules/contains.ts

@@ -4,13 +4,21 @@ import { AbstractRule } from '../../src/rules/abstract-rule';
 import { In } from '../../src/rules/in';
 
 describe('In', () => {
+    class Foo {
+        /**
+         * bar
+         */
+        public bar: string = 'foobar';
+    }
 
     it('is rule', () => {
         assert.instanceOf(new In(), AbstractRule);
     });
 
     it('values is valid', () => {
         assert.isTrue(new In('foobar').validate('foo'));
+        assert.isTrue(new In('foobar').validate('FOO'));
+        assert.isTrue(new In('fooBAR').validate('bar'));
         assert.isTrue(new In(String('foobar')).validate('foo'));
         assert.isTrue(new In([1, 2, 3]).validate(1));
         assert.isTrue(new In(new Array('foo', 'bar', 'foobar')).validate('foo'));
@@ -20,6 +28,13 @@ describe('In', () => {
         assert.isTrue(new In(new Map().set('foo', 'bar')).validate('foo'));
         assert.isTrue(new In({foo: 'bar'}).validate('foo'));
         assert.isTrue(new In(Object({foo: 'bar'})).validate('foo'));
+        assert.isTrue(new In('Foo', false).validate('foo'));
+        assert.isTrue(new In('FOO', false, true).validate('FOO'));
+        assert.isTrue(new In(null).validate(null));
+
+        const foo: Foo = new Foo();
+        assert.isTrue(new In(foo).validate(foo));
+        assert.isTrue(new In(foo).validate('bar'));
     });
 
     it('values is not valid', () => {
@@ -34,6 +49,11 @@ describe('In', () => {
         assert.isFalse(new In({foo: 'bar'}).validate('bar'));
         assert.isFalse(new In(Object({foo: 'bar'})).validate('bar'));
         assert.isFalse(new In().validate(null));
+        assert.isFalse(new In('foobar', false).validate('foo'));
+        assert.isFalse(new In('FOO', false, true).validate('foo'));
+        assert.isFalse(new In().validate(null));
+        assert.isFalse(new In(new Foo()).validate(new Foo()));
+        assert.isFalse(new In(new Foo()).validate('foobar'));
     });
 
 });

test/rules/in.ts

@@ -29,6 +29,8 @@ describe('Validator', () => {
         assert.instanceOf(V.cnpj(), V);
         assert.instanceOf(V.consonant(), V);
         assert.instanceOf(V.contains('foo'), V);
+        assert.instanceOf(V.contains('foo', false), V);
+        assert.instanceOf(V.contains('foo', false, true), V);
         assert.instanceOf(V.cpf(), V);
         assert.instanceOf(V.empty(), V);
         assert.instanceOf(V.even(), V);
@@ -38,6 +40,8 @@ describe('Validator', () => {
         assert.instanceOf(V.functionInstance(), V);
         assert.instanceOf(V.functionType(), V);
         assert.instanceOf(V.in([]), V);
+        assert.instanceOf(V.in([], false), V);
+        assert.instanceOf(V.in([], false, true), V);
         assert.instanceOf(V.instanceOf(Object), V);
         assert.instanceOf(V.intType(), V);
         assert.instanceOf(V.intVal(), V);
@@ -111,6 +115,8 @@ describe('Validator', () => {
         assert.instanceOf(v.cnpj(), V);
         assert.instanceOf(v.consonant(), V);
         assert.instanceOf(v.contains('foo'), V);
+        assert.instanceOf(v.contains('foo', false), V);
+        assert.instanceOf(v.contains('foo', false, true), V);
         assert.instanceOf(v.cpf(), V);
         assert.instanceOf(v.empty(), V);
         assert.instanceOf(v.even(), V);
@@ -120,6 +126,8 @@ describe('Validator', () => {
         assert.instanceOf(v.functionInstance(), V);
         assert.instanceOf(v.functionType(), V);
         assert.instanceOf(v.in([]), V);
+        assert.instanceOf(v.in([], false), V);
+        assert.instanceOf(v.in([], false, true), V);
         assert.instanceOf(v.instanceOf(Object), V);
         assert.instanceOf(v.intType(), V);
         assert.instanceOf(v.intVal(), V);