backbone-associations-rails 0.4.2 → 0.5.0

data/Rakefile

@@ -44,11 +44,12 @@ namespace :backbone_associations do
       exit
     end
 
-    # Update marionette
+    # Update backbone-associations
     puts "Updating backbone-associations..."
-    url = "https://raw.github.com/dhruvaray/backbone-associations/#{sha}/lib/backbone-associations.js"
+    base_url = "https://raw.github.com/dhruvaray/backbone-associations/#{sha}"
+    files = %w{backbone-associations.js backbone-associations-min.js}
     Dir.chdir './vendor/assets/javascripts' do
-      `curl -O #{url}`
+      files.each {|file| `curl -O #{base_url}/#{file}`}
     end
 
     # Update version file

data/lib/backbone-associations-rails/version.rb

@@ -1,7 +1,7 @@
 module Backbone
   module Associations
     module Rails
-      VERSION = '0.4.2'
+      VERSION = '0.5.0'
     end
   end
 end

data/vendor/assets/javascripts/backbone-associations-min.js

@@ -0,0 +1,11 @@
+(function(){var v=this,g,h,w,m,r,s,z,o,A,B;"undefined"===typeof window?(g=require("underscore"),h=require("backbone"),"undefined"!==typeof exports&&(exports=module.exports=h)):(g=v._,h=v.Backbone);w=h.Model;m=h.Collection;r=w.prototype;s=m.prototype;A=/[\.\[\]]+/g;z="change add remove reset sort destroy".split(" ");B=["reset","sort"];h.Associations={VERSION:"0.5.0"};h.Associations.Many=h.Many="Many";h.Associations.One=h.One="One";o=h.AssociatedModel=h.Associations.AssociatedModel=w.extend({relations:void 0,
+_proxyCalls:void 0,get:function(a){var c=r.get.call(this,a);return c?c:this._getAttr.apply(this,arguments)},set:function(a,c,d){var b;if(g.isObject(a)||a==null){b=a;d=c}else{b={};b[a]=c}a=this._set(b,d);this._processPendingEvents();return a},_set:function(a,c){var d,b,n,f,j=this;if(!a)return this;for(d in a){b||(b={});if(d.match(A)){var k=x(d);f=g.initial(k);k=k[k.length-1];f=this.get(f);if(f instanceof o){f=b[f.cid]||(b[f.cid]={model:f,data:{}});f.data[k]=a[d]}}else{f=b[this.cid]||(b[this.cid]={model:this,
+data:{}});f.data[d]=a[d]}}if(b)for(n in b){f=b[n];this._setAttr.call(f.model,f.data,c)||(j=false)}else j=this._setAttr.call(this,a,c);return j},_setAttr:function(a,c){var d;c||(c={});if(c.unset)for(d in a)a[d]=void 0;this.parents=this.parents||[];this.relations&&g.each(this.relations,function(b){var d=b.key,f=b.relatedModel,j=b.collectionType,k=b.map,i=this.attributes[d],y=i&&i.idAttribute,e,q,l,p;f&&g.isString(f)&&(f=t(f));j&&g.isString(j)&&(j=t(j));k&&g.isString(k)&&(k=t(k));q=b.options?g.extend({},
+b.options,c):c;if(a[d]){e=g.result(a,d);e=k?k(e):e;if(b.type===h.Many){if(j&&!j.prototype instanceof m)throw Error("collectionType must inherit from Backbone.Collection");if(e instanceof m)l=e;else if(i){i._deferEvents=true;i.set(e,c);l=i}else{l=j?new j:this._createCollection(f);l.add(e,q)}}else if(b.type===h.One&&f)if(e instanceof o)l=e;else if(i)if(i&&e[y]&&i.get(y)===e[y]){i._deferEvents=true;i._set(e,c);l=i}else l=new f(e,q);else l=new f(e,q);if((p=a[d]=l)&&!p._proxyCallback){p._proxyCallback=
+function(){return this._bubbleEvent.call(this,d,p,arguments)};p.on("all",p._proxyCallback,this)}}if(a.hasOwnProperty(d)){b=a[d];f=this.attributes[d];if(b){b.parents=b.parents||[];g.indexOf(b.parents,this)==-1&&b.parents.push(this)}else if(f&&f.parents.length>0)f.parents=g.difference(f.parents,[this])}},this);return r.set.call(this,a,c)},_bubbleEvent:function(a,c,d){var b=d[0].split(":"),n=b[0],f=d[0]=="nested-change",j=d[1],k=d[2],i=-1,h=c._proxyCalls,e,q=g.indexOf(z,n)!==-1;if(!f){g.size(b)>1&&(e=
+b[1]);g.indexOf(B,n)!==-1&&(k=j);if(c instanceof m&&q&&j){var l=x(e),p=g.initial(l);(b=c.find(function(a){if(j===a)return true;if(!a)return false;var b=a.get(p);if((b instanceof o||b instanceof m)&&j===b)return true;b=a.get(l);if((b instanceof o||b instanceof m)&&j===b||b instanceof m&&k&&k===b)return true}))&&(i=c.indexOf(b))}e=a+(i!==-1&&(n==="change"||e)?"["+i+"]":"")+(e?"."+e:"");if(/\[\*\]/g.test(e))return this;b=e.replace(/\[\d+\]/g,"[*]");i=[];i.push.apply(i,d);i[0]=n+":"+e;h=c._proxyCalls=
+h||{};if(this._isEventAvailable.call(this,h,e))return this;h[e]=true;if("change"===n){this._previousAttributes[a]=c._previousAttributes;this.changed[a]=c}this.trigger.apply(this,i);"change"===n&&this.get(e)!=d[2]&&this.trigger.apply(this,["nested-change",e,d[1]]);h&&e&&delete h[e];if(e!==b){i[0]=n+":"+b;this.trigger.apply(this,i)}return this}},_isEventAvailable:function(a,c){return g.find(a,function(a,b){return c.indexOf(b,c.length-b.length)!==-1})},_createCollection:function(a){var c=a;g.isString(c)&&
+(c=t(c));if(c&&c.prototype instanceof o){a=new m;a.model=c}else throw Error("type must inherit from Backbone.AssociatedModel");return a},_processPendingEvents:function(){if(!this.visited){this.visited=true;this._deferEvents=false;g.each(this._pendingEvents,function(a){a.c.trigger.apply(a.c,a.a)});this._pendingEvents=[];g.each(this.relations,function(a){(a=this.attributes[a.key])&&a._processPendingEvents()},this);delete this.visited}},trigger:function(a){if(this._deferEvents){this._pendingEvents=this._pendingEvents||
+[];this._pendingEvents.push({c:this,a:arguments})}else r.trigger.apply(this,arguments)},toJSON:function(a){var c,d;if(!this.visited){this.visited=true;c=r.toJSON.apply(this,arguments);this.relations&&g.each(this.relations,function(b){var h=this.attributes[b.key];if(h){d=h.toJSON(a);c[b.key]=g.isArray(d)?g.compact(d):d}},this);delete this.visited}return c},clone:function(){return new this.constructor(this.toJSON())},_getAttr:function(a){var c=this,a=x(a),d,b;if(!(g.size(a)<1)){for(b=0;b<a.length;b++){d=
+a[b];if(!c)break;c=c instanceof m?isNaN(d)?void 0:c.at(d):c.attributes[d]}return c}}});var C=/[^\.\[\]]+/g,x=function(a){return a===""?[""]:g.isString(a)?a.match(C):a||[]},t=function(a){return g.reduce(a.split("."),function(a,d){return a[d]},v)},D=function(a,c,d){var b;g.find(a,function(a){if(b=g.find(a.relations,function(b){return a.get(b.key)===c},this))return true},this);return b&&b.map?b.map(d):d},u={};g.each(["set","remove","reset"],function(a){u[a]=m.prototype[a];s[a]=function(c,d){this.model.prototype instanceof
+o&&this.parents&&(arguments[0]=D(this.parents,this,c));return u[a].apply(this,arguments)}});u.trigger=s.trigger;s.trigger=function(a){if(this._deferEvents){this._pendingEvents=this._pendingEvents||[];this._pendingEvents.push({c:this,a:arguments})}else u.trigger.apply(this,arguments)};s._processPendingEvents=o.prototype._processPendingEvents}).call(this);

data/vendor/assets/javascripts/backbone-associations.js

@@ -1,5 +1,5 @@
 //
-//  Backbone-associations.js 0.4.2
+//  Backbone-associations.js 0.5.0
 //
 //  (c) 2013 Dhruva Ray, Jaynti Kanani, Persistent Systems Ltd.
 //  Backbone-associations may be freely distributed under the MIT license.
@@ -19,12 +19,15 @@
     // The top-level namespace. All public Backbone classes and modules will be attached to this.
     // Exported for the browser and CommonJS.
     var _, Backbone, BackboneModel, BackboneCollection, ModelProto,
-        defaultEvents, AssociatedModel, pathChecker;
+        CollectionProto, defaultEvents, AssociatedModel, pathChecker,
+        collectionEvents;
 
-    if (typeof require !== 'undefined') {
+    if (typeof window === 'undefined') {
         _ = require('underscore');
         Backbone = require('backbone');
-        exports = module.exports = Backbone;
+        if (typeof exports !== 'undefined') {
+            exports = module.exports = Backbone;
+        }
     } else {
         _ = root._;
         Backbone = root.Backbone;
@@ -33,20 +36,25 @@
     BackboneModel = Backbone.Model;
     BackboneCollection = Backbone.Collection;
     ModelProto = BackboneModel.prototype;
+    CollectionProto = BackboneCollection.prototype;
     pathChecker = /[\.\[\]]+/g;
 
     // Built-in Backbone `events`.
-    defaultEvents = ["change", "add", "remove", "reset", "destroy",
-        "sync", "error", "sort", "request"];
+    defaultEvents = ["change", "add", "remove", "reset", "sort", "destroy"];
+    collectionEvents = ["reset", "sort"];
+
+    Backbone.Associations = {
+        VERSION:"0.5.0"
+    };
 
     // Backbone.AssociatedModel
     // --------------
 
     //Add `Many` and `One` relations to Backbone Object.
-    Backbone.Many = "Many";
-    Backbone.One = "One";
+    Backbone.Associations.Many = Backbone.Many = "Many";
+    Backbone.Associations.One = Backbone.One = "One";
     // Define `AssociatedModel` (Extends Backbone.Model).
-    AssociatedModel = Backbone.AssociatedModel = BackboneModel.extend({
+    AssociatedModel = Backbone.AssociatedModel = Backbone.Associations.AssociatedModel = BackboneModel.extend({
         // Define relations with Associated Model.
         relations:undefined,
         // Define `Model` property which can keep track of already fired `events`,
@@ -56,12 +64,12 @@
         // Get the value of an attribute.
         get:function (attr) {
             var obj = ModelProto.get.call(this, attr);
-            return obj ? obj : this.getAttr.apply(this, arguments);
+            return obj ? obj : this._getAttr.apply(this, arguments);
         },
 
         // Set a hash of model attributes on the Backbone Model.
         set:function (key, value, options) {
-            var attributes, attr, modelMap, modelId, obj, result = this;
+            var attributes, result;
             // Duplicate backbone's behavior to allow separate key/value parameters,
             // instead of a single 'attributes' object.
             if (_.isObject(key) || key == null) {
@@ -71,12 +79,23 @@
                 attributes = {};
                 attributes[key] = value;
             }
+            result = this._set(attributes, options);
+            // Trigger events which have been blocked until the entire object graph is updated.
+            this._processPendingEvents();
+            return result;
+
+        },
+
+        // Works with an attribute hash and options + fully qualified paths
+        _set:function (attributes, options) {
+            var attr, modelMap, modelId, obj, result = this;
             if (!attributes) return this;
             for (attr in attributes) {
                 //Create a map for each unique object whose attributes we want to set
                 modelMap || (modelMap = {});
                 if (attr.match(pathChecker)) {
-                    var pathTokens = getPathArray(attr), initials = _.initial(pathTokens), last = pathTokens[pathTokens.length - 1],
+                    var pathTokens = getPathArray(attr), initials = _.initial(pathTokens),
+                        last = pathTokens[pathTokens.length - 1],
                         parentModel = this.get(initials);
                     if (parentModel instanceof AssociatedModel) {
                         obj = modelMap[parentModel.cid] || (modelMap[parentModel.cid] = {'model':parentModel, 'data':{}});
@@ -87,26 +106,30 @@
                     obj.data[attr] = attributes[attr];
                 }
             }
+
             if (modelMap) {
                 for (modelId in modelMap) {
                     obj = modelMap[modelId];
-                    this.setAttr.call(obj.model, obj.data, options) || (result = false);
+                    this._setAttr.call(obj.model, obj.data, options) || (result = false);
+
                 }
             } else {
-                return this.setAttr.call(this, attributes, options);
+                result = this._setAttr.call(this, attributes, options);
             }
             return result;
+
         },
 
         // Set a hash of model attributes on the object,
         // fire Backbone `event` with options.
         // It maintains relations between models during the set operation.
         // It also bubbles up child events to the parent.
-        setAttr:function (attributes, options) {
+        _setAttr:function (attributes, options) {
             var attr;
             // Extract attributes and options.
             options || (options = {});
             if (options.unset) for (attr in attributes) attributes[attr] = void 0;
+            this.parents = this.parents || [];
 
             if (this.relations) {
                 // Iterate over `this.relations` and `set` model and collection values
@@ -114,17 +137,26 @@
                 _.each(this.relations, function (relation) {
                     var relationKey = relation.key, relatedModel = relation.relatedModel,
                         collectionType = relation.collectionType,
+                        map = relation.map,
+                        currVal = this.attributes[relationKey],
+                        idKey = currVal && currVal.idAttribute,
                         val, relationOptions, data, relationValue;
+
+                    //Get class if relation and map is stored as a string.
+                    relatedModel && _.isString(relatedModel) && (relatedModel = map2Scope(relatedModel));
+                    collectionType && _.isString(collectionType) && (collectionType = map2Scope(collectionType));
+                    map && _.isString(map) && (map = map2Scope(map));
+                    // Merge in `options` specific to this relation.
+                    relationOptions = relation.options ? _.extend({}, relation.options, options) : options;
+
                     if (attributes[relationKey]) {
-                        //Get value of attribute with relation key in `val`.
+                        // Get value of attribute with relation key in `val`.
                         val = _.result(attributes, relationKey);
-                        // Get class if relation is stored as a string.
-                        relatedModel && _.isString(relatedModel) && (relatedModel = eval(relatedModel));
-                        collectionType && _.isString(collectionType) && (collectionType = eval(collectionType));
-                        // Merge in `options` specific to this relation.
-                        relationOptions = relation.options ? _.extend({}, relation.options, options) : options;
+                        // Map `val` if a transformation function is provided.
+                        val = map ? map(val) : val;
+
                         // If `relation.type` is `Backbone.Many`,
-                        // create `Backbone.Collection` with passed data and perform Backbone `set`.
+                        // Create `Backbone.Collection` with passed data and perform Backbone `set`.
                         if (relation.type === Backbone.Many) {
                             // `collectionType` of defined `relation` should be instance of `Backbone.Collection`.
                             if (collectionType && !collectionType.prototype instanceof BackboneCollection) {
@@ -133,18 +165,46 @@
 
                             if (val instanceof BackboneCollection) {
                                 data = val;
-                                attributes[relationKey] = data;
                             } else {
-                                data = collectionType ? new collectionType() : this._createCollection(relatedModel);
-                                data.add(val, relationOptions);
-                                attributes[relationKey] = data;
+                                // Create a new collection
+                                if (!currVal) {
+                                    data = collectionType ? new collectionType() : this._createCollection(relatedModel);
+                                    data.add(val, relationOptions);
+                                } else {
+                                    // Setting this flag will prevent events from firing immediately. That way clients
+                                    // will not get events until the entire object graph is updated.
+                                    currVal._deferEvents = true;
+                                    // Use Backbone.Collection's smart `set` method
+                                    currVal.set(val, options);
+                                    data = currVal;
+                                }
                             }
 
                         } else if (relation.type === Backbone.One && relatedModel) {
-                            data = val instanceof AssociatedModel ? val : new relatedModel(val);
-                            attributes[relationKey] = data;
+                            if (val instanceof AssociatedModel) {
+                                data = val;
+                            } else {
+                                //Create a new model
+                                if (!currVal) {
+                                    data = new relatedModel(val, relationOptions);
+                                } else {
+                                    //Is the passed in data for the same key?
+                                    if (currVal && val[idKey] && currVal.get(idKey) === val[idKey]) {
+                                        // Setting this flag will prevent events from firing immediately. That way clients
+                                        // will not get events until the entire object graph is updated.
+                                        currVal._deferEvents = true;
+                                        // Perform the traditional `set` operation
+                                        currVal._set(val, options);
+                                        data = currVal;
+                                    } else {
+                                        data = new relatedModel(val, relationOptions);
+                                    }
+                                }
+                            }
+
                         }
 
+                        attributes[relationKey] = data;
                         relationValue = data;
 
                         // Add proxy events to respective parents.
@@ -157,80 +217,134 @@
                         }
 
                     }
+                    //Distinguish between the value of undefined versus a set no-op
+                    if (attributes.hasOwnProperty(relationKey)) {
+                        //Maintain reverse pointers - a.k.a parents
+                        var updated = attributes[relationKey];
+                        var original = this.attributes[relationKey];
+                        if (updated) {
+                            updated.parents = updated.parents || [];
+                            (_.indexOf(updated.parents, this) == -1) && updated.parents.push(this);
+                        } else if (original && original.parents.length > 0) {
+                            original.parents = _.difference(original.parents, [this]);
+                        }
+                    }
                 }, this);
             }
             // Return results for `BackboneModel.set`.
-            return ModelProto.set.call(this, attributes, options);
+            return  ModelProto.set.call(this, attributes, options);
         },
         // Bubble-up event to `parent` Model
         _bubbleEvent:function (relationKey, relationValue, eventArguments) {
             var args = eventArguments,
                 opt = args[0].split(":"),
                 eventType = opt[0],
+                catch_all = args[0] == "nested-change",
                 eventObject = args[1],
+                colObject = args[2],
                 indexEventObject = -1,
                 _proxyCalls = relationValue._proxyCalls,
+                cargs,
                 eventPath,
-                eventAvailable;
+                basecolEventPath,
+                isDefaultEvent = _.indexOf(defaultEvents, eventType) !== -1;
+
+            //Short circuit the listen in to the nested-graph event
+            if (catch_all) return;
+
             // Change the event name to a fully qualified path.
             _.size(opt) > 1 && (eventPath = opt[1]);
+
+            if (_.indexOf(collectionEvents, eventType) !== -1) {
+                colObject = eventObject;
+            }
+
             // Find the specific object in the collection which has changed.
-            if (relationValue instanceof BackboneCollection && "change" === eventType && eventObject) {
+            if (relationValue instanceof BackboneCollection && isDefaultEvent && eventObject) {
                 var pathTokens = getPathArray(eventPath),
                     initialTokens = _.initial(pathTokens), colModel;
 
                 colModel = relationValue.find(function (model) {
                     if (eventObject === model) return true;
-                    if (model) {
-                        var changedModel = model.get(initialTokens);
-                        if ((changedModel instanceof AssociatedModel || changedModel instanceof BackboneCollection) && eventObject === changedModel) return true;
-                        changedModel = model.get(pathTokens);
-                        return ((changedModel instanceof AssociatedModel || changedModel instanceof BackboneCollection) && eventObject === changedModel);
-                    }
-                    return false;
+                    if (!model) return false;
+                    var changedModel = model.get(initialTokens);
+
+                    if ((changedModel instanceof AssociatedModel || changedModel instanceof BackboneCollection)
+                        && eventObject === changedModel)
+                        return true;
+
+                    changedModel = model.get(pathTokens);
+
+                    if ((changedModel instanceof AssociatedModel || changedModel instanceof BackboneCollection)
+                        && eventObject === changedModel)
+                        return true;
+
+                    if (changedModel instanceof BackboneCollection && colObject
+                        && colObject === changedModel)
+                        return true;
                 });
                 colModel && (indexEventObject = relationValue.indexOf(colModel));
             }
+
             // Manipulate `eventPath`.
-            eventPath = relationKey + (indexEventObject !== -1 ?
+            eventPath = relationKey + ((indexEventObject !== -1 && (eventType === "change" || eventPath)) ?
                 "[" + indexEventObject + "]" : "") + (eventPath ? "." + eventPath : "");
-            args[0] = eventType + ":" + eventPath;
+
+            // Short circuit collection * events
+            if (/\[\*\]/g.test(eventPath)) return this;
+            basecolEventPath = eventPath.replace(/\[\d+\]/g, '[*]');
+
+            cargs = [];
+            cargs.push.apply(cargs, args);
+            cargs[0] = eventType + ":" + eventPath;
 
             // If event has been already triggered as result of same source `eventPath`,
             // no need to re-trigger event to prevent cycle.
-            if (_proxyCalls) {
-                eventAvailable = _.find(_proxyCalls, function (value, eventKey) {
-                    return eventPath.indexOf(eventKey, eventPath.length - eventKey.length) !== -1;
-                });
-                if (eventAvailable) return this;
-            } else {
-                _proxyCalls = relationValue._proxyCalls = {};
-            }
+            _proxyCalls = relationValue._proxyCalls = (_proxyCalls || {});
+            if (this._isEventAvailable.call(this, _proxyCalls, eventPath)) return this;
+
             // Add `eventPath` in `_proxyCalls` to keep track of already triggered `event`.
             _proxyCalls[eventPath] = true;
 
-
-            //Set up previous attributes correctly. Backbone v0.9.10 upwards...
+            // Set up previous attributes correctly.
             if ("change" === eventType) {
                 this._previousAttributes[relationKey] = relationValue._previousAttributes;
                 this.changed[relationKey] = relationValue;
             }
 
             // Bubble up event to parent `model` with new changed arguments.
-            this.trigger.apply(this, args);
+            this.trigger.apply(this, cargs);
+
+            //Only fire for change. Not change:attribute
+            if ("change" === eventType && this.get(eventPath) != args[2]) {
+                this.trigger.apply(this, ["nested-change", eventPath, args[1]]);
+            }
 
             // Remove `eventPath` from `_proxyCalls`,
-            // if `eventPath` and `_proxCalls` are available,
+            // if `eventPath` and `_proxyCalls` are available,
             // which allow event to be triggered on for next operation of `set`.
-            if (eventPath && _proxyCalls) {
-                delete _proxyCalls[eventPath];
+            if (_proxyCalls && eventPath) delete _proxyCalls[eventPath];
+
+            // Create a collection modified event with wild-card
+            if (eventPath !== basecolEventPath) {
+                cargs[0] = eventType + ":" + basecolEventPath;
+                this.trigger.apply(this, cargs);
             }
+
             return this;
         },
+
+        // Has event been fired from this source. Used to prevent event recursion in cyclic graphs
+        _isEventAvailable:function (_proxyCalls, path) {
+            return _.find(_proxyCalls, function (value, eventKey) {
+                return path.indexOf(eventKey, path.length - eventKey.length) !== -1;
+            });
+        },
+
         // Returns New `collection` of type `relation.relatedModel`.
         _createCollection:function (type) {
             var collection, relatedModel = type;
-            _.isString(relatedModel) && (relatedModel = eval(relatedModel));
+            _.isString(relatedModel) && (relatedModel = map2Scope(relatedModel));
             // Creates new `Backbone.Collection` and defines model class.
             if (relatedModel && relatedModel.prototype instanceof AssociatedModel) {
                 collection = new BackboneCollection();
@@ -240,6 +354,43 @@
             }
             return collection;
         },
+
+        // Process all pending events after the entire object graph has been updated
+        _processPendingEvents:function () {
+            if (!this.visited) {
+                this.visited = true;
+
+                this._deferEvents = false;
+
+                // Trigger all pending events
+                _.each(this._pendingEvents, function (e) {
+                    e.c.trigger.apply(e.c, e.a);
+                });
+
+                this._pendingEvents = [];
+
+                // Traverse down the object graph and call process pending events on sub-trees
+                _.each(this.relations, function (relation) {
+                    var val = this.attributes[relation.key];
+                    val && val._processPendingEvents();
+                }, this);
+
+                delete this.visited;
+            }
+        },
+
+        // Override trigger to defer events in the object graph.
+        trigger:function (name) {
+            // Defer event processing
+            if (this._deferEvents) {
+                this._pendingEvents = this._pendingEvents || [];
+                // Maintain a queue of pending events to trigger after the entire object graph is updated.
+                this._pendingEvents.push({c:this, a:arguments});
+            } else {
+                ModelProto.trigger.apply(this, arguments);
+            }
+        },
+
         // The JSON representation of the model.
         toJSON:function (options) {
             var json, aJson;
@@ -268,8 +419,8 @@
             return new this.constructor(this.toJSON());
         },
 
-        //Navigate the path to the leaf object in the path to query for the attribute value
-        getAttr:function (path) {
+        // Navigate the path to the leaf object in the path to query for the attribute value
+        _getAttr:function (path) {
 
             var result = this,
             //Tokenize the path
@@ -281,7 +432,9 @@
                 key = attrs[i];
                 if (!result) break;
                 //Navigate the path to get to the result
-                result = result instanceof BackboneCollection && (!isNaN(key)) ? result.at(key) : result.attributes[key];
+                result = result instanceof BackboneCollection
+                    ? (isNaN(key) ? undefined : result.at(key))
+                    : result.attributes[key];
             }
             return result;
         }
@@ -293,5 +446,62 @@
     var getPathArray = function (path) {
         if (path === '') return [''];
         return _.isString(path) ? (path.match(delimiters)) : path || [];
-    }
-}).call(this);
+    };
+
+    var map2Scope = function (path) {
+        return _.reduce(path.split('.'), function (memo, elem) {
+            return memo[elem]
+        }, root);
+    };
+
+    //Infer the relation from the collection's parents and find the appropriate map for the passed in `models`
+    var map2models = function (parents, target, models) {
+        var relation;
+        //Iterate over collection's parents
+        _.find(parents, function (parent) {
+            //Iterate over relations
+            relation = _.find(parent.relations, function (rel) {
+                return parent.get(rel.key) === target;
+            }, this);
+            if (relation) return true;//break;
+        }, this);
+
+        //If we found a relation and it has a mapping function
+        if (relation && relation.map) {
+            return relation.map(models)
+        }
+        return models;
+    };
+
+    var proxies = {};
+    // Proxy Backbone collection methods
+    _.each(['set', 'remove', 'reset'], function (method) {
+        proxies[method] = BackboneCollection.prototype[method];
+
+        CollectionProto[method] = function (models, options) {
+            //Short-circuit if this collection doesn't hold `AssociatedModels`
+            if (this.model.prototype instanceof AssociatedModel && this.parents) {
+                //Find a map function if available and perform a transformation
+                arguments[0] = map2models(this.parents, this, models);
+            }
+            return proxies[method].apply(this, arguments);
+        }
+    });
+
+    // Override trigger to defer events in the object graph.
+    proxies['trigger'] = CollectionProto['trigger'];
+    CollectionProto['trigger'] = function (name) {
+        if (this._deferEvents) {
+            this._pendingEvents = this._pendingEvents || [];
+            // Maintain a queue of pending events to trigger after the entire object graph is updated.
+            this._pendingEvents.push({c:this, a:arguments});
+        } else {
+            proxies['trigger'].apply(this, arguments);
+        }
+    };
+
+    // Attach process pending event functionality on collections as well. Re-use from `AssociatedModel`
+    CollectionProto._processPendingEvents = AssociatedModel.prototype._processPendingEvents;
+
+
+}).call(this);

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: backbone-associations-rails
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-25 00:00:00.000000000 Z
+date: 2013-06-20 00:00:00.000000000 Z
 dependencies: []
 description: Backbone-associations provides a way of specifying 1:1 and 1:N relationships
   between Backbone models. Additionally, parent model instances (and objects extended
@@ -29,6 +29,7 @@ files:
 - backbone-associations-rails.gemspec
 - lib/backbone-associations-rails.rb
 - lib/backbone-associations-rails/version.rb
+- vendor/assets/javascripts/backbone-associations-min.js
 - vendor/assets/javascripts/backbone-associations.js
 homepage: https://github.com/wingrunr21/backbone-associations-rails
 licenses: []