backbone_extensions 0.0.5 → 0.0.6

data/README.markdown

@@ -13,5 +13,6 @@ Installing
   3. In your application.js //= require backbone
   4. In your application.js //= require backbone_extensions/include
   5. In your application.js //= require backbone_extensions/decorator
+  6. In your application.js //= require backbone_extensions/associations
 
-Copyright (c) 2012 Ryan Dy, released under the MIT license
+Copyright (c) 2012-3 Ryan Dy, Thomas Bukowski, released under the MIT license

data/config/jshint.yml

@@ -8,6 +8,7 @@
 
 paths:
   - lib/assets/javascripts/**/*.js
+  - spec/javascripts/**/*.js
 
 exclude_paths:
 
@@ -20,7 +21,7 @@ exclude_paths:
 adsafe:   false     # true if ADsafe rules should be enforced. See http://www.ADsafe.org/
 bitwise:  true      # true if bitwise operators should not be allowed
 newcap:   true      # true if Initial Caps must be used with constructor functions
-eqeqeq:   false     # true if === should be required (for ALL equality comparisons)
+eqeqeq:   true      # true if === should be required (for ALL equality comparisons)
 immed:    false     # true if immediate function invocations must be wrapped in parens
 nomen:    false     # true if initial or trailing underscore in identifiers should be forbidden
 onevar:   false     # true if only one var statement per function should be allowed
@@ -43,6 +44,7 @@ fragment: false     # true if HTML fragments should be allowed
 laxbreak: false     # true if statement breaks should not be checked
 on:       false     # true if HTML event handlers (e.g. onclick="...") should be allowed
 sub:      false     # true if subscript notation may be used for expressions better expressed in dot notation
+validthis: true     # true if suppresses warnings about possible strict violations when the code is running in strict mode and you use this in a non-constructor function
 
 # other options
 
@@ -55,6 +57,14 @@ predef:           # Names of predefined global variables - comma-separated strin
   - _
   - Backbone
   - jQuery
+  - $
+  - describe
+  - it
+  - beforeEach
+  - afterEach
+  - expect
+  - jasmine
+  - spyOn
 
 browser:  true      # true if the standard browser globals should be predefined
 rhino:    false     # true if the Rhino environment globals should be predefined
@@ -64,12 +74,12 @@ devel:    false     # true if functions like alert, confirm, console, prompt etc
 
 # jshint options
 loopfunc: true      # true if functions should be allowed to be defined within loops
-asi:      true      # true if automatic semicolon insertion should be tolerated
-boss:     true      # true if advanced usage of assignments and == should be allowed
-couch:    true      # true if CouchDB globals should be predefined
+asi:      false     # true if automatic semicolon insertion should be tolerated
+boss:     false     # true if advanced usage of assignments and == should be allowed
+couch:    false     # true if CouchDB globals should be predefined
 curly:    false     # true if curly braces around blocks should be required (even in if/for/while)
 noarg:    true      # true if arguments.caller and arguments.callee should be disallowed
-node:     true      # true if the Node.js environment globals should be predefined
+node:     false     # true if the Node.js environment globals should be predefined
 noempty:  true      # true if empty blocks should be disallowed
 nonew:    true      # true if using `new` for side-effects should be disallowed
 

data/lib/assets/javascripts/backbone_extensions/associations.js

@@ -0,0 +1,166 @@
+//= require backbone_extensions/include
+//= require underscore.string
+(function(_, Backbone) {
+  'use strict';
+  function mixin(namespace) {
+    namespace = namespace || {};
+
+    function mergeAssociationOptions() {
+      return _(arguments).chain().toArray().reduce(function(result, options) { return _(result).extend(options); }, {})
+          .omit('class', 'className', 'inverseOf', 'parseName', 'through').value();
+    }
+
+    function buildAssociation(associationType, associationName, options) {
+      function through() {
+        function association() {
+          var t = (_(options.through).isFunction() && options.through.call(this)) || _.str.camelize(options.through);
+          return this[t] && this[t]() && this[t]()[associationName] && this[t]()[associationName]();
+        }
+        return options.through && association.call(this);
+      }
+
+      function throughCollection() {
+        return (this.collection && this.collection[associationName] && this.collection[associationName]()) ||
+            (this._options && this._options.collection && this._options.collection[associationName] && this._options.collection[associationName]());
+      }
+
+      function createAssociation() {
+        var collectionName = _.str.classify(associationName), className = options.className && _.str.classify(options.className),
+            newOptions = mergeAssociationOptions(options, this._options);
+
+        if (options.inverseOf) {
+          newOptions[_.str.camelize(options.inverseOf)] = _(function() { return this; }).bind(this);
+        }
+
+        return _((options['class'] && new options['class'](null, newOptions)) ||
+            (className && namespace[className] && new namespace[className](null, newOptions)) ||
+            (namespace[collectionName] && new namespace[collectionName](null, newOptions))).tap(_(function(association) {
+              through.call(this, association);
+            }).bind(this));
+      }
+
+      var associations = {
+        hasMany: createAssociation,
+        hasOne: function() { return throughCollection.call(this) || createAssociation.call(this); },
+        belongsTo: function() { return throughCollection.call(this) || through.call(this); }
+      };
+
+      this.prototype[associationName] = function() {
+        return (this._associations || (this._associations = {})) && this._associations[associationName] ||
+            (this._associations[associationName] = (this._options && _(this._options).result(associationName)) || associations[associationType].call(this));
+      };
+    }
+
+    function parseAssociation(associationType, associationName, options) {
+      function parseResponseWith(key, response) {
+        var camelized = _.str.camelize(key), underscored = _.str.underscored(key);
+        if (response[camelized]) {
+          return {key: camelized, response: response[camelized]};
+        }
+        else if (response[underscored]) {
+          return {key: underscored, response: response[underscored]};
+        }
+        else {
+          return {response: null};
+        }
+      }
+
+      function through(response) {
+        var t = parseResponseWith(_(options).result('through'), response).response,
+            singularAssociationName = _.singularize && _(associationName).singularize(),
+            p = options.parseName || singularAssociationName;
+        return {response: t && p && _(t)[associationType === 'hasOne' ? 'result' : 'pluck'](p)};
+      }
+
+      if (options.parse) {
+        var associations = {
+          hasMany: function(assocResponse, association, newOptions) {
+            association.add(assocResponse, newOptions);
+          },
+          hasOne: function(assocResponse, association, newOptions) {
+            association.clear({silent: true}).set(assocResponse, newOptions);
+          }
+        };
+
+        if (associations[associationType]) {
+          var parseFunc = _(options.parse).isFunction() &&
+                  function(response) { return {response: options.parse.call(this, response) }; } ||
+                  function(response) {
+                    return (options.through && through.call(this, response)) ||
+                        (options.parseName && parseResponseWith(options.parseName, response)) ||
+                        (options.className && parseResponseWith(options.className, response)) ||
+                        parseResponseWith(associationName, response);
+                  };
+
+          if(!this._parsers) {
+            var originalParse = this.prototype.parse,
+                parsers = this._parsers = [];
+            this.prototype.parse = function(response) {
+              return _(originalParse.call(this, response)).tap(_(function(parsedResponse) {
+                _(parsers)
+                    .chain()
+                    .map(function(parser) {
+                      return _(parser.parseFn.call(this, parsedResponse)).tap(_(function(result) {
+                        parser.associationFn.call(this, result.response);
+                      }).bind(this)).key;
+                    }, this)
+                    .each(function(key) {
+                      return key && delete parsedResponse[key];
+                    });
+              }).bind(this));
+            };
+          }
+
+          this._parsers.push({
+            parseFn: parseFunc,
+            associationFn: function(assocResponse) {
+              associations[associationType].call(this, assocResponse, this[associationName](), mergeAssociationOptions(options, this.options));
+            }
+          });
+        }
+      }
+    }
+
+    return {
+      included: function(source) {
+        var associations = _({
+          belongsTo: {}, hasMany: {parse: true}, hasOne: {parse: true}
+        }).reduce(function(associations, defaultOptions, associationType) {
+          associations[associationType] = function(name, options) {
+            var associationName = _.str.camelize(name);
+            options = _({}).extend(defaultOptions, options);
+            buildAssociation.call(this, associationType, associationName, options);
+            parseAssociation.call(this, associationType, associationName, options);
+            return this;
+          };
+          return associations;
+        }, {});
+
+        _(source).extend(associations, {
+          associations: function() {
+            _(arguments).chain().toArray().each(function(options) {
+              _(associations).chain().keys().each(function(associationType) {
+                if (options[associationType]) {
+                  associations[associationType].call(source, options[associationType], _(options).omit(associationType));
+                }
+              });
+            });
+          },
+
+          extend: _(source.extend).wrap(function(oldExtend, protoProps, classProps) {
+            return _(oldExtend.call(this, protoProps, classProps)).tap(function() {
+              source.associations((protoProps || {}).associations);
+            });
+          })
+        });
+
+        source.prototype.initialize = _(source.prototype.initialize).wrap(function(oldInitialize, attrsOrModels, options) {
+          this._options = _(options).clone();
+          oldInitialize.call(this, attrsOrModels, options);
+        });
+      }
+    };
+  }
+
+  Backbone.extensions = _(Backbone.extensions || {}).extend({associations: mixin});
+})(_, Backbone);

data/lib/assets/javascripts/backbone_extensions/decorator.js

@@ -1,59 +1,45 @@
-(function(Backbone, $) {
-  function decorateModels(self, models) {
-    var decoratee = models instanceof Backbone.Collection ? models.models : models,
-        proto = _(self)
-            .chain()
-            .functions()
-            .without('collection', 'constructor', 'initialize', 'model')
-            .inject(function(result, method) { result[method] = self[method]; return result; }, {})
-            .value();
-
-    if (decoratee instanceof Array) {
-      _(proto).each(function(fn, name) {
-        self[name] = function() {
-          var args = arguments;
-          return _(decoratee).map(function(model) {
-            return fn.apply(model, args);
-          });
-        };
-      });
-    } else {
-      _(proto).each(function(fn, name) {
-        self[name] = function() {
-          return fn.apply(decoratee, arguments);
-        };
-      });
-    }
+(function(_, Backbone) {
+  'use strict';
+  function Decorator(models, options) {
+    this._decoratee = models instanceof Backbone.Collection ? models.models : models;
+    this.initialize.call(this, models, options);
   }
 
-  function Decorator(models, options) {
-    decorateModels(this, models);
-    this.initialize.apply(this, arguments);
+  function wrapDecorator(fn) {
+    return function() {
+      var args = arguments;
+      if (_(this._decoratee).isArray()) {
+        return _(this._decoratee).map(function(model) {
+          return fn.apply(model, args);
+        });
+      } else {
+        return fn.apply(this._decoratee, args);
+      }
+    };
   }
 
   _(Decorator).extend({
     extend: function(protoProps, classProps) {
-      var Klass = Backbone.Model.extend.apply(this, arguments);
-
-      if (protoProps.model) {
-        protoProps.model.prototype.decorator = function() {
-          return new Klass(this);
-        };
-      }
-
-      if (protoProps.collection) {
-        protoProps.collection.prototype.decorator = function() {
-          return new Klass(this);
-        };
-      }
-
-      return Klass;
+      var proto = _(protoProps).chain().omit('collection', 'constructor', 'initialize', 'model').reduce(function(proto, fn, name) {
+        proto[name] = wrapDecorator(fn);
+        return proto;
+      }, {}).value();
+
+      return _(Backbone.Model.extend.call(this, _(protoProps).extend(proto), classProps)).tap(function(Klass) {
+        _(['model', 'collection']).each(function(type) {
+          if (protoProps[type]) {
+            protoProps[type].prototype.decorator = function() {
+              return new Klass(this);
+            };
+          }
+        });
+      });
     }
-  }, Backbone.include ? Backbone.include : {});
+  }, Backbone.extensions && Backbone.extensions.include || {});
 
   _(Decorator.prototype).extend({
-    initialize: $.noop
+    initialize: function(models, options) {}
   });
 
-  Backbone.Decorator = Decorator;
-})(Backbone, jQuery);
+  Backbone.extensions = _(Backbone.extensions || {}).extend({Decorator: Decorator});
+})(_, Backbone);

data/lib/assets/javascripts/backbone_extensions/delegate_events.js

@@ -0,0 +1,94 @@
+(function(_, Backbone) {
+  'use strict';
+  function bindModelEvents(tuple) {
+    var self = this, subject = tuple[0], eventNames = tuple[1], modelEvents = self._modelEvents;
+    modelEvents.push(tuple);
+
+    _(subject && eventNames).each(function(callback, event) {
+      _(event.split(' ')).each(function(e) {
+        _([callback]).chain().flatten().each(function(c) {
+          if (_(c).isFunction()) {
+            subject.on(e, c, self);
+          } else {
+            subject.on(e, self[c], self);
+          }
+        });
+      });
+    });
+  }
+
+  function unbindModelEvents() {
+    var self = this, modelEvents = self._modelEvents;
+    _(modelEvents).each(function(tuple) {
+      var subject = tuple[0], events = tuple[1];
+
+      _(subject && events).each(function(callback, event) {
+        _(event.split(' ')).each(function(e) {
+          _([callback]).chain().flatten().each(function(c) {
+            if (_(c).isFunction()) {
+              subject.off(e, c);
+            } else {
+              subject.off(e, self[c]);
+            }
+          });
+        });
+      });
+    });
+  }
+
+  function wrapUndelegateEvents(callback) {
+    var oldUndelegateEvents = this.undelegateEvents;
+    this.undelegateEvents();
+    this.undelegateEvents = function() {};
+    callback.call(this);
+    this.undelegateEvents = oldUndelegateEvents;
+  }
+
+  var delegateEvents = {
+    included: function(source) {
+      _(source.prototype).extend({
+        initialize: _(source.prototype.initialize).wrap(function(oldInitialize, attrsOrModels, options) {
+          this._modelEvents = [];
+          oldInitialize.call(this, attrsOrModels, options);
+        }),
+
+        delegateEvents: _(source.prototype.delegateEvents).wrap(function(oldDelegateEvents) {
+          var self = this, args = _(arguments).rest(1);
+
+          if (!args.length) {
+            return oldDelegateEvents.call(this);
+          }
+
+          wrapUndelegateEvents.call(this, function() {
+            _(args).chain().toArray().compact().each(function(obj) {
+              var arg = _(obj);
+              if (arg.isArray()) {
+                bindModelEvents.call(self, obj);
+              } else {
+                arg.each(function(callbacks, event) {
+                  _([callbacks]).chain().flatten().each(function(callback) {
+                    oldDelegateEvents.call(self, _({}).tap(function(obj) {
+                      obj[event] = callback;
+                    }));
+                  });
+                });
+              }
+            });
+          });
+        }),
+
+        undelegateEvents: _(source.prototype.undelegateEvents).wrap(function(oldUndelegateEvents) {
+          unbindModelEvents.call(this);
+          return oldUndelegateEvents.call(this);
+        }),
+
+        remove: _(source.prototype.remove).wrap(function(oldRemove) {
+          this.undelegateEvents();
+          return oldRemove.call(this);
+        })
+      });
+    }
+  };
+
+  Backbone.extensions = _(Backbone.extensions || {}).extend({delegateEvents: delegateEvents});
+})(_, Backbone);

data/lib/assets/javascripts/backbone_extensions/include.js

@@ -1,4 +1,5 @@
-(function(Backbone) {
+(function(_, Backbone) {
+  'use strict';
   var include = {
     include: function() {
       var self = this;
@@ -11,5 +12,5 @@
     }
   };
 
-  Backbone.include = include;
-})(Backbone);
+  Backbone.extensions = _(Backbone.extensions || {}).extend({include: include});
+})(_, Backbone);

data/lib/backbone_extensions/version.rb

@@ -1,3 +1,3 @@
 module BackboneExtensions
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: backbone_extensions
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
 - Ryan Dy
+- Thomas Bukowski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-02 00:00:00.000000000 Z
+date: 2013-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fuubar
@@ -96,12 +97,15 @@ description: Adds extensions to the backbone javascript library. It adds the jav
   underscore, backbone and the extensions you need.
 email:
 - ryan.dy@gmail.com
+- me@neodude.net
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - config/jshint.yml
+- lib/assets/javascripts/backbone_extensions/associations.js
 - lib/assets/javascripts/backbone_extensions/decorator.js
+- lib/assets/javascripts/backbone_extensions/delegate_events.js
 - lib/assets/javascripts/backbone_extensions/include.js
 - lib/backbone_extensions/version.rb
 - lib/backbone_extensions.rb
@@ -122,7 +126,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -446599863856035963
+      hash: 1650966973307354674
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -131,10 +135,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -446599863856035963
+      hash: 1650966973307354674
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.19
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Extensions to backbone javascript library as a rails engine