feat(rules): Added Range rule

Author: ricardogobbosouza

README.md

@@ -141,6 +141,7 @@ The library can be loaded either as a standalone script, or through an [AMD](htt
 - [PrimeNumber](docs/prime-number.md)
 - [Prnt](docs/prnt.md)
 - [Punct](docs/punct.md)
+- [Range](docs/range.md)
 - [RegexInstance](docs/regex-instance.md)
 - [RegexType](docs/regex-type.md)
 - [RegexVal](docs/regex-val.md)

awesome-validator.min.js

@@ -0,0 +1,24 @@
+# Range
+
+Validates lengths.
+
+Valid values:
+
+```js
+validator.range(1).validate('foo'));
+validator.range(100).validate(100));
+validator.range(100, 200, false).validate(150));
+validator.range(1).validate({foo: 'bar'}));
+validator.range(1).validate([1]));
+```
+
+Invalid values:
+
+```js
+validator.range(5).validate('foo'));
+validator.range(3, 5, false).validate('foo'));
+validator.range(100).validate(50));
+validator.range(100, 200, false).validate(100));
+validator.range(2).validate({foo: 'bar'}));
+validator.range(2).validate([1]));
+```

docs/range.md

@@ -62,6 +62,7 @@ export * from './positive';
 export * from './prime-number';
 export * from './prnt';
 export * from './punct';
+export * from './range';
 export * from './regex-instance';
 export * from './regex-type';
 export * from './regex-val';

src/rules/index.ts

@@ -0,0 +1,50 @@
+import { AbstractRule } from './abstract-rule';
+import { AllOf } from './all-of';
+import { ArrayType } from './array-type';
+import { Max } from './max';
+import { Min } from './min';
+import { NumberVal } from './number-val';
+import { ObjectTypeStrict } from './object-type-strict';
+
+export class Range extends AbstractRule {
+
+    /**
+     * Parse.
+     */
+    public static parse(input: any): number {
+        if (new NumberVal().validate(input)) {
+            return Number(input);
+        }
+
+        if (new ObjectTypeStrict().validate(input) || new ArrayType().validate(input)) {
+            return Object.keys(input).length;
+        }
+
+        if (input instanceof Set || input instanceof Map) {
+            return input.size;
+        }
+
+        return String(input).length;
+    }
+
+    /**
+     * Length.
+     */
+    public constructor(
+        public readonly min?: number | null,
+        public readonly max?: number | null,
+        public readonly inclusive: boolean = true
+    ) {
+        super();
+    }
+
+    /**
+     * Validate.
+     */
+    public validate(input: any): boolean {
+        return new AllOf(
+            new Min(this.min, this.inclusive),
+            new Max(this.max, this.inclusive)
+        ).validate(Range.parse(input));
+    }
+}

src/rules/range.ts

@@ -38,7 +38,7 @@ export class Validator extends AllOf {
     public static intVal = (): Validator => new Validator(new rules.IntVal());
     public static json = (): Validator => new Validator(new rules.Json());
     public static label = (): Validator => new Validator(new rules.Label());
-    public static leapDate= (format?: momment.MomentFormatSpecification): Validator => new Validator(new rules.LeapDate(format));
+    public static leapDate = (format?: momment.MomentFormatSpecification): Validator => new Validator(new rules.LeapDate(format));
     public static leapYear = (format?: momment.MomentFormatSpecification): Validator => new Validator(new rules.LeapYear(format));
     public static lowercase = (): Validator => new Validator(new rules.Lowercase());
     public static luhn = (): Validator => new Validator(new rules.Luhn());
@@ -72,6 +72,7 @@ export class Validator extends AllOf {
     public static primeNumber = (): Validator => new Validator(new rules.PrimeNumber());
     public static prnt = (additionalChars?: string): Validator => new Validator(new rules.Prnt(additionalChars));
     public static punct = (additionalChars?: string): Validator => new Validator(new rules.Punct(additionalChars));
+    public static range = (min?: number | null, max?: number | null, inclusive: boolean = true): Validator => new Validator(new rules.Range(min, max, inclusive));
     public static regexInstance = (): Validator => new Validator(new rules.RegexInstance());
     public static regexType = (): Validator => new Validator(new rules.RegexType());
     public static regexVal = (): Validator => new Validator(new rules.RegexVal());
@@ -168,6 +169,7 @@ export class Validator extends AllOf {
     public primeNumber = (): this => this.addRule(new rules.PrimeNumber());
     public prnt = (additionalChars?: string): this => this.addRule(new rules.Prnt(additionalChars));
     public punct = (additionalChars?: string): this => this.addRule(new rules.Punct(additionalChars));
+    public range = (min?: number | null, max?: number | null, inclusive: boolean = true): this => this.addRule(new rules.Range(min, max, inclusive));
     public regexInstance = (): this => this.addRule(new rules.RegexInstance());
     public regexType = (): this => this.addRule(new rules.RegexType());
     public regexVal = (): this => this.addRule(new rules.RegexVal());

src/validator.ts

@@ -0,0 +1,67 @@
+import { assert } from 'chai';
+
+import { AbstractRule } from '../../src/rules/abstract-rule';
+import { Range } from '../../src/rules/range';
+
+describe('Range', () => {
+
+    it('is rule', () => {
+        assert.instanceOf(new Range(), AbstractRule);
+    });
+
+    it('values is valid', () => {
+        assert.isTrue(new Range(1).validate('foo'));
+        assert.isTrue(new Range(null, 5).validate('foo'));
+        assert.isTrue(new Range(1, 5).validate('foo'));
+        assert.isTrue(new Range(1, 5, false).validate('foo'));
+        assert.isTrue(new Range().validate(0));
+        assert.isTrue(new Range(100).validate(100));
+        assert.isTrue(new Range(100, 200).validate(100));
+        assert.isTrue(new Range(null, 200).validate(150));
+        assert.isTrue(new Range(100, 200, false).validate(150));
+        assert.isTrue(new Range(1).validate({foo: 'bar'}));
+        assert.isTrue(new Range(1, 5).validate({foo: 'bar'}));
+        assert.isTrue(new Range(1, 5, false).validate({foo: 'bar', bar: 'foo'}));
+        assert.isTrue(new Range(0, 5).validate({}));
+        assert.isTrue(new Range(1).validate([1]));
+        assert.isTrue(new Range(1, 5).validate([1]));
+        assert.isTrue(new Range(1, 5, false).validate([1, 2]));
+        assert.isTrue(new Range(0, 5).validate([]));
+        assert.isTrue(new Range(1).validate(new Set([1, 2, 3])));
+        assert.isTrue(new Range(null, 5).validate(new Set([1, 2, 3])));
+        assert.isTrue(new Range(1, 5).validate(new Set([1, 2, 3])));
+        assert.isTrue(new Range(1, 5, false).validate(new Set([1, 2, 3])));
+        assert.isTrue(new Range(1).validate(new Map<number, number>([[1, 1], [2, 2], [3, 3]])));
+        assert.isTrue(new Range(null, 5).validate(new Map<number, number>([[1, 1], [2, 2], [3, 3]])));
+        assert.isTrue(new Range(1, 5).validate(new Map<number, number>([[1, 1], [2, 2], [3, 3]])));
+        assert.isTrue(new Range(1, 5, false).validate(new Map<number, number>([[1, 1], [2, 2], [3, 3]])));
+    });
+
+    it('values is not valid', () => {
+        assert.isFalse(new Range(5).validate('foo'));
+        assert.isFalse(new Range(null, 5).validate('foobar'));
+        assert.isFalse(new Range(5, 10).validate('foo'));
+        assert.isFalse(new Range(3, 5, false).validate('foo'));
+        assert.isFalse(new Range(100).validate(50));
+        assert.isFalse(new Range(100, 200).validate(50));
+        assert.isFalse(new Range(100, 200, false).validate(100));
+        assert.isFalse(new Range(null, 200).validate(250));
+        assert.isFalse(new Range(2).validate({foo: 'bar'}));
+        assert.isFalse(new Range(2, 5).validate({foo: 'bar'}));
+        assert.isFalse(new Range(2, 5, false).validate({foo: 'bar', bar: 'foo'}));
+        assert.isFalse(new Range(0, 5, false).validate({}));
+        assert.isFalse(new Range(2).validate([1]));
+        assert.isFalse(new Range(2, 5).validate([1]));
+        assert.isFalse(new Range(2, 5, false).validate([1, 2]));
+        assert.isFalse(new Range(0, 5, false).validate([]));
+        assert.isFalse(new Range(5).validate(new Set([1, 2, 3])));
+        assert.isFalse(new Range(null, 2).validate(new Set([1, 2, 3])));
+        assert.isFalse(new Range(5, 10).validate(new Set([1, 2, 3])));
+        assert.isFalse(new Range(3, 5, false).validate(new Set([1, 2, 3])));
+        assert.isFalse(new Range(5).validate(new Map<number, number>([[1, 1], [2, 2], [3, 3]])));
+        assert.isFalse(new Range(null, 2).validate(new Map<number, number>([[1, 1], [2, 2], [3, 3]])));
+        assert.isFalse(new Range(5, 10).validate(new Map<number, number>([[1, 1], [2, 2], [3, 3]])));
+        assert.isFalse(new Range(3, 5, false).validate(new Map<number, number>([[1, 1], [2, 2], [3, 3]])));
+    });
+
+});

test/rules/range.ts

@@ -61,9 +61,13 @@ describe('Validator', () => {
         assert.instanceOf(V.luhn(), V);
         assert.instanceOf(V.macAddress(), V);
         assert.instanceOf(V.max(), V);
+        assert.instanceOf(V.max(null), V);
+        assert.instanceOf(V.max(undefined), V);
         assert.instanceOf(V.max(100), V);
         assert.instanceOf(V.max(100, false), V);
         assert.instanceOf(V.min(), V);
+        assert.instanceOf(V.min(null), V);
+        assert.instanceOf(V.min(undefined), V);
         assert.instanceOf(V.min(100), V);
         assert.instanceOf(V.min(100, false), V);
         assert.instanceOf(V.multiple(0), V);
@@ -98,6 +102,12 @@ describe('Validator', () => {
         assert.instanceOf(V.prnt('foo'), V);
         assert.instanceOf(V.punct(), V);
         assert.instanceOf(V.punct('foo'), V);
+        assert.instanceOf(V.range(), V);
+        assert.instanceOf(V.range(100), V);
+        assert.instanceOf(V.range(100, 100), V);
+        assert.instanceOf(V.range(100, 200, false), V);
+        assert.instanceOf(V.range(null, 100), V);
+        assert.instanceOf(V.range(undefined, 100), V);
         assert.instanceOf(V.regexInstance(), V);
         assert.instanceOf(V.regexType(), V);
         assert.instanceOf(V.regexVal(), V);
@@ -227,6 +237,12 @@ describe('Validator', () => {
         assert.instanceOf(v.prnt('foo'), V);
         assert.instanceOf(v.punct(), V);
         assert.instanceOf(v.punct('foo'), V);
+        assert.instanceOf(v.range(), V);
+        assert.instanceOf(v.range(100), V);
+        assert.instanceOf(v.range(100, 100), V);
+        assert.instanceOf(v.range(100, 200, false), V);
+        assert.instanceOf(v.range(null, 100), V);
+        assert.instanceOf(v.range(undefined, 100), V);
         assert.instanceOf(v.regexInstance(), V);
         assert.instanceOf(v.regexType(), V);
         assert.instanceOf(v.regexVal(), V);