Merge a1c1fe0 into f368b8a

src/attributes/decorator.js

@@ -1,9 +1,9 @@
 const Schema = require('../schema');
 const Serialization = require('../serialization');
 const Validation = require('../validation');
+const Initialization = require('../initialization');
 const Errors = require('../errors');
 const { SCHEMA } = require('../symbols');
-const Initializer = require('./initializer');
 const {
   attributeDescriptorFor,
   attributesDescriptorFor
@@ -22,7 +22,7 @@ function attributesDecorator(schema, schemaOptions = {}) {
         const instance = Reflect.construct(target, constructorArgs, newTarget);
         const passedAttributes = Object.assign({}, constructorArgs[0]);
 
-        Initializer.initialize(passedAttributes, schema, instance);
+        Initialization.initialize(schema, passedAttributes, instance);
 
         return instance;
       }

src/initialization/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+  forSchema: require('./initialization'),
+  initialize: require('./initialize')
+};

src/initialization/initialization.js

@@ -0,0 +1,24 @@
+const { ATTRIBUTES } = require('../symbols');
+const initializationOrderFor = require('./initializationOrder');
+
+module.exports = function forSchema(schema) {
+  const initializationOrder = initializationOrderFor(schema);
+
+  return {
+    initialize(attributes, instance) {
+      instance[ATTRIBUTES] = Object.create(null);
+
+      for(let i = 0; i < initializationOrder.length; i++) {
+        const [ attrName, attrInitializer ] = initializationOrder[i];
+        const attrDescriptor = schema[attrName];
+        const attrPassedValue = attributes[attrName];
+
+        if(attrPassedValue !== undefined) {
+          instance[attrName] = attrPassedValue;
+        } else {
+          instance[attrName] = attrInitializer(attrDescriptor, instance);
+        }
+      }
+    }
+  };
+};

src/initialization/initializationOrder.js

@@ -0,0 +1,30 @@
+const { isFunction } = require('lodash');
+
+function isStaticInitialization(attrDescriptor) {
+  return !isFunction(attrDescriptor.default);
+}
+
+function staticInitialization(attrDescriptor) {
+  return attrDescriptor.default;
+}
+
+function derivedInitialization(attrDescriptor, instance) {
+  return attrDescriptor.default(instance);
+}
+
+module.exports = function initializationOrderFor(schema) {
+  const staticInitializations = [];
+  const derivedInitializations = [];
+
+  for(let attrName in schema) {
+    const attributeDescriptor = schema[attrName];
+
+    if(isStaticInitialization(attributeDescriptor)) {
+      staticInitializations.push([attrName, staticInitialization]);
+    } else {
+      derivedInitializations.push([attrName, derivedInitialization]);
+    }
+  }
+
+  return [...staticInitializations, ...derivedInitializations];
+};

src/initialization/initialize.js

@@ -0,0 +1,5 @@
+const { INITIALIZE } = require('../symbols');
+
+module.exports = function initialize(schema, attributes, instance) {
+  schema[INITIALIZE].initialize(attributes, instance);
+};

src/schema/normalization.js

@@ -1,6 +1,7 @@
 const Validation = require('../validation');
+const Initialization = require('../initialization');
 const TypeDescriptor = require('../typeDescriptor');
-const { VALIDATE } = require('../symbols');
+const { VALIDATE, INITIALIZE } = require('../symbols');
 
 module.exports = function normalizeSchema(rawSchema, schemaOptions) {
   const schema = Object.create(null);
@@ -15,5 +16,11 @@ module.exports = function normalizeSchema(rawSchema, schemaOptions) {
     value: schemaValidation
   });
 
+  const initialization = Initialization.forSchema(schema);
+
+  Object.defineProperty(schema, INITIALIZE, {
+    value: initialization
+  });
+
   return schema;
 };

src/symbols.js

@@ -1,5 +1,6 @@
 module.exports = {
   SCHEMA: Symbol('schema'),
   ATTRIBUTES: Symbol('attributes'),
-  VALIDATE: Symbol('validate')
+  VALIDATE: Symbol('validate'),
+  INITIALIZE: Symbol('initialize')
 };

test/unit/instanceAndUpdate.spec.js

@@ -9,6 +9,10 @@ describe('instantiating a structure', () => {
       name: {
         type: String,
         default: 'Name'
+      },
+      uuid: {
+        type: String,
+        default: (instance) => instance.getUuid()
       }
     })(class User {
       constructor() {
@@ -18,6 +22,10 @@ describe('instantiating a structure', () => {
       userMethod() {
         return 'I am a user';
       }
+
+      getUuid() {
+        return 10;
+      }
     });
   });
 
@@ -48,9 +56,8 @@ describe('instantiating a structure', () => {
   it('does not mutate the attributes object passed to the constructor', () => {
     const attributesObject = {};
 
-    const user = new User(attributesObject);
+    new User(attributesObject);
 
-    expect(user.name).to.equal('Name');
     expect(attributesObject).to.be.empty;
   });
 
@@ -71,6 +78,26 @@ describe('instantiating a structure', () => {
     expect(user.name).to.equal('Self');
     expect(user.attributes.name).to.equal('Self');
   });
+
+  describe('attributes initialization', () => {
+    describe('default value', () => {
+      context('when attribute default value is a static value', () => {
+        it('defaults to the static value', () => {
+          const user = new User();
+
+          expect(user.name).to.equal('Name');
+        });
+      });
+
+      context('when attribute default value is a function', () => {
+        it('calls the function using the instance of the object as parameter and perform coercion', () => {
+          const user = new User();
+
+          expect(user.uuid).to.equal('10');
+        });
+      });
+    });
+  });
 });
 
 describe('instantiating a structure with dynamic attribute types', () => {