RubyGems - backbone-nested-attributes - Versions diffs - 0.2.2 - Mend

backbone-nested-attributes 0.2.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (52) hide show

data/.gitignore +21 -0
data/.rvmrc +1 -0
data/Gemfile +12 -0
data/LICENSE.txt +22 -0
data/README.md +187 -0
data/Rakefile +15 -0
data/app/assets/javascripts/backbone-nested-attributes/all.js +2 -0
data/app/assets/javascripts/backbone-nested-attributes/model.js +175 -0
data/app/assets/javascripts/backbone-nested-attributes/undoable.js +60 -0
data/backbone-nested-attributes.gemspec +20 -0
data/lib/backbone-nested-attributes.rb +6 -0
data/lib/backbone-nested-attributes/engine.rb +7 -0
data/lib/backbone-nested-attributes/version.rb +5 -0
data/spec/dummy/README.rdoc +261 -0
data/spec/dummy/Rakefile +7 -0
data/spec/dummy/app/assets/javascripts/application.js +18 -0
data/spec/dummy/app/assets/stylesheets/application.css +13 -0
data/spec/dummy/app/controllers/application_controller.rb +3 -0
data/spec/dummy/app/helpers/application_helper.rb +2 -0
data/spec/dummy/app/mailers/.gitkeep +0 -0
data/spec/dummy/app/models/.gitkeep +0 -0
data/spec/dummy/app/views/layouts/application.html.erb +14 -0
data/spec/dummy/config.ru +4 -0
data/spec/dummy/config/application.rb +79 -0
data/spec/dummy/config/boot.rb +10 -0
data/spec/dummy/config/database.yml +25 -0
data/spec/dummy/config/environment.rb +5 -0
data/spec/dummy/config/environments/development.rb +37 -0
data/spec/dummy/config/environments/production.rb +67 -0
data/spec/dummy/config/environments/test.rb +37 -0
data/spec/dummy/config/initializers/backtrace_silencers.rb +7 -0
data/spec/dummy/config/initializers/inflections.rb +15 -0
data/spec/dummy/config/initializers/mime_types.rb +5 -0
data/spec/dummy/config/initializers/secret_token.rb +7 -0
data/spec/dummy/config/initializers/session_store.rb +8 -0
data/spec/dummy/config/initializers/wrap_parameters.rb +14 -0
data/spec/dummy/config/locales/en.yml +5 -0
data/spec/dummy/config/routes.rb +58 -0
data/spec/dummy/db/.gitkeep +0 -0
data/spec/dummy/lib/assets/.gitkeep +0 -0
data/spec/dummy/log/.gitkeep +0 -0
data/spec/dummy/public/404.html +26 -0
data/spec/dummy/public/422.html +26 -0
data/spec/dummy/public/500.html +25 -0
data/spec/dummy/public/favicon.ico +0 -0
data/spec/dummy/script/rails +6 -0
data/spec/javascripts/backbone-nested-attributes/ModelSpec.js +626 -0
data/spec/javascripts/backbone-nested-attributes/UndoableSpec.js +489 -0
data/spec/javascripts/helpers/SpecHelper.js +7 -0
data/spec/javascripts/helpers/mock-ajax.js +207 -0
data/spec/javascripts/support/jasmine.yml +76 -0
metadata +156 -0

data/spec/dummy/public/500.html ADDED Viewed

@@ -0,0 +1,25 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>We're sorry, but something went wrong (500)</title>
+  <style type="text/css">
+    body { background-color: #fff; color: #666; text-align: center; font-family: arial, sans-serif; }
+    div.dialog {
+      width: 25em;
+      padding: 0 4em;
+      margin: 4em auto 0 auto;
+      border: 1px solid #ccc;
+      border-right-color: #999;
+      border-bottom-color: #999;
+    }
+    h1 { font-size: 100%; color: #f00; line-height: 1.5em; }
+  </style>
+</head>
+<body>
+  <!-- This file lives in public/500.html -->
+  <div class="dialog">
+    <h1>We're sorry, but something went wrong.</h1>
+  </div>
+</body>
+</html>

data/spec/dummy/public/favicon.ico ADDED Viewed

File without changes

data/spec/dummy/script/rails ADDED Viewed

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require File.expand_path('../../config/boot',  __FILE__)
+require 'rails/commands'

data/spec/javascripts/backbone-nested-attributes/ModelSpec.js ADDED Viewed

@@ -0,0 +1,626 @@
+describe("Backbone.NestedAttributesModel", function() {
+  var model,
+      Post,
+      post,
+      Comment,
+      comment,
+      Person,
+      author
+  beforeEach(function() {
+    model = new Backbone.NestedAttributesModel({})
+  })
+  it("should be a Backbone.Model", function() {
+    expect(model).toBeAnInstanceOf(Backbone.Model)
+  })
+  describe("with a has one relationship", function() {
+    beforeEach(function() {
+      Post = Backbone.NestedAttributesModel.extend({
+        relations: [
+          {
+            type: 'one',
+            key: 'author',
+            relatedModel: function () { return Person }
+          }
+        ]
+      })
+      Person = Backbone.NestedAttributesModel.extend({})
+    })
+    describe("when creating", function() {
+      it("does not initializes the author attribute", function() {
+        model = new Post
+        expect(model.get('author')).not.toBeDefined()
+      });
+      describe("while setting attributes", function() {
+        beforeEach(function() {
+          model = new Post({ title: 'Some Title', author: { name: 'Jon Snow'} })
+        })
+        it("sets the normal attributes", function() {
+          expect(model.get('title')).toEqual('Some Title')
+        })
+        it("creates the author model", function() {
+          author = model.get('author')
+          expect(author).toBeAnInstanceOf(Person)
+          expect(author.get('name')).toEqual('Jon Snow')
+        })
+        describe("passing a model to the relation attribute", function() {
+          beforeEach(function() {
+            author = new Person({ name: 'Jon Snow' })
+            model = new Post({ title: 'Some Title', author: author })
+          })
+          it("store the given model in the relation attribute", function() {
+            expect(model.get('author')).toBe(author)
+          })
+        })
+      })
+    })
+    describe("when updating", function() {
+      beforeEach(function() {
+        model = new Post
+      })
+      it("store the given model in the relation attribute", function() {
+        model.set({ author: { name: 'Jon Snow' } })
+        author = model.get('author')
+        expect(author).toBeAnInstanceOf(Person)
+        expect(author.get('name')).toEqual('Jon Snow')
+      })
+      it("allows passing key, value when setting a relation attribute", function() {
+        model.set('author', { name: 'Jon Snow' })
+        author = model.get('author')
+        expect(author).toBeAnInstanceOf(Person)
+        expect(author.get('name')).toEqual('Jon Snow')
+      })
+      describe("passing a model to the relation attribute", function() {
+        beforeEach(function() {
+          author = new Person({ name: 'Jon Snow' })
+          model = new Post
+        })
+        it("store the given model in the relation attribute", function() {
+          model.set({ title: 'Some title', author: author })
+          expect(model.get('author')).toBe(author)
+        })
+      })
+    })
+    describe("cloning", function() {
+      beforeEach(function() {
+        post = new Post({ title: 'Some Title', author: { name: 'Jon Snow' } })
+      })
+      it("creates a new post object, with the same attributes, including nested has one relations, that are not shared", function() {
+        var newPost = post.clone()
+        expect(newPost).not.toBe(post)
+        expect(newPost.get('author')).not.toBe(post.get('author'))
+        expect(newPost.get('title')).toEqual(post.get('title'))
+        expect(newPost.get('author').get('name')).toEqual(post.get('author').get('name'))
+      })
+    })
+    describe("event bubbling", function() {
+      var changedModel, changedCount
+      beforeEach(function() {
+        changedCount = 0
+        changedModel = undefined
+        model = new Post({ title: 'Some Title', author: { name: 'Jon Snow' } })
+        author = model.get('author')
+      })
+      describe("when a nested model is changed", function() {
+        it("triggers a nested:change event on the parent, with the changed model as an argument", function() {
+          model.on('nested:change', function (model) {
+            changedModel = model
+          })
+          author.set({ name: 'Robb Stark' })
+          expect(changedModel).toBe(author)
+        })
+        it("triggers a nested:change only once, after setting nested attributes again", function() {
+          model.set({ title: 'Some Title', author: { name: 'Jon Snow' } })
+          author = model.get('author')
+          model.on('nested:change', function (model) {
+            changedModel = model
+            changedCount += 1
+          })
+          author.set({ name: 'Robb Stark' })
+          expect(changedModel).toBe(author)
+          expect(changedCount).toEqual(1)
+        })
+        it("triggers a change:<relationKey> event on the parent, with the changed model as an argument", function() {
+          model.on('change:author', function (model) {
+            changedModel = model
+          })
+          author.set({ name: 'Robb Stark' })
+          expect(changedModel).toBe(author)
+        })
+        it("triggers a change:<relationKey> only once, after setting nested attributes again", function() {
+          model.set({ title: 'Some Title', author: { body: 'Jon Snow' } })
+          author = model.get('author')
+          model.on('change:author', function (model) {
+            changedModel = model
+            changedCount += 1
+          })
+          author.set({ name: 'Robb Stark' })
+          expect(changedModel).toBe(author)
+          expect(changedCount).toEqual(1)
+        })
+        describe("and the nested model triggers a nested:change", function() {
+          it("triggers a nested:change on the parent", function() {
+            model.on('nested:change', function (model) {
+              changedModel = model
+            })
+            author.trigger('nested:change', author)
+            expect(changedModel).toBe(author)
+          })
+        })
+      })
+      describe("when clearing", function() {
+        it("stops listening to relation nested:change events", function() {
+          model.on('nested:change', function (model) {
+            changedModel = model
+          })
+          model.clear()
+          author.set({ name: 'Robb Stark' })
+          expect(changedModel).toBeUndefined()
+        })
+        it("stops listening to relation change:<relationKey> events", function() {
+          model.clear()
+          model.on('change:author', function (model) {
+            changedModel = model
+          })
+          author.set({ name: 'Robb Stark' })
+          expect(changedModel).toBeUndefined()
+        })
+      })
+    })
+    describe("toJSON", function() {
+      beforeEach(function() {
+        model = new Post({ title: 'Some Title', author: { name: 'Jon Snow' } })
+      })
+      it("serializes its own attributes, as well as the relation ones", function() {
+        expect(model.toJSON()).toEqual({ title: 'Some Title', author: { name: 'Jon Snow' } })
+      })
+      describe("with nested attributes support", function() {
+        it("serializes the relation attributes with a _attributes suffix", function() {
+          expect(model.toJSON({ nested: true })).toEqual({
+            title: 'Some Title',
+            author_attributes: { name: 'Jon Snow' }
+          })
+        })
+      })
+    })
+  })
+  describe("with a has many relationship", function() {
+    beforeEach(function() {
+      Post = Backbone.NestedAttributesModel.extend({
+        relations: [
+          {
+            key:  'comments',
+            relatedModel: function () { return Comment }
+          }
+        ]
+      })
+      Comment = Backbone.NestedAttributesModel.extend({})
+    })
+    describe("when creating", function() {
+      it("initializes the comments attribute with an empty collection", function() {
+        model = new Post
+        expect(model.get('comments')).toBeDefined()
+        expect(model.get('comments')).toBeAnInstanceOf(Backbone.Collection)
+      });
+      describe("while setting attributes", function() {
+        beforeEach(function() {
+          model = new Post({ title: 'Some Title', comments: [{ body: 'some comment'} ] })
+        })
+        it("sets the normal attributes", function() {
+          expect(model.get('title')).toEqual('Some Title')
+        })
+        it("creates the comment inside comments collection", function() {
+          comment = model.get('comments').at(0)
+          expect(comment).toBeAnInstanceOf(Comment)
+          expect(comment.get('body')).toEqual('some comment')
+        })
+        describe("passing a collection to a relation attribute", function() {
+          var comments, Comments
+          beforeEach(function() {
+            Comments = Backbone.Collection.extend({ model: Comment })
+            comments = new Comments({ body: 'some comment' }, { body: 'some other comment' })
+            model = new Post({ title: 'Some Title', comments: comments })
+          })
+          it("does not store the given collection, but instead creates a new one with models from the given collection", function() {
+            expect(model.get('comments')).not.toBe(comments)
+            expect(model.get('comments')).not.toBeAnInstanceOf(Comments)
+            expect(model.get('comments')).toBeAnInstanceOf(Backbone.Collection)
+            expect(model.get('comments').at(0)).toBe(comments.at(0))
+            expect(model.get('comments').at(1)).toBe(comments.at(1))
+          })
+        })
+      })
+    })
+    describe("when updating", function() {
+      beforeEach(function() {
+        model = new Post
+      })
+      it("creates the comment inside comments collection", function() {
+        model.set({ comments: [{ body: 'some comment' }] })
+        comment = model.get('comments').at(0)
+        expect(comment).toBeAnInstanceOf(Comment)
+        expect(comment.get('body')).toEqual('some comment')
+      })
+      it("does not creates a new collection, but updates it instead", function() {
+        var originalCollection = model.get('comments')
+        model.set({ comments: [{ body: 'some comment' }] })
+        expect(model.get('comments')).toBe(originalCollection)
+      })
+      it("updates existing models in the collection", function() {
+        var existingComment
+        model.set({ comments: [{ id: '123', body: 'some comment' }] })
+        existingComment = model.get('comments').at(0)
+        model.set({ comments: [{ id: existingComment.id, body: 'some other comment' }] })
+        expect(model.get('comments').at(0).get('body')).toEqual('some other comment')
+      })
+      it("allows passing key, value when setting a relation attribute", function() {
+        model.set('comments', [{ body: 'some comment' }])
+        comment = model.get('comments').at(0)
+        expect(comment).toBeAnInstanceOf(Comment)
+        expect(comment.get('body')).toEqual('some comment')
+      })
+      it("allows one to update non-nested attributes without modifying nested ones", function() {
+        model = new Post({ title: 'new title', comments: [{ body: 'some comment' }] })
+        model.set('title', 'other title')
+        expect(model.get('title')).toEqual('other title')
+        expect(model.get('comments').length).toEqual(1)
+      })
+      describe("passing a collection to a relation attribute", function() {
+        var comments, Comments
+        beforeEach(function() {
+          Comments = Backbone.Collection.extend({ model: Comment })
+          comments = new Comments({ body: 'some comment' }, { body: 'some other comment' })
+          model = new Post
+        })
+        it("does not store the given collection, but instead updates the existing one with models from the given collection", function() {
+          var originalCollection = model.get('comments')
+          model.set({ title: 'Some Title', comments: comments })
+          expect(model.get('comments')).toBe(originalCollection)
+          expect(model.get('comments').at(0)).toBe(comments.at(0))
+          expect(model.get('comments').at(1)).toBe(comments.at(1))
+        })
+      })
+    })
+    describe("cloning", function() {
+      beforeEach(function() {
+        post = new Post({ title: 'Some Title', comments: [{ body: 'some comment' }] })
+      })
+      it("creates a new post object, with the same attributes, including nested, but do not share the nested collections", function() {
+        var newPost = post.clone()
+        expect(newPost).not.toBe(post)
+        expect(newPost.get('comments')).not.toBe(post.get('comments'))
+        expect(newPost.get('comments').at(0)).not.toBe(post.get('comments').at(0))
+        expect(newPost.get('title')).toEqual(post.get('title'))
+        expect(newPost.get('comments').at(0).get('body')).toEqual(post.get('comments').at(0).get('body'))
+      })
+    })
+    describe("specifying the collection type", function() {
+      var Comments
+      beforeEach(function() {
+        Comments = Backbone.Collection.extend({ model: Comment })
+        Post = Backbone.NestedAttributesModel.extend({
+          relations: [
+            {
+              key:  'comments',
+              collectionType: function () { return Comments }
+            }
+          ]
+        })
+        model = new Post({ title: 'Some Title', comments: [{ body: 'some comment' }] })
+      })
+      it("uses the given collection as the relation attribute", function() {
+        expect(model.get('comments')).toBeAnInstanceOf(Comments)
+        expect(model.get('comments').at(0)).toBeAnInstanceOf(Comment)
+      })
+    })
+    describe("event bubbling", function() {
+      var changedModel, changedCount
+      beforeEach(function() {
+        changedCount = 0
+        changedModel = undefined
+        model = new Post({ title: 'Some Title', comments: [{ body: 'some comment' }] })
+        comment = model.get('comments').at(0)
+      })
+      describe("when a nested model is changed", function() {
+        it("triggers a nested:change event on the parent, with the changed model as an argument", function() {
+          model.on('nested:change', function (model) {
+            changedModel = model
+          })
+          comment.set({ body: 'some new body' })
+          expect(changedModel).toBe(comment)
+        })
+        it("triggers a nested:change only once, after setting nested attributes again", function() {
+          model.set({ title: 'Some Title', comments: [{ body: 'some other comment' }] })
+          comment = model.get('comments').at(0)
+          model.on('nested:change', function (model) {
+            changedModel = model
+            changedCount += 1
+          })
+          comment.set({ body: 'some new body' })
+          expect(changedModel).toBe(comment)
+          expect(changedCount).toEqual(1)
+        })
+        it("triggers a change:<relationKey> event on the parent, with the changed model as an argument", function() {
+          model.on('change:comments', function (model) {
+            changedModel = model
+          })
+          comment.set({ body: 'some new body' })
+          expect(changedModel).toBe(comment)
+        })
+        it("triggers a change:<relationKey> only once, after setting nested attributes again", function() {
+          model.set({ title: 'Some Title', comments: [{ body: 'some other comment' }] })
+          comment = model.get('comments').at(0)
+          model.on('change:comments', function (model) {
+            changedModel = model
+            changedCount += 1
+          })
+          comment.set({ body: 'some new body' })
+          expect(changedModel).toBe(comment)
+          expect(changedCount).toEqual(1)
+        })
+        describe("and the nested model triggers a nested:change", function() {
+          it("triggers a nested:change on the parent", function() {
+            model.on('nested:change', function (model) {
+              changedModel = model
+            })
+            comment.trigger('nested:change', comment)
+            expect(changedModel).toBe(comment)
+          })
+        })
+      })
+      describe("when adding a new model to a nested relation", function() {
+        it("triggers a nested:change event on the parent, with the added model as an argument", function() {
+          model.on('nested:change', function (model) {
+            changedModel = model
+          })
+          model.get('comments').add({ body: 'other comment' })
+          comment = model.get('comments').at(1)
+          expect(changedModel).toBe(comment)
+        })
+        it("triggers a change:<relationKey> event on the parent, with the added model as an argument", function() {
+          model.on('change:comments', function (model) {
+            changedModel = model
+          })
+          model.get('comments').add({ body: 'other comment' })
+          comment = model.get('comments').at(1)
+          expect(changedModel).toBe(comment)
+        })
+      })
+      describe("when removing a new model to a nested relation", function() {
+        it("triggers a nested:change event on the parent, with the removed model as an argument", function() {
+          model.on('nested:change', function (model) {
+            changedModel = model
+          })
+          comment = model.get('comments').at(0)
+          model.get('comments').remove(comment)
+          expect(changedModel).toBe(comment)
+        })
+        it("triggers a change:<relationKey> event on the parent, with the removed model as an argument", function() {
+          model.on('change:comments', function (model) {
+            changedModel = model
+          })
+          comment = model.get('comments').at(0)
+          model.get('comments').remove(comment)
+          expect(changedModel).toBe(comment)
+        })
+      })
+      describe("when clearing", function() {
+        it("stops listening to collection nested:change events", function() {
+          model.on('nested:change', function (model) {
+            changedModel = model
+          })
+          model.clear()
+          comment.set({ body: 'some new body' })
+          expect(changedModel).toBeUndefined()
+        })
+        it("stops listening to collection change:<relationKey> events", function() {
+          model.on('change:comments', function (model) {
+            changedModel = model
+          })
+          model.clear()
+          comment.set({ body: 'some new body' })
+          expect(changedModel).toBeUndefined()
+        })
+      })
+    })
+    describe("toJSON", function() {
+      beforeEach(function() {
+        model = new Post({ title: 'Some Title', comments: [{ body: 'some comment' }] })
+      })
+      it("serializes its own attributes, as well as the relation one", function() {
+        expect(model.toJSON()).toEqual({ title: 'Some Title', comments: [{ body: 'some comment' }] })
+      })
+      describe("with nested attributes support", function() {
+        it("serializes the relation attributes with a _attributes suffix", function() {
+          expect(model.toJSON({ nested: true })).toEqual({
+            title: 'Some Title',
+            comments_attributes: [{ body: 'some comment' }]
+          })
+        })
+        describe("when a nested model is removed", function() {
+          describe("and it is a new model", function() {
+            beforeEach(function() {
+              comment = model.get('comments').at(0)
+            })
+            it("is not serialized on the relation", function() {
+              model.get('comments').remove(comment)
+              expect(model.toJSON({ nested: true })).toEqual({
+                title: 'Some Title',
+                comments_attributes: []
+              })
+            })
+          })
+          describe("and it is not a new model", function() {
+            beforeEach(function() {
+              comment = model.get('comments').at(0)
+              comment.set({ id: '123' })
+            })
+            it("is serialized on the relation, with { _destroy: true } attribute, besides its own attributes", function() {
+              model.get('comments').remove(comment)
+              expect(model.toJSON({ nested: true })).toEqual({
+                title: 'Some Title',
+                comments_attributes: [{
+                  id: comment.get('id'),
+                  body: comment.get('body'),
+                  _destroy: true
+                }]
+              })
+            })
+            describe("after synchronizing the parent model", function() {
+              beforeEach(function() {
+                jasmine.Ajax.useMock()
+                model.url = 'http://someapi.com'
+              })
+              it("is not serialized on the relation", function() {
+                model.get('comments').remove(comment)
+                model.save()
+                var request = mostRecentAjaxRequest();
+                request.response({status: 200, responseText: { title: 'Some Title', comments: [] }})
+                expect(model.toJSON({ nested: true })).toEqual({
+                  title: 'Some Title',
+                  comments_attributes: []
+                })
+              })
+            })
+            describe("after clearing the parent model", function() {
+              it("is not serialized on the relation", function() {
+                model.get('comments').remove(comment)
+                model.clear()
+                expect(model.toJSON({ nested: true })).toEqual({
+                  title: undefined,
+                  comments_attributes: []
+                })
+              })
+            })
+          })
+        })
+      })
+    })
+  })
+})