feat(rules): Added Callable rule

Author: ricardogobbosouza

README.md

@@ -94,6 +94,7 @@ The library can be loaded either as a standalone script, or through an [AMD](htt
 - [BooleanType](docs/boolean-type.md)
 - [BooleanVal](docs/boolean-val.md)
 - [Bsn](docs/bsn.md)
+- [Callable](docs/callable.md)
 - [Charset](docs/charset.md)
 - [Cnh](docs/cnh.md)
 - [Cnpj](docs/cnpj.md)

awesome-validator.min.js

@@ -0,0 +1,27 @@
+# Callable
+
+Validates if the input is a callable.
+
+Valid values:
+
+```js
+const obj: any = {
+    foo(): string {
+        return 'foo';
+    }
+};
+
+validator.callable().validate((): string => 'foo');
+validator.callable().validate('eval');
+validator.callable().validate('Array.isArray');
+validator.callable().validate([obj, 'foo']);
+```
+
+Invalid values:
+
+```js
+validator.callable().validate('');
+validator.callable().validate('foo');
+validator.callable().validate(null);
+validator.callable().validate(undefined);
+```

docs/callable.md

@@ -0,0 +1,33 @@
+import { AbstractTryCatch } from './abstract-try-catch';
+import { ArrayType } from './array-type';
+import { FunctionType } from './function-type';
+import { ObjectType } from './object-type';
+import { StringType } from './string-type';
+
+export class Callable extends AbstractTryCatch {
+
+    /**
+     * Validate Function.
+     */
+    protected validateFunction(input: any): boolean {
+        if (new FunctionType().validate(input)) {
+            return true;
+        }
+
+        if (new StringType().validate(input)) {
+            /* tslint:disable no-eval */
+            return new FunctionType().validate(eval(input));
+            /* tslint:enable no-eval */
+        }
+
+        if (new ArrayType().validate(input) &&
+            input.length === 2 &&
+            new ObjectType().validate(input[0]) &&
+            new StringType().validate(input[1])
+        ) {
+            return new FunctionType().validate(input[0][input[1]]);
+        }
+
+        return false;
+    }
+}

src/rules/callable.ts

@@ -15,6 +15,7 @@ export * from './boolean-instance';
 export * from './boolean-type';
 export * from './boolean-val';
 export * from './bsn';
+export * from './callable';
 export * from './charset';
 export * from './cnh';
 export * from './cnpj';

src/rules/index.ts

@@ -0,0 +1,48 @@
+import { assert } from 'chai';
+
+import { AbstractRule } from '../../src/rules/abstract-rule';
+import { Callable } from '../../src/rules/callable';
+
+describe('Callable', () => {
+
+    let callable: Callable;
+
+    beforeEach(() => {
+        callable = new Callable();
+    });
+
+    it('is rule', () => {
+        assert.instanceOf(callable, AbstractRule);
+    });
+
+    it('values is valid', () => {
+        const obj: any = {
+            /**
+             * Foo.
+             */
+            foo(): string {
+                return 'foo';
+            }
+        };
+
+        assert.isTrue(callable.validate((): string => 'foo'));
+        assert.isTrue(callable.validate('eval'));
+        assert.isTrue(callable.validate('Array.isArray'));
+        assert.isTrue(callable.validate([obj, 'foo']));
+    });
+
+    it('values is not valid', () => {
+        assert.isFalse(callable.validate(null));
+        assert.isFalse(callable.validate(undefined));
+        assert.isFalse(callable.validate([]));
+        assert.isFalse(callable.validate({}));
+        assert.isFalse(callable.validate(new Array('foo')));
+        assert.isFalse(callable.validate(new Object({foo: 'bar'})));
+        assert.isFalse(callable.validate(true));
+        assert.isFalse(callable.validate(false));
+        assert.isFalse(callable.validate(1));
+        assert.isFalse(callable.validate(''));
+        assert.isFalse(callable.validate('foo'));
+    });
+
+});