js_stack 0.5.4 → 0.5.5

data/vendor/assets/javascripts/js_stack/base/marionette.js

@@ -1 +1 @@
-//= require js_stack/base/marionette/1.7.0
+//= require js_stack/base/marionette/1.7.3

data/vendor/assets/javascripts/js_stack/plugins/backbone/mutators/0.4.2.js

@@ -0,0 +1,207 @@
+/*! Backbone.Mutators - v0.4.2
+------------------------------
+Build @ 2014-03-27
+Documentation and Full License Available at:
+http://asciidisco.github.com/Backbone.Mutators/index.html
+git://github.com/asciidisco/Backbone.Mutators.git
+Copyright (c) 2014 Sebastian Golasch <public@asciidisco.com>
+
+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.*/
+(function (root, factory, undef) {
+    'use strict';
+
+    if (typeof exports === 'object') {
+        // Node. Does not work with strict CommonJS, but
+        // only CommonJS-like enviroments that support module.exports,
+        // like Node.
+        module.exports = factory(require('underscore'), require('backbone'));
+    } else if (typeof define === 'function' && define.amd) {
+        // AMD. Register as an anonymous module.
+        define(['underscore', 'backbone'], function (_, Backbone) {
+            // Check if we use the AMD branch of Back
+            _ = _ === undef ? root._ : _;
+            Backbone = Backbone === undef ? root.Backbone : Backbone;
+            return (root.returnExportsGlobal = factory(_, Backbone, root));
+        });
+    } else {
+        // Browser globals
+        root.returnExportsGlobal = factory(root._, root.Backbone);
+    }
+
+// Usage:
+//
+// Note: This plugin is UMD compatible, you can use it in node, amd and vanilla js envs
+//
+// Vanilla JS:
+// <script src="underscore.js"></script>
+// <script src="backbone.js"></script>
+// <script src="backbone.mutators.js"></script>
+//
+// Node:
+// var _ = require('underscore');
+// var Backbone = require('backbone');
+// var Mutators = require('backbone.mutators');
+//
+//
+// AMD:
+// define(['underscore', 'backbone', 'backbone.mutators'], function (_, Backbone, Mutators) {
+//    // insert sample from below
+//    return User;
+// });
+//
+// var User = Backbone.Model.extend({
+//    mutators: {
+//        fullname: function () {
+//            return this.firstname + ' ' + this.lastname;
+//        }
+//    },
+//
+//    defaults: {
+//        firstname: 'Sebastian',
+//        lastname: 'Golasch'
+//    }
+// });
+//
+// var user = new User();
+// user.get('fullname') // returns 'Sebastian Golasch'
+// user.toJSON() // return '{firstname: 'Sebastian', lastname: 'Golasch', fullname: 'Sebastian Golasch'}'
+
+}(this, function (_, Backbone, root, undef) {
+    'use strict';
+
+    // check if we use the amd branch of backbone and underscore
+    Backbone = Backbone === undef ? root.Backbone : Backbone;
+    _ = _ === undef ? root._ : _;
+
+    // extend backbones model prototype with the mutator functionality
+    var Mutator     = function () {},
+        oldGet      = Backbone.Model.prototype.get,
+        oldSet      = Backbone.Model.prototype.set,
+        oldToJson   = Backbone.Model.prototype.toJSON;
+
+    // This is necessary to ensure that Models declared without the mutators object do not throw and error
+    Mutator.prototype.mutators = {};
+
+    // override get functionality to fetch the mutator props
+    Mutator.prototype.get = function (attr) {
+        var isMutator = this.mutators !== undef;
+
+        // check if we have a getter mutation
+        if (isMutator === true && _.isFunction(this.mutators[attr]) === true) {
+            return this.mutators[attr].call(this);
+        }
+
+        // check if we have a deeper nested getter mutation
+        if (isMutator === true && _.isObject(this.mutators[attr]) === true && _.isFunction(this.mutators[attr].get) === true) {
+            return this.mutators[attr].get.call(this);
+        }
+
+        return oldGet.call(this, attr);
+    };
+
+    // override set functionality to set the mutator props
+    Mutator.prototype.set = function (key, value, options) {
+        var isMutator = this.mutators !== undef,
+            ret = null,
+            attrs = null;
+
+    ret = oldSet.call(this, key, value, options);
+
+        // seamleassly stolen from backbone core
+        // check if the setter action is triggered
+        // using key <-> value or object
+        if (_.isObject(key) || key === null) {
+            attrs = key;
+            options = value;
+        } else {
+            attrs = {};
+            attrs[key] = value;
+        }
+
+        // check if we have a deeper nested setter mutation
+        if (isMutator === true && _.isObject(this.mutators[key]) === true) {
+
+            // check if we need to set a single value
+            if (_.isFunction(this.mutators[key].set) === true) {
+                ret = this.mutators[key].set.call(this, key, attrs[key], options, _.bind(oldSet, this));
+            } else if(_.isFunction(this.mutators[key])){
+                ret = this.mutators[key].call(this, key, attrs[key], options, _.bind(oldSet, this));
+            }
+        }
+
+        if (isMutator === true && _.isObject(attrs)) {
+            _.each(attrs, _.bind(function (attr, attrKey) {
+                if (_.isObject(this.mutators[attrKey]) === true) {
+                    // check if we need to set a single value
+
+                    var meth = this.mutators[attrKey];
+                    if(_.isFunction(meth.set)){
+                        meth = meth.set;
+                    }
+
+                    if(_.isFunction(meth)){
+                        if (options === undef || (_.isObject(options) === true && options.silent !== true && (options.mutators !== undef && options.mutators.silent !== true))) {
+                            this.trigger('mutators:set:' + attrKey);
+                        }
+                        meth.call(this, attrKey, attr, options, _.bind(oldSet, this));
+                    }
+
+                }
+            }, this));
+        }
+
+        return ret;
+    };
+
+    // override toJSON functionality to serialize mutator properties
+    Mutator.prototype.toJSON = function (options) {
+        // fetch ye olde values
+        var attr = oldToJson.call(this),
+            isSaving,
+            isTransient;
+        // iterate over all mutators (if there are some)
+        _.each(this.mutators, _.bind(function (mutator, name) {
+            // check if we have some getter mutations
+            if (_.isObject(this.mutators[name]) === true && _.isFunction(this.mutators[name].get)) {
+                isSaving = _.has(options || {}, 'emulateHTTP');
+                isTransient = this.mutators[name].transient;
+                if (!isSaving || !isTransient) {
+                  attr[name] = _.bind(this.mutators[name].get, this)();
+                }
+            } else if (_.isFunction(this.mutators[name])) {
+                attr[name] = _.bind(this.mutators[name], this)();
+            }
+        }, this));
+
+        return attr;
+    };
+
+    // override get functionality to get HTML-escaped the mutator props
+    Mutator.prototype.escape = function (attr){
+        var val = this.get(attr);
+        return _.escape(val == null ? '' : '' + val);
+    };
+
+    // extend the models prototype
+    _.extend(Backbone.Model.prototype, Mutator.prototype);
+
+    // make mutators globally available under the Backbone namespace
+    Backbone.Mutators = Mutator;
+    return Mutator;
+}));

data/vendor/assets/javascripts/js_stack/plugins/backbone/virtualcollection/0.4.12.js

@@ -0,0 +1,351 @@
+(function(global, factory) {
+
+  // Set up lib appropriately for the environment. Start with AMD.
+  if (typeof define === 'function' && define.amd) {
+    define(['underscore', 'backbone'], factory);
+
+  // Next for Node.js or CommonJS.
+  } else if (typeof module !== 'undefined' && module.exports) {
+    module.exports = factory(require('underscore'), require('backbone'));
+
+  // Finally, use browser globals.
+  } else {
+    factory(global._, global.Backbone);
+  }
+
+}(this, function(_, Backbone) {
+  'use strict';
+
+  var vc, iterators, proxy;
+
+  iterators = ['forEach', 'each', 'map', 'collect', 'reduce', 'foldl',
+    'inject', 'reduceRight', 'foldr', 'find', 'detect', 'filter', 'select',
+    'reject', 'every', 'all', 'some', 'any', 'include', 'contains', 'invoke',
+    'max', 'min', 'toArray', 'size', 'first', 'head', 'take', 'initial', 'rest',
+    'tail', 'drop', 'last', 'without', 'indexOf', 'shuffle', 'lastIndexOf',
+    'isEmpty', 'chain'];
+
+  proxy = ['add', 'remove'];
+
+  /**
+   * Constructor for the virtual collection
+   * @param {Collection} collection
+   * @param {Function|Object} filter function, or hash of properties to match
+   * @param {Object} options
+   *      @param {[Function|Object]} filter function, or hash of properties to match
+   *      @param {[Function|String]} comparator
+   */
+  function VirtualCollection(collection, options) {
+    this.collection = collection;
+    options = options || {};
+    this.comparator = options.comparator;
+
+    _.bindAll(this, 'each', 'map', 'get', 'at', 'indexOf', 'sort', 'closeWith',
+     '_rebuildIndex', '_models', '_onAdd', '_onRemove', '_onChange', '_onReset',
+     '_indexAdd', '_indexRemove');
+
+    // set filter
+    this.filterFunction = VirtualCollection.buildFilter(options.filter);
+
+    // build index
+    this._rebuildIndex();
+
+    this.listenTo(this.collection, 'add',    this._onAdd,    this);
+    this.listenTo(this.collection, 'remove', this._onRemove, this);
+    this.listenTo(this.collection, 'change', this._onChange, this);
+    this.listenTo(this.collection, 'reset',  this._onReset,  this);
+
+    if (options.close_with) {
+      this.closeWith(options.close_with);
+    }
+  }
+
+  /**
+   * [static] Returns a function that returns true for models that meet the specified conditions
+   * @param  {Object} hash of model attributes or {Function} filter
+   * @return {Function} filtering function
+   */
+  VirtualCollection.buildFilter = function (filter) {
+    if (!filter) {
+      // If no filter is passed, all models should be added
+      return function () { return true; };
+    } else if (_.isFunction(filter)) {
+      // If filter is passed a function, just return it
+      return filter;
+    } else if (filter.constructor === Object) {
+      // If filter is a hash of attributes, return a function that checks each of them
+      return function (model) {
+        return !Boolean(_(Object.keys(filter)).detect(function (key) {
+          return model.get(key) !== filter[key];
+        }));
+      };
+    }
+  };
+
+  vc = VirtualCollection.prototype;
+
+
+  // mix in Underscore method as proxies
+  _.each(iterators, function (method) {
+    vc[method] = function () {
+      var args = Array.prototype.slice.call(arguments);
+      args.unshift(this._models());
+      return _[method].apply(_, args);
+    };
+  });
+
+  // proxy functions to parent
+  _.each(proxy, function (method) {
+    vc[method] = function () {
+      var args = Array.prototype.slice.call(arguments);
+      return this.collection[method].apply(this.collection, args);
+    };
+  });
+
+  /**
+   * Returns a model if it belongs to the virtual collection
+   * @param  {String} id
+   * @return {Model}
+   */
+  vc.get = function (id) {
+    var model = this.collection.get(id);
+    if (model && this.filterFunction(model)) {
+      return model;
+    }
+  };
+
+  /**
+   * Returns the model at the position in the index
+   * @param  {Number} index
+   * @return {Model}
+   */
+  vc.at = function (index) {
+    return this.collection.get(this.index[index]);
+  };
+
+  vc.where = Backbone.Collection.prototype.where;
+  vc.findWhere = Backbone.Collection.prototype.findWhere;
+
+  /**
+   * Returns the index of the model in the virtual collection
+   * @param  {Model} model
+   * @return {Number} index
+   */
+  vc.indexOf = function (model) {
+    return this.index.indexOf(model.cid);
+  };
+
+  /**
+   * Returns a JSON representation of all the models in the index
+   * @return {Array} JSON models
+   */
+  vc.toJSON = function() {
+    return _.map(this._models(), function(model) {
+      return model.toJSON();
+    });
+  };
+
+  /**
+   * Sorts the models in the virtual collection
+   *
+   * You only need to trigger this manually if you change the comparator
+   * @param  {Object} options
+   * @return {VirtualCollection}
+   */
+  vc.sort = function (options) {
+    var self = this;
+    if (!this.comparator) throw new Error('Cannot sort a set without a comparator');
+    options = options || {};
+
+    // Run sort based on type of `comparator`.
+    if (_.isString(this.comparator)) {
+      this.index = _.sortBy(this.index, function (cid) {
+        var model = this.collection.get(cid);
+        return model.get(this.comparator);
+      }, this);
+    } else if (this.comparator.length === 1) {
+      this.index = _.sortBy(this.index, function (cid) {
+        var model = this.collection.get(cid);
+        return this.comparator.call(self, model);
+      }, this);
+    } else {
+      this.index.sort(function (cid1, cid2) {
+        var model1 = self.collection.get(cid1),
+          model2 = self.collection.get(cid2);
+
+        return self.comparator.call(self, model1, model2);
+      });
+    }
+
+    if (!options.silent) this.trigger('sort', this, options);
+    return this;
+  };
+
+  /**
+   * Change the filter and update collection
+   *
+   * @param  {Object} hash of model attributes or {Function} filter
+   * @return {VirtualCollection}
+   */
+
+  vc.updateFilter = function(filter){
+    // Reset the filter
+    this.filterFunction = VirtualCollection.buildFilter(filter);
+
+    // Update the models
+    this._rebuildIndex();
+
+    // Trigger filter event
+    this.trigger('filter', this, filter);
+
+    // Trigger reset event
+    this.trigger('reset', this, filter);
+
+    return this;
+  };
+
+  /**
+   * A utility function for unbiding listeners
+   * @param  {View} view (marionette view)
+   */
+  vc.closeWith = function (view) {
+    view.on('close', function () {
+      this.stopListening();
+    }, this);
+  };
+
+  // private
+
+  vc._rebuildIndex = function () {
+    this.index = [];
+    this.collection.each(function (model, index) {
+      if (this.filterFunction(model, index)) {
+        this.index.push(model.cid);
+      }
+    }, this);
+    if (this.comparator) {
+      this.sort({silent: true});
+    }
+    this.length = this.index.length;
+  };
+
+  /**
+   * Returns an array of models in the virtual collection
+   * @return {Array}
+   */
+  vc._models = function () {
+    return _.map(this.index, function (cid) {
+      return this.collection.get(cid);
+    }, this);
+  };
+
+  /**
+   * Handles the collection:add event
+   * May update the virtual collection's index
+   * @param  {Model} model
+   * @return {undefined}
+   */
+  vc._onAdd = function (model, collection, options) {
+    if (this.filterFunction(model)) {
+      this._indexAdd(model);
+      this.trigger('add', model, this, options);
+    }
+  };
+
+  /**
+   * Handles the collection:remove event
+   * May update the virtual collection's index
+   * @param  {Model} model
+   * @return {undefined}
+   */
+  vc._onRemove = function (model, collection, options) {
+    if (_(this.index).contains(model.cid)) {
+      var i = this._indexRemove(model);
+      if (options) {
+        var options_clone = _.clone(options);
+        options_clone.index = i;
+      }
+
+      this.trigger('remove', model, this, options_clone);
+    }
+  };
+
+  /**
+   * Handles the collection:change event
+   * May update the virtual collection's index
+   * @param {Model} model
+   * @param {Object} object
+   */
+  vc._onChange = function (model, options) {
+    var already_here = _.contains(this.index, model.cid);
+    if (this.filterFunction(model)) {
+      if (already_here) {
+        this.trigger('change', model, this, options);
+      } else {
+        this._indexAdd(model);
+        this.trigger('add', model, this, options);
+      }
+    } else {
+      if (already_here) {
+        this._indexRemove(model);
+        this.trigger('remove', model, this, options);
+      }
+    }
+  };
+
+  /**
+   * Handles the collection:reset event
+   * @param {Collection} collection
+   * @param {Object} object
+   */
+  vc._onReset = function (collection, options) {
+    this._rebuildIndex();
+    this.trigger('reset', this, options);
+  };
+
+  /**
+   * Adds a model to the virtual collection index
+   * Inserting it in the correct order
+   * @param  {Model} model
+   * @return {undefined}
+   */
+  vc._indexAdd = function (model) {
+    if (this.index.indexOf(model.cid) === -1) {
+
+      if (!this.comparator) { // order inherit's from parent collection
+        var i, orig_index = this.collection.indexOf(model);
+        for (i = 0; i < this.length; i++) {
+          if (this.collection.indexOf(this.collection.get(this.index[i])) > orig_index) {
+            break;
+          }
+        }
+        this.index.splice(i, 0, model.cid);
+
+      } else { // the virtual collection has a custom order
+        this.index.push(model.cid);
+        this.sort({silent: true});
+      }
+      this.length = this.index.length;
+    }
+  };
+
+  /**
+   * Removes a model from the virtual collection index
+   * @param  {Model} model
+   * @return {int} the index for the removed model or -1 if not found
+   */
+  vc._indexRemove = function (model) {
+    var i = this.index.indexOf(model.cid);
+    if (i !== -1) {
+      this.index.splice(i, 1);
+      this.length = this.index.length;
+    }
+    return i;
+  };
+
+  _.extend(vc, Backbone.Events);
+
+  Backbone.VirtualCollection = VirtualCollection;
+
+  return VirtualCollection;
+}));

data/vendor/assets/javascripts/js_stack/plugins/backbone.mutators.js

@@ -1 +1 @@
-//= require js_stack/plugins/backbone/mutators/0.4.1
+//= require js_stack/plugins/backbone/mutators/0.4.2

data/vendor/assets/javascripts/js_stack/plugins/backbone.virtualcollection.js

@@ -1 +1 @@
-//= require js_stack/plugins/backbone/virtualcollection/0.4.11
+//= require js_stack/plugins/backbone/virtualcollection/0.4.12

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: js_stack
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.5.5
 platform: ruby
 authors:
 - Tomasz Pewiński
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-23 00:00:00.000000000 Z
+date: 2014-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: haml_coffee_assets
@@ -115,6 +115,7 @@ files:
 - vendor/assets/javascripts/js_stack/base/marionette/1.6.2.js
 - vendor/assets/javascripts/js_stack/base/marionette/1.6.4.js
 - vendor/assets/javascripts/js_stack/base/marionette/1.7.0.js
+- vendor/assets/javascripts/js_stack/base/marionette/1.7.3.js
 - vendor/assets/javascripts/js_stack/base/underscore.js
 - vendor/assets/javascripts/js_stack/base/underscore/1.5.2.js
 - vendor/assets/javascripts/js_stack/base/underscore/1.6.0.js
@@ -133,6 +134,7 @@ files:
 - vendor/assets/javascripts/js_stack/plugins/backbone/associations/0.6.1.js
 - vendor/assets/javascripts/js_stack/plugins/backbone/deepmodel/0.10.4.js
 - vendor/assets/javascripts/js_stack/plugins/backbone/mutators/0.4.1.js
+- vendor/assets/javascripts/js_stack/plugins/backbone/mutators/0.4.2.js
 - vendor/assets/javascripts/js_stack/plugins/backbone/pageable/1.3.2.js
 - vendor/assets/javascripts/js_stack/plugins/backbone/pageable/1.4.5.js
 - vendor/assets/javascripts/js_stack/plugins/backbone/routefilter/0.2.0.js
@@ -141,6 +143,7 @@ files:
 - vendor/assets/javascripts/js_stack/plugins/backbone/validation/0.8.1.js
 - vendor/assets/javascripts/js_stack/plugins/backbone/validation/0.9.1.js
 - vendor/assets/javascripts/js_stack/plugins/backbone/virtualcollection/0.4.11.js
+- vendor/assets/javascripts/js_stack/plugins/backbone/virtualcollection/0.4.12.js
 - vendor/assets/javascripts/js_stack/plugins/backbone/virtualcollection/0.4.5.js
 - vendor/assets/javascripts/js_stack/plugins/backbone/virtualcollection/0.4.8.js
 - vendor/assets/javascripts/js_stack/plugins/cocktail.js