feat(rules): Added KeyValue 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)
+- [KeyValue](docs/key-value.md)
 - [Key](docs/key.md)
 - [Label](docs/label.md)
 - [LanguageCode](docs/language-code.md)

awesome-validator.min.js

@@ -0,0 +1,17 @@
+# Key Value
+
+Valid values:
+
+```js
+validator.keyValue('foo', 'equals', 'bar').validate({foo: 'foobar', bar: 'foobar'});
+validator.keyValue('foo', 'equals', 'bar').validate({foo: 10, bar: 10});
+```
+
+Invalid values:
+
+```js
+validator.keyValue('invalidCompared', 'equals', 'bar').validate({foz: 'foobar', bar: 'foobar'});
+validator.keyValue('foo', 'invalidRule', 'bar').validate({foo: 'foobar', bar: 'foobar'});
+validator.keyValue('foo', 'equals', 'invalidBase').validate({foo: 'foobar', baz: 'foobar'});
+validator.keyValue('foo', 'equals', 'bar').validate({foo: 'foobar', bar: 'foobaz'});
+```

docs/key-value.md

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

src/rules/index.ts

@@ -0,0 +1,34 @@
+import { Validatable } from './../validatable';
+import { Validator } from './../validator';
+import { AbstractRule } from './abstract-rule';
+import { Key } from './key';
+
+export class KeyValue extends AbstractRule {
+
+    /**
+     * KeyValue.
+     */
+    public constructor(
+        protected readonly comparedKey: any,
+        protected readonly ruleName: any,
+        protected readonly baseKey: any
+    ) {
+        super();
+    }
+
+    /**
+     * Validate.
+     */
+    public validate(input: any): boolean {
+        const ruleCompared: Key = new Key(this.comparedKey);
+        const ruleBase: Key = new Key(this.baseKey);
+
+        if (!ruleCompared.validate(input) || !ruleBase.validate(input) || !(this.ruleName in Validator)) {
+            return false;
+        }
+
+        const rule: Validatable = Validator[this.ruleName](ruleBase.getReferenceValueStored());
+
+        return rule.validate(ruleCompared.getReferenceValueStored());
+    }
+}

src/rules/key-value.ts

@@ -0,0 +1,24 @@
+import { assert } from 'chai';
+
+import { AbstractRule } from '../../src/rules/abstract-rule';
+import { KeyValue } from '../../src/rules/key-value';
+
+describe('KeyValue', () => {
+
+    it('is rule', () => {
+        assert.instanceOf(new KeyValue('foo', 'alwaysValid', 'foo'), AbstractRule);
+    });
+
+    it('values is valid', () => {
+        assert.isTrue(new KeyValue('foo', 'equals', 'bar').validate({foo: 'foobar', bar: 'foobar'}));
+        assert.isTrue(new KeyValue('foo', 'equals', 'bar').validate({foo: 10, bar: 10}));
+    });
+
+    it('values is not valid', () => {
+        assert.isFalse(new KeyValue('invalidCompared', 'equals', 'bar').validate({foz: 'foobar', bar: 'foobar'}));
+        assert.isFalse(new KeyValue('foo', 'invalidRule', 'bar').validate({foo: 'foobar', bar: 'foobar'}));
+        assert.isFalse(new KeyValue('foo', 'equals', 'invalidBase').validate({foo: 'foobar', baz: 'foobar'}));
+        assert.isFalse(new KeyValue('foo', 'equals', 'bar').validate({foo: 'foobar', bar: 'foobaz'}));
+    });
+
+});