js_stack 0.0.1

data/vendor/assets/javascripts/js_stack/backbone.virtualcollection/backbone.virtualcollection-0.4.5.js

@@ -0,0 +1,293 @@
+(function (global) {
+  'use strict';
+
+  var _ = global._, Backbone = global.Backbone, vc, iterators;
+
+  if ((!_  || !Backbone) && (typeof require !== 'undefined')) {
+    _ = require('underscore');
+    Backbone = require('backbone');
+  }
+
+  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'];
+
+  /**
+   * 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');
+
+    if (!options.filter) {
+      this.filter = function () { return true; };
+    } else if (_.isFunction(options.filter)) {
+      this.filter = options.filter;
+    } else if (options.filter.constructor === Object) {
+      this.filter = VirtualCollection.buildFilterFromHash(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
+   * @return {Function} filtering function
+   */
+  VirtualCollection.buildFilterFromHash = function (hash) {
+    return function (model) {
+      return !Boolean(_(Object.keys(hash)).detect(function (key) {
+        return model.get(key) !== hash[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);
+    };
+  });
+
+  /**
+   * 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.filter(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]);
+  };
+
+  /**
+   * 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);
+  };
+
+  /**
+   * 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;
+  };
+
+  /**
+   * 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) {
+      if (this.filter(model)) {
+        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.filter(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)) {
+      this._indexRemove(model);
+      this.trigger('remove', model, this, options);
+    }
+  };
+
+  /**
+   * 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.filter(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 {undefined}
+   */
+  vc._indexRemove = function (model) {
+    var i = this.index.indexOf(model.cid);
+    if (i !== -1) {
+      this.index.splice(i, 1);
+      this.length = this.index.length;
+    }
+  };
+
+  if (!_ && (typeof require !== 'undefined')) {
+    _ = require('underscore');
+  }
+  if (!Backbone && (typeof require !== 'undefined')) {
+    Backbone = require('backbone');
+  }
+  if (typeof module !== 'undefined' && module.exports) {
+    module.exports = VirtualCollection;
+  }
+  _.extend(vc, Backbone.Events);
+
+  Backbone.VirtualCollection = VirtualCollection;
+
+}(this));

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

@@ -0,0 +1 @@
+//= require js_stack/backbone.virtualcollection/backbone.virtualcollection-0.4.5

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

@@ -0,0 +1 @@
+//= require backbone.marionette

data/vendor/assets/javascripts/js_stack.js

@@ -0,0 +1,8 @@
+//= require js_stack/backbone
+//= require js_stack/backbone.stickit
+//= require js_stack/marionette
+//= require js_stack/backbone.validation
+//= require js_stack/backbone.pageable
+//= require js_stack/backbone.deepmodel
+//= require js_stack/backbone.associations
+//= require js_stack/backbone.virtualcollection

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: js_stack
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tomasz Pewiński
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: backbone-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.1
+- !ruby/object:Gem::Dependency
+  name: marionette-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: standard SPA stack used at netguru.co
+email:
+- pewniak747@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- js_stack.gemspec
+- js_stack/.gitignore
+- lib/js_stack.rb
+- lib/js_stack/version.rb
+- vendor/assets/javascripts/js_stack.js
+- vendor/assets/javascripts/js_stack/backbone.associations.js
+- vendor/assets/javascripts/js_stack/backbone.associations/backbone.associations-0.5.1.js
+- vendor/assets/javascripts/js_stack/backbone.deepmodel.js
+- vendor/assets/javascripts/js_stack/backbone.deepmodel/backbone.deepmodel-0.10.4.js
+- vendor/assets/javascripts/js_stack/backbone.js
+- vendor/assets/javascripts/js_stack/backbone.pageable.js
+- vendor/assets/javascripts/js_stack/backbone.pageable/backbone.pageable-1.3.2.js
+- vendor/assets/javascripts/js_stack/backbone.stickit.js
+- vendor/assets/javascripts/js_stack/backbone.stickit/backbone.stickit-0.6.3.js
+- vendor/assets/javascripts/js_stack/backbone.validation.js
+- vendor/assets/javascripts/js_stack/backbone.validation/backbone.validation-0.8.1.js
+- vendor/assets/javascripts/js_stack/backbone.virtualcollection.js
+- vendor/assets/javascripts/js_stack/backbone.virtualcollection/backbone.virtualcollection-0.4.5.js
+- vendor/assets/javascripts/js_stack/marionette.js
+homepage: https://github.com/netguru/js_stack
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: standard SPA stack used at netguru.co
+test_files: []