backbone-nested-attributes 0.2.2

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+spec/dummy/db/*.sqlite3
+spec/dummy/log/*.log
+spec/dummy/tmp/
+spec/dummy/.sass-cache

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.3-p0@backbone-nested-attributes --create

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in backbone-nested-attributes.gemspec
+gemspec
+
+gem 'sqlite3'
+
+gem 'jquery-rails'
+
+gem 'backbone-on-rails'
+
+gem 'jasmine'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Vicente Mundim
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,187 @@
+# Backbone.NestedAttributesModel
+
+Add Rails-like nested attributes support for Backbone.Model.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'backbone-nested-attributes'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install backbone-nested-attributes
+
+Then, add this line in your `application.js`:
+
+    //= require backbone-nested-attributes/all
+
+## Usage
+
+Make your model extend from `Backbone.NestedAttributesModel`, instead of `Backbone.Model` and declare your relationships:
+
+```javascript
+var Post = Backbone.NestedAttributesModel.extend({
+  relations: [
+    {
+      type: 'one',
+      key: 'author',
+      relatedModel: function () { return Person }
+    },
+    {
+      key:  'comments',
+      relatedModel: function () { return Comment }
+    }
+  ]
+})
+
+var Comment = Backbone.NestedAttributesModel.extend({})
+var Person = Backbone.NestedAttributesModel.extend({})
+```
+
+Now you can create your posts like this:
+
+```javascript
+var post = new Post({
+  id: 123,
+  title: 'My Title',
+  author: { id: 987, name: "Vicente Mundim" },
+  comments: [
+    {
+      id: 765,
+      body: "Nice writeup!"
+    },
+    {
+      id: 766,
+      body: "Keep it going!"
+    }
+  ]
+})
+
+post.get('author')   // returns a Person model
+post.get('comments') // returns a Backbone.Collection of Comment models
+```
+
+When saving data, you can choose whether to send attributes as usual, or with nested attributes support by giving `{ nested: true }` to `save`:
+
+```javascript
+post.save({}, { nested: true }) 
+```
+
+This will send data to the server like this:
+
+```javascript
+{
+  id: 123,
+  title: 'My Title',
+  author_attributes: { id: 987, name: "Vicente Mundim" },
+  comments_attributes: [
+    {
+      id: 765,
+      body: "Nice writeup!"
+    },
+    {
+      id: 766,
+      body: "Keep it going!"
+    }
+  ]
+}
+```
+
+It keeps track of deleted models in `1-N` relations:
+
+```javascript
+var comment = post.get('comments').at(0)
+post.get('comments').remove(comment)
+
+post.save({}, { nested: true })
+```
+
+Send this data to the server:
+
+```javascript
+{
+  id: 123,
+  title: 'My Title',
+  author_attributes: { id: 987, name: "Vicente Mundim" },
+  comments_attributes: [
+    {
+      id: 765,
+      body: "Nice writeup!",
+      _destroy: true
+    },
+    {
+      id: 766,
+      body: "Keep it going!"
+    }
+  ]
+}
+```
+
+## Backbone.UndoableModel
+
+If you're using some [bind](https://github.com/NYTimes/backbone.stickit) plugin and you want to cancel changes that were made without reloading the page or hitting the backend you'll definitively want to take a look at Backbone.UndoableModel:
+
+```javascript
+var Post = Backbone.UndoableModel.extend({
+  relations: [ // UndoableModel is a NestedAttributesModel, so it can have relations
+    {
+      type: 'one',
+      key: 'author',
+      relatedModel: function () { return Person }
+    },
+    {
+      key:  'comments',
+      relatedModel: function () { return Comment }
+    }
+  ]
+})
+
+var Comment = Backbone.UndoableModel.extend({})
+var Person = Backbone.UndoableModel.extend({})
+
+var post = new Post({
+  id: 123,
+  title: 'My Title',
+  author: { id: 987, name: "Vicente Mundim" },
+  comments: [
+    {
+      id: 765,
+      body: "Nice writeup!"
+    },
+    {
+      id: 766,
+      body: "Keep it going!"
+    }
+  ]
+})
+
+post.set({ title: 'My new title' })
+post.get('author').set({ name: 'Jon Snow' })
+post.get('comments').at(0).set({ body: 'Great post!' })
+
+post.undo() // that's it, post is now reverted to its initial attributes, as well as its relations
+
+post.get('title')                      // 'My Title'
+post.get('author').get('name')         // 'Vicente Mundim'
+post.get('comments').at(0).get('body') // "Nice writeup!"
+```
+
+## More info
+
+Check out the specs:
+
+* [Backbone.NestedAttributesModel](https://github.com/dtmconsultoria/backbone-nested-attributes/blob/master/spec/javascripts/backbone-nested-attributes/ModelSpec.js)
+* [Backbone.UndoableModel](https://github.com/dtmconsultoria/backbone-nested-attributes/blob/master/spec/javascripts/backbone-nested-attributes/UndoableSpec.js)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,15 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+Bundler::GemHelper.install_tasks
+
+task :jasmine => 'app:jasmine'
+
+task :default => 'app:jasmine:ci'

data/app/assets/javascripts/backbone-nested-attributes/all.js

@@ -0,0 +1,2 @@
+//= require backbone-nested-attributes/model
+//= require backbone-nested-attributes/undoable

data/app/assets/javascripts/backbone-nested-attributes/model.js

@@ -0,0 +1,175 @@
+(function(Backbone, _) {
+  var BackboneModelPrototype = Backbone.Model.prototype
+
+  function setNestedAttributes(model, key, value, options) {
+    var attributes = attributesFor(key, value, options)
+
+    if (attributes) {
+      _(model.relations).each(function (relation) {
+        if (relation.type == 'one') {
+          setHasOneNestedAttributeFor(model, relation, attributes)
+        } else {
+          setNestedAttributeFor(model, relation, attributes)
+        }
+      })
+    }
+
+    configureNestedAttributesEvents(model)
+
+    return attributes
+  }
+
+  function setHasOneNestedAttributeFor(model, relation, attributes) {
+    var key           = relation.key,
+        value         = attributes[key],
+        ModelClass    = _(relation).result('relatedModel')
+
+    if (value) {
+      value = value instanceof Backbone.Model ? value : new ModelClass(value)
+
+      configureEventBubbling(model, value, relation)
+      attributes[key] = value
+    }
+  }
+
+  function setNestedAttributeFor(model, relation, attributes) {
+    var key           = relation.key,
+        value         = attributes[key],
+        currentValue  = model.get(key),
+        nested        = currentValue || createNestedAttributeCollection(relation)
+
+    value = value instanceof Backbone.Collection ? value.slice() : value
+
+    configureEventBubbling(model, nested, relation)
+
+    if (value) {
+      nested.set(value)
+    }
+
+    attributes[key] = nested
+
+    return attributes
+  }
+
+  function configureNestedAttributesEvents(model) {
+    if (!model._hasNestedAttributesEventsConfigured) {
+      model.on('sync', function () {
+        _(model.relations).each(function (relation) {
+          var collection = model.get(relation.key)
+
+          collection.deletedModels.reset()
+        })
+      })
+
+      model._hasNestedAttributesEventsConfigured = true
+    }
+  }
+
+  function configureEventBubbling(model, nested, relation) {
+    if (!nested._hasEventBubblingConfigured) {
+      model.listenTo(nested, 'add change nested:change remove', function (nestedModel, options) {
+        model.trigger('nested:change change:' + relation.key, nestedModel, options)
+      })
+
+      nested._hasEventBubblingConfigured = true
+    }
+  }
+
+  function clearNestedEvents(model) {
+    _(model.relations).each(function (relation) {
+      var nested = model.get(relation.key)
+
+      model.stopListening(nested)
+      nested.off('remove', nestedModelRemoved, nested)
+
+      if (nested.deletedModels) {
+        nested.deletedModels.reset()
+      }
+    }, model)
+  }
+
+  function nestedToJson(json, relations, options) {
+    _(relations).each(function (relation) {
+      var key     = relation.key,
+          value   = json[key],
+          deleted = [],
+          jsonValue
+
+      if (value) {
+        if (options && options.nested) {
+          delete json[key]
+          key = key + '_attributes'
+
+          if (value.deletedModels) {
+            deleted = value.deletedModels.toJSON(options)
+          }
+        }
+
+        jsonValue = value.toJSON(options)
+
+        if (_(jsonValue).isArray()) {
+          json[key] = jsonValue.concat(deleted)
+        } else {
+          json[key] = jsonValue
+        }
+      }
+    })
+
+    return json
+  }
+
+  function createNestedAttributeCollection(relation) {
+    var CollectionType = _(relation).result('collectionType') || Backbone.Collection,
+        collection     = new CollectionType
+
+    collection.model = _(relation).result('relatedModel') || collection.model
+
+    collection.deletedModels = new Backbone.Collection
+    collection.on('remove', nestedModelRemoved, collection)
+
+    return collection
+  }
+
+  function nestedModelRemoved(model) {
+    if (!model.isNew()) {
+      model.set({ _destroy: true })
+      this.deletedModels.add(model) // this refers to the collection
+    }
+  }
+
+  function attributesFor(key, value, options) {
+    var attributes
+
+    // Duplicate backbone's behavior to allow separate key/value parameters,
+    // instead of a single 'attributes' object.
+    if (_.isObject(key) || key == null) {
+      attributes = key
+      options = value
+    } else {
+      attributes = {}
+      attributes[key] = value
+    }
+
+    return attributes
+  }
+
+  Backbone.NestedAttributesModel = Backbone.Model.extend({
+    set: function (key, value, options) {
+      var attributes = setNestedAttributes(this, key, value, options)
+      return BackboneModelPrototype.set.call(this, attributes, options)
+    },
+
+    toJSON: function (options) {
+      return nestedToJson(BackboneModelPrototype.toJSON.apply(this, arguments), this.relations, options)
+    },
+
+    clone: function() {
+      return new this.constructor(this.toJSON());
+    },
+
+    clear: function (options) {
+      clearNestedEvents(this)
+      return BackboneModelPrototype.clear.apply(this, arguments)
+    }
+  })
+})(Backbone, _)