spine_paginator 0.1.0

data/spec/lib/spine.js

@@ -0,0 +1,1184 @@
+// Generated by CoffeeScript 1.6.2
+(function() {
+  var $, Controller, Events, Log, Model, Module, Spine, createObject, isArray, isBlank, makeArray, moduleKeywords,
+    __slice = [].slice,
+    __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; },
+    __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+
+  Events = {
+    bind: function(ev, callback) {
+      var calls, evs, name, _i, _len;
+
+      evs = ev.split(' ');
+      calls = this.hasOwnProperty('_callbacks') && this._callbacks || (this._callbacks = {});
+      for (_i = 0, _len = evs.length; _i < _len; _i++) {
+        name = evs[_i];
+        calls[name] || (calls[name] = []);
+        calls[name].push(callback);
+      }
+      return this;
+    },
+    one: function(ev, callback) {
+      var handler;
+
+      return this.bind(ev, handler = function() {
+        this.unbind(ev, handler);
+        return callback.apply(this, arguments);
+      });
+    },
+    trigger: function() {
+      var args, callback, ev, list, _i, _len, _ref;
+
+      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      ev = args.shift();
+      list = this.hasOwnProperty('_callbacks') && ((_ref = this._callbacks) != null ? _ref[ev] : void 0);
+      if (!list) {
+        return;
+      }
+      for (_i = 0, _len = list.length; _i < _len; _i++) {
+        callback = list[_i];
+        if (callback.apply(this, args) === false) {
+          break;
+        }
+      }
+      return true;
+    },
+    listenTo: function(obj, ev, callback) {
+      obj.bind(ev, callback);
+      this.listeningTo || (this.listeningTo = []);
+      this.listeningTo.push(obj);
+      return this;
+    },
+    listenToOnce: function(obj, ev, callback) {
+      var listeningToOnce;
+
+      listeningToOnce = this.listeningToOnce || (this.listeningToOnce = []);
+      listeningToOnce.push(obj);
+      obj.one(ev, function() {
+        var idx;
+
+        idx = listeningToOnce.indexOf(obj);
+        if (idx !== -1) {
+          listeningToOnce.splice(idx, 1);
+        }
+        return callback.apply(this, arguments);
+      });
+      return this;
+    },
+    stopListening: function(obj, ev, callback) {
+      var idx, listeningTo, retain, _i, _j, _k, _len, _len1, _len2, _ref, _ref1, _results;
+
+      if (arguments.length === 0) {
+        retain = [];
+        _ref = [this.listeningTo, this.listeningToOnce];
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          listeningTo = _ref[_i];
+          if (!listeningTo) {
+            continue;
+          }
+          for (_j = 0, _len1 = listeningTo.length; _j < _len1; _j++) {
+            obj = listeningTo[_j];
+            if (!(!(__indexOf.call(retain, obj) >= 0))) {
+              continue;
+            }
+            obj.unbind();
+            retain.push(obj);
+          }
+        }
+        this.listeningTo = void 0;
+        return this.listeningToOnce = void 0;
+      } else if (obj) {
+        if (ev) {
+          obj.unbind(ev, callback);
+        }
+        if (!ev) {
+          obj.unbind();
+        }
+        _ref1 = [this.listeningTo, this.listeningToOnce];
+        _results = [];
+        for (_k = 0, _len2 = _ref1.length; _k < _len2; _k++) {
+          listeningTo = _ref1[_k];
+          if (!listeningTo) {
+            continue;
+          }
+          idx = listeningTo.indexOf(obj);
+          if (idx !== -1) {
+            _results.push(listeningTo.splice(idx, 1));
+          } else {
+            _results.push(void 0);
+          }
+        }
+        return _results;
+      }
+    },
+    unbind: function(ev, callback) {
+      var cb, evs, i, list, name, _i, _j, _len, _len1, _ref;
+
+      if (arguments.length === 0) {
+        this._callbacks = {};
+        return this;
+      }
+      if (!ev) {
+        return this;
+      }
+      evs = ev.split(' ');
+      for (_i = 0, _len = evs.length; _i < _len; _i++) {
+        name = evs[_i];
+        list = (_ref = this._callbacks) != null ? _ref[name] : void 0;
+        if (!list) {
+          continue;
+        }
+        if (!callback) {
+          delete this._callbacks[name];
+          continue;
+        }
+        for (i = _j = 0, _len1 = list.length; _j < _len1; i = ++_j) {
+          cb = list[i];
+          if (!(cb === callback)) {
+            continue;
+          }
+          list = list.slice();
+          list.splice(i, 1);
+          this._callbacks[name] = list;
+          break;
+        }
+      }
+      return this;
+    }
+  };
+
+  Events.on = Events.bind;
+
+  Events.off = Events.unbind;
+
+  Log = {
+    trace: true,
+    logPrefix: '(App)',
+    log: function() {
+      var args;
+
+      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      if (!this.trace) {
+        return;
+      }
+      if (this.logPrefix) {
+        args.unshift(this.logPrefix);
+      }
+      if (typeof console !== "undefined" && console !== null) {
+        if (typeof console.log === "function") {
+          console.log.apply(console, args);
+        }
+      }
+      return this;
+    }
+  };
+
+  moduleKeywords = ['included', 'extended'];
+
+  Module = (function() {
+    Module.include = function(obj) {
+      var key, value, _ref;
+
+      if (!obj) {
+        throw new Error('include(obj) requires obj');
+      }
+      for (key in obj) {
+        value = obj[key];
+        if (__indexOf.call(moduleKeywords, key) < 0) {
+          this.prototype[key] = value;
+        }
+      }
+      if ((_ref = obj.included) != null) {
+        _ref.apply(this);
+      }
+      return this;
+    };
+
+    Module.extend = function(obj) {
+      var key, value, _ref;
+
+      if (!obj) {
+        throw new Error('extend(obj) requires obj');
+      }
+      for (key in obj) {
+        value = obj[key];
+        if (__indexOf.call(moduleKeywords, key) < 0) {
+          this[key] = value;
+        }
+      }
+      if ((_ref = obj.extended) != null) {
+        _ref.apply(this);
+      }
+      return this;
+    };
+
+    Module.proxy = function(func) {
+      var _this = this;
+
+      return function() {
+        return func.apply(_this, arguments);
+      };
+    };
+
+    Module.prototype.proxy = function(func) {
+      var _this = this;
+
+      return function() {
+        return func.apply(_this, arguments);
+      };
+    };
+
+    function Module() {
+      if (typeof this.init === "function") {
+        this.init.apply(this, arguments);
+      }
+    }
+
+    return Module;
+
+  })();
+
+  Model = (function(_super) {
+    __extends(Model, _super);
+
+    Model.extend(Events);
+
+    Model.records = [];
+
+    Model.irecords = {};
+
+    Model.crecords = {};
+
+    Model.attributes = [];
+
+    Model.configure = function() {
+      var attributes, name;
+
+      name = arguments[0], attributes = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+      this.className = name;
+      this.deleteAll();
+      if (attributes.length) {
+        this.attributes = attributes;
+      }
+      this.attributes && (this.attributes = makeArray(this.attributes));
+      this.attributes || (this.attributes = []);
+      this.unbind();
+      return this;
+    };
+
+    Model.toString = function() {
+      return "" + this.className + "(" + (this.attributes.join(", ")) + ")";
+    };
+
+    Model.find = function(id) {
+      var record;
+
+      record = this.exists(id);
+      if (!record) {
+        throw new Error("\"" + this.className + "\" model could not find a record for the ID \"" + id + "\"");
+      }
+      return record;
+    };
+
+    Model.exists = function(id) {
+      var _ref, _ref1;
+
+      return (_ref = (_ref1 = this.irecords[id]) != null ? _ref1 : this.crecords[id]) != null ? _ref.clone() : void 0;
+    };
+
+    Model.refresh = function(values, options) {
+      var record, records, result, _i, _len;
+
+      if (options == null) {
+        options = {};
+      }
+      if (options.clear) {
+        this.deleteAll();
+      }
+      records = this.fromJSON(values);
+      if (!isArray(records)) {
+        records = [records];
+      }
+      for (_i = 0, _len = records.length; _i < _len; _i++) {
+        record = records[_i];
+        if (record.id && this.irecords[record.id]) {
+          this.records[this.records.indexOf(this.irecords[record.id])] = record;
+        } else {
+          record.id || (record.id = record.cid);
+          this.records.push(record);
+        }
+        this.irecords[record.id] = record;
+        this.crecords[record.cid] = record;
+      }
+      this.sort();
+      result = this.cloneArray(records);
+      this.trigger('refresh', this.cloneArray(records));
+      return result;
+    };
+
+    Model.select = function(callback) {
+      var record, _i, _len, _ref, _results;
+
+      _ref = this.records;
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        record = _ref[_i];
+        if (callback(record)) {
+          _results.push(record.clone());
+        }
+      }
+      return _results;
+    };
+
+    Model.findByAttribute = function(name, value) {
+      var record, _i, _len, _ref;
+
+      _ref = this.records;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        record = _ref[_i];
+        if (record[name] === value) {
+          return record.clone();
+        }
+      }
+      return null;
+    };
+
+    Model.findAllByAttribute = function(name, value) {
+      return this.select(function(item) {
+        return item[name] === value;
+      });
+    };
+
+    Model.each = function(callback) {
+      var record, _i, _len, _ref, _results;
+
+      _ref = this.records;
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        record = _ref[_i];
+        _results.push(callback(record.clone()));
+      }
+      return _results;
+    };
+
+    Model.all = function() {
+      return this.cloneArray(this.records);
+    };
+
+    Model.first = function() {
+      var _ref;
+
+      return (_ref = this.records[0]) != null ? _ref.clone() : void 0;
+    };
+
+    Model.last = function() {
+      var _ref;
+
+      return (_ref = this.records[this.records.length - 1]) != null ? _ref.clone() : void 0;
+    };
+
+    Model.count = function() {
+      return this.records.length;
+    };
+
+    Model.deleteAll = function() {
+      this.records = [];
+      this.irecords = {};
+      return this.crecords = {};
+    };
+
+    Model.destroyAll = function(options) {
+      var record, _i, _len, _ref, _results;
+
+      _ref = this.records;
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        record = _ref[_i];
+        _results.push(record.destroy(options));
+      }
+      return _results;
+    };
+
+    Model.update = function(id, atts, options) {
+      return this.find(id).updateAttributes(atts, options);
+    };
+
+    Model.create = function(atts, options) {
+      var record;
+
+      record = new this(atts);
+      return record.save(options);
+    };
+
+    Model.destroy = function(id, options) {
+      return this.find(id).destroy(options);
+    };
+
+    Model.change = function(callbackOrParams) {
+      if (typeof callbackOrParams === 'function') {
+        return this.bind('change', callbackOrParams);
+      } else {
+        return this.trigger.apply(this, ['change'].concat(__slice.call(arguments)));
+      }
+    };
+
+    Model.fetch = function(callbackOrParams) {
+      if (typeof callbackOrParams === 'function') {
+        return this.bind('fetch', callbackOrParams);
+      } else {
+        return this.trigger.apply(this, ['fetch'].concat(__slice.call(arguments)));
+      }
+    };
+
+    Model.toJSON = function() {
+      return this.records;
+    };
+
+    Model.fromJSON = function(objects) {
+      var value, _i, _len, _results;
+
+      if (!objects) {
+        return;
+      }
+      if (typeof objects === 'string') {
+        objects = JSON.parse(objects);
+      }
+      if (isArray(objects)) {
+        _results = [];
+        for (_i = 0, _len = objects.length; _i < _len; _i++) {
+          value = objects[_i];
+          _results.push(new this(value));
+        }
+        return _results;
+      } else {
+        return new this(objects);
+      }
+    };
+
+    Model.fromForm = function() {
+      var _ref;
+
+      return (_ref = new this).fromForm.apply(_ref, arguments);
+    };
+
+    Model.sort = function() {
+      if (this.comparator) {
+        this.records.sort(this.comparator);
+      }
+      return this.records;
+    };
+
+    Model.cloneArray = function(array) {
+      var value, _i, _len, _results;
+
+      _results = [];
+      for (_i = 0, _len = array.length; _i < _len; _i++) {
+        value = array[_i];
+        _results.push(value.clone());
+      }
+      return _results;
+    };
+
+    Model.idCounter = 0;
+
+    Model.uid = function(prefix) {
+      var uid;
+
+      if (prefix == null) {
+        prefix = '';
+      }
+      uid = prefix + this.idCounter++;
+      if (this.exists(uid)) {
+        uid = this.uid(prefix);
+      }
+      return uid;
+    };
+
+    function Model(atts) {
+      Model.__super__.constructor.apply(this, arguments);
+      if (atts) {
+        this.load(atts);
+      }
+      this.cid = this.constructor.uid('c-');
+    }
+
+    Model.prototype.isNew = function() {
+      return !this.exists();
+    };
+
+    Model.prototype.isValid = function() {
+      return !this.validate();
+    };
+
+    Model.prototype.validate = function() {};
+
+    Model.prototype.load = function(atts) {
+      var key, value;
+
+      if (atts.id) {
+        this.id = atts.id;
+      }
+      for (key in atts) {
+        value = atts[key];
+        if (atts.hasOwnProperty(key) && typeof this[key] === 'function') {
+          this[key](value);
+        } else {
+          this[key] = value;
+        }
+      }
+      return this;
+    };
+
+    Model.prototype.attributes = function() {
+      var key, result, _i, _len, _ref;
+
+      result = {};
+      _ref = this.constructor.attributes;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        key = _ref[_i];
+        if (key in this) {
+          if (typeof this[key] === 'function') {
+            result[key] = this[key]();
+          } else {
+            result[key] = this[key];
+          }
+        }
+      }
+      if (this.id) {
+        result.id = this.id;
+      }
+      return result;
+    };
+
+    Model.prototype.eql = function(rec) {
+      return !!(rec && rec.constructor === this.constructor && (rec.cid === this.cid) || (rec.id && rec.id === this.id));
+    };
+
+    Model.prototype.save = function(options) {
+      var error, record;
+
+      if (options == null) {
+        options = {};
+      }
+      if (options.validate !== false) {
+        error = this.validate();
+        if (error) {
+          this.trigger('error', error);
+          return false;
+        }
+      }
+      this.trigger('beforeSave', options);
+      record = this.isNew() ? this.create(options) : this.update(options);
+      this.stripCloneAttrs();
+      this.trigger('save', options);
+      return record;
+    };
+
+    Model.prototype.stripCloneAttrs = function() {
+      var key, value;
+
+      if (this.hasOwnProperty('cid')) {
+        return;
+      }
+      for (key in this) {
+        if (!__hasProp.call(this, key)) continue;
+        value = this[key];
+        if (this.constructor.attributes.indexOf(key) > -1) {
+          delete this[key];
+        }
+      }
+      return this;
+    };
+
+    Model.prototype.updateAttribute = function(name, value, options) {
+      var atts;
+
+      atts = {};
+      atts[name] = value;
+      return this.updateAttributes(atts, options);
+    };
+
+    Model.prototype.updateAttributes = function(atts, options) {
+      this.load(atts);
+      return this.save(options);
+    };
+
+    Model.prototype.changeID = function(id) {
+      var records;
+
+      records = this.constructor.irecords;
+      records[id] = records[this.id];
+      delete records[this.id];
+      this.id = id;
+      return this.save();
+    };
+
+    Model.prototype.destroy = function(options) {
+      var i, record, records, _i, _len;
+
+      if (options == null) {
+        options = {};
+      }
+      this.trigger('beforeDestroy', options);
+      records = this.constructor.records.slice(0);
+      for (i = _i = 0, _len = records.length; _i < _len; i = ++_i) {
+        record = records[i];
+        if (!(this.eql(record))) {
+          continue;
+        }
+        records.splice(i, 1);
+        break;
+      }
+      this.constructor.records = records;
+      delete this.constructor.irecords[this.id];
+      delete this.constructor.crecords[this.cid];
+      this.destroyed = true;
+      this.trigger('destroy', options);
+      this.trigger('change', 'destroy', options);
+      if (this.listeningTo) {
+        this.stopListening();
+      }
+      this.unbind();
+      return this;
+    };
+
+    Model.prototype.dup = function(newRecord) {
+      var result;
+
+      result = new this.constructor(this.attributes());
+      if (newRecord === false) {
+        result.cid = this.cid;
+      } else {
+        delete result.id;
+      }
+      return result;
+    };
+
+    Model.prototype.clone = function() {
+      return createObject(this);
+    };
+
+    Model.prototype.reload = function() {
+      var original;
+
+      if (this.isNew()) {
+        return this;
+      }
+      original = this.constructor.find(this.id);
+      this.load(original.attributes());
+      return original;
+    };
+
+    Model.prototype.toJSON = function() {
+      return this.attributes();
+    };
+
+    Model.prototype.toString = function() {
+      return "<" + this.constructor.className + " (" + (JSON.stringify(this)) + ")>";
+    };
+
+    Model.prototype.fromForm = function(form) {
+      var checkbox, key, name, result, _i, _j, _k, _len, _len1, _len2, _name, _ref, _ref1, _ref2;
+
+      result = {};
+      _ref = $(form).find('[type=checkbox]:not([value])');
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        checkbox = _ref[_i];
+        result[checkbox.name] = $(checkbox).prop('checked');
+      }
+      _ref1 = $(form).find('[type=checkbox][name$="[]"]');
+      for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
+        checkbox = _ref1[_j];
+        name = checkbox.name.replace(/\[\]$/, '');
+        result[name] || (result[name] = []);
+        if ($(checkbox).prop('checked')) {
+          result[name].push(checkbox.value);
+        }
+      }
+      _ref2 = $(form).serializeArray();
+      for (_k = 0, _len2 = _ref2.length; _k < _len2; _k++) {
+        key = _ref2[_k];
+        result[_name = key.name] || (result[_name] = key.value);
+      }
+      return this.load(result);
+    };
+
+    Model.prototype.exists = function() {
+      return this.constructor.exists(this.id);
+    };
+
+    Model.prototype.update = function(options) {
+      var clone, records;
+
+      this.trigger('beforeUpdate', options);
+      records = this.constructor.irecords;
+      records[this.id].load(this.attributes());
+      this.constructor.sort();
+      clone = records[this.id].clone();
+      clone.trigger('update', options);
+      clone.trigger('change', 'update', options);
+      return clone;
+    };
+
+    Model.prototype.create = function(options) {
+      var clone, record;
+
+      this.trigger('beforeCreate', options);
+      if (!this.id) {
+        this.id = this.cid;
+      }
+      record = this.dup(false);
+      this.constructor.records.push(record);
+      this.constructor.irecords[this.id] = record;
+      this.constructor.crecords[this.cid] = record;
+      this.constructor.sort();
+      clone = record.clone();
+      clone.trigger('create', options);
+      clone.trigger('change', 'create', options);
+      return clone;
+    };
+
+    Model.prototype.bind = function(events, callback) {
+      var binder, singleEvent, _fn, _i, _len, _ref,
+        _this = this;
+
+      this.constructor.bind(events, binder = function(record) {
+        if (record && _this.eql(record)) {
+          return callback.apply(_this, arguments);
+        }
+      });
+      _ref = events.split(' ');
+      _fn = function(singleEvent) {
+        var unbinder;
+
+        return _this.constructor.bind("unbind", unbinder = function(record, event, cb) {
+          if (record && _this.eql(record)) {
+            if (event && event !== singleEvent) {
+              return;
+            }
+            if (cb && cb !== callback) {
+              return;
+            }
+            _this.constructor.unbind(singleEvent, binder);
+            return _this.constructor.unbind("unbind", unbinder);
+          }
+        });
+      };
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        singleEvent = _ref[_i];
+        _fn(singleEvent);
+      }
+      return this;
+    };
+
+    Model.prototype.one = function(events, callback) {
+      var handler,
+        _this = this;
+
+      return this.bind(events, handler = function() {
+        _this.unbind(events, handler);
+        return callback.apply(_this, arguments);
+      });
+    };
+
+    Model.prototype.trigger = function() {
+      var args, _ref;
+
+      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      args.splice(1, 0, this);
+      return (_ref = this.constructor).trigger.apply(_ref, args);
+    };
+
+    Model.prototype.listenTo = function(obj, events, callback) {
+      obj.bind(events, callback);
+      this.listeningTo || (this.listeningTo = []);
+      return this.listeningTo.push(obj);
+    };
+
+    Model.prototype.listenToOnce = function(obj, events, callback) {
+      var handler, listeningToOnce,
+        _this = this;
+
+      listeningToOnce = this.listeningToOnce || (this.listeningToOnce = []);
+      listeningToOnce.push(obj);
+      return obj.bind(events, handler = function() {
+        var idx;
+
+        idx = listeningToOnce.indexOf(obj);
+        if (idx !== -1) {
+          listeningToOnce.splice(idx, 1);
+        }
+        obj.unbind(events, handler);
+        return callback.apply(obj, arguments);
+      });
+    };
+
+    Model.prototype.stopListening = function(obj, events, callback) {
+      var idx, listeningTo, retain, _i, _j, _k, _len, _len1, _len2, _ref, _ref1, _ref2, _results;
+
+      if (arguments.length === 0) {
+        retain = [];
+        _ref = [this.listeningTo, this.listeningToOnce];
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          listeningTo = _ref[_i];
+          if (!listeningTo) {
+            continue;
+          }
+          _ref1 = this.listeningTo;
+          for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
+            obj = _ref1[_j];
+            if (!(!(__indexOf.call(retain, obj) >= 0))) {
+              continue;
+            }
+            obj.unbind();
+            retain.push(obj);
+          }
+        }
+        this.listeningTo = void 0;
+        this.listeningToOnce = void 0;
+        return;
+      }
+      if (obj) {
+        if (!events) {
+          obj.unbind();
+        }
+        if (events) {
+          obj.unbind(events, callback);
+        }
+        _ref2 = [this.listeningTo, this.listeningToOnce];
+        _results = [];
+        for (_k = 0, _len2 = _ref2.length; _k < _len2; _k++) {
+          listeningTo = _ref2[_k];
+          if (!listeningTo) {
+            continue;
+          }
+          idx = listeningTo.indexOf(obj);
+          if (idx !== -1) {
+            _results.push(listeningTo.splice(idx, 1));
+          } else {
+            _results.push(void 0);
+          }
+        }
+        return _results;
+      }
+    };
+
+    Model.prototype.unbind = function(events, callback) {
+      var event, _i, _len, _ref, _results;
+
+      if (arguments.length === 0) {
+        return this.trigger('unbind');
+      } else if (events) {
+        _ref = events.split(' ');
+        _results = [];
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          event = _ref[_i];
+          _results.push(this.trigger('unbind', event, callback));
+        }
+        return _results;
+      }
+    };
+
+    return Model;
+
+  })(Module);
+
+  Model.prototype.on = Model.prototype.bind;
+
+  Model.prototype.off = Model.prototype.unbind;
+
+  Controller = (function(_super) {
+    __extends(Controller, _super);
+
+    Controller.include(Events);
+
+    Controller.include(Log);
+
+    Controller.prototype.eventSplitter = /^(\S+)\s*(.*)$/;
+
+    Controller.prototype.tag = 'div';
+
+    function Controller(options) {
+      this.release = __bind(this.release, this);
+      var context, key, parent_prototype, value, _ref;
+
+      this.options = options;
+      _ref = this.options;
+      for (key in _ref) {
+        value = _ref[key];
+        this[key] = value;
+      }
+      if (!this.el) {
+        this.el = document.createElement(this.tag);
+      }
+      this.el = $(this.el);
+      this.$el = this.el;
+      if (this.className) {
+        this.el.addClass(this.className);
+      }
+      if (this.attributes) {
+        this.el.attr(this.attributes);
+      }
+      if (!this.events) {
+        this.events = this.constructor.events;
+      }
+      if (!this.elements) {
+        this.elements = this.constructor.elements;
+      }
+      context = this;
+      while (parent_prototype = context.constructor.__super__) {
+        if (parent_prototype.events) {
+          this.events = $.extend({}, parent_prototype.events, this.events);
+        }
+        if (parent_prototype.elements) {
+          this.elements = $.extend({}, parent_prototype.elements, this.elements);
+        }
+        context = parent_prototype;
+      }
+      if (this.events) {
+        this.delegateEvents(this.events);
+      }
+      if (this.elements) {
+        this.refreshElements();
+      }
+      Controller.__super__.constructor.apply(this, arguments);
+    }
+
+    Controller.prototype.release = function() {
+      this.trigger('release', this);
+      this.el.remove();
+      this.unbind();
+      return this.stopListening();
+    };
+
+    Controller.prototype.$ = function(selector) {
+      return $(selector, this.el);
+    };
+
+    Controller.prototype.delegateEvents = function(events) {
+      var eventName, key, match, method, selector, _results,
+        _this = this;
+
+      _results = [];
+      for (key in events) {
+        method = events[key];
+        if (typeof method === 'function') {
+          method = (function(method) {
+            return function() {
+              method.apply(_this, arguments);
+              return true;
+            };
+          })(method);
+        } else {
+          if (!this[method]) {
+            throw new Error("" + method + " doesn't exist");
+          }
+          method = (function(method) {
+            return function() {
+              _this[method].apply(_this, arguments);
+              return true;
+            };
+          })(method);
+        }
+        match = key.match(this.eventSplitter);
+        eventName = match[1];
+        selector = match[2];
+        if (selector === '') {
+          _results.push(this.el.bind(eventName, method));
+        } else {
+          _results.push(this.el.delegate(selector, eventName, method));
+        }
+      }
+      return _results;
+    };
+
+    Controller.prototype.refreshElements = function() {
+      var key, value, _ref, _results;
+
+      _ref = this.elements;
+      _results = [];
+      for (key in _ref) {
+        value = _ref[key];
+        _results.push(this[value] = this.$(key));
+      }
+      return _results;
+    };
+
+    Controller.prototype.delay = function(func, timeout) {
+      return setTimeout(this.proxy(func), timeout || 0);
+    };
+
+    Controller.prototype.html = function(element) {
+      this.el.html(element.el || element);
+      this.refreshElements();
+      return this.el;
+    };
+
+    Controller.prototype.append = function() {
+      var e, elements, _ref;
+
+      elements = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      elements = (function() {
+        var _i, _len, _results;
+
+        _results = [];
+        for (_i = 0, _len = elements.length; _i < _len; _i++) {
+          e = elements[_i];
+          _results.push(e.el || e);
+        }
+        return _results;
+      })();
+      (_ref = this.el).append.apply(_ref, elements);
+      this.refreshElements();
+      return this.el;
+    };
+
+    Controller.prototype.appendTo = function(element) {
+      this.el.appendTo(element.el || element);
+      this.refreshElements();
+      return this.el;
+    };
+
+    Controller.prototype.prepend = function() {
+      var e, elements, _ref;
+
+      elements = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      elements = (function() {
+        var _i, _len, _results;
+
+        _results = [];
+        for (_i = 0, _len = elements.length; _i < _len; _i++) {
+          e = elements[_i];
+          _results.push(e.el || e);
+        }
+        return _results;
+      })();
+      (_ref = this.el).prepend.apply(_ref, elements);
+      this.refreshElements();
+      return this.el;
+    };
+
+    Controller.prototype.replace = function(element) {
+      var previous, _ref;
+
+      _ref = [this.el, $(element.el || element)], previous = _ref[0], this.el = _ref[1];
+      previous.replaceWith(this.el);
+      this.delegateEvents(this.events);
+      this.refreshElements();
+      return this.el;
+    };
+
+    return Controller;
+
+  })(Module);
+
+  $ = (typeof window !== "undefined" && window !== null ? window.jQuery : void 0) || (typeof window !== "undefined" && window !== null ? window.Zepto : void 0) || function(element) {
+    return element;
+  };
+
+  createObject = Object.create || function(o) {
+    var Func;
+
+    Func = function() {};
+    Func.prototype = o;
+    return new Func();
+  };
+
+  isArray = function(value) {
+    return Object.prototype.toString.call(value) === '[object Array]';
+  };
+
+  isBlank = function(value) {
+    var key;
+
+    if (!value) {
+      return true;
+    }
+    for (key in value) {
+      return false;
+    }
+    return true;
+  };
+
+  makeArray = function(args) {
+    return Array.prototype.slice.call(args, 0);
+  };
+
+  Spine = this.Spine = {};
+
+  if (typeof module !== "undefined" && module !== null) {
+    module.exports = Spine;
+  }
+
+  Spine.version = '1.1.0';
+
+  Spine.isArray = isArray;
+
+  Spine.isBlank = isBlank;
+
+  Spine.$ = $;
+
+  Spine.Events = Events;
+
+  Spine.Log = Log;
+
+  Spine.Module = Module;
+
+  Spine.Controller = Controller;
+
+  Spine.Model = Model;
+
+  Module.extend.call(Spine, Events);
+
+  Module.create = Module.sub = Controller.create = Controller.sub = Model.sub = function(instances, statics) {
+    var Result, _ref;
+
+    Result = (function(_super) {
+      __extends(Result, _super);
+
+      function Result() {
+        _ref = Result.__super__.constructor.apply(this, arguments);
+        return _ref;
+      }
+
+      return Result;
+
+    })(this);
+    if (instances) {
+      Result.include(instances);
+    }
+    if (statics) {
+      Result.extend(statics);
+    }
+    if (typeof Result.unbind === "function") {
+      Result.unbind();
+    }
+    return Result;
+  };
+
+  Model.setup = function(name, attributes) {
+    var Instance, _ref;
+
+    if (attributes == null) {
+      attributes = [];
+    }
+    Instance = (function(_super) {
+      __extends(Instance, _super);
+
+      function Instance() {
+        _ref = Instance.__super__.constructor.apply(this, arguments);
+        return _ref;
+      }
+
+      return Instance;
+
+    })(this);
+    Instance.configure.apply(Instance, [name].concat(__slice.call(attributes)));
+    return Instance;
+  };
+
+  Spine.Class = Module;
+
+}).call(this);