feat(rules): Added KeySet rule

Author: ricardogobbosouza

README.md

@@ -146,6 +146,7 @@ The library can be loaded either as a standalone script, or through an [AMD](htt
 - [Iterable](docs/iterable.md)
 - [Json](docs/json.md)
 - [KeyNested](docs/key-nested.md)
+- [KeySet](docs/key-set.md)
 - [KeyValue](docs/key-value.md)
 - [Key](docs/key.md)
 - [Label](docs/label.md)

awesome-validator.min.js

@@ -0,0 +1,17 @@
+# KeySet
+
+Validates a keys in a defined structure.
+
+Valid values:
+
+```js
+validator.keySet(new Key('foo')).validate({foo: 'foobar'});
+validator.keySet(validtor.key('foo')).validate(new Map<string, string>([['foo', 'bar']]));
+```
+
+Invalid values:
+
+```js
+validator.keySet(validator.key('foo')).validate({bar: 'foobar'});
+validator.keySet(new Key('foo')).validate(new Map<string, string>());
+```

docs/key-set.md

@@ -67,6 +67,7 @@ export * from './ip';
 export * from './iterable';
 export * from './json';
 export * from './key-nested';
+export * from './key-set';
 export * from './key-value';
 export * from './key';
 export * from './label';

src/rules/index.ts

@@ -0,0 +1,51 @@
+import { Validatable } from './../validatable';
+import { AllOf } from './all-of';
+import { Key } from './key';
+
+export class KeySet extends AllOf {
+
+    /**
+     * Add rule.
+     */
+    public addRule(rule: Validatable): this {
+        let r: Validatable | undefined = rule;
+
+        if (rule instanceof AllOf && rule.getRules().length === 1) {
+            r = rule.getRules().shift();
+        }
+
+        if (r instanceof Key) {
+            this.rules.add(r);
+        }
+
+        return this;
+    }
+
+    /**
+     * Validate.
+     */
+    public validate(input: any): boolean {
+        return this.hasValidStructure(input) && super.validate(input);
+    }
+
+    /**
+     * Has valid structure.
+     */
+    protected hasValidStructure(input: any): boolean {
+        let i: number = 0;
+
+        for (const rule of this.getRules()) {
+            if (!(rule instanceof Key) || (!new Key(rule.reference).validate(input) && rule.mandatory)) {
+                return false;
+            }
+
+            i++;
+        }
+
+        if (input instanceof Map) {
+            return i === input.size;
+        }
+
+        return i === Object.keys(input).length;
+    }
+}

src/rules/key-set.ts

@@ -0,0 +1,29 @@
+import { assert } from 'chai';
+
+import { AbstractRule } from '../../src/rules/abstract-rule';
+import { AllOf } from '../../src/rules/all-of';
+import { Key } from '../../src/rules/key';
+import { KeySet } from '../../src/rules/key-set';
+import { StringType } from '../../src/rules/string-type';
+
+describe('KeySet', () => {
+
+    it('is rule', () => {
+        assert.instanceOf(new KeySet(), AbstractRule);
+    });
+
+    it('values is valid', () => {
+        assert.isTrue(new KeySet(new Key('foo')).validate({foo: 'foobar'}));
+        assert.isTrue(new KeySet(new AllOf(new Key('foo'))).validate({foo: 'foobar'}));
+        assert.isTrue(new KeySet(new Key('foo')).validate(new Map<string, string>([['foo', 'bar']])));
+        assert.isTrue(new KeySet(new Key('bar', undefined, false)).validate({foo: 'foobar'}));
+    });
+
+    it('values is not valid', () => {
+        assert.isFalse(new KeySet(new Key('foo')).validate({bar: 'foobar'}));
+        assert.isFalse(new KeySet(new StringType()).validate({bar: 'foobar'}));
+        assert.isFalse(new KeySet(new Key('foo')).validate(new Map<string, string>()));
+        assert.isFalse(new KeySet().validate({bar: 'foobar'}));
+    });
+
+});