feat(rules): Added DateTime rule

Author: ricardogobbosouza

README.md

@@ -92,6 +92,7 @@ The library can be loaded either as a standalone script, or through an [AMD](htt
 - [Consonant](docs/consonant.md)
 - [Contains](docs/contains.md)
 - [Cpf](docs/cpf.md)
+- [DateTime](docs/date-time.md)
 - [Digit](docs/digit.md)
 - [Empty](docs/empty.md)
 - [Even](docs/even.md)

awesome-validator.min.js

@@ -0,0 +1,25 @@
+# DateTime
+
+Validates if input is a date.
+
+Valid values:
+
+```js
+validator.dateTime().validate('2008');
+validator.dateTime().validate(new Date(2008, 1, 29));
+validator.dateTime().validate('2008-02-29');
+validator.dateTime().validate(2008);
+validator.dateTime().validate(moment([2008]));
+validator.dateTime().validate([]);
+validator.dateTime().validate({});
+validator.dateTime('DD-MM-YYYY').validate('29-02-2008');
+validator.dateTime('DD/MM/YYYY HH:mm:ss').validate('20/10/2008 10:30:29');
+```
+
+Invalid values:
+
+```js
+validator.dateTime().validate('');
+validator.dateTime().validate('2009-12-00');
+validator.dateTime('DD/MM/YYYY').validate('2008-02-29');
+```

docs/date-time.md

@@ -8,30 +8,9 @@ import { StringType } from './string-type';
 export abstract class AbstractDate extends AbstractRule {
 
     /**
-     * AbstractDate.
-     */
-    public constructor(public readonly format?: moment.MomentFormatSpecification) {
-        super();
-    }
-
-    /**
-     * Validate.
-     */
-    public validate(input: any): boolean {
-        const date: moment.Moment = this.parseDate(input);
-
-        return date.isValid() && this.validateDate(date);
-    }
-
-    /**
-     * Validate Date.
-     */
-    protected abstract validateDate(date: moment.Moment): boolean;
-
-    /**
-     * Parse Date.
+     * Parse.
      */
-    private parseDate(input: any): moment.Moment {
+    public static parse(input: any, format?: moment.MomentFormatSpecification): moment.Moment {
         if (new NumberVal().validate(input)) {
             if (moment([input]).isValid()) {
                 return moment([input]);
@@ -41,7 +20,7 @@ export abstract class AbstractDate extends AbstractRule {
         }
 
         if (new StringType().validate(input)) {
-            return moment(input, this.format);
+            return moment(input, format, !!format);
         }
 
         if (new BooleanType().validate(input)) {
@@ -50,4 +29,25 @@ export abstract class AbstractDate extends AbstractRule {
 
         return moment(input);
     }
+
+    /**
+     * AbstractDate.
+     */
+    public constructor(public readonly format?: moment.MomentFormatSpecification) {
+        super();
+    }
+
+    /**
+     * Validate.
+     */
+    public validate(input: any): boolean {
+        const date: moment.Moment = AbstractDate.parse(input, this.format);
+
+        return date.isValid() && this.validateDate(date);
+    }
+
+    /**
+     * Validate Date.
+     */
+    protected abstract validateDate(date: moment.Moment): boolean;
 }

src/rules/abstract-date.ts

@@ -0,0 +1,13 @@
+import * as moment from 'moment';
+
+import { AbstractDate } from './abstract-date';
+
+export class DateTime extends AbstractDate {
+
+    /**
+     * Validate Date.
+     */
+    protected validateDate(date: moment.Moment): boolean {
+        return true;
+    }
+}

src/rules/date-time.ts

@@ -13,6 +13,7 @@ export * from './cnpj';
 export * from './consonant';
 export * from './contains';
 export * from './cpf';
+export * from './date-time';
 export * from './digit';
 export * from './empty';
 export * from './even';

src/rules/index.ts

@@ -23,6 +23,7 @@ export class Validator extends AllOf {
     public static consonant = (additionalChars?: string): Validator => new Validator(new rules.Consonant(additionalChars));
     public static contains = (value?: any, contains: boolean = true, identical: boolean = false): Validator => new Validator(new rules.Contains(value, contains, identical));
     public static cpf = (): Validator => new Validator(new rules.Cpf());
+    public static dateTime = (format?: momment.MomentFormatSpecification): Validator => new Validator(new rules.DateTime(format));
     public static digit = (additionalChars?: string): Validator => new Validator(new rules.Digit(additionalChars));
     public static empty = (): Validator => new Validator(new rules.Empty());
     public static even = (): Validator => new Validator(new rules.Even());
@@ -118,6 +119,7 @@ export class Validator extends AllOf {
     public consonant = (additionalChars?: string): this => this.addRule(new rules.Consonant(additionalChars));
     public contains = (value?: any, contains: boolean = true, identical: boolean = false): this => this.addRule(new rules.Contains(value, contains, identical));
     public cpf = (): this => this.addRule(new rules.Cpf());
+    public dateTime = (format?: momment.MomentFormatSpecification): this => this.addRule(new rules.DateTime(format));
     public digit = (additionalChars?: string): this => this.addRule(new rules.Digit(additionalChars));
     public empty = (): this => this.addRule(new rules.Empty());
     public even = (): this => this.addRule(new rules.Even());

src/validator.ts

@@ -0,0 +1,44 @@
+import * as moment from 'moment';
+
+import { assert } from 'chai';
+
+import { AbstractRule } from '../../src/rules/abstract-rule';
+import { DateTime } from '../../src/rules/date-time';
+
+describe('DateTime', () => {
+
+    let dateTime: DateTime;
+
+    beforeEach(() => {
+        dateTime = new DateTime();
+    });
+
+    it('is rule', () => {
+        assert.instanceOf(dateTime, AbstractRule);
+    });
+
+    it('values is valid', () => {
+        assert.isTrue(dateTime.validate('2008'));
+        assert.isTrue(dateTime.validate(new Date(2008, 1, 29)));
+        assert.isTrue(dateTime.validate('2008-02-29'));
+        assert.isTrue(dateTime.validate(2008));
+        assert.isTrue(dateTime.validate(moment([2008])));
+        assert.isTrue(dateTime.validate([]));
+        assert.isTrue(dateTime.validate({}));
+    });
+
+    it('values is valid with format', () => {
+        assert.isTrue(new DateTime('DD-MM-YYYY').validate('29-02-2008'));
+        assert.isTrue(new DateTime('DD/MM/YYYY HH:mm:ss').validate('20/10/2008 10:30:29'));
+    });
+
+    it('values is not valid', () => {
+        assert.isFalse(dateTime.validate(''));
+        assert.isFalse(dateTime.validate('2009-12-00'));
+    });
+
+    it('values is not valid with format', () => {
+        assert.isFalse(new DateTime('DD/MM/YYYY').validate('2008-02-29'));
+    });
+
+});

test/rules/date-time.ts

@@ -34,6 +34,8 @@ describe('Validator', () => {
         assert.instanceOf(V.contains('foo', false), V);
         assert.instanceOf(V.contains('foo', false, true), V);
         assert.instanceOf(V.cpf(), V);
+        assert.instanceOf(V.dateTime(), V);
+        assert.instanceOf(V.dateTime('DD-MM-YYYY'), V);
         assert.instanceOf(V.digit(), V);
         assert.instanceOf(V.digit('foo'), V);
         assert.instanceOf(V.empty(), V);
@@ -161,6 +163,8 @@ describe('Validator', () => {
         assert.instanceOf(v.contains('foo', false), V);
         assert.instanceOf(v.contains('foo', false, true), V);
         assert.instanceOf(v.cpf(), V);
+        assert.instanceOf(v.dateTime(), V);
+        assert.instanceOf(v.dateTime('DD-MM-YYYY'), V);
         assert.instanceOf(v.digit(), V);
         assert.instanceOf(v.digit('foo'), V);
         assert.instanceOf(v.empty(), V);