Closes #23. Closes #84. #77.

Author: jmdobry

CHANGELOG.md

@@ -1,4 +1,4 @@
-##### 0.10.0 - 25 June 2014
+##### 0.10.0 - 29 June 2014
 
 ###### Breaking API changes
 - #76 - Queries and filtering. See [TRANSITION.md](https://github.com/jmdobry/angular-data/blob/master/TRANSITION.md).
@@ -7,9 +7,11 @@
 
 ###### Backwards compatible API changes
 - #17 - Where predicates should be able to handle OR, not just AND
+- #23 - Computed Properties
 - #78 - Added optional callback to `bindOne` and `bindAll`
 - #79 - `ejectAll` should clear matching completed queries
 - #83 - Implement `DS.loadRelations(resourceName, instance(Id), relations[, options])`
+- #84 - idAttribute of a resource can be a computed property
 
 ##### 0.9.1 - 30 May 2014
 

TRANSITION.md

@@ -1,8 +1,14 @@
-### 0.9.x. ---> 0.10.0 - 25 June 2014
+### 0.9.x. ---> 0.10.0 - 29 June 2014
 
 #### Breaking API changes
 ##### #76 - Queries and filtering.
 
+###### Before
+`IllegalArgumentError` has an `errors` field.
+
+###### After
+`IllegalArgumentError` no longer has an `errors` field.
+
 ###### Before
 ```javascript
 DS.findAll('post', {

dist/angular-data.js

@@ -4093,6 +4093,22 @@ function defineResource(definition) {
       this.utils.deepMixIn(def[def.class].prototype, def.methods);
     }
 
+    if (def.computed) {
+      this.utils.forOwn(def.computed, function (fn, field) {
+        if (def.methods && field in def.methods) {
+          _this.$log.warn(errorPrefix + 'Computed property "' + field + '" conflicts with previously defined prototype method!');
+        }
+        var match = fn.toString().match(/function.*?\(([\s\S]*?)\)/);
+        var deps = match[1].split(',');
+        fn.deps = _this.utils.filter(deps, function (dep) {
+          return !!dep;
+        });
+        angular.forEach(fn.deps, function (val, index) {
+          fn.deps[index] = val.trim();
+        });
+      });
+    }
+
     this.store[def.name] = {
       collection: [],
       completedQueries: {},
@@ -4104,7 +4120,9 @@ function defineResource(definition) {
       observers: {},
       collectionModified: 0
     };
-  } catch (err) {
+  }
+  catch
+    (err) {
     delete this.definitions[definition.name];
     delete this.store[definition.name];
     throw err;
@@ -4691,6 +4709,27 @@ function _inject(definition, resource, attrs) {
     resource.modified[innerId] = _this.utils.updateTimestamp(resource.modified[innerId]);
     resource.collectionModified = _this.utils.updateTimestamp(resource.collectionModified);
 
+    if (definition.computed) {
+      var item = _this.get(definition.name, innerId);
+      _this.utils.forOwn(definition.computed, function (fn, field) {
+        var compute = false;
+        // check if required fields changed
+        angular.forEach(fn.deps, function (dep) {
+          if (dep in changed || dep in removed || dep in changed || !(field in item)) {
+            compute = true;
+          }
+        });
+        if (compute) {
+          var args = [];
+          angular.forEach(fn.deps, function (dep) {
+            args.push(item[dep]);
+          });
+          // recompute property
+          item[field] = fn.apply(item, args);
+        }
+      });
+    }
+
     if (definition.idAttribute in changed) {
       $log.error('Doh! You just changed the primary key of an object! ' +
         'I don\'t know how to handle this yet, so your data for the "' + definition.name +
@@ -4705,6 +4744,14 @@ function _inject(definition, resource, attrs) {
       injected.push(_inject.call(_this, definition, resource, attrs[i]));
     }
   } else {
+    // check if "idAttribute" is a computed property
+    if (definition.computed && definition.computed[definition.idAttribute]) {
+      var args = [];
+      angular.forEach(definition.computed[definition.idAttribute].deps, function (dep) {
+        args.push(attrs[dep]);
+      });
+      attrs[definition.idAttribute] = definition.computed[definition.idAttribute].apply(attrs, args);
+    }
     if (!(definition.idAttribute in attrs)) {
       throw new _this.errors.R(errorPrefix + 'attrs: Must contain the property specified by `idAttribute`!');
     } else {

dist/angular-data.min.js

@@ -394,3 +394,54 @@ You can configure your server to also return the `comment` and `organization` re
 ```
 
 If you've told angular-data about the relations, then the comments and organization will be injected into the data store in addition to the user.
+
+@doc overview
+@id computed
+@name Computed Properties
+@description
+
+Angular-data supports computed properties. When you define a computed property you also define the fields that it depends on.
+The computed property will only be updated when one of those fields changes.
+
+## Example
+```js
+DS.defineResource('user', {
+  computed: {
+    // each function's argument list defines the fields
+    // that the computed property depends on
+    fullName: function (first, last) {
+      return first + ' ' + last;
+    }
+  }
+});
+
+var user = DS.inject('user', {
+  id: 1,
+  first: 'John',
+  last: 'Anderson'
+});
+
+user.fullName; // "John Anderson"
+
+user.first = 'Fred';
+
+// angular-data relies on dirty-checking, so the
+// computed property hasn't been updated yet
+user.fullName; // "John Anderson"
+
+DS.digest();
+
+user.fullName; // "Fred Anderson"
+
+user.first = 'George';
+  
+$timeout(function () {
+  user.fullName; // "George Anderson"
+});
+
+user.first = 'William';
+  
+$scope.$apply(function () {
+  user.fullName; // "William Anderson"
+});
+```

guide/angular-data/resource/resource.md

@@ -1,5 +1,5 @@
 // Setup global test variables
-var $rootScope, $q, $log, DSHttpAdapterProvider, DSProvider, DSLocalStorageAdapter, DS, DSUtils, DSHttpAdapter, app, $httpBackend, p1, p2, p3, p4, p5;
+var $rootScope, $q, $log, $timeout, DSHttpAdapterProvider, DSProvider, DSLocalStorageAdapter, DS, DSUtils, DSHttpAdapter, app, $httpBackend, p1, p2, p3, p4, p5;
 
 var user1, organization2, comment3, profile4;
 var comment11, comment12, comment13, organization14, profile15, user10, user16, user17, user18, organization15, user20, comment19, user22, profile21;
@@ -116,13 +116,14 @@ beforeEach(function () {
 });
 
 function startInjector() {
-  inject(function (_$rootScope_, _$q_, _$httpBackend_, _DS_, _$log_, _DSUtils_, _DSHttpAdapter_, _DSLocalStorageAdapter_) {
+  inject(function (_$rootScope_, _$q_, _$timeout_, _$httpBackend_, _DS_, _$log_, _DSUtils_, _DSHttpAdapter_, _DSLocalStorageAdapter_) {
     // Setup global mocks
 
     localStorage.clear();
     $q = _$q_;
     $rootScope = _$rootScope_;
     DS = _DS_;
+    $timeout = _$timeout_;
     DSUtils = _DSUtils_;
     DSHttpAdapter = _DSHttpAdapter_;
     DSLocalStorageAdapter = _DSLocalStorageAdapter_;

karma.start.js

@@ -120,6 +120,22 @@ function defineResource(definition) {
       this.utils.deepMixIn(def[def.class].prototype, def.methods);
     }
 
+    if (def.computed) {
+      this.utils.forOwn(def.computed, function (fn, field) {
+        if (def.methods && field in def.methods) {
+          _this.$log.warn(errorPrefix + 'Computed property "' + field + '" conflicts with previously defined prototype method!');
+        }
+        var match = fn.toString().match(/function.*?\(([\s\S]*?)\)/);
+        var deps = match[1].split(',');
+        fn.deps = _this.utils.filter(deps, function (dep) {
+          return !!dep;
+        });
+        angular.forEach(fn.deps, function (val, index) {
+          fn.deps[index] = val.trim();
+        });
+      });
+    }
+
     this.store[def.name] = {
       collection: [],
       completedQueries: {},
@@ -131,7 +147,9 @@ function defineResource(definition) {
       observers: {},
       collectionModified: 0
     };
-  } catch (err) {
+  }
+  catch
+    (err) {
     delete this.definitions[definition.name];
     delete this.store[definition.name];
     throw err;

src/datastore/sync_methods/defineResource.js

@@ -11,6 +11,27 @@ function _inject(definition, resource, attrs) {
     resource.modified[innerId] = _this.utils.updateTimestamp(resource.modified[innerId]);
     resource.collectionModified = _this.utils.updateTimestamp(resource.collectionModified);
 
+    if (definition.computed) {
+      var item = _this.get(definition.name, innerId);
+      _this.utils.forOwn(definition.computed, function (fn, field) {
+        var compute = false;
+        // check if required fields changed
+        angular.forEach(fn.deps, function (dep) {
+          if (dep in changed || dep in removed || dep in changed || !(field in item)) {
+            compute = true;
+          }
+        });
+        if (compute) {
+          var args = [];
+          angular.forEach(fn.deps, function (dep) {
+            args.push(item[dep]);
+          });
+          // recompute property
+          item[field] = fn.apply(item, args);
+        }
+      });
+    }
+
     if (definition.idAttribute in changed) {
       $log.error('Doh! You just changed the primary key of an object! ' +
         'I don\'t know how to handle this yet, so your data for the "' + definition.name +
@@ -25,6 +46,14 @@ function _inject(definition, resource, attrs) {
       injected.push(_inject.call(_this, definition, resource, attrs[i]));
     }
   } else {
+    // check if "idAttribute" is a computed property
+    if (definition.computed && definition.computed[definition.idAttribute]) {
+      var args = [];
+      angular.forEach(definition.computed[definition.idAttribute].deps, function (dep) {
+        args.push(attrs[dep]);
+      });
+      attrs[definition.idAttribute] = definition.computed[definition.idAttribute].apply(attrs, args);
+    }
     if (!(definition.idAttribute in attrs)) {
       throw new _this.errors.R(errorPrefix + 'attrs: Must contain the property specified by `idAttribute`!');
     } else {

src/datastore/sync_methods/inject.js

@@ -115,4 +115,125 @@ describe('DS.defineResource(definition)', function () {
     assert.equal(lifecycle.beforeInject.callCount, 1, 'beforeInject should have been called');
     assert.equal(lifecycle.afterInject.callCount, 1, 'afterInject should have been called');
   });
+  it('should allow definition of computed properties', function () {
+    var callCount = 0;
+
+    DS.defineResource({
+      name: 'person',
+      computed: {
+        fullName: function (first, last) {
+          callCount++;
+          return first + ' ' + last;
+        }
+      }
+    });
+
+    DS.inject('person', {
+      first: 'John',
+      last: 'Anderson',
+      email: '[email protected]',
+      id: 1
+    });
+
+    var person = DS.get('person', 1);
+
+    assert.deepEqual(JSON.stringify(person), JSON.stringify({
+      first: 'John',
+      last: 'Anderson',
+      email: '[email protected]',
+      id: 1,
+      fullName: 'John Anderson'
+    }));
+    assert.equal(person.fullName, 'John Anderson');
+    assert.equal(lifecycle.beforeInject.callCount, 1, 'beforeInject should have been called');
+    assert.equal(lifecycle.afterInject.callCount, 1, 'afterInject should have been called');
+
+    person.first = 'Johnny';
+
+    // digest loop hasn't happened yet
+    assert.equal(DS.get('person', 1).first, 'Johnny');
+    assert.equal(DS.get('person', 1).fullName, 'John Anderson');
+
+    DS.digest();
+
+    assert.deepEqual(person, {
+      first: 'Johnny',
+      last: 'Anderson',
+      email: '[email protected]',
+      id: 1,
+      fullName: 'Johnny Anderson'
+    });
+    assert.equal(person.fullName, 'Johnny Anderson');
+
+    // should work with $timeout
+    $timeout(function () {
+      person.first = 'Jack';
+
+      DS.digest();
+
+      assert.deepEqual(person, {
+        first: 'Jack',
+        last: 'Anderson',
+        email: '[email protected]',
+        id: 1,
+        fullName: 'Jack Anderson'
+      });
+      assert.equal(person.fullName, 'Jack Anderson');
+    });
+
+    $timeout.flush();
+
+    // computed property function should not be called
+    // when a property changes that isn't a dependency
+    // of the computed property
+    person.email = '[email protected]';
+
+    DS.digest();
+
+    assert.equal(callCount, 3, 'fullName() should have been called 3 times');
+  });
+  it('should work if idAttribute is a computed property computed property', function () {
+    DS.defineResource({
+      name: 'person',
+      computed: {
+        id: function (first, last) {
+          return first + '_' + last;
+        }
+      }
+    });
+
+    DS.inject('person', {
+      first: 'John',
+      last: 'Anderson',
+      email: '[email protected]'
+    });
+
+    var person = DS.get('person', 'John_Anderson');
+
+    assert.deepEqual(JSON.stringify(person), JSON.stringify({
+      first: 'John',
+      last: 'Anderson',
+      email: '[email protected]',
+      id: 'John_Anderson'
+    }));
+    assert.equal(person.id, 'John_Anderson');
+    assert.equal(lifecycle.beforeInject.callCount, 1, 'beforeInject should have been called');
+    assert.equal(lifecycle.afterInject.callCount, 1, 'afterInject should have been called');
+
+    person.first = 'Johnny';
+
+    // digest loop hasn't happened yet
+    assert.equal(DS.get('person', 'John_Anderson').first, 'Johnny');
+    assert.equal(DS.get('person', 'John_Anderson').id, 'John_Anderson');
+
+    DS.digest();
+
+    assert.deepEqual(person, {
+      first: 'Johnny',
+      last: 'Anderson',
+      email: '[email protected]',
+      id: 'Johnny_Anderson'
+    });
+    assert.equal(person.id, 'Johnny_Anderson');
+  });
 });