Merge branch 'facultymatt-features/computed-props'

Author: iobaixas

src/module.js

@@ -12,7 +12,7 @@ var RMModule = angular.module('restmod', ['ng', 'platanus.inflector']);
  */
 RMModule.provider('restmod', [function() {
 
-  var BASE_CHAIN = ['RMBuilderExt', 'RMBuilderRelations'];
+  var BASE_CHAIN = ['RMBuilderExt', 'RMBuilderRelations', 'RMBuilderComputed'];
 
   function wrapInInvoke(_mixin) {
     return function(_injector) {

src/module/extended/builder-computed.js

@@ -0,0 +1,41 @@
+'use strict';
+
+RMModule.factory('RMBuilderComputed', ['restmod',
+  function(restmod) {
+    /**
+     * @class RMBuilderComputedApi
+     *
+     * @description
+     *
+     * Builder DSL extension to build computed properties.
+     *
+     * A computed property is a "virtual" property which is created using
+     * other model properties. For example, a user has a firstName and lastName,
+     * A computed property, fullName, is generated from the two.
+     *
+     * Adds the following property modifiers:
+     * * `computed` function will be assigned as getter to Model, maps to {@link RMBuilderComputedApi#attrAsComputed}
+     *
+     */
+    var EXT = {
+
+      /**
+       * @memberof RMBuilderComputedApi#
+       *
+       * @description Registers a model computed property
+       *
+       * @param {string}  _attr Attribute name
+       * @param {function} _fn Function that returns the desired attribute value when run.
+       * @return {BuilderApi} self
+       */
+      attrAsComputed: function(_attr, _fn) {
+        this.attrComputed(_attr, _fn);
+        return this;
+      }
+    };
+
+    return restmod.mixin(function() {
+      this.extend('attrAsComputed', EXT.attrAsComputed, ['computed']);
+    });
+  }
+]);

src/module/factory.js

@@ -25,6 +25,7 @@ RMModule.factory('RMModelFactory', ['$injector', 'inflector', 'RMUtils', 'RMScop
       },
       serializer = new Serializer(Model),
       defaults = [],                    // attribute defaults as an array of [key, value]
+      computes = [],                    // computed attributes
       meta = {},                        // atribute metadata
       hooks = {},
       builder;                          // the model builder
@@ -331,10 +332,17 @@ RMModule.factory('RMModelFactory', ['$injector', 'inflector', 'RMUtils', 'RMScop
 
       // default initializer: loads the default parameter values
       $initialize: function() {
-        var tmp;
-        for(var i = 0; (tmp = defaults[i]); i++) {
+        var tmp, i, self = this;
+        for(i = 0; (tmp = defaults[i]); i++) {
           this[tmp[0]] = (typeof tmp[1] === 'function') ? tmp[1].apply(this) : tmp[1];
         }
+
+        for(i = 0; (tmp = computes[i]); i++) {
+          Object.defineProperty(self, tmp[0], {
+            enumerable: true,
+            get: tmp[1]
+          });
+        }
       }
 
     }, CommonApi, RecordApi, ExtendedApi);
@@ -433,6 +441,24 @@ RMModule.factory('RMModelFactory', ['$injector', 'inflector', 'RMUtils', 'RMScop
         return this;
       },
 
+      /**
+       * @memberof BuilderApi#
+       *
+       * @description Sets a computed value for an attribute.
+       *
+       * Computed values are set only on object construction phase.
+       * Computed values are always masked
+       *
+       * @param {string} _attr Attribute name
+       * @param {function} _fn Function that returns value
+       * @return {BuilderApi} self
+       */
+      attrComputed: function(_attr, _fn) {
+        computes.push([_attr, _fn]);
+        this.attrMask(_attr, true);
+        return this;
+      },
+
       /**
        * @memberof BuilderApi#
        *

test/computed-spec.js

@@ -0,0 +1,106 @@
+'use strict';
+
+describe('RMBuilderComputed', function() {
+
+  var $injector, restmod, RMBuilderComputed, UserModel;
+
+  beforeEach(module('restmod'));
+
+  beforeEach(module(function($provide) {
+    $provide.factory('UserModel', function(restmod) {
+      return restmod.model('/api/users', {
+        firstName: ''
+      });
+    });
+  }));
+
+  // cache entities to be used in tests
+  beforeEach(inject(['$injector',
+    function(_$injector) {
+      $injector = _$injector;
+      restmod = $injector.get('restmod');
+      RMBuilderComputed = $injector.get('RMBuilderComputed');
+      UserModel = restmod.model('/api/users', {
+        firstName: ''
+      });
+    }
+  ]));
+
+  describe('computed property', function() {
+
+    describe('basics', function() {
+
+      var DeviceModel, device;
+
+      beforeEach(function() {
+        DeviceModel = restmod.model('/api/devices', {
+          vendor: 'default vendor',
+          model: 'default model',
+          fancyName: {
+            computed: function() {
+              return this.vendor + ': ' + this.model;
+            }
+          }
+        });
+        device = DeviceModel.$new().$decode();
+      });
+
+      it('calculates using given function', function() {
+        expect(device.fancyName).toEqual('default vendor: default model');
+      });
+
+      it('changes when model properties update', function() {
+        device.vendor = 'Apple';
+        device.model = 'iPhone';
+        expect(device.fancyName).toEqual('Apple: iPhone');
+      });
+
+      it('should be masked by default',function() {
+        var encoded = device.$encode();
+        expect(encoded.fancyName).toBeUndefined();
+      });
+
+      it('should be listed in $each',function() {
+        var test = {};
+        device.$each(function(v, k) { test[k] = v; });
+        expect(test.fancyName).toBeDefined();
+      });
+
+    });
+
+    describe('with relations', function() {
+
+      var DeviceModel, device;
+
+      beforeEach(function() {
+
+        DeviceModel = restmod.model('/api/devices', {
+          vendor: '',
+          model: '',
+          user: {
+            hasOne: 'UserModel'
+          },
+          ownedBy: {
+            computed: function() {
+              return this.user.firstName + '\'s ' + this.model;
+            }
+          }
+        });
+        device = DeviceModel.$new().$decode({
+          vendor: 'Apple',
+          model: 'Watch',
+          user: {
+            firstName: 'Johnny'
+          }
+        });
+      });
+
+      it('can access related models', function() {
+        expect(device.ownedBy).toEqual('Johnny\'s Watch');
+      });
+
+    });
+
+  });
+
+});