feat(rules): Rename Range rule to Between

Author: ricardogobbosouza

README.md

@@ -85,6 +85,7 @@ The library can be loaded either as a standalone script, or through an [AMD](htt
 - [ArrayInstance](docs/array-instance.md)
 - [ArrayType](docs/array-type.md)
 - [ArrayVal](docs/array-val.md)
+- [Between](docs/between.md)
 - [BooleanInstance](docs/boolean-instance.md)
 - [BooleanType](docs/boolean-type.md)
 - [BooleanVal](docs/boolean-val.md)
@@ -167,7 +168,6 @@ The library can be loaded either as a standalone script, or through an [AMD](htt
 - [Prnt](docs/prnt.md)
 - [PropertyKey](docs/property-key.md)
 - [Punct](docs/punct.md)
-- [Range](docs/range.md)
 - [Readable](docs/readable.md)
 - [RegexInstance](docs/regex-instance.md)
 - [RegexType](docs/regex-type.md)

docs/between.md

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

docs/range.md

@@ -1,8 +1,8 @@
 import * as moment from 'moment';
 
 import { AbstractRule } from './abstract-rule';
+import { Between } from './between';
 import { DateTime } from './date-time';
-import { Range } from './range';
 
 export class Age extends AbstractRule {
 
@@ -23,7 +23,7 @@ export class Age extends AbstractRule {
     public validate(input: any): boolean {
         const date: moment.Moment = DateTime.parse(input, this.format);
 
-        return date.isValid() && new Range(
+        return date.isValid() && new Between(
             this.max ? moment().subtract(this.max, 'years').hour(0).minute(0).second(0) : null,
             this.min ? moment().subtract(this.min, 'years').hour(23).minute(59).second(59) : null
         ).validate(date);

src/rules/age.ts

@@ -3,10 +3,10 @@ import { AllOf } from './all-of';
 import { Max } from './max';
 import { Min } from './min';
 
-export class Range extends AbstractRule {
+export class Between extends AbstractRule {
 
     /**
-     * RanRangee.
+     * Between.
      */
     public constructor(
         public readonly min?: any,

src/rules/range.ts src/rules/between.tssrc/rules/range.ts renamed to src/rules/between.ts

@@ -6,6 +6,7 @@ export * from './any-of';
 export * from './array-instance';
 export * from './array-type';
 export * from './array-val';
+export * from './between';
 export * from './boolean-instance';
 export * from './boolean-type';
 export * from './boolean-val';
@@ -88,7 +89,6 @@ export * from './prime-number';
 export * from './prnt';
 export * from './property-key';
 export * from './punct';
-export * from './range';
 export * from './readable';
 export * from './regex-instance';
 export * from './regex-type';

src/rules/index.ts

@@ -1,7 +1,7 @@
+import { Between } from './between';
 import { File } from './file';
-import { Range } from './range';
 
-export class Size extends Range {
+export class Size extends Between {
 
     /**
      * Validate.

src/rules/size.ts

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