feat(rules): Added Unique rule

Author: ricardogobbosouza

README.md

@@ -121,6 +121,7 @@ The library can be loaded either as a standalone script, or through an [AMD](htt
 - [Tld](docs/tld.md)
 - [TrueVal](docs/true-val.md)
 - [TypeOf](docs/type-of.md)
+- [Unique](docs/unique.md)
 - [Uppercase](docs/uppercase.md)
 - [Url](docs/url.md)
 - [Uuid](docs/uuid.md)

awesome-validator.min.js

@@ -0,0 +1,29 @@
+# Unique
+
+Validates whether the input array contains only unique values.
+
+Valid values:
+
+```js
+validator.unique().validate([]);
+validator.unique().validate([1, 2, 3]);
+validator.unique().validate([true, false]);
+validator.unique().validate(['alpha', 'beta', 'gamma', 'delta']);
+validator.unique().validate([0, 2.71, 3.14]);
+validator.unique().validate([[], ['str'], [1]]);
+validator.unique().validate([{'key': 'value'}, {'other_key': 'value'}]);
+```
+
+Invalid values:
+
+```js
+validator.unique().validate('test');
+validator.unique().validate([1, 2, 2, 3]);
+validator.unique().validate([1, 2, 3, 1]);
+validator.unique().validate([true, false, false]);
+validator.unique().validate(['alpha', 'beta', 'gamma', 'delta', 'beta']);
+validator.unique().validate([0, 3.14, 2.71, 3.14]);
+validator.unique().validate([[], [1], [1]]);
+validator.unique().validate([{'key': 'value'}, {'key': 'value'}]);
+validator.unique().validate([1, true, 'test']);
+```

docs/unique.md

@@ -42,6 +42,7 @@ export * from './string-type';
 export * from './tld';
 export * from './true-val';
 export * from './type-of';
+export * from './unique';
 export * from './uppercase';
 export * from './url';
 export * from './uuid';

src/rules/index.ts

@@ -0,0 +1,23 @@
+import { ArrayVal } from './array-val';
+
+export class Unique extends ArrayVal {
+
+    /**
+     * Validate.
+     */
+    public validate(input: any): boolean {
+        if (!super.validate(input)) {
+            return false;
+        }
+
+        const unique: any[] = input
+            .map((value: any) => JSON.stringify(value))
+            .reverse()
+            .filter((e: any, i: number, a: any[]) => a.indexOf(e, i + 1) === -1)
+            .reverse()
+            .map((value: any) => JSON.parse(value))
+        ;
+
+        return JSON.stringify(input) === JSON.stringify(unique);
+    }
+}

src/rules/unique.ts

@@ -313,6 +313,13 @@ export class Validator extends rules.AllOf {
         return this.addRule(new rules.TypeOf(pattern));
     }
 
+    /**
+     * Unique.
+     */
+    public unique(): this {
+        return this.addRule(new rules.Unique());
+    }
+
     /**
      * Uppercase.
      */

src/validator.ts

@@ -0,0 +1,39 @@
+import { assert } from 'chai';
+
+import { AbstractRule } from '../../src/rules/abstract-rule';
+import { Unique } from '../../src/rules/unique';
+
+describe('Unique', () => {
+
+    let unique: Unique;
+
+    beforeEach(() => {
+        unique = new Unique();
+    });
+
+    it('is rule', () => {
+        assert.instanceOf(unique, AbstractRule);
+    });
+
+    it('values is valid', () => {
+        assert.isTrue(unique.validate([]));
+        assert.isTrue(unique.validate([1, 2, 3]));
+        assert.isTrue(unique.validate([true, false]));
+        assert.isTrue(unique.validate(['alpha', 'beta', 'gamma', 'delta']));
+        assert.isTrue(unique.validate([0, 2.71, 3.14]));
+        assert.isTrue(unique.validate([[], ['str'], [1]]));
+        assert.isTrue(unique.validate([{key: 'value'}, {other_key: 'value'}]));
+    });
+
+    it('values is not valid', () => {
+        assert.isFalse(unique.validate('test'));
+        assert.isFalse(unique.validate([1, 2, 2, 3]));
+        assert.isFalse(unique.validate([1, 2, 3, 1]));
+        assert.isFalse(unique.validate([true, false, false]));
+        assert.isFalse(unique.validate(['alpha', 'beta', 'gamma', 'delta', 'beta']));
+        assert.isFalse(unique.validate([0, 3.14, 2.71, 3.14]));
+        assert.isFalse(unique.validate([[], [1], [1]]));
+        assert.isFalse(unique.validate([{key: 'value'}, {key: 'value'}]));
+    });
+
+});

test/rules/unique.ts

@@ -59,6 +59,7 @@ describe('Validator', () => {
         assert.instanceOf(validator.tld(), Validator);
         assert.instanceOf(validator.trueVal(), Validator);
         assert.instanceOf(validator.typeOf(/foo/), Validator);
+        assert.instanceOf(validator.unique(), Validator);
         assert.instanceOf(validator.uppercase(), Validator);
         assert.instanceOf(validator.url(), Validator);
         assert.instanceOf(validator.uuid(), Validator);