backbone-relational-rails 0.6.0 → 0.6.1

data/README.md

@@ -18,7 +18,7 @@ Add the following directive to your Javascript manifest file (application.js):
 
 ## Versioning
 
-backbone-relational-rails 0.6.0 == Backbone-relational 0.6.0
+backbone-relational-rails 0.6.1 == Backbone-relational 0.6.1
 
 Every attempt is made to mirror the currently shipping Backbone-relational version number wherever possible.
 The major, minor, and patch version numbers will always represent the Backbone-relational version. Should a gem

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

@@ -1,7 +1,7 @@
 module Backbone
   module Relational
     module Rails
-      VERSION = "0.6.0"
+      VERSION = "0.6.1"
     end
   end
 end

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

@@ -148,8 +148,8 @@
 		 * @param {Backbone.RelationalModel} modelType
 		 */
 		setupSuperModel: function( modelType ) {
-			_.find( this._subModels, function( subModelDef ) {
-				return _.find( subModelDef.subModels, function( subModelTypeName, typeValue ) {
+			_.find( this._subModels || [], function( subModelDef ) {
+				return _.find( subModelDef.subModels || [], function( subModelTypeName, typeValue ) {
 					var subModelType = this.getObjectByName( subModelTypeName );
 
 					if ( modelType === subModelType ) {
@@ -176,8 +176,8 @@
 		 * @param {String|Object} relation.relatedModel
 		 */
 		addReverseRelation: function( relation ) {
-			var exists = _.any( this._reverseRelations, function( rel ) {
-					return _.all( relation, function( val, key ) {
+			var exists = _.any( this._reverseRelations || [], function( rel ) {
+					return _.all( relation || [], function( val, key ) {
 							return val === rel[ key ];
 						});
 				});
@@ -191,7 +191,7 @@
 					}
 					model.prototype.relations.push( relation );
 					
-					_.each( model._subModels, function( subModel ) {
+					_.each( model._subModels || [], function( subModel ) {
 							addRelation( subModel, relation );
 						}, this );
 				};
@@ -252,9 +252,9 @@
 			var parts = name.split( '.' ),
 				type = null;
 
-			_.find( this._modelScopes, function( scope ) {
-				type = _.reduce( parts, function( memo, val ) {
-					return memo[ val ];
+			_.find( this._modelScopes || [], function( scope ) {
+				type = _.reduce( parts || [], function( memo, val ) {
+					return memo ? memo[ val ] : undefined;
 				}, scope );
 
 				if ( type && type !== scope ) {
@@ -337,11 +337,18 @@
 		 * @param {Backbone.RelationalModel} model
 		 */
 		register: function( model ) {
-			var modelColl = model.collection;
 			var coll = this.getCollection( model );
-			coll && coll.add( model );
-			model.bind( 'destroy', this.unregister, this );
-			model.collection = modelColl;
+
+			if ( coll ) {
+				if ( coll.get( model ) ) {
+					throw new Error( "Cannot instantiate more than one Backbone.RelationalModel with the same id per type!" );
+				}
+
+				var modelColl = model.collection;
+				coll.add( model );
+				model.bind( 'destroy', this.unregister, this );
+				model.collection = modelColl;
+			}
 		},
 		
 		/**
@@ -404,10 +411,15 @@
 		}
 
 		if ( instance ) {
-			this.keyContents = this.instance.get( this.keySource );
+			var contentKey = this.keySource;
+			if ( contentKey !== this.key && typeof this.instance.get( this.key ) === 'object' ) {
+				contentKey = this.key;
+			}
+
+			this.keyContents = this.instance.get( contentKey );
 
 			// Explicitly clear 'keySource', to prevent a leaky abstraction if 'keySource' differs from 'key'.
-			if ( this.key !== this.keySource ) {
+			if ( this.keySource !== this.key ) {
 				this.instance.unset( this.keySource, { silent: true } );
 			}
 
@@ -511,7 +523,7 @@
 
 			// Check if we're not attempting to create a duplicate relationship
 			if ( i && i._relations.length ) {
-				var exists = _.any( i._relations, function( rel ) {
+				var exists = _.any( i._relations || [], function( rel ) {
 						var hasReverseRelation = this.reverseRelation.key && rel.reverseRelation.key;
 						return rel.relatedModel === rm && rel.key === k &&
 							( !hasReverseRelation || this.reverseRelation.key === rel.reverseRelation.key );
@@ -564,8 +576,8 @@
 			var reverseRelations = [];
 			// Iterate over 'model', 'this.related.models' (if this.related is a Backbone.Collection), or wrap 'this.related' in an array.
 			var models = !_.isUndefined( model ) ? [ model ] : this.related && ( this.related.models || [ this.related ] );
-			_.each( models , function( related ) {
-					_.each( related.getRelations(), function( relation ) {
+			_.each( models || [], function( related ) {
+					_.each( related.getRelations() || [], function( relation ) {
 							if ( this._isReverseRelation( relation ) ) {
 								reverseRelations.push( relation );
 							}
@@ -614,7 +626,7 @@
 				.unbind( 'relational:add', this._relatedModelAdded )
 				.unbind( 'relational:remove', this._relatedModelRemoved );
 			
-			_.each( this.getReverseRelations(), function( relation ) {
+			_.each( this.getReverseRelations() || [], function( relation ) {
 					relation.removeRelated( this.instance );
 				}, this );
 		}
@@ -634,7 +646,7 @@
 			this.setRelated( model );
 
 			// Notify new 'related' object of the new relation.
-			_.each( this.getReverseRelations(), function( relation ) {
+			_.each( this.getReverseRelations() || [], function( relation ) {
 					relation.addRelated( this.instance );
 				}, this );
 		},
@@ -688,7 +700,7 @@
 			
 			// Notify old 'related' object of the terminated relation
 			if ( oldRelated && this.related !== oldRelated ) {
-				_.each( this.getReverseRelations( oldRelated ), function( relation ) {
+				_.each( this.getReverseRelations( oldRelated ) || [], function( relation ) {
 						relation.removeRelated( this.instance, options );
 					}, this );
 			}
@@ -696,7 +708,7 @@
 			// Notify new 'related' object of the new relation. Note we do re-apply even if this.related is oldRelated;
 			// that can be necessary for bi-directional relations if 'this.instance' was created after 'this.related'.
 			// In that case, 'this.instance' will already know 'this.related', but the reverse might not exist yet.
-			_.each( this.getReverseRelations(), function( relation ) {
+			_.each( this.getReverseRelations() || [], function( relation ) {
 					relation.addRelated( this.instance, options );
 				}, this);
 			
@@ -841,7 +853,7 @@
 					this.keyContents = _.isArray( this.keyContents ) ? this.keyContents : [ this.keyContents ];
 
 					// Try to find instances of the appropriate 'relatedModel' in the store
-					_.each( this.keyContents, function( item ) {
+					_.each( this.keyContents || [], function( item ) {
 							var model = null;
 							if ( item instanceof this.relatedModel ) {
 								model = item;
@@ -871,11 +883,6 @@
 			options = this.sanitizeOptions( options );
 			this.keyContents = attr;
 			
-			// Notify old 'related' object of the terminated relation
-			_.each( this.getReverseRelations(), function( relation ) {
-					relation.removeRelated( this.instance, options );
-				}, this );
-			
 			// Replace 'this.related' by 'attr' if it is a Backbone.Collection
 			if ( attr instanceof Backbone.Collection ) {
 				this._prepareCollection( attr );
@@ -885,25 +892,42 @@
 			// Re-use the current 'this.related' if it is a Backbone.Collection, and remove any current entries.
 			// Otherwise, create a new collection.
 			else {
-				var coll;
+				var oldIds = {}, newIds = {};
 
-				if ( this.related instanceof Backbone.Collection ) {
-					coll = this.related;
-					coll.remove( coll.models );
+				if (!_.isArray( attr ) && attr !== undefined) {
+					attr = [ attr ];
 				}
-				else {
+				var oldIds;
+				_.each( attr, function( attributes ) {
+					newIds[ attributes.id ] = true;
+				});
+
+				var coll = this.related;
+				if ( coll instanceof Backbone.Collection ) {
+					// Make sure to operate on a copy since we're removing while iterating
+					_.each( coll.models.slice(0) , function( model ) {
+						// When fetch is called with the 'keepNewModels' option, we don't want to remove
+						// client-created new models when the fetch is completed.
+						if ( !options.keepNewModels || !model.isNew() ) {
+							oldIds[ model.id ] = true;
+							coll.remove( model, { silent: (model.id in newIds) } );
+						}
+					});
+				} else {
 					coll = this._prepareCollection();
 				}
 
+				_.each( attr, function( attributes ) {
+					var model = this.relatedModel.findOrCreate( attributes, { create: this.options.createModels } );
+					if (model) {
+						coll.add( model, { silent: (attributes.id in oldIds)} );
+					}
+				}, this);
+
 				this.setRelated( coll );
-				this.findRelated( options );
+
 			}
 			
-			// Notify new 'related' object of the new relation
-			_.each( this.getReverseRelations(), function( relation ) {
-					relation.addRelated( this.instance, options );
-				}, this );
-			
 			var dit = this;
 			Backbone.Relational.eventQueue.add( function() {
 				!options.silentChange && dit.instance.trigger( 'update:' + dit.key, dit.instance, dit.related, options );
@@ -914,7 +938,7 @@
 			options = this.sanitizeOptions( options );
 			if ( !this.related.getByCid( model ) && !this.related.get( model ) ) {
 				// Check if this new model was specified in 'this.keyContents'
-				var item = _.any( this.keyContents, function( item ) {
+				var item = _.any( this.keyContents || [], function( item ) {
 						var id = Backbone.Relational.store.resolveIdForItem( this.relatedModel, item );
 						return !_.isNull( id ) && id === model.id;
 					}, this );
@@ -939,7 +963,7 @@
 			
 			options = this.sanitizeOptions( options );
 			
-			_.each( this.getReverseRelations( model ), function( relation ) {
+			_.each( this.getReverseRelations( model ) || [], function( relation ) {
 					relation.addRelated( this.instance, options );
 				}, this );
 
@@ -962,7 +986,7 @@
 
 			options = this.sanitizeOptions( options );
 			
-			_.each( this.getReverseRelations( model ), function( relation ) {
+			_.each( this.getReverseRelations( model ) || [], function( relation ) {
 					relation.removeRelated( this.instance, options );
 				}, this );
 			
@@ -1078,7 +1102,7 @@
 			this.acquire(); // Setting up relations often also involve calls to 'set', and we only want to enter this function once
 			this._relations = [];
 			
-			_.each( this.relations, function( rel ) {
+			_.each( this.relations || [], function( rel ) {
 					var type = !_.isString( rel.type ) ? rel.type :	Backbone[ rel.type ] || Backbone.Relational.store.getObjectByName( rel.type );
 					if ( type && type.prototype instanceof Backbone.Relation ) {
 						new type( this, rel ); // Also pushes the new Relation into _relations
@@ -1099,7 +1123,7 @@
 		 */
 		updateRelations: function( options ) {
 			if ( this._isInitialized && !this.isLocked() ) {
-				_.each( this._relations, function( rel ) {
+				_.each( this._relations || [], function( rel ) {
 					// Update from data in `rel.keySource` if set, or `rel.key` otherwise
 					var val = this.attributes[ rel.keySource ] || this.attributes[ rel.key ];
 					if ( rel.related !== val ) {
@@ -1149,8 +1173,8 @@
 		/**
 		 * Retrieve related objects.
 		 * @param key {string} The relation key to fetch models for.
-		 * @param options {Object} Options for 'Backbone.Model.fetch' and 'Backbone.sync'.
-		 * @param update {boolean} Whether to force a fetch from the server (updating existing models).
+		 * @param [options] {Object} Options for 'Backbone.Model.fetch' and 'Backbone.sync'.
+		 * @param [update=false] {boolean} Whether to force a fetch from the server (updating existing models).
 		 * @return {jQuery.when[]} An array of request objects
 		 */
 		fetchRelated: function( key, options, update ) {
@@ -1170,12 +1194,12 @@
 					var model;
 
 					if ( _.isObject( item ) ) {
-						model = rel.relatedModel.build( item );
+						model = rel.relatedModel.findOrCreate( item );
 					}
 					else {
 						var attrs = {};
 						attrs[ rel.relatedModel.prototype.idAttribute ] = item;
-						model = rel.relatedModel.build( attrs );
+						model = rel.relatedModel.findOrCreate( attrs );
 					}
 
 					return model;
@@ -1194,7 +1218,7 @@
 						{
 							error: function() {
 								var args = arguments;
-								_.each( models, function( model ) {
+								_.each( models || [], function( model ) {
 										model.trigger( 'destroy', model, model.collection, options );
 										options.error && options.error.apply( model, args );
 									});
@@ -1208,7 +1232,7 @@
 					requests = [ rel.related.fetch( opts ) ];
 				}
 				else {
-					requests = _.map( models, function( model ) {
+					requests = _.map( models || [], function( model ) {
 						var opts = _.defaults(
 							{
 								error: function() {
@@ -1306,7 +1330,7 @@
 				attributes[ this.idAttribute ] = null;
 			}
 
-			_.each( this.getRelations(), function( rel ) {
+			_.each( this.getRelations() || [], function( rel ) {
 					delete attributes[ rel.key ];
 				});
 
@@ -1316,25 +1340,25 @@
 		/**
 		 * Convert relations to JSON, omits them when required
 		 */
-		toJSON: function() {
+		toJSON: function(options) {
 			// If this Model has already been fully serialized in this branch once, return to avoid loops
 			if ( this.isLocked() ) {
 				return this.id;
 			}
 			
 			this.acquire();
-			var json = Backbone.Model.prototype.toJSON.call( this );
+			var json = Backbone.Model.prototype.toJSON.call( this, options );
 			
 			if ( this.constructor._superModel && !( this.constructor._subModelTypeAttribute in json ) ) {
 				json[ this.constructor._subModelTypeAttribute ] = this.constructor._subModelTypeValue;
 			}
 			
-			_.each( this._relations, function( rel ) {
+			_.each( this._relations || [], function( rel ) {
 					var value = json[ rel.key ];
 
 					if ( rel.options.includeInJSON === true) {
 						if ( value && _.isFunction( value.toJSON ) ) {
-							json[ rel.keyDestination ] = value.toJSON();
+							json[ rel.keyDestination ] = value.toJSON( options );
 						}
 						else {
 							json[ rel.keyDestination ] = null;
@@ -1406,7 +1430,7 @@
 			}
 
 			// Initialize all reverseRelations that belong to this new model.
-			_.each( this.prototype.relations, function( rel ) {
+			_.each( this.prototype.relations || [], function( rel ) {
 					if ( !rel.model ) {
 						rel.model = this;
 					}
@@ -1471,7 +1495,7 @@
 				if ( this._superModel ) {
 					//
 					if ( this._superModel.prototype.relations ) {
-						var supermodelRelationsExist = _.any( this.prototype.relations, function( rel ) {
+						var supermodelRelationsExist = _.any( this.prototype.relations || [], function( rel ) {
 							return rel.model && rel.model !== this;
 						}, this );
 
@@ -1487,7 +1511,7 @@
 
 			// If we came here through 'build' for a model that has 'subModelTypes', and not all of them have been resolved yet, try to resolve each.
 			if ( this.prototype.subModelTypes && _.keys( this.prototype.subModelTypes ).length !== _.keys( this._subModels ).length ) {
-				_.each( this.prototype.subModelTypes, function( subModelTypeName ) {
+				_.each( this.prototype.subModelTypes || [], function( subModelTypeName ) {
 					var subModelType = Backbone.Relational.store.getObjectByName( subModelTypeName );
 					subModelType && subModelType.initializeModelHierarchy();
 				});
@@ -1505,14 +1529,15 @@
 		 * @return {Backbone.RelationalModel}
 		 */
 		findOrCreate: function( attributes, options ) {
+			var parsedAttributes = (_.isObject( attributes ) && this.prototype.parse) ? this.prototype.parse( attributes ) : attributes;
 			// Try to find an instance of 'this' model type in the store
-			var model = Backbone.Relational.store.find( this, attributes );
+			var model = Backbone.Relational.store.find( this, parsedAttributes );
 
 			// If we found an instance, update it with the data in 'item'; if not, create an instance
 			// (unless 'options.create' is false).
 			if ( _.isObject( attributes ) ) {
 				if ( model ) {
-					model.set( attributes, options );
+					model.set( parsedAttributes, options );
 				}
 				else if ( !options || ( options && options.create !== false ) ) {
 					model = this.build( attributes, options );
@@ -1534,9 +1559,9 @@
 		if ( !( model instanceof Backbone.Model ) ) {
 			var attrs = model;
 			options.collection = this;
-			
-			if ( typeof this.model.build !== 'undefined' ) {
-				model = this.model.build( attrs, options );
+
+			if ( typeof this.model.findOrCreate !== 'undefined' ) {
+				model = this.model.findOrCreate( attrs, options );
 			}
 			else {
 				model = new this.model( attrs, options );
@@ -1567,32 +1592,25 @@
 		var modelsToAdd = [];
 
 		//console.debug( 'calling add on coll=%o; model=%o, options=%o', this, models, options );
-		_.each( models, function( model ) {
-				if ( !( model instanceof Backbone.Model ) ) {
-					// Try to find 'model' in Backbone.store. If it already exists, set the new properties on it.
-					var existingModel = Backbone.Relational.store.find( this.model, model[ this.model.prototype.idAttribute ] );
-					if ( existingModel ) {
-						existingModel.set( existingModel.parse ? existingModel.parse( model ) : model, options );
-						model = existingModel;
-					}
-					else {
-						model = Backbone.Collection.prototype._prepareModel.call( this, model, options );
-					}
-				}
-
-				if ( model instanceof Backbone.Model && !this.get( model ) && !this.getByCid( model ) ) {
-					modelsToAdd.push( model );
-				}
-			}, this );
+		_.each( models || [], function( model ) {
+			if ( !( model instanceof Backbone.Model ) ) {
+				// `_prepareModel` attempts to find `model` in Backbone.store through `findOrCreate`,
+				// and sets the new properties on it if is found. Otherwise, a new model is instantiated.
+				model = Backbone.Collection.prototype._prepareModel.call( this, model, options );
+			}
 
+			if ( model instanceof Backbone.Model && !this.get( model ) && !this.getByCid( model ) ) {
+				modelsToAdd.push( model );
+			}
+		}, this );
 
 		// Add 'models' in a single batch, so the original add will only be called once (and thus 'sort', etc).
 		if ( modelsToAdd.length ) {
 			add.call( this, modelsToAdd, options );
 
-			_.each( modelsToAdd, function( model ) {
-					this.trigger( 'relational:add', model, this, options );
-				}, this );
+			_.each( modelsToAdd || [], function( model ) {
+				this.trigger( 'relational:add', model, this, options );
+			}, this );
 		}
 		
 		return this;
@@ -1612,7 +1630,7 @@
 		}
 
 		//console.debug('calling remove on coll=%o; models=%o, options=%o', this, models, options );
-		_.each( models, function( model ) {
+		_.each( models || [], function( model ) {
 				model = this.getByCid( model ) || this.get( model );
 
 				if ( model instanceof Backbone.Model ) {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: backbone-relational-rails
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
   prerelease: 
 platform: ruby
 authors:
@@ -56,7 +56,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2242082046468411203
+      hash: -4585206542888784471
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -65,7 +65,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2242082046468411203
+      hash: -4585206542888784471
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24