Move fields initialization to init method

Initialization should be carried out by constructor but unfortunately ES6
specification forbides referring to `this` before calling super. It makes
impossible to validate default values by calling deserialize method in
constructor. To workaround this behaviour this commit moves actual
initialization to `init` function and makes constructor responsible only for
validation of default value and freezing params.

lib/fields/boolean.js

@@ -20,10 +20,6 @@ class BooleanField extends Field {
      */
     constructor(params) {
         super(params);
-
-        if (this.params.default !== undefined && typeof this.params.default !== 'boolean') {
-            throw new Error('Default value must be a boolean');
-        }
     }
 
     /**

lib/fields/email.js

@@ -21,11 +21,12 @@ class EmailField extends StringField {
      * @param {string} [params.default]
      */
     constructor(params) {
-        super(Object.assign({}, params, { trim: true }));
+        super(params);
+    }
 
-        if (this.params.default !== undefined && !validateEmail(this.params.default)) {
-            throw new Error('Default value must be a valid email address');
-        }
+    init(params) {
+        super.init(params);
+        this.params.trim = true;
     }
 
     /**

lib/fields/enum.js

@@ -21,7 +21,11 @@ class EnumField extends Field {
      * @param {string} [params.default]
      */
     constructor(choices, params) {
-        super(params);
+        super(choices, params);
+    }
+
+    init(choices, params) {
+        super.init(params);
 
         if (!choices) {
             throw new Error('Choices list is missing');

lib/fields/field.js

@@ -6,13 +6,40 @@ const customError = require('custom-error');
  * Generic field class. Every other field class must inherit from this one.
  */
 class Field {
+    constructor() {
+        this.init.apply(this, arguments);
+
+        // Validate default value
+
+        if (this.params.default !== undefined) {
+            // Check if default value is deserializable
+
+            try {
+                this.deserialize(this.params.default);
+            } catch (error) {
+                if (error instanceof Field.ValidationError) {
+                    throw new Error(`Default value is invalid: ${error.message.toLowerCase()}`);
+                } else {
+                    throw error;
+                }
+            }
+        }
+
+        // Freeze params
+
+        Object.freeze(this.params);
+    }
+
     /**
-     * @param {object} [params]
-     * @param {boolean} [params.optional]
-     * @param {*} [params.default]
+     * Initializes field's instance. It should be carried out by constructor but unfortunately ES6 specification
+     * forbides referring to `this` before calling super. It makes impossible to validate default values by calling
+     * deserialize method in constructor. To workaround this behaviour actual initialization is made by init function
+     * and constructor is responsible only for validation of default value and freezing params.
+     *
+     * @param params
      */
-    constructor(params) {
-        this.params = Object.freeze(Object.assign({}, params));
+    init(params) {
+        this.params = Object.assign({}, params);
     }
 
     /**

lib/fields/integer.js

@@ -22,10 +22,10 @@ class IntegerField extends NumberField {
      */
     constructor(params) {
         super(params);
+    }
 
-        if (this.params.default !== undefined && !Number.isInteger(this.params.default)) {
-            throw new Error('Default value must be an integer');
-        }
+    init(params) {
+        super.init(params);
 
         if (this.params.min !== undefined && !Number.isInteger(this.params.min)) {
             throw new Error('Min value must be an integer');

lib/fields/model.js

@@ -17,26 +17,26 @@ const Field = require('./field');
  */
 class ModelField extends Field {
     /**
-     * @param {object} FieldModel - model which will be used to serialize/deserialize object's properties
+     * @param {object|function} model - model which will be used to serialize/deserialize object's properties
      * @param {object} [params]
      * @param {boolean} [params.optional]
      */
-    constructor(FieldModel, params) {
-        super(params);
+    constructor(model, params) {
+        super(model, params);
+    }
 
-        if (!FieldModel) {
-            throw new Error('Model is missing');
-        }
+    init(model, params) {
+        super.init(params);
 
-        if (typeof FieldModel === 'object') {
-            FieldModel = Model.extend(FieldModel);
+        if (!model) {
+            throw new Error('Model is missing');
         }
 
-        if (this.params.default !== undefined) {
-            throw new Error('This field doesn\'t accept default value');
+        if (typeof model === 'object') {
+            model = Model.extend(model);
         }
 
-        this.Model = FieldModel;
+        this.Model = model;
     }
 
     /**

lib/fields/number.js

@@ -24,10 +24,10 @@ class NumberField extends Field {
      */
     constructor(params) {
         super(params);
+    }
 
-        if (this.params.default !== undefined && !Number.isFinite(this.params.default)) {
-            throw new Error('Default value must be a number');
-        }
+    init(params) {
+        super.init(params);
 
         if (this.params.min !== undefined && !Number.isFinite(this.params.min)) {
             throw new Error('Min value must be a number');

lib/fields/string.js

@@ -22,10 +22,10 @@ class StringField extends Field {
      */
     constructor(params) {
         super(params);
+    }
 
-        if (this.params.default !== undefined && typeof this.params.default !== 'string') {
-            throw new Error('Default value must be a string');
-        }
+    init(params) {
+        super.init(params);
 
         if (this.params.minLength !== undefined && (!Number.isInteger(this.params.minLength) || this.params.minLength < 0)) {
             throw new Error('Min length must be a positive integer');

test/fields/boolean-spec.js

@@ -22,12 +22,6 @@ describe('BooleanField', function () {
             expect(field).to.be.instanceOf(Field);
             expect(field).to.be.instanceOf(BooleanField);
         });
-
-        it('should throw error when default value is not a boolean', function () {
-            let call = () => new BooleanField({ default: 'true' });
-
-            expect(call).to.throw(Error, 'Default value must be a boolean');
-        });
     });
 
     describe('deserialize method', function () {

test/fields/email-spec.js

@@ -24,18 +24,6 @@ describe('EmailField', function () {
             expect(field).to.be.instanceOf(Field);
             expect(field).to.be.instanceOf(EmailField);
         });
-
-        it('should throw error when default value is not a string', function () {
-            let call = () => new EmailField({ default: 7 });
-
-            expect(call).to.throw(Error, 'Default value must be a string');
-        });
-
-        it('should throw error when default value is not a valid email address', function () {
-            let call = () => new EmailField({ default: 'abcdef' });
-
-            expect(call).to.throw(Error, 'Default value must be a valid email address');
-        });
     });
 
     describe('deserialize method', function () {

test/fields/field-spec.js

@@ -13,18 +13,65 @@ describe('Field', function () {
             expect(field.params).to.be.deep.equal({});
         });
 
-        it('should create new instance when all params are specified', function () {
+        it('should pass all specified arguments to init method', function () {
+            class TestField extends Field {
+                init() {
+                    this.args = Array.prototype.slice.call(arguments);
+                    super.init.apply(this, arguments);
+                }
+            }
+
+            let field = new TestField(1, 2, 3);
+
+            expect(field.args).to.be.deep.equal([1, 2, 3]);
+        });
+
+        it('should freeze params', function () {
+            let field = new Field();
+
+            expect(field.params).to.be.frozen;
+        });
+
+        it('should throw error when default value is invalid', function () {
+            class TestField extends Field {
+                deserialize() {
+                    throw new Field.ValidationError('Value is invalid');
+                }
+            }
+
+            let call = () => new TestField({ default: true });
+
+            expect(call).to.throw(Error, 'Default value is invalid: value is invalid');
+        });
+
+        it('should throw error when unexpected error occurs during deserialization of default value', function () {
+            let error = new Error();
+            class TestField extends Field {
+                deserialize() {
+                    throw error;
+                }
+            }
+
+            let call = () => new TestField({ default: true });
+
+            expect(call).to.throw(error);
+        });
+    });
+
+    describe('init method', function () {
+        it('should copy params to field', function () {
             let params = {
                 default: {},
                 optional: true,
                 foo: 'bar'
             };
 
-            let field = new Field(params);
+            let field = {};
+            Field.prototype.init.call(field, params);
 
-            expect(field).to.be.instanceOf(Field);
             expect(field.params).to.be.deep.equal(params);
-            expect(field.params).to.be.deep.frozen;
+            expect(field.params).to.be.not.equal(params);
+            expect(field.params).to.be.not.frozen;
         });
     });
 

test/fields/integer-spec.js

@@ -25,24 +25,6 @@ describe('IntegerField', function () {
             expect(field).to.be.instanceOf(IntegerField);
         });
 
-        it('should throw error when default value is not a number', function () {
-            let call = () => new IntegerField({ default: '7' });
-
-            expect(call).to.throw(Error, 'Default value must be a number');
-        });
-
-        it('should throw error when default value is not finite', function () {
-            let call = () => new IntegerField({ default: Infinity });
-
-            expect(call).to.throw(Error, 'Default value must be a number');
-        });
-
-        it('should throw error when default value is not an integer', function () {
-            let call = () => new IntegerField({ default: 7.7 });
-
-            expect(call).to.throw(Error, 'Default value must be an integer');
-        });
-
         it('should throw error when min value is not a number', function () {
             let call = () => new IntegerField({ min: null });
 

test/fields/model-spec.js

@@ -38,12 +38,6 @@ describe('ModelField', function() {
 
             expect(call).to.throw(Error, 'Model is missing');
         });
-
-        it('should throw error when default value is specified', function() {
-            let call = () => new ModelField({}, { default: {} });
-
-            expect(call).to.throw(Error, 'This field doesn\'t accept default value');
-        });
     });
 
     describe('deserialize method', function () {

test/fields/number-spec.js

@@ -25,18 +25,6 @@ describe('NumberField', function () {
             expect(field).to.be.instanceOf(NumberField);
         });
 
-        it('should throw error when default value is not a number', function () {
-            let call = () => new NumberField({ default: '7' });
-
-            expect(call).to.throw(Error, 'Default value must be a number');
-        });
-
-        it('should throw error when default value is not finite', function () {
-            let call = () => new NumberField({ default: Infinity });
-
-            expect(call).to.throw(Error, 'Default value must be a number');
-        });
-
         it('should throw error when min value is not a number', function () {
             let call = () => new NumberField({ min: null });
 

test/fields/string-spec.js

@@ -16,7 +16,7 @@ describe('StringField', function () {
 
         it('should create new instance of field when all params are specified', function () {
             let field = new StringField({
-                default: 'abc',
+                default: 'a b c d e f g',
                 optional: true,
                 trim: true,
                 maxLength: 100,
@@ -27,12 +27,6 @@ describe('StringField', function () {
             expect(field).to.be.instanceOf(StringField);
         });
 
-        it('should throw error when default value is not a string', function () {
-            let call = () => new StringField({ default: 7 });
-
-            expect(call).to.throw(Error, 'Default value must be a string');
-        });
-
         it('should throw error when min length isn\'t an integer', function () {
             let call = () => new StringField({ minLength: 7.000001 });