underscored and camelized syntax now supported

Author: bradrobertson

SpecRunner.html

@@ -12,6 +12,7 @@
   <script type="text/javascript" src="lib/underscore.js"></script>
   <script type="text/javascript" src="lib/backbone.js"></script>
   <script type="text/javascript" src="lib/rails_nested_attributes_collection.js"></script>
+  <script type="text/javascript" src="spec/spec_helper.js"></script>
 
   <!-- include spec files here... -->
   <script type="text/javascript" src="spec/rails_model.spec.js"></script>

spec/rails_model.spec.js

@@ -2,46 +2,56 @@
 *
 *
 *   Testing the RailsModel
+*   See spec_helper.js for model and colleciton defn's
 *
 */
 describe("RailsModel", function() {
   var book,
-      Book,
-      Pages = Backbone.RailsNestedAttributesCollection.extend();
-
-  beforeEach(function() {
-    Book = Backbone.RailsModel.extend({
-      hasMany: {
-        pages: {
-          collection: Pages
-        }
-      }
-    });
-
+      Book;
+      
+  beforeEach(function(){
+    Book = Backbone.RailsModel.extend();
   });
 
   // since we override the constructor
   it("should behave like a Backbone Model", function() {
     book = new Book();
+    expect(book instanceof Backbone.Model).toBeTruthy();
     expect(book.attributes).toBeDefined();
   });
 
   describe("hasMany associations", function() {
+    
+    beforeEach(function() {
+      Book = Backbone.RailsModel.extend(hasManyNested);
+    });
 
-    describe("empty model", function() {
+    describe("Empty model", function() {
       beforeEach(function() {
         book = new Book();
       });
 
-      it("should have a pages collection", function() {
-        expect(book.pages instanceof Pages).toBeTruthy();
+      it("should have collections set", function() {
+        expect(book.pages instanceof Collections.Pages).toBeTruthy();
+        expect(book.customerReviews instanceof Collections.CustomerReviews).toBeTruthy();
       });
 
       describe("serialization", function() {
-        it("should not contain the books collection", function() {
-          // testing both nested attrs and not nested cases
-          expect(book.toJSON().pages).toBeUndefined();
+        it("should not contain the books and reviews collections", function() {
           expect(book.toJSON().pages_attributes).toBeUndefined();
+          expect(book.toJSON().customer_reviews_attributes).toBeUndefined();
+        });
+        
+        describe("asNestedAttributes: false", function(){
+          beforeEach(function(){
+            Book = Backbone.RailsModel.extend(hasManyNotNested);
+            book = new Book();
+          });
+          
+          it("should not contain the books and reviews collection", function() {
+            expect(book.toJSON().pages).toBeUndefined();
+            expect(book.toJSON().customer_reviews).toBeUndefined();
+          });
         });
       });
 
@@ -50,55 +60,62 @@ describe("RailsModel", function() {
     describe("Populated model", function() {
       beforeEach(function() {
         book = new Book({
-          pages: [{one:1}, {two:2}]
+          pages: [{one:1}, {two:2}],
+          customer_reviews: [{one:'great'},{two:'mediocre'},{three:'soso'}]
         });
       });
 
-      it("should have a populated collection", function() {
+      it("should have a populated each collection", function() {
         expect(book.pages.length).toEqual(2);
         expect(book.pages.at(0).get('one')).toEqual(1);
         expect(book.pages.at(1).get('two')).toEqual(2);
+
+        expect(book.customerReviews.length).toEqual(3);
+        expect(book.customerReviews.at(0).get('one')).toEqual('great');
+        expect(book.customerReviews.at(1).get('two')).toEqual('mediocre');
+        expect(book.customerReviews.at(2).get('three')).toEqual('soso');
       });
 
       it("should not have the collection set as attributes", function(){
         expect(book.get('pages')).toBeUndefined();
+        expect(book.get('customer_reviews')).toBeUndefined();
       });
 
       describe("serialization", function() {
-        describe("using asNestedAttributes", function() {
-          it("should have pages_attributes", function() {
-            expect(book.toJSON().pages_attributes).toBeDefined();
-            expect(book.toJSON().pages_attributes[0].one).toEqual(1);
-          });
+        it("should have both collection's attributes", function() {
+          expect(book.toJSON().pages_attributes).toBeDefined();
+          expect(book.toJSON().pages_attributes[0].one).toEqual(1);
+          
+          expect(book.toJSON().customer_reviews_attributes).toBeDefined();
+          expect(book.toJSON().customer_reviews_attributes[0].one).toEqual('great');
+        });
 
-          it("should not have pages", function() {
-            expect(book.toJSON().pages).toBeUndefined();
-          });
+        it("should not have pages or customer_reviews", function() {
+          expect(book.toJSON().pages).toBeUndefined();
+          expect(book.toJSON().customer_reviews).toBeUndefined();
         });
 
-        describe("not using asNestedAttributes", function() {
+        describe("asNestedAttributes: false", function() {
           beforeEach(function() {
-            Book = Backbone.RailsModel.extend({
-              hasMany: {
-                pages: {
-                  collection: Pages,
-                  asNestedAttributes: false
-                }
-              }
-            });
+            Book = Backbone.RailsModel.extend(hasManyNotNested);
 
             book = new Book({
-              pages: [{one:1}, {two:2}]
+              pages: [{one:1}, {two:2}],
+              customer_reviews: [{one:'great'},{two:'mediocre'},{three:'soso'}]
             });
           });
 
           it("should have pages", function(){
             expect(book.toJSON().pages).toBeDefined();
             expect(book.toJSON().pages[0].one).toEqual(1);
+            
+            expect(book.toJSON().customer_reviews).toBeDefined();
+            expect(book.toJSON().customer_reviews[0].one).toEqual('great');
           });
 
           it("should not have pages_attributes", function() {
             expect(book.toJSON().pages_attributes).toBeUndefined();
+            expect(book.toJSON().customer_reviews_attributes).toBeUndefined();
           });
         });
       });

spec/spec_helper.js

@@ -1,2 +1,68 @@
+var Models = {},
+    Collections = {},
+    hasManyNested,
+    hasOneNested,
+    hasOneAndManyNested,
+    hasManyNotNested,
+    hasOneNotNested,
+    hasOneAndManyNotNested;
 
-NestedCollection =
+beforeEach(function(){
+  Models.Author = Backbone.Model.extend();
+  Models.PublishingHouse = Backbone.Model.extend();
+
+  Collections.Pages = Backbone.RailsNestedAttributesCollection.extend();
+  Collections.CustomerReviews = Backbone.RailsNestedAttributesCollection.extend();
+  
+  hasManyNested = {
+    hasMany: {
+      pages: {
+        collection: Collections.Pages
+      },
+      customerReviews: {
+        collection: Collections.CustomerReviews
+      }
+    }
+  };
+
+  hasOneNested = {
+    hasOne: {
+      author: {
+        model: Models.Author
+      },
+      publishingHouse: {
+        model: Models.PublishingHouse
+      }
+    }
+  };
+
+  hasOneAndManyNested = _.extend(hasManyNested, hasOneNested);
+  
+  hasManyNotNested = {
+    hasMany: {
+      pages: {
+        collection: Collections.Pages,
+        asNestedAttributes: false
+      },
+      customerReviews: {
+        collection: Collections.CustomerReviews,
+        asNestedAttributes: false
+      }
+    }
+  };
+
+  hasOneNotNested = {
+    hasOne: {
+      author: {
+        model: Models.Author,
+        asNestedAttributes: false
+      },
+      publishingHouse: {
+        model: Models.PublishingHouse,
+        asNestedAttributes: false
+      }
+    }
+  };
+
+  hasOneAndManyNotNested = _.extend(hasManyNotNested, hasOneNotNested);
+});

src/rails_model.js

@@ -3,8 +3,69 @@
 *
 *   A model that allows has_one and has_many associations
 *
+*   Associations are defined in the `class` definition using:
+*
+*   var Book = Backbone.RailsModel.extend({
+*     hasMany: {
+*       pages: {
+*         collection: Pages
+*       },
+*       customerReviews: {
+*         collection: CustomerReviews
+*       }
+*     },
+*     hasOne: {
+*       publishingHouse: {
+*         model: PublishingHouse
+*       }
+*     }
+*   });
+*
+*   Note that we specify our associations using the Javascript camelcased convention
+*   The json coming in is expected to use the rails underscored convention however.
+*
+*   For example, one would populate the above Book object using
+*
+*   var book = new Book( {customer_reviews: [{one:1}, {two:2}]} )
+*
 */
 (function(){
+  
+  var 
+      /**
+      *
+      *   @private
+      *   
+      *   Trim whitespace from the front and back of a string
+      */
+      trim = String.prototype.trim || function(){
+        return this.replace(/^\s+|\s+$/g, '') ;
+      },
+      /**
+      *
+      *   @private
+      *   @param {String} string The string to be converted
+      *
+      *   Convert underscored string into camelcase (taken from undescore.string.js)
+      */
+      camelize = function(string){
+        return trim.call(string).replace(/(\-|_|\s)+(.)?/g, function(match, separator, chr) {
+          return chr ? chr.toUpperCase() : '';
+        });
+      },
+      /**
+      *
+      *   @private
+      *   @param {String} string The string to be converted      
+      *
+      *   Convert camelcased string into underscored (taken from undescore.string.js)
+      */
+      underscored = function(string){
+        return trim.call(string).
+          replace(/([A-Z\d]+)([A-Z][a-z])/, '$1_$2').
+          replace(/([a-z\d])([A-Z]+)/g, '$1_$2').
+          replace(/\-|\s+/g, '_').toLowerCase();
+      };
 
 
   Backbone.RailsModel = Backbone.Model.extend({
@@ -31,8 +92,9 @@
       Backbone.Model.prototype.constructor.apply(this, arguments);
 
       _.each(this.hasMany, function(properties, association){
-        self[association] = new properties.collection(self.get(association));
-        self.unset(association, {silent: true});
+        var railsAssociation = underscored(association);
+        self[association] = new properties.collection(self.get( railsAssociation ));
+        self.unset(railsAssociation, {silent: true});
       });
     },
 
@@ -49,7 +111,7 @@
           attrs = _.clone(this.attributes);
 
       _.each(this.hasMany, function(properties, association){
-        var associationKey = association + (properties.asNestedAttributes === false ? "" : "_attributes");
+        var associationKey = underscored(association) + (properties.asNestedAttributes === false ? "" : "_attributes");
 
         if ( self[association].length ){
           attrs[associationKey] = self[association].toJSON();