laces 0.1.0

data/templates/app/assets/javascripts/lib/backbone.coffee

@@ -0,0 +1,27 @@
+#= require_self
+#= require lib/backbone/events
+#= require lib/backbone/model
+#= require lib/backbone/collection
+#= require lib/backbone/router
+#= require lib/backbone/history
+#= require lib/backbone/view
+#= require lib/backbone/sync
+#= require lib/backbone/helpers
+
+root             = this
+previousBackbone = root.Backbone
+root.Backbone    = {}
+slice            = Array::slice
+Backbone         = if typeof exports isnt "undefined" then exports else root.Backbone
+Backbone.VERSION = "0.5.3"
+
+_ = root._
+_ = require("underscore")._  if not _ and (typeof require isnt "undefined")
+$ = root.jQuery or root.Zepto or root.ender
+
+Backbone.noConflict = ->
+  root.Backbone = previousBackbone
+  this
+
+Backbone.emulateHTTP = false
+Backbone.emulateJSON = false

data/templates/app/assets/javascripts/lib/backbone/collection.js

@@ -0,0 +1,249 @@
+// Backbone.Collection
+// -------------------
+
+// Provides a standard collection class for our sets of models, ordered
+// or unordered. If a `comparator` is specified, the Collection will maintain
+// its models in sort order, as they're added and removed.
+Backbone.Collection = function(models, options) {
+  options || (options = {});
+  if (options.comparator) this.comparator = options.comparator;
+  _.bindAll(this, '_onModelEvent', '_removeReference');
+  this._reset();
+  if (models) this.reset(models, {silent: true});
+  this.initialize.apply(this, arguments);
+};
+
+// Define the Collection's inheritable methods.
+_.extend(Backbone.Collection.prototype, Backbone.Events, {
+
+  // The default model for a collection is just a **Backbone.Model**.
+  // This should be overridden in most cases.
+  model : Backbone.Model,
+
+  // Initialize is an empty function by default. Override it with your own
+  // initialization logic.
+  initialize : function(){},
+
+  // The JSON representation of a Collection is an array of the
+  // models' attributes.
+  toJSON : function() {
+    return this.map(function(model){ return model.toJSON(); });
+  },
+
+  // Add a model, or list of models to the set. Pass **silent** to avoid
+  // firing the `added` event for every new model.
+  add : function(models, options) {
+    if (_.isArray(models)) {
+      for (var i = 0, l = models.length; i < l; i++) {
+        this._add(models[i], options);
+      }
+    } else {
+      this._add(models, options);
+    }
+    return this;
+  },
+
+  // Remove a model, or a list of models from the set. Pass silent to avoid
+  // firing the `removed` event for every model removed.
+  remove : function(models, options) {
+    if (_.isArray(models)) {
+      for (var i = 0, l = models.length; i < l; i++) {
+        this._remove(models[i], options);
+      }
+    } else {
+      this._remove(models, options);
+    }
+    return this;
+  },
+
+  // Get a model from the set by id.
+  get : function(id) {
+    if (id == null) return null;
+    return this._byId[id.id != null ? id.id : id];
+  },
+
+  // Get a model from the set by client id.
+  getByCid : function(cid) {
+    return cid && this._byCid[cid.cid || cid];
+  },
+
+  // Get the model at the given index.
+  at: function(index) {
+    return this.models[index];
+  },
+
+  // Force the collection to re-sort itself. You don't need to call this under normal
+  // circumstances, as the set will maintain sort order as each item is added.
+  sort : function(options) {
+    options || (options = {});
+    if (!this.comparator) throw new Error('Cannot sort a set without a comparator');
+    this.models = this.sortBy(this.comparator);
+    if (!options.silent) this.trigger('reset', this, options);
+    return this;
+  },
+
+  // Pluck an attribute from each model in the collection.
+  pluck : function(attr) {
+    return _.map(this.models, function(model){ return model.get(attr); });
+  },
+
+  // When you have more items than you want to add or remove individually,
+  // you can reset the entire set with a new list of models, without firing
+  // any `added` or `removed` events. Fires `reset` when finished.
+  reset : function(models, options) {
+    models  || (models = []);
+    options || (options = {});
+    this.each(this._removeReference);
+    this._reset();
+    this.add(models, {silent: true});
+    if (!options.silent) this.trigger('reset', this, options);
+    return this;
+  },
+
+  // Fetch the default set of models for this collection, resetting the
+  // collection when they arrive. If `add: true` is passed, appends the
+  // models to the collection instead of resetting.
+  fetch : function(options) {
+    options || (options = {});
+    var collection = this;
+    var success = options.success;
+    var parse   = options.parse;
+    options.success = function(resp, status, xhr) {
+      if (parse)
+        parse_results = parse.call(collection, resp, xhr);
+      else
+        parse_results = collection.parse(resp, xhr);
+      collection[options.add ? 'add' : 'reset'](parse_results, options);
+      if (success) success(collection, resp);
+    };
+    options.error = wrapError(options.error, collection, options);
+    return (this.sync || Backbone.sync).call(this, 'read', this, options);
+  },
+
+  // Create a new instance of a model in this collection. After the model
+  // has been created on the server, it will be added to the collection.
+  // Returns the model, or 'false' if validation on a new model fails.
+  create : function(model, options) {
+    var coll = this;
+    options || (options = {});
+    model = this._prepareModel(model, options);
+    if (!model) return false;
+    var success = options.success;
+    options.success = function(nextModel, resp, xhr) {
+      coll.add(nextModel, options);
+      if (success) success(nextModel, resp, xhr);
+    };
+    model.save(null, options);
+    return model;
+  },
+
+  // **parse** converts a response into a list of models to be added to the
+  // collection. The default implementation is just to pass it through.
+  parse : function(resp, xhr) {
+    return resp;
+  },
+
+  // Proxy to _'s chain. Can't be proxied the same way the rest of the
+  // underscore methods are proxied because it relies on the underscore
+  // constructor.
+  chain: function () {
+    return _(this.models).chain();
+  },
+
+  // Reset all internal state. Called when the collection is reset.
+  _reset : function(options) {
+    this.length = 0;
+    this.models = [];
+    this._byId  = {};
+    this._byCid = {};
+  },
+
+  // Prepare a model to be added to this collection
+  _prepareModel: function(model, options) {
+    if (!(model instanceof Backbone.Model)) {
+      var attrs = model;
+      model = new this.model(attrs, {collection: this});
+      if (model.validate && !model._performValidation(model.attributes, options)) model = false;
+    } else if (!model.collection) {
+      model.collection = this;
+    }
+    return model;
+  },
+
+  // Internal implementation of adding a single model to the set, updating
+  // hash indexes for `id` and `cid` lookups.
+  // Returns the model, or 'false' if validation on a new model fails.
+  _add : function(model, options) {
+    options || (options = {});
+    model = this._prepareModel(model, options);
+    if (!model) return false;
+    var already = this.getByCid(model);
+    if (already) throw new Error(["Can't add the same model to a set twice", already.id]);
+    this._byId[model.id] = model;
+    this._byCid[model.cid] = model;
+    var index = options.at != null ? options.at :
+                this.comparator ? this.sortedIndex(model, this.comparator) :
+                this.length;
+    this.models.splice(index, 0, model);
+    model.bind('all', this._onModelEvent);
+    this.length++;
+    options.index = index;
+    if (!options.silent) model.trigger('add', model, this, options);
+    return model;
+  },
+
+  // Internal implementation of removing a single model from the set, updating
+  // hash indexes for `id` and `cid` lookups.
+  _remove : function(model, options) {
+    options || (options = {});
+    model = this.getByCid(model) || this.get(model);
+    if (!model) return null;
+    delete this._byId[model.id];
+    delete this._byCid[model.cid];
+    var index = this.indexOf(model);
+    this.models.splice(index, 1);
+    this.length--;
+    options.index = index;
+    if (!options.silent) model.trigger('remove', model, this, options);
+    this._removeReference(model);
+    return model;
+  },
+
+  // Internal method to remove a model's ties to a collection.
+  _removeReference : function(model) {
+    if (this == model.collection) {
+      delete model.collection;
+    }
+    model.unbind('all', this._onModelEvent);
+  },
+
+  // Internal method called every time a model in the set fires an event.
+  // Sets need to update their indexes when models change ids. All other
+  // events simply proxy through. "add" and "remove" events that originate
+  // in other collections are ignored.
+  _onModelEvent : function(ev, model, collection, options) {
+    if ((ev == 'add' || ev == 'remove') && collection != this) return;
+    if (ev == 'destroy') {
+      this._remove(model, options);
+    }
+    if (model && ev === 'change:' + model.idAttribute) {
+      delete this._byId[model.previous(model.idAttribute)];
+      this._byId[model.id] = model;
+    }
+    this.trigger.apply(this, arguments);
+  }
+
+});
+
+// Underscore methods that we want to implement on the Collection.
+var methods = ['forEach', 'each', 'map', 'reduce', 'reduceRight', 'find', 'detect',
+  'filter', 'select', 'reject', 'every', 'all', 'some', 'any', 'include',
+  'contains', 'invoke', 'max', 'min', 'sortBy', 'sortedIndex', 'toArray', 'size',
+  'first', 'rest', 'last', 'without', 'indexOf', 'lastIndexOf', 'isEmpty', 'groupBy'];
+
+// Mix in each Underscore method as a proxy to `Collection#models`.
+_.each(methods, function(method) {
+  Backbone.Collection.prototype[method] = function() {
+    return _[method].apply(_, [this.models].concat(_.toArray(arguments)));
+  };
+});

data/templates/app/assets/javascripts/lib/backbone/events.js

@@ -0,0 +1,64 @@
+ // Backbone.Events
+  // -----------------
+
+  // A module that can be mixed in to *any object* in order to provide it with
+  // custom events. You may `bind` or `unbind` a callback function to an event;
+  // `trigger`-ing an event fires all callbacks in succession.
+  //
+  //     var object = {};
+  //     _.extend(object, Backbone.Events);
+  //     object.bind('expand', function(){ alert('expanded'); });
+  //     object.trigger('expand');
+  //
+  Backbone.Events = {
+
+    // Bind an event, specified by a string name, `ev`, to a `callback` function.
+    // Passing `"all"` will bind the callback to all events fired.
+    bind : function(ev, callback, context) {
+      var calls = this._callbacks || (this._callbacks = {});
+      var list  = calls[ev] || (calls[ev] = {});
+      var tail = list.tail || (list.tail = list.next = {});
+      tail.callback = callback;
+      tail.context = context;
+      list.tail = tail.next = {};
+      return this;
+    },
+
+    // Remove one or many callbacks. If `callback` is null, removes all
+    // callbacks for the event. If `ev` is null, removes all bound callbacks
+    // for all events.
+    unbind : function(ev, callback) {
+      var calls, node, prev;
+      if (!ev) {
+        this._callbacks = null;
+      } else if (calls = this._callbacks) {
+        if (!callback) {
+          calls[ev] = {};
+        } else if (node = calls[ev]) {
+          while ((prev = node) && (node = node.next)) {
+            if (node.callback !== callback) continue;
+            prev.next = node.next;
+            node.context = node.callback = null;
+            break;
+          }
+        }
+      }
+      return this;
+    },
+
+    // Trigger an event, firing all bound callbacks. Callbacks are passed the
+    // same arguments as `trigger` is, apart from the event name.
+    // Listening for `"all"` passes the true event name as the first argument.
+    trigger : function(eventName) {
+      var node, calls, callback, args, ev, events = ['all', eventName];
+      if (!(calls = this._callbacks)) return this;
+      while (ev = events.pop()) {
+        if (!(node = calls[ev])) continue;
+        args = ev == 'all' ? arguments : Array.prototype.slice.call(arguments, 1);
+        while (node = node.next) if (callback = node.callback) callback.apply(node.context || this, args);
+      }
+      return this;
+    }
+
+  };
+

data/templates/app/assets/javascripts/lib/backbone/helpers.js

@@ -0,0 +1,68 @@
+// Helpers
+// -------
+
+// Shared empty constructor function to aid in prototype-chain creation.
+var ctor = function(){};
+
+// Helper function to correctly set up the prototype chain, for subclasses.
+// Similar to `goog.inherits`, but uses a hash of prototype properties and
+// class properties to be extended.
+var inherits = function(parent, protoProps, staticProps) {
+  var child;
+
+  // The constructor function for the new subclass is either defined by you
+  // (the "constructor" property in your `extend` definition), or defaulted
+  // by us to simply call `super()`.
+  if (protoProps && protoProps.hasOwnProperty('constructor')) {
+    child = protoProps.constructor;
+  } else {
+    child = function(){ return parent.apply(this, arguments); };
+  }
+
+  // Inherit class (static) properties from parent.
+  _.extend(child, parent);
+
+  // Set the prototype chain to inherit from `parent`, without calling
+  // `parent`'s constructor function.
+  ctor.prototype = parent.prototype;
+  child.prototype = new ctor();
+
+  // Add prototype properties (instance properties) to the subclass,
+  // if supplied.
+  if (protoProps) _.extend(child.prototype, protoProps);
+
+  // Add static properties to the constructor function, if supplied.
+  if (staticProps) _.extend(child, staticProps);
+
+  // Correctly set child's `prototype.constructor`.
+  child.prototype.constructor = child;
+
+  // Set a convenience property in case the parent's prototype is needed later.
+  child.__super__ = parent.prototype;
+
+  return child;
+};
+
+// Helper function to get a URL from a Model or Collection as a property
+// or as a function.
+var getUrl = function(object) {
+  if (!(object && object.url)) return null;
+  return _.isFunction(object.url) ? object.url() : object.url;
+};
+
+// Throw an error when a URL is needed, and none is supplied.
+var urlError = function() {
+  throw new Error('A "url" property or function must be specified');
+};
+
+// Wrap an optional error callback with a fallback error event.
+var wrapError = function(onError, originalModel, options) {
+  return function(model, resp) {
+    var resp = model === originalModel ? resp : model;
+    if (onError) {
+      onError(model, resp, options);
+    } else {
+      model.trigger('error', model, resp, options);
+    }
+  };
+};

data/templates/app/assets/javascripts/lib/backbone/history.js

@@ -0,0 +1,144 @@
+// Backbone.History
+// ----------------
+
+// Handles cross-browser history management, based on URL fragments. If the
+// browser does not support `onhashchange`, falls back to polling.
+Backbone.History = function() {
+  this.handlers = [];
+  _.bindAll(this, 'checkUrl');
+};
+
+// Cached regex for cleaning hashes.
+var hashStrip = /^#*/;
+
+// Cached regex for detecting MSIE.
+var isExplorer = /msie [\w.]+/;
+
+// Has the history handling already been started?
+var historyStarted = false;
+
+// Set up all inheritable **Backbone.History** properties and methods.
+_.extend(Backbone.History.prototype, {
+
+  // The default interval to poll for hash changes, if necessary, is
+  // twenty times a second.
+  interval: 50,
+
+  // Get the cross-browser normalized URL fragment, either from the URL,
+  // the hash, or the override.
+  getFragment : function(fragment, forcePushState) {
+    if (fragment == null) {
+      if (this._hasPushState || forcePushState) {
+        fragment = window.location.pathname;
+        var search = window.location.search;
+        if (search) fragment += search;
+      } else {
+        fragment = window.location.hash;
+      }
+    }
+    fragment = decodeURIComponent(fragment.replace(hashStrip, ''));
+    if (!fragment.indexOf(this.options.root)) fragment = fragment.substr(this.options.root.length);
+    return fragment;
+  },
+
+  // Start the hash change handling, returning `true` if the current URL matches
+  // an existing route, and `false` otherwise.
+  start : function(options) {
+
+    // Figure out the initial configuration. Do we need an iframe?
+    // Is pushState desired ... is it available?
+    if (historyStarted) throw new Error("Backbone.history has already been started");
+    this.options          = _.extend({}, {root: '/'}, this.options, options);
+    this._wantsPushState  = !!this.options.pushState;
+    this._hasPushState    = !!(this.options.pushState && window.history && window.history.pushState);
+    var fragment          = this.getFragment();
+    var docMode           = document.documentMode;
+    var oldIE             = (isExplorer.exec(navigator.userAgent.toLowerCase()) && (!docMode || docMode <= 7));
+    if (oldIE) {
+      this.iframe = $('<iframe src="javascript:0" tabindex="-1" />').hide().appendTo('body')[0].contentWindow;
+      this.navigate(fragment);
+    }
+
+    // Depending on whether we're using pushState or hashes, and whether
+    // 'onhashchange' is supported, determine how we check the URL state.
+    if (this._hasPushState) {
+      $(window).bind('popstate', this.checkUrl);
+    } else if ('onhashchange' in window && !oldIE) {
+      $(window).bind('hashchange', this.checkUrl);
+    } else {
+      setInterval(this.checkUrl, this.interval);
+    }
+
+    // Determine if we need to change the base url, for a pushState link
+    // opened by a non-pushState browser.
+    this.fragment = fragment;
+    historyStarted = true;
+    var loc = window.location;
+    var atRoot  = loc.pathname == this.options.root;
+    if (this._wantsPushState && !this._hasPushState && !atRoot) {
+      this.fragment = this.getFragment(null, true);
+      window.location.replace(this.options.root + '#' + this.fragment);
+      // Return immediately as browser will do redirect to new url
+      return true;
+    } else if (this._wantsPushState && this._hasPushState && atRoot && loc.hash) {
+      this.fragment = loc.hash.replace(hashStrip, '');
+      window.history.replaceState({}, document.title, loc.protocol + '//' + loc.host + this.options.root + this.fragment);
+    }
+
+    if (!this.options.silent) {
+      return this.loadUrl();
+    }
+  },
+
+  // Add a route to be tested when the fragment changes. Routes added later may
+  // override previous routes.
+  route : function(route, callback) {
+    this.handlers.unshift({route : route, callback : callback});
+  },
+
+  // Checks the current URL to see if it has changed, and if it has,
+  // calls `loadUrl`, normalizing across the hidden iframe.
+  checkUrl : function(e) {
+    var current = this.getFragment();
+    if (current == this.fragment && this.iframe) current = this.getFragment(this.iframe.location.hash);
+    if (current == this.fragment || current == decodeURIComponent(this.fragment)) return false;
+    if (this.iframe) this.navigate(current);
+    this.loadUrl() || this.loadUrl(window.location.hash);
+  },
+
+  // Attempt to load the current URL fragment. If a route succeeds with a
+  // match, returns `true`. If no defined routes matches the fragment,
+  // returns `false`.
+  loadUrl : function(fragmentOverride) {
+    var fragment = this.fragment = this.getFragment(fragmentOverride);
+    var matched = _.any(this.handlers, function(handler) {
+      if (handler.route.test(fragment)) {
+        handler.callback(fragment);
+        return true;
+      }
+    });
+    return matched;
+  },
+
+  // Save a fragment into the hash history. You are responsible for properly
+  // URL-encoding the fragment in advance. This does not trigger
+  // a `hashchange` event.
+  navigate : function(fragment, triggerRoute) {
+    var frag = (fragment || '').replace(hashStrip, '');
+    if (this.fragment == frag || this.fragment == decodeURIComponent(frag)) return;
+    if (this._hasPushState) {
+      var loc = window.location;
+      if (frag.indexOf(this.options.root) != 0) frag = this.options.root + frag;
+      this.fragment = frag;
+      window.history.pushState({}, document.title, loc.protocol + '//' + loc.host + frag);
+    } else {
+      window.location.hash = this.fragment = frag;
+      if (this.iframe && (frag != this.getFragment(this.iframe.location.hash))) {
+        this.iframe.document.open().close();
+        this.iframe.location.hash = frag;
+      }
+    }
+    if (triggerRoute) this.loadUrl(fragment);
+  }
+
+});