feat(rules): Added rules for Symbol

Author: ricardogobbosouza

README.md

@@ -145,6 +145,9 @@ The library can be loaded either as a standalone script, or through an [AMD](htt
 - [StringInstance](docs/string-instance.md)
 - [StringType](docs/string-type.md)
 - [StringVal](docs/string-val.md)
+- [SymbolInstance](docs/symbol-instance.md)
+- [SymbolType](docs/symbol-type.md)
+- [SymbolVal](docs/symbol-val.md)
 - [SymbolicLink](docs/symbolic-link.md)
 - [Tld](docs/tld.md)
 - [TrueVal](docs/true-val.md)

awesome-validator.min.js

@@ -0,0 +1,19 @@
+# Symbol Instance
+
+Validates if the given input is symbol instance.
+
+Valid values:
+
+```js
+validator.symbolInstance().validate(Symbol());
+validator.symbolInstance().validate(Symbol('foo'));
+validator.symbolInstance().validate(Symbol(10));
+```
+
+Invalid values:
+
+```js
+validator.symbolInstance().validate(null);
+validator.symbolInstance().validate('foo');
+validator.symbolInstance().validate(10);
+```

docs/symbol-instance.md

@@ -0,0 +1,19 @@
+# Symbol Type
+
+Validates whether the type of an input is symbol.
+
+Valid values:
+
+```js
+validator.symbolType().validate(Symbol());
+validator.symbolType().validate(Symbol('foo'));
+validator.symbolType().validate(Symbol(10));
+```
+
+Invalid values:
+
+```js
+validator.symbolType().validate(null);
+validator.symbolType().validate('foo');
+validator.symbolType().validate(10);
+```

docs/symbol-type.md

@@ -0,0 +1,28 @@
+# Symbol Val
+
+Validates whether the value of input is symbol.
+
+Valid values:
+
+```js
+validator.symbolVal().validate(0);
+validator.symbolVal().validate(1);
+validator.symbolVal().validate(Number(1));
+validator.symbolVal().validate(Number());
+validator.symbolVal().validate('');
+validator.symbolVal().validate('foo');
+validator.symbolVal().validate(String());
+validator.symbolVal().validate(String('foo'));
+validator.symbolVal().validate(Symbol());
+validator.symbolVal().validate(undefined);
+```
+
+Invalid values:
+
+```js
+validator.symbolVal().validate(null);
+validator.symbolVal().validate(false);
+validator.symbolVal().validate(true);
+validator.symbolVal().validate([]);
+validator.symbolVal().validate({});
+```

docs/symbol-val.md

@@ -66,6 +66,9 @@ export * from './space';
 export * from './string-instance';
 export * from './string-type';
 export * from './string-val';
+export * from './symbol-instance';
+export * from './symbol-type';
+export * from './symbol-val';
 export * from './symbolic-link';
 export * from './tld';
 export * from './true-val';

src/rules/index.ts

@@ -0,0 +1,11 @@
+import { AbstractConstructotName } from './abstract-constructor-name';
+
+export class SymbolInstance extends AbstractConstructotName {
+
+    /**
+     * Get constructor name.
+     */
+    protected getConstructorName(): string {
+        return 'Symbol';
+    }
+}

src/rules/symbol-instance.ts

@@ -0,0 +1,12 @@
+import { AbstractRule } from './abstract-rule';
+import { TypeOf } from './type-of';
+
+export class SymbolType extends AbstractRule {
+
+    /**
+     * Validate.
+     */
+    public validate(input: any): boolean {
+        return new TypeOf(/symbol/i).validate(input);
+    }
+}

src/rules/symbol-type.ts

@@ -0,0 +1,12 @@
+import { AbstractRule } from './abstract-rule';
+import { TypeOf } from './type-of';
+
+export class SymbolVal extends AbstractRule {
+
+    /**
+     * Validate.
+     */
+    public validate(input: any): boolean {
+        return new TypeOf(/number|string|symbol|undefined/i).validate(input);
+    }
+}

src/rules/symbol-val.ts

@@ -75,6 +75,9 @@ export class Validator extends AllOf {
     public static stringInstance = (): Validator => new Validator(new rules.StringInstance());
     public static stringType = (): Validator => new Validator(new rules.StringType());
     public static stringVal = (): Validator => new Validator(new rules.StringVal());
+    public static symbolInstance = (): Validator => new Validator(new rules.SymbolInstance());
+    public static symbolType = (): Validator => new Validator(new rules.SymbolType());
+    public static symbolVal = (): Validator => new Validator(new rules.SymbolVal());
     public static symbolicLink = (): Validator => new Validator(new rules.SymbolicLink());
     public static tld = (): Validator => new Validator(new rules.Tld());
     public static trueVal = (): Validator => new Validator(new rules.TrueVal());
@@ -158,6 +161,9 @@ export class Validator extends AllOf {
     public stringInstance = (): this => this.addRule(new rules.StringInstance());
     public stringType = (): this => this.addRule(new rules.StringType());
     public stringVal = (): this => this.addRule(new rules.StringVal());
+    public symbolInstance = (): this => this.addRule(new rules.SymbolInstance());
+    public symbolType = (): this => this.addRule(new rules.SymbolType());
+    public symbolVal = (): this => this.addRule(new rules.SymbolVal());
     public symbolicLink = (): this => this.addRule(new rules.SymbolicLink());
     public tld = (): this => this.addRule(new rules.Tld());
     public trueVal = (): this => this.addRule(new rules.TrueVal());