spine-rails 0.0.1 → 0.0.2

data/.gitignore

@@ -1,4 +1,6 @@
-*.gem
+*.swp
+*.swo
+.#*
 .bundle
-Gemfile.lock
-pkg/*
+.DS_Store
+*~

data/Gemfile

@@ -1,4 +1,9 @@
-source "http://rubygems.org"
+source 'http://rubygems.org'
 
 # Specify your gem's dependencies in spine-rails.gemspec
 gemspec
+# Rails is already being pulled in through gemspec
+# gem "rails", :git => "git://github.com/rails/rails.git"
+gem "rack", :git => "git://github.com/rack/rack.git"
+gem "sprockets", :git => "git://github.com/sstephenson/sprockets.git"
+gem "i18n", "0.6.0beta1"

data/Gemfile.lock

@@ -0,0 +1,26 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    daemons (1.1.3)
+    eventmachine (0.12.10)
+    json (1.5.2)
+    rack (1.3.0)
+    shotgun (0.9)
+      rack (>= 1.0)
+    sinatra (1.2.6)
+      rack (~> 1.1)
+      tilt (< 2.0, >= 1.2.2)
+    thin (1.2.11)
+      daemons (>= 1.0.9)
+      eventmachine (>= 0.12.6)
+      rack (>= 1.0.0)
+    tilt (1.3.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  json
+  shotgun
+  sinatra (~> 1.0)
+  thin

data/Rakefile

@@ -1,2 +1,10 @@
 require 'bundler'
 Bundler::GemHelper.install_tasks
+
+# require "spec/rake/spectask"
+# desc "Run all examples"
+# Spec::Rake::SpecTask.new(:spec) do |t|
+#   t.ruby_opts  = ['-r test/unit']
+#   t.spec_opts = %w[--color]
+# end
+task :default => :spec

data/{vendor → app}/assets/javascripts/json2.js

@@ -1,6 +1,6 @@
 /*
     http://www.JSON.org/json2.js
-    2011-02-23
+    2009-09-29
 
     Public Domain.
 
@@ -146,7 +146,7 @@
     redistribute.
 */
 
-/*jslint evil: true, strict: false, regexp: false */
+/*jslint evil: true, strict: false */
 
 /*members "", "\b", "\t", "\n", "\f", "\r", "\"", JSON, "\\", apply,
     call, charCodeAt, getUTCDate, getUTCFullYear, getUTCHours,
@@ -159,13 +159,15 @@
 // Create a JSON object only if one does not already exist. We create the
 // methods in a closure to avoid creating global variables.
 
-var JSON;
-if (!JSON) {
-    JSON = {};
+if (!this.JSON) {
+  this.JSON = {};
 }
 
+if (this.module)
+  module.exports = JSON;
+
 (function () {
-    "use strict";
+  
 
     function f(n) {
         // Format integers to have at least two digits.
@@ -177,19 +179,19 @@ if (!JSON) {
         Date.prototype.toJSON = function (key) {
 
             return isFinite(this.valueOf()) ?
-                this.getUTCFullYear()     + '-' +
-                f(this.getUTCMonth() + 1) + '-' +
-                f(this.getUTCDate())      + 'T' +
-                f(this.getUTCHours())     + ':' +
-                f(this.getUTCMinutes())   + ':' +
-                f(this.getUTCSeconds())   + 'Z' : null;
+                   this.getUTCFullYear()   + '-' +
+                 f(this.getUTCMonth() + 1) + '-' +
+                 f(this.getUTCDate())      + 'T' +
+                 f(this.getUTCHours())     + ':' +
+                 f(this.getUTCMinutes())   + ':' +
+                 f(this.getUTCSeconds())   + 'Z' : null;
         };
 
-        String.prototype.toJSON      =
-            Number.prototype.toJSON  =
-            Boolean.prototype.toJSON = function (key) {
-                return this.valueOf();
-            };
+        String.prototype.toJSON =
+        Number.prototype.toJSON =
+        Boolean.prototype.toJSON = function (key) {
+            return this.valueOf();
+        };
     }
 
     var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
@@ -216,11 +218,13 @@ if (!JSON) {
 // sequences.
 
         escapable.lastIndex = 0;
-        return escapable.test(string) ? '"' + string.replace(escapable, function (a) {
-            var c = meta[a];
-            return typeof c === 'string' ? c :
-                '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
-        }) + '"' : '"' + string + '"';
+        return escapable.test(string) ?
+            '"' + string.replace(escapable, function (a) {
+                var c = meta[a];
+                return typeof c === 'string' ? c :
+                    '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+            }) + '"' :
+            '"' + string + '"';
     }
 
 
@@ -303,9 +307,11 @@ if (!JSON) {
 // Join all of the elements together, separated with commas, and wrap them in
 // brackets.
 
-                v = partial.length === 0 ? '[]' : gap ?
-                    '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']' :
-                    '[' + partial.join(',') + ']';
+                v = partial.length === 0 ? '[]' :
+                    gap ? '[\n' + gap +
+                            partial.join(',\n' + gap) + '\n' +
+                                mind + ']' :
+                          '[' + partial.join(',') + ']';
                 gap = mind;
                 return v;
             }
@@ -315,8 +321,8 @@ if (!JSON) {
             if (rep && typeof rep === 'object') {
                 length = rep.length;
                 for (i = 0; i < length; i += 1) {
-                    if (typeof rep[i] === 'string') {
-                        k = rep[i];
+                    k = rep[i];
+                    if (typeof k === 'string') {
                         v = str(k, value);
                         if (v) {
                             partial.push(quote(k) + (gap ? ': ' : ':') + v);
@@ -328,7 +334,7 @@ if (!JSON) {
 // Otherwise, iterate through all of the keys in the object.
 
                 for (k in value) {
-                    if (Object.prototype.hasOwnProperty.call(value, k)) {
+                    if (Object.hasOwnProperty.call(value, k)) {
                         v = str(k, value);
                         if (v) {
                             partial.push(quote(k) + (gap ? ': ' : ':') + v);
@@ -340,9 +346,9 @@ if (!JSON) {
 // Join all of the member texts together, separated with commas,
 // and wrap them in braces.
 
-            v = partial.length === 0 ? '{}' : gap ?
-                '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}' :
-                '{' + partial.join(',') + '}';
+            v = partial.length === 0 ? '{}' :
+                gap ? '{\n' + gap + partial.join(',\n' + gap) + '\n' +
+                        mind + '}' : '{' + partial.join(',') + '}';
             gap = mind;
             return v;
         }
@@ -383,7 +389,7 @@ if (!JSON) {
             rep = replacer;
             if (replacer && typeof replacer !== 'function' &&
                     (typeof replacer !== 'object' ||
-                    typeof replacer.length !== 'number')) {
+                     typeof replacer.length !== 'number')) {
                 throw new Error('JSON.stringify');
             }
 
@@ -413,7 +419,7 @@ if (!JSON) {
                 var k, v, value = holder[key];
                 if (value && typeof value === 'object') {
                     for (k in value) {
-                        if (Object.prototype.hasOwnProperty.call(value, k)) {
+                        if (Object.hasOwnProperty.call(value, k)) {
                             v = walk(value, k);
                             if (v !== undefined) {
                                 value[k] = v;
@@ -431,7 +437,6 @@ if (!JSON) {
 // Unicode characters with escape sequences. JavaScript handles many characters
 // incorrectly, either silently deleting them, or treating them as line endings.
 
-            text = String(text);
             cx.lastIndex = 0;
             if (cx.test(text)) {
                 text = text.replace(cx, function (a) {
@@ -453,10 +458,10 @@ if (!JSON) {
 // we look to see that the remaining characters are only whitespace or ']' or
 // ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.
 
-            if (/^[\],:{}\s]*$/
-                    .test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
-                        .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
-                        .replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
+            if (/^[\],:{}\s]*$/.
+test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@').
+replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']').
+replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
 
 // In the third stage we use the eval function to compile the text into a
 // JavaScript structure. The '{' operator is subject to a syntactic ambiguity

data/app/assets/javascripts/spine.js

@@ -0,0 +1,717 @@
+(function() {
+  var $, Controller, Events, Log, Model, Module, Spine, guid, isArray, isBlank, makeArray, moduleKeywords;
+  var __slice = Array.prototype.slice, __indexOf = Array.prototype.indexOf || function(item) {
+    for (var i = 0, l = this.length; i < l; i++) {
+      if (this[i] === item) return i;
+    }
+    return -1;
+  }, __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; }, __hasProp = Object.prototype.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;
+  };
+  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;
+    },
+    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 false;
+      }
+      for (_i = 0, _len = list.length; _i < _len; _i++) {
+        callback = list[_i];
+        if (callback.apply(this, args) === false) {
+          break;
+        }
+      }
+      return true;
+    },
+    unbind: function(ev, callback) {
+      var cb, i, list, _len, _ref;
+      if (!ev) {
+        this._callbacks = {};
+        return this;
+      }
+      list = (_ref = this._callbacks) != null ? _ref[ev] : void 0;
+      if (!list) {
+        return this;
+      }
+      if (!callback) {
+        delete this._callbacks[ev];
+        return this;
+      }
+      for (i = 0, _len = list.length; i < _len; i++) {
+        cb = list[i];
+        if (cb === callback) {
+          list = list.slice();
+          list.splice(i, 1);
+          this._callbacks[ev] = list;
+          break;
+        }
+      }
+      return this;
+    }
+  };
+  Log = {
+    trace: true,
+    logPrefix: '(App)',
+    log: function() {
+      var args;
+      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      if (!this.trace) {
+        return;
+      }
+      if (typeof console === 'undefined') {
+        return;
+      }
+      if (this.logPrefix) {
+        args.unshift(this.logPrefix);
+      }
+      console.log.apply(console, args);
+      return this;
+    }
+  };
+  moduleKeywords = ['included', 'extended'];
+  Module = (function() {
+    Module.include = function(obj) {
+      var included, key, value;
+      if (!obj) {
+        throw 'include(obj) requires obj';
+      }
+      for (key in obj) {
+        value = obj[key];
+        if (__indexOf.call(moduleKeywords, key) < 0) {
+          this.prototype[key] = value;
+        }
+      }
+      included = obj.included;
+      if (included) {
+        included.apply(this);
+      }
+      return this;
+    };
+    Module.extend = function(obj) {
+      var extended, key, value;
+      if (!obj) {
+        throw 'extend(obj) requires obj';
+      }
+      for (key in obj) {
+        value = obj[key];
+        if (__indexOf.call(moduleKeywords, key) < 0) {
+          this[key] = value;
+        }
+      }
+      extended = obj.extended;
+      if (extended) {
+        extended.apply(this);
+      }
+      return this;
+    };
+    Module.proxy = function(func) {
+      return __bind(function() {
+        return func.apply(this, arguments);
+      }, this);
+    };
+    Module.prototype.proxy = function(func) {
+      return __bind(function() {
+        return func.apply(this, arguments);
+      }, this);
+    };
+    function Module() {
+      if (typeof this.init === "function") {
+        this.init.apply(this, arguments);
+      }
+    }
+    return Module;
+  })();
+  Model = (function() {
+    __extends(Model, Module);
+    Model.extend(Events);
+    Model.records = {};
+    Model.attributes = [];
+    Model.configure = function() {
+      var attributes, name;
+      name = arguments[0], attributes = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+      this.className = name;
+      this.records = {};
+      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.records[id];
+      if (!record) {
+        throw 'Unknown record';
+      }
+      return record.clone();
+    };
+    Model.exists = function(id) {
+      try {
+        return this.find(id);
+      } catch (e) {
+        return false;
+      }
+    };
+    Model.refresh = function(values, options) {
+      var record, _i, _len, _ref;
+      if (options == null) {
+        options = {};
+      }
+      if (options.clear) {
+        this.records = {};
+      }
+      _ref = this.fromJSON(values);
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        record = _ref[_i];
+        record.newRecord = false;
+        record.id || (record.id = guid());
+        this.records[record.id] = record;
+      }
+      this.trigger('refresh');
+      return this;
+    };
+    Model.select = function(callback) {
+      var id, record, result;
+      result = (function() {
+        var _ref, _results;
+        _ref = this.records;
+        _results = [];
+        for (id in _ref) {
+          record = _ref[id];
+          if (callback(record)) {
+            _results.push(record);
+          }
+        }
+        return _results;
+      }).call(this);
+      return this.cloneArray(result);
+    };
+    Model.findByAttribute = function(name, value) {
+      var id, record, _ref;
+      _ref = this.records;
+      for (id in _ref) {
+        record = _ref[id];
+        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 key, value, _ref, _results;
+      _ref = this.records;
+      _results = [];
+      for (key in _ref) {
+        value = _ref[key];
+        _results.push(callback(value.clone()));
+      }
+      return _results;
+    };
+    Model.all = function() {
+      return this.cloneArray(this.recordsValues());
+    };
+    Model.first = function() {
+      var record;
+      record = this.recordsValues()[0];
+      return record != null ? record.clone() : void 0;
+    };
+    Model.last = function() {
+      var record, values;
+      values = this.recordsValues();
+      record = values[values.length - 1];
+      return record != null ? record.clone() : void 0;
+    };
+    Model.count = function() {
+      return this.recordsValues().length;
+    };
+    Model.deleteAll = function() {
+      var key, value, _ref, _results;
+      _ref = this.records;
+      _results = [];
+      for (key in _ref) {
+        value = _ref[key];
+        _results.push(delete this.records[key]);
+      }
+      return _results;
+    };
+    Model.destroyAll = function() {
+      var key, value, _ref, _results;
+      _ref = this.records;
+      _results = [];
+      for (key in _ref) {
+        value = _ref[key];
+        _results.push(this.records[key].destroy());
+      }
+      return _results;
+    };
+    Model.update = function(id, atts) {
+      return this.find(id).updateAttributes(atts);
+    };
+    Model.create = function(atts) {
+      var record;
+      record = new this(atts);
+      return record.save();
+    };
+    Model.destroy = function(id) {
+      return this.find(id).destroy();
+    };
+    Model.change = function(callbackOrParams) {
+      if (typeof callbackOrParams === 'function') {
+        return this.bind('change', callbackOrParams);
+      } else {
+        return this.trigger('change', callbackOrParams);
+      }
+    };
+    Model.fetch = function(callbackOrParams) {
+      if (typeof callbackOrParams === 'function') {
+        return this.bind('fetch', callbackOrParams);
+      } else {
+        return this.trigger('fetch', callbackOrParams);
+      }
+    };
+    Model.toJSON = function() {
+      return this.recordsValues();
+    };
+    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.recordsValues = function() {
+      var key, result, value, _ref;
+      result = [];
+      _ref = this.records;
+      for (key in _ref) {
+        value = _ref[key];
+        result.push(value);
+      }
+      return result;
+    };
+    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.prototype.newRecord = true;
+    function Model(atts) {
+      Model.__super__.constructor.apply(this, arguments);
+      this.ids = [];
+      if (atts) {
+        this.load(atts);
+      }
+    }
+    Model.prototype.isNew = function() {
+      return this.newRecord;
+    };
+    Model.prototype.isValid = function() {
+      return !this.validate();
+    };
+    Model.prototype.validate = function() {};
+    Model.prototype.load = function(atts) {
+      var key, value, _results;
+      _results = [];
+      for (key in atts) {
+        value = atts[key];
+        _results.push(this[key] = value);
+      }
+      return _results;
+    };
+    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];
+        result[key] = this[key];
+      }
+      result.id = this.id;
+      return result;
+    };
+    Model.prototype.eql = function(rec) {
+      var _ref, _ref2;
+      return rec && rec.constructor === this.constructor && (rec.id === this.id || (_ref = this.id, __indexOf.call(rec.ids, _ref) >= 0) || (_ref2 = rec.id, __indexOf.call(this.ids, _ref2) >= 0));
+    };
+    Model.prototype.save = function() {
+      var error;
+      error = this.validate();
+      if (error) {
+        this.trigger('error', this, error);
+        return false;
+      }
+      this.trigger('beforeSave', this);
+      if (this.newRecord) {
+        this.create();
+      } else {
+        this.update();
+      }
+      this.trigger('save', this);
+      return this;
+    };
+    Model.prototype.updateAttribute = function(name, value) {
+      this[name] = value;
+      return this.save();
+    };
+    Model.prototype.updateAttributes = function(atts) {
+      this.load(atts);
+      return this.save();
+    };
+    Model.prototype.changeID = function(id) {
+      var records;
+      this.ids.push(this.id);
+      records = this.constructor.records;
+      records[id] = records[this.id];
+      delete records[this.id];
+      this.id = id;
+      return this.save();
+    };
+    Model.prototype.destroy = function() {
+      this.trigger('beforeDestroy', this);
+      delete this.constructor.records[this.id];
+      this.destroyed = true;
+      this.trigger('destroy', this);
+      this.trigger('change', this, 'destroy');
+      this.unbind();
+      return this;
+    };
+    Model.prototype.dup = function(newRecord) {
+      var result;
+      result = new this.constructor(this.attributes());
+      if (newRecord === false) {
+        result.newRecord = this.newRecord;
+      } else {
+        delete result.id;
+      }
+      return result;
+    };
+    Model.prototype.clone = function() {
+      return Object.create(this);
+    };
+    Model.prototype.reload = function() {
+      var original;
+      if (this.newRecord) {
+        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.exists = function() {
+      return this.id && this.id in this.constructor.records;
+    };
+    Model.prototype.update = function() {
+      var clone, records;
+      this.trigger('beforeUpdate', this);
+      records = this.constructor.records;
+      records[this.id].load(this.attributes());
+      clone = records[this.id].clone();
+      this.trigger('update', clone);
+      return this.trigger('change', clone, 'update');
+    };
+    Model.prototype.create = function() {
+      var clone, records;
+      this.trigger('beforeCreate', this);
+      if (!this.id) {
+        this.id = guid();
+      }
+      this.newRecord = false;
+      records = this.constructor.records;
+      records[this.id] = this.dup(false);
+      clone = records[this.id].clone();
+      this.trigger('create', clone);
+      return this.trigger('change', clone, 'create');
+    };
+    Model.prototype.bind = function(events, callback) {
+      var binder, unbinder;
+      this.constructor.bind(events, binder = __bind(function(record) {
+        if (record && this.eql(record)) {
+          return callback.apply(this, arguments);
+        }
+      }, this));
+      this.constructor.bind('unbind', unbinder = __bind(function(record) {
+        if (record && this.eql(record)) {
+          this.constructor.unbind(events, binder);
+          return this.constructor.unbind('unbind', unbinder);
+        }
+      }, this));
+      return binder;
+    };
+    Model.prototype.trigger = function() {
+      var _ref;
+      return (_ref = this.constructor).trigger.apply(_ref, arguments);
+    };
+    Model.prototype.unbind = function() {
+      return this.trigger('unbind', this);
+    };
+    return Model;
+  })();
+  Controller = (function() {
+    __extends(Controller, Module);
+    Controller.include(Events);
+    Controller.include(Log);
+    Controller.prototype.eventSplitter = /^(\w+)\s*(.*)$/;
+    Controller.prototype.tag = 'div';
+    function Controller(options) {
+      this.release = __bind(this.release, this);
+      var key, 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);
+      if (this.className) {
+        this.el.addClass(this.className);
+      }
+      this.release(function() {
+        return this.el.remove();
+      });
+      if (!this.events) {
+        this.events = this.constructor.events;
+      }
+      if (!this.elements) {
+        this.elements = this.constructor.elements;
+      }
+      if (this.events) {
+        this.delegateEvents();
+      }
+      if (this.elements) {
+        this.refreshElements();
+      }
+      Controller.__super__.constructor.apply(this, arguments);
+    }
+    Controller.prototype.release = function(callback) {
+      if (typeof callback === 'function') {
+        return this.bind('release', callback);
+      } else {
+        return this.trigger('release');
+      }
+    };
+    Controller.prototype.$ = function(selector) {
+      return $(selector, this.el);
+    };
+    Controller.prototype.delegateEvents = function() {
+      var eventName, key, match, method, selector, _ref, _results;
+      _ref = this.events;
+      _results = [];
+      for (key in _ref) {
+        method = _ref[key];
+        if (typeof method !== 'function') {
+          method = this.proxy(this[method]);
+        }
+        match = key.match(this.eventSplitter);
+        eventName = match[1];
+        selector = match[2];
+        _results.push(selector === '' ? this.el.bind(eventName, method) : 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.refreshElements();
+      return this.el;
+    };
+    return Controller;
+  })();
+  $ = this.jQuery || this.Zepto || function(element) {
+    return element;
+  };
+  if (typeof Object.create !== 'function') {
+    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);
+  };
+  guid = function() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+      var r, v;
+      r = Math.random() * 16 | 0;
+      v = c === 'x' ? r : r & 3 | 8;
+      return v.toString(16);
+    }).toUpperCase();
+  };
+  Spine = this.Spine = {};
+  if (typeof module !== "undefined" && module !== null) {
+    module.exports = Spine;
+  }
+  Spine.version = '0.0.9';
+  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;
+    result = (function() {
+      __extends(result, this);
+      function result() {
+        result.__super__.constructor.apply(this, arguments);
+      }
+      return result;
+    }).call(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;
+    if (attributes == null) {
+      attributes = [];
+    }
+    Instance = (function() {
+      __extends(Instance, this);
+      function Instance() {
+        Instance.__super__.constructor.apply(this, arguments);
+      }
+      return Instance;
+    }).call(this);
+    Instance.configure.apply(Instance, [name].concat(__slice.call(attributes)));
+    return Instance;
+  };
+  Module.init = Controller.init = Model.init = function(a1, a2, a3, a4, a5) {
+    return new this(a1, a2, a3, a4, a5);
+  };
+  Spine.Class = Module;
+}).call(this);