backbone_extensions 0.0.23 → 0.0.24

data/Rakefile

@@ -1,10 +1,12 @@
 #!/usr/bin/env rake
+ENV['JASMINE_SPEC_FORMAT'] = 'Fuubar'
 begin
   require 'bundler/setup'
 rescue LoadError
   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
 end
 
+require 'yajl/json_gem'
 Bundler::GemHelper.install_tasks
 
 require 'jshint/tasks'

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

@@ -1,21 +1,22 @@
 //= require backbone_extensions/include
 //= require underscore.string
-(function(_, Backbone) {
+(function() {
   'use strict';
-  var global = this, fn = {};
+  var exports = this, _ = exports._, Backbone = exports.Backbone;
+  var fn = {};
   function mixin(namespace, globalOptions) {
-    namespace = namespace || global || {};
+    namespace = namespace || exports || {};
     globalOptions = globalOptions || {};
-    _(fn).extend({
+    _.extend(fn, {
       mergeOptions: function() {
-        return _(arguments).chain().toArray().reduce(function(result, options) { return _(result).extend(options); }, {})
+        return _.chain(arguments).toArray().reduce(function(result, options) { return _.extend(result, options); }, {})
             .omit('class', 'className', 'inverseOf', 'parseName', 'through').value();
       },
 
       buildAssociation: function(namespace, associationType, associationName, options) {
         function through() {
           function association() {
-            var t = (_(options.through).isFunction() && options.through.call(this)) || _.str.camelize(options.through);
+            var t = (_.isFunction(options.through) && 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);
@@ -34,9 +35,9 @@
             newOptions[_.str.camelize(options.inverseOf)] = function() { return self; };
           }
 
-          return _((options['class'] && new options['class'](null, newOptions)) ||
+          return _.tap((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) {
+              (namespace[collectionName] && new namespace[collectionName](null, newOptions)), function(association) {
             through.call(self, association);
           });
         }
@@ -49,28 +50,28 @@
 
         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));
+              (this._associations[associationName] = (this._options && _.result(this._options, associationName)) || associations[associationType].call(this));
         };
       },
 
       parseAssociation: function(associationType, associationName, options) {
         function parseResponseWith(key, response) {
           var result;
-          return _([_.str.camelize, _.str.underscored]).any(function(fn) {
+          return _.any([_.str.camelize, _.str.underscored], function(fn) {
             var k = fn(key);
             return (result = response[k] && {key: k, response: response[k]});
           }) && result || {response: null};
         }
 
         function through(response) {
-          var t = parseResponseWith(_(options).result('through'), response).response,
-              singularAssociationName = _.singularize && _(associationName).singularize(),
+          var t = parseResponseWith(_.result(options, 'through'), response).response,
+              singularAssociationName = _.singularize && _.singularize(associationName),
               p = options.parseName || singularAssociationName;
-          return {response: t && p && _(t)[associationType === 'hasOne' ? 'result' : 'pluck'](p)};
+          return {response: t && p && _[associationType === 'hasOne' && 'result' || 'pluck'](t, p)};
         }
 
         if (options.parse) {
-          if (!_(this).has('_parsers')) {
+          if (!_.has(this, '_parsers')) {
             this._parsers = [];
           }
 
@@ -85,14 +86,13 @@
 
           if (associations[associationType]) {
             var parsers = this._parsers;
-            if (_(parsers).isEmpty()) {
-              this.prototype.parse = _(this.prototype.parse).wrap(function(oldParse, response) {
+            if (_.isEmpty(parsers)) {
+              this.prototype.parse = _.wrap(this.prototype.parse, function(oldParse, response) {
                 var self = this;
-                return _(oldParse.call(self, response)).tap(function(parsedResponse) {
-                  _(parsers)
-                      .chain()
+                return _.tap(oldParse.call(self, response), function(parsedResponse) {
+                  _.chain(parsers)
                       .map(function(parser) {
-                        return _(parser.parseFn.call(self).call(self, parsedResponse)).tap(function(result) {
+                        return _.tap(parser.parseFn.call(self).call(self, parsedResponse), function(result) {
                           parser.associationFn.call(self, result.response);
                         }).key;
                       })
@@ -105,7 +105,7 @@
 
             this._parsers.push({
               parseFn: function() {
-                return _(options.parse).isFunction() &&
+                return _.isFunction(options.parse) &&
                     function(response) { return {response: options.parse.call(this, response) }; } ||
                     function(response) {
                       return (options.through && through.call(this, response)) ||
@@ -126,12 +126,12 @@
 
     return {
       included: function(source) {
-        var associations = _({
+        var associations = _.reduce({
           belongsTo: {}, hasMany: {parse: true}, hasOne: {parse: true}
-        }).reduce(function(associations, defaultOptions, associationType) {
+        }, function(associations, defaultOptions, associationType) {
               associations[associationType] = function(name, options) {
                 var associationName = _.str.camelize(name);
-                options = _({}).extend(defaultOptions, globalOptions, options);
+                options = _.extend({}, defaultOptions, globalOptions, options);
                 fn.buildAssociation.call(this, namespace, associationType, associationName, options);
                 fn.parseAssociation.call(this, associationType, associationName, options);
                 return this;
@@ -139,30 +139,30 @@
               return associations;
             }, {});
 
-        _(source).extend(associations, {
+        _.extend(source, associations, {
           associations: function() {
             var self = this;
-            _(arguments).chain().toArray().compact().each(function(options) {
-              _(associations).chain().keys().each(function(associationType) {
+            _.chain(arguments).toArray().compact().each(function(options) {
+              _.chain(associations).keys().each(function(associationType) {
                 if (options[associationType]) {
-                  associations[associationType].call(self, options[associationType], _(options).omit(associationType));
+                  associations[associationType].call(self, options[associationType], _.omit(options, associationType));
                 }
               });
             });
           },
 
-          extend: _(source.extend).wrap(function(oldExtend, protoProps, classProps) {
-            return _(oldExtend.call(this, protoProps, classProps)).tap(function(Klass) {
+          extend: _.wrap(source.extend, function(oldExtend, protoProps, classProps) {
+            return _.tap(oldExtend.call(this, protoProps, classProps), function(Klass) {
               var args = (protoProps || {}).associations;
               if (args) {
-                Klass.associations.apply(Klass, _([args]).flatten());
+                Klass.associations.apply(Klass, _.flatten([args]));
               }
             });
           })
         });
 
-        source.prototype.initialize = _(source.prototype.initialize).wrap(function(oldInitialize, attrsOrModels, options) {
-          this._options = this._options || _(options).clone();
+        source.prototype.initialize = _.wrap(source.prototype.initialize, function(oldInitialize, attrsOrModels, options) {
+          this._options = this._options || _.clone(options);
           oldInitialize.call(this, attrsOrModels, options);
         });
       }
@@ -170,5 +170,5 @@
   }
   mixin.fn = fn;
 
-  Backbone.extensions = _(Backbone.extensions || {}).extend({associations: mixin});
-}).call(this, _, Backbone);
+  Backbone.extensions = _.extend(Backbone.extensions || {}, {associations: mixin});
+}).call(this);

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

@@ -1,5 +1,6 @@
-(function(_, Backbone) {
+(function() {
   'use strict';
+  var exports = this, _ = exports._, Backbone = exports.Backbone;
   function Decorator(models, options) {
     this._decoratee = models instanceof Backbone.Collection ? models.models : models;
     this.initialize.call(this, models, options);
@@ -8,8 +9,8 @@
   function wrapDecorator(fnName) {
     return function() {
       var Klass = this.constructor, args = arguments;
-      if (_(this._decoratee).isArray()) {
-        return _(this._decoratee).map(function(model) {
+      if (_.isArray(this._decoratee)) {
+        return _.map(this._decoratee, function(model) {
           return (Klass.fn[fnName]).apply(model, args);
         });
       } else {
@@ -18,17 +19,15 @@
     };
   }
 
-  _(Decorator).extend({
+  _.extend(Decorator, {
     extend: function(protoProps, classProps) {
-      var proto = _(protoProps)
-          .chain()
-          .omit('collection', 'constructor', 'initialize', 'model'),
+      var proto = _.chain(protoProps).omit('collection', 'constructor', 'initialize', 'model'),
           wrapped = proto.reduce(function(proto, fn, name) {
             return (proto[name] = wrapDecorator(name)) && proto;
           }, {}).value();
       this.fn = proto.value();
-      return _(Backbone.Model.extend.call(this, _(protoProps).extend(wrapped), classProps)).tap(function(Klass) {
-        _(['model', 'collection']).each(function(type) {
+      return _.tap(Backbone.Model.extend.call(this, _.extend(protoProps, wrapped), classProps), function(Klass) {
+        _.each(['model', 'collection'], function(type) {
           if (protoProps[type]) {
             protoProps[type].prototype.decorator = function() {
               return new Klass(this);
@@ -39,9 +38,9 @@
     }
   }, Backbone.extensions && Backbone.extensions.include || {});
 
-  _(Decorator.prototype).extend({
+  _.extend(Decorator.prototype, {
     initialize: function(models, options) {}
   });
 
-  Backbone.extensions = _(Backbone.extensions || {}).extend({Decorator: Decorator});
-}).call(this, _, Backbone);
+  Backbone.extensions = _.extend(Backbone.extensions || {}, {Decorator: Decorator});
+}).call(this);

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

@@ -1,13 +1,14 @@
-(function(_, Backbone) {
+(function() {
   'use strict';
+  var exports = this, _ = exports._, Backbone = exports.Backbone;
   function bindModelEvents(tuple) {
     var self = this, subject = tuple[0], eventNames = tuple[1], isJquery = !!_(subject).result('jquery'),
         modelEvents = self._modelCallbacks, context = tuple[2];
     modelEvents.push(tuple);
-    _(subject && eventNames).each(function(callback, event) {
-      _(event.split(' ')).each(function(e) {
-        _([callback]).chain().flatten().each(function(c) {
-          var fn = _(c).isFunction() ? c : self[c];
+    _.each(subject && eventNames, function(callback, event) {
+      _.each(event.split(' '), function(e) {
+        _.chain([callback]).flatten().each(function(c) {
+          var fn = _.isFunction(c) ? c : self[c];
             if (isJquery) {
               if (context) {
                 subject.on(e, context, fn);
@@ -24,12 +25,12 @@
 
   function unbindModelEvents() {
     var self = this, modelEvents = self._modelCallbacks;
-    _(modelEvents).each(function(tuple) {
-      var subject = tuple[0], events = tuple[1], context = tuple[2], isJquery = !!_(subject).result('jquery');
-      _(subject && events).each(function(callback, event) {
-        _(event.split(' ')).each(function(e) {
-          _([callback]).chain().flatten().each(function(c) {
-            var fn = _(c).isFunction() ? c : self[c];
+    _.each(modelEvents, function(tuple) {
+      var subject = tuple[0], events = tuple[1], context = tuple[2], isJquery = !!_.result(subject, 'jquery');
+      _.each(subject && events, function(callback, event) {
+        _.each(event.split(' '), function(e) {
+          _.chain([callback]).flatten().each(function(c) {
+            var fn = _.isFunction(c) ? c : self[c];
             if (isJquery) {
               if (context) {
                 subject.off(e, context, fn);
@@ -55,27 +56,28 @@
 
   var delegateEvents = {
     included: function(source) {
-      _(source.prototype).extend({
-        initialize: _(source.prototype.initialize).wrap(function(oldInitialize, attrsOrModels, options) {
+      _.extend(source.prototype, {
+        initialize: _.wrap(source.prototype.initialize, function(oldInitialize, attrsOrModels, options) {
           this._modelCallbacks = [];
           oldInitialize.call(this, attrsOrModels, options);
         }),
 
-        delegateEvents: _(source.prototype.delegateEvents).wrap(function(oldDelegateEvents) {
-          var self = this, args = _(arguments).rest();
+        delegateEvents: _.wrap(source.prototype.delegateEvents, function(oldDelegateEvents) {
+          var self = this, args = _.rest(arguments);
 
           if (!args.length) {
             return oldDelegateEvents.call(this);
           }
+
           wrapUndelegateEvents.call(this, function() {
-            _(args).chain().toArray().compact().each(function(obj) {
+            _.chain(args).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) {
+                  _.chain([callbacks]).flatten().each(function(callback) {
+                    oldDelegateEvents.call(self, _.tap({}, function(obj) {
                       obj[event] = callback;
                     }));
                   });
@@ -85,12 +87,12 @@
           });
         }),
 
-        undelegateEvents: _(source.prototype.undelegateEvents).wrap(function(oldUndelegateEvents) {
+        undelegateEvents: _.wrap(source.prototype.undelegateEvents, function(oldUndelegateEvents) {
           unbindModelEvents.call(this);
           return oldUndelegateEvents.call(this);
         }),
 
-        remove: _(source.prototype.remove).wrap(function(oldRemove) {
+        remove: _.wrap(source.prototype.remove, function(oldRemove) {
           this.undelegateEvents();
           return oldRemove.call(this);
         })
@@ -98,5 +100,5 @@
     }
   };
 
-  Backbone.extensions = _(Backbone.extensions || {}).extend({delegateEvents: delegateEvents});
-}).call(this, _, Backbone);
+  Backbone.extensions = _.extend(Backbone.extensions || {}, {delegateEvents: delegateEvents});
+}).call(this);

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

@@ -1,10 +1,11 @@
-(function(_, Backbone) {
+(function() {
   'use strict';
+  var exports = this, _ = exports._, Backbone = exports.Backbone;
   var include = {
     include: function() {
       var self = this;
-      _(arguments).chain().toArray().each(function(module) {
-        if (module && module.included && _(module.included).isFunction()) {
+      _.chain(arguments).toArray().each(function(module) {
+        if (module && module.included && _.isFunction(module.included)) {
           module.included(self);
         }
       });
@@ -12,5 +13,5 @@
     }
   };
 
-  Backbone.extensions = _(Backbone.extensions || {}).extend({include: include});
-}).call(this, _, Backbone);
+  Backbone.extensions = _.extend(Backbone.extensions || {}, {include: include});
+}).call(this);

data/lib/backbone_extensions/version.rb

@@ -1,3 +1,3 @@
 module BackboneExtensions
-  VERSION = '0.0.23'
+  VERSION = '0.0.24'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: backbone_extensions
 version: !ruby/object:Gem::Version
-  version: 0.0.23
+  version: 0.0.24
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-13 00:00:00.000000000 Z
+date: 2013-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fuubar
@@ -35,7 +35,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.2.1
+        version: 1.3.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -43,7 +43,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.2.1
+        version: 1.3.2
 - !ruby/object:Gem::Dependency
   name: jshint_on_rails
   requirement: !ruby/object:Gem::Requirement
@@ -76,6 +76,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -126,7 +142,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4389807345042330580
+      hash: 3920379791586607175
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -135,10 +151,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4389807345042330580
+      hash: 3920379791586607175
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.21
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Extensions to backbone javascript library as a rails engine