backbone-associations-rails 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in backbone-associations-rails.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Stafford Brunk
+
+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,26 @@
+# backbone-associations-rails [![Gem Version](https://badge.fury.io/rb/backbone-associations-rails.png)](http://badge.fury.io/rb/backbone-associations-rails)
+
+This gem vendors the [Backbone-associations](https://github.com/dhruvaray/backbone-associations) library for easy usage in the Rails asset pipeline.
+
+## Dependencies
+
+```backbone-associations``` requires Backbone.js >= 0.9.2 and Underscore.js >= 1.3.1
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    group :assets
+      gem 'backbone-associations-rails'
+    end
+
+Then require it in your javascript manifest file (```application.js``` by default)
+
+    //= reuqire backbone-associations
+
+## Versioning
+
+```backbone-associations-rails``` will track the version of ```backbone-associations```.
+
+## Issues
+For issues with ```backbone-associations```, please file an issue over at their [issue tracker](https://github.com/dhruvaray/backbone-associations/issues).

data/Rakefile

@@ -0,0 +1,58 @@
+require "bundler/gem_tasks"
+require 'open-uri'
+require 'json'
+
+
+# Helper Functions
+def name
+  @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def version
+  line = File.read("lib/#{name}/version.rb")[/^\s*VERSION\s*=\s*.*/]
+  line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+end
+
+def latest_tag
+  tags = JSON.parse(open('https://api.github.com/repos/dhruvaray/backbone-associations/tags').read)
+  tags.sort!{|a,b| b["name"] <=> a["name"]}
+  tags.first
+end
+
+namespace :backbone_associations do
+
+  desc "Fetches and displays the latest backbone-associations tag"
+  task :latest do
+    tag = latest_tag
+    puts "The latest backbone-associations tag is #{tag["name"]} with commit #{tag["commit"]["sha"]}"
+  end
+
+  desc "Updates the vendored backbone-associations version to the latest tag"
+  task :update do
+    tag = latest_tag
+
+    # Pull attributes we need
+    name = tag["name"]
+    sha = tag["commit"]["sha"]
+
+    # Cleanup the name
+    name.gsub!(/^v/, '')
+    name.gsub!(/-/, '.')
+
+    if name == version
+      puts "Gem version #{version} matches the latest backbone-associations version #{name}"
+      exit
+    end
+
+    # Update marionette
+    puts "Updating backbone-associations..."
+    url = "https://raw.github.com/dhruvaray/backbone-associations/#{sha}/lib/backbone-associations.js"
+    Dir.chdir './vendor/assets/javascripts' do
+      `curl -O #{url}`
+    end
+
+    # Update version file
+    puts "Updating version.rb..."
+    `sed -i "" "s/      VERSION = '.*'/      VERSION = '#{name}'/g" lib/backbone-associations-rails/version.rb`
+  end
+end

data/backbone-associations-rails.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'backbone-associations-rails/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "backbone-associations-rails"
+  gem.version       = Backbone::Associations::Rails::VERSION
+  gem.authors       = ["Stafford Brunk"]
+  gem.email         = ["stafford.brunk@gmail.com"]
+  gem.description   = %q{Backbone-associations provides a way of specifying 1:1 and 1:N relationships between Backbone models. Additionally, parent model instances (and objects extended from Backbone.Events) can listen in to CRUD events initiated on any children - in the object graph - by providing an appropriately qualified event path name.}
+  gem.summary       = %q{Packages the backbone.associations library for use with the asset pipline}
+  gem.homepage      = "https://github.com/wingrunr21/backbone-associations-rails"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/lib/backbone-associations-rails.rb

@@ -0,0 +1,10 @@
+require "backbone-associations-rails/version"
+
+module Backbone
+  module Associations
+    module Rails
+      class Engine < ::Rails::Engine
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Backbone
+  module Associations
+    module Rails
+      VERSION = '0.1.0'
+    end
+  end
+end

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

@@ -0,0 +1,197 @@
+//
+// Backbone-associations.js 0.1.0
+//
+// (c) 2012 Dhruva Ray, Jaynti Kanani
+//
+// Backbone-associations may be freely distributed under the MIT license; see the accompanying LICENSE.txt.
+//
+// Depends on [Backbone](https://github.com/documentcloud/backbone) (and thus on [Underscore](https://github.com/documentcloud/underscore/) as well)
+//
+// A complete [Test & Benchmark Suite](../test/test-suite.html) is included for your perusal.
+
+// Initial Setup
+// --------------
+(function() {	
+    // The top-level namespace. All public Backbone classes and modules will be attached to this. 
+    // Exported for the browser and CommonJS.	
+    var _, Backbone;
+    if ( typeof window === 'undefined' ) {
+        _ = require( 'underscore' );
+        Backbone = require( 'backbone' );	
+        exports = module.exports = Backbone;		
+    }
+    else {
+        _ = window._;
+        Backbone = window.Backbone;		
+        exports = window;		
+    }	
+    // Backbone.AssociatedModel
+    // --------------
+
+    //Add `Many` and `One` relations to Backbone Object
+    Backbone.Many  = "Many";
+    Backbone.One  = "One";	
+    //Define `AssociatedModel` (Extends Backbone.Model)
+    Backbone.AssociatedModel = Backbone.Model.extend({
+        //Define relations with Associated Model
+        relations: undefined,				
+        //Set a hash of model attributes on the object, 
+        //firing `"change"` unless you choose to silence it.
+        //It maintains relations between models during the set operation. It also bubbles up child events to the parent.
+        set: function( key, value, options ) {						
+            var attributes,processedRelations,tbp;			
+            // 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;
+            }			
+            // Extract attributes and options.
+            options || (options = {});
+            if(!attributes) return;
+            if (options.unset) for (attr in attributes) attributes[attr] = void 0;			
+            //Check for existence of relations in this model
+            if(this.relations){			
+                //Iterate over `this.relations` and `set` model and collection values
+                _.each(this.relations ,function(relation){
+                    if (attributes[relation.key] != undefined ){					
+                        //Get value of attribute with relation key in `val`
+                        var val = getValue(attributes,relation.key);                        					
+                        //Get class if relation is stored as a string
+                        relation.relatedModel && _.isString(relation.relatedModel) && (relation.relatedModel = eval(relation.relatedModel));
+                        relation.collectionType && _.isString(relation.collectionType) && (relation.collectionType = eval(relation.collectionType));						
+                        //Track reference change of associated model for `change:attribute` event
+                        var refChanged = false;
+                        //If `relation` defines model as associated collection...
+                        if(relation.type === Backbone.Many){				
+                            //`relation.collectionType` should be instance of `Backbone.Collection`
+                            if(relation.collectionType && !relation.collectionType.prototype instanceof Backbone.Collection){								 
+                                throw new Error( 'collectionType must inherit from Backbone.Collection' );																		
+                            }							
+                            //Create new `Backbone.Collection` with `collectionType`
+                            if(!this.attributes[relation.key]){
+                                this.attributes[relation.key] = relation.collectionType ? new relation.collectionType() : this._createCollection(relation.relatedModel);								
+                                refChanged = true;
+                            }
+                            // Get all models if `val` is already instanceof `Backbone.Collection`
+                            if(val instanceof Backbone.Collection){
+                                val = val.models;						
+                            }    
+                            //Resetting new Collection with new value and options							
+                            this.attributes[relation.key].reset(val,options);																					
+                        }						
+                        //If `relation` defines model as associated model...
+                        else if(relation.type == Backbone.One && relation.relatedModel){	                            
+                            //Create New `Backbone.Model` using `relation.relatedModel` if `attributes` is not null							
+                            if(!this.attributes[relation.key]){                            
+                                //If `val` is already instance of  `AssociatedModel`, reserve `relation.key` for `Backbone.Model.prototype.set`
+                                if(val instanceof Backbone.AssociatedModel) return;                            
+                                this.attributes[relation.key] = new relation.relatedModel();
+                                refChanged = true;
+                            }
+                            //If the new attributes is a smaller subset, then use the default values for that attribute - if available.
+                            else{   
+                                var opt = {};
+                                var defaults = getValue(this.attributes[relation.key], 'defaults');                                
+                                _.each(this.attributes[relation.key].attributes,function(value,key){                                    
+                                    !_.has(val,key) && (opt[key] = (defaults ? defaults[key] : void 0));
+                                });
+                                this.attributes[relation.key].set(opt,{silent:true});                               
+                            }		
+                            //Set `val` to model with options
+                            this.attributes[relation.key].set(val,options);							
+                        }
+                        //Add proxy events to respective parents
+                        this.attributes[relation.key].off("all");
+                        this.attributes[relation.key].on("all",function(events){this.trigger(events,_.rest(arguments))},this);
+                        //If reference has changed, trigger `change:attribute` event
+                        refChanged && this.trigger('change:'+relation.key,options);
+                        //Create a local `processedRelations` array to store the relation key which has been processed. 
+                        //We cannot use `this.relations` because if there is no value defined for `relation.key`, it will not get processed by either Backbone `set` or the `AssociatedModel` set
+                        !processedRelations && (processedRelations=[]);
+                        if(_.indexOf(processedRelations,relation.key)===-1){
+                            processedRelations.push(relation.key);
+                        }						
+                    }															
+                },this);
+            };				
+            if(processedRelations){	
+                //Find attributes yet to be processed - `tbp`
+                tbp = {};
+                for(var key in attributes){
+                    if(_.indexOf(processedRelations,key)===-1){
+                        tbp[key] = attributes[key];
+                    }
+                }
+            }
+            //Set all `attributes` to `tbp` 
+            else{
+                tbp = attributes;
+            }			
+            //Returns results for `Backbone.Model.prototype.set`
+            return Backbone.Model.prototype.set.call( this, tbp , options);
+        },		
+        //Returns New `collection` of type `relation.relatedModel` 	
+        _createCollection: function(type) {		
+            var collection;					
+            if ( type && type.prototype instanceof Backbone.AssociatedModel ) {			
+                //Creates new `Backbone.Collection` and defines model class
+                collection = new Backbone.Collection();
+                collection.model = type;								
+            }	
+            else{
+                throw new Error( 'type must inherit from Backbone.AssociatedModel' );
+            }
+            return collection;
+        },		
+        //The JSON representation of the model.
+        toJSON : function(){		
+            //Get json representation from `Backbone.Model.prototype.toJSON`
+            var json = Backbone.Model.prototype.toJSON.apply( this, arguments );
+            //If `this.relations` is defined, iterate through each `relation` and added it's json representation to parents' json representation
+            if(this.relations){
+                _.each(this.relations ,function(relation){  
+                    if(this.attributes[relation.key]){
+                        json[relation.key] = (this.attributes[relation.key].cid !== this.cid) ? this.attributes[relation.key].toJSON() : void 0;
+                    }
+                },this);
+            }
+            return json;
+        },
+        //deep `clone` the model.
+        clone : function(){		
+            //Get shallow clone from `Backbone.Model.prototype.clone`
+            var cloneObj = Backbone.Model.prototype.clone.apply( this, arguments );
+            //If `this.relations` is defined, iterate through each `relation` and `clone`
+            if(this.relations){
+                _.each(this.relations ,function(relation){  
+                    if(this.attributes[relation.key]){
+                        var sourceObj = cloneObj.attributes[relation.key];
+                        if(sourceObj instanceof Backbone.Collection){
+                            //Creates new `collection` using `relation`
+                            var newCollection = relation.collectionType ? new relation.collectionType() : this._createCollection(relation.relatedModel);                            
+                            //Added each `clone` model to `newCollection`
+                            sourceObj.each(function(model){
+                                newCollection.add(model.clone());                            
+                            });                            
+                            cloneObj.attributes[relation.key] = newCollection;
+                        }   
+                        else if(sourceObj instanceof Backbone.Model){
+                            cloneObj.attributes[relation.key] = sourceObj.clone();
+                        }
+                    }
+                },this);
+            }
+            return cloneObj;
+        }			
+    });	
+    // Duplicate Backbone's behavior. To get a value from a Backbone object as a property
+    // or as a function.
+    var getValue = function(object, prop) {
+        if (!(object && object[prop])) return null;
+        return _.isFunction(object[prop]) ? object[prop]() : object[prop];
+    };
+})();

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: backbone-associations-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Stafford Brunk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-07 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
+  from Backbone.Events) can listen in to CRUD events initiated on any children - in
+  the object graph - by providing an appropriately qualified event path name.
+email:
+- stafford.brunk@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- backbone-associations-rails.gemspec
+- lib/backbone-associations-rails.rb
+- lib/backbone-associations-rails/version.rb
+- vendor/assets/javascripts/backbone-associations.js
+homepage: https://github.com/wingrunr21/backbone-associations-rails
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Packages the backbone.associations library for use with the asset pipline
+test_files: []