spine-rails 0.0.1 → 0.0.2

data/app/assets/javascripts/spine/ajax.js

@@ -0,0 +1,194 @@
+(function() {
+  var $, Ajax, Base, Collection, Include, Model, Singleton;
+  var __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;
+  };
+  if (typeof Spine === "undefined" || Spine === null) {
+    Spine = require("spine");
+  }
+  $ = Spine.$;
+  Model = Spine.Model;
+  Ajax = {
+    getURL: function(object) {
+      return object && (typeof object.url === "function" ? object.url() : void 0) || object.url;
+    },
+    enabled: true,
+    pending: false,
+    requests: [],
+    disable: function(callback) {
+      this.enabled = false;
+      callback();
+      return this.enabled = true;
+    },
+    requestNext: function() {
+      var next;
+      next = this.requests.shift();
+      if (next) {
+        return this.request(next);
+      } else {
+        return this.pending = false;
+      }
+    },
+    request: function(callback) {
+      return (callback()).complete(__bind(function() {
+        return this.requestNext();
+      }, this));
+    },
+    queue: function(callback) {
+      if (!this.enabled) {
+        return;
+      }
+      if (this.pending) {
+        return this.requests.push(callback);
+      } else {
+        this.pending = true;
+        return this.request(callback);
+      }
+    }
+  };
+  Base = (function() {
+    function Base() {}
+    Base.prototype.defaults = {
+      contentType: "application/json",
+      dataType: "json",
+      processData: false
+    };
+    Base.prototype.ajax = function(params, defaults) {
+      return $.ajax($.extend({}, this.defaults, defaults, params));
+    };
+    Base.prototype.queue = function(callback) {
+      return Ajax.queue(callback);
+    };
+    return Base;
+  })();
+  Collection = (function() {
+    __extends(Collection, Base);
+    function Collection(model) {
+      this.model = model;
+      this.errorResponse = __bind(this.errorResponse, this);
+      this.recordsResponse = __bind(this.recordsResponse, this);
+    }
+    Collection.prototype.findAll = function(params) {
+      return this.ajax(params, {
+        type: "GET",
+        url: Ajax.getURL(this.model)
+      }).success(this.recordsResponse).error(this.errorResponse);
+    };
+    Collection.prototype.fetch = function() {
+      return this.findAll().success(__bind(function(records) {
+        return this.model.refresh(records);
+      }, this));
+    };
+    Collection.prototype.recordsResponse = function(data, status, xhr) {
+      return this.model.trigger("ajaxSuccess", null, status, xhr);
+    };
+    Collection.prototype.errorResponse = function(xhr, statusText, error) {
+      return this.model.trigger("ajaxError", null, xhr, statusText, error);
+    };
+    return Collection;
+  })();
+  Singleton = (function() {
+    __extends(Singleton, Base);
+    function Singleton(record) {
+      this.record = record;
+      this.errorResponse = __bind(this.errorResponse, this);
+      this.blankResponse = __bind(this.blankResponse, this);
+      this.recordResponse = __bind(this.recordResponse, this);
+      this.model = this.record.constructor;
+    }
+    Singleton.prototype.find = function(params) {
+      return this.ajax(params, {
+        type: "GET",
+        url: this.url
+      });
+    };
+    Singleton.prototype.create = function(params) {
+      return this.queue(__bind(function() {
+        return this.ajax(params, {
+          type: "POST",
+          data: JSON.stringify(this.record),
+          url: Ajax.getURL(this.model)
+        }).success(this.recordResponse).error(this.errorResponse);
+      }, this));
+    };
+    Singleton.prototype.update = function(params) {
+      return this.queue(__bind(function() {
+        return this.ajax(params, {
+          type: "PUT",
+          data: JSON.stringify(this.record),
+          url: Ajax.getURL(this.record)
+        }).success(this.recordResponse).error(this.errorResponse);
+      }, this));
+    };
+    Singleton.prototype.destroy = function(params) {
+      return this.queue(__bind(function() {
+        return this.ajax(params, {
+          type: "DELETE",
+          url: Ajax.getURL(this.record)
+        }).success(this.recordResponse).error(this.errorResponse);
+      }, this));
+    };
+    Singleton.prototype.recordResponse = function(data, status, xhr) {
+      this.record.trigger("ajaxSuccess", this.record, status, xhr);
+      if (Spine.isBlank(data)) {
+        return;
+      }
+      data = this.model.fromJSON(data);
+      return Ajax.disable(__bind(function() {
+        if (data.id && this.record.id !== data.id) {
+          this.record.changeID(data.id);
+        }
+        return this.record.updateAttributes(data.attributes());
+      }, this));
+    };
+    Singleton.prototype.blankResponse = function(data, status, xhr) {
+      return this.record.trigger("ajaxSuccess", this.record, status, xhr);
+    };
+    Singleton.prototype.errorResponse = function(xhr, statusText, error) {
+      return this.record.trigger("ajaxError", this.record, xhr, statusText, error);
+    };
+    return Singleton;
+  })();
+  Model.host = "";
+  Include = {
+    ajax: function() {
+      return new Singleton(this);
+    },
+    url: function() {
+      var base;
+      base = Ajax.getURL(this.constructor);
+      if (base.charAt(base.length - 1) !== "/") {
+        base += "/";
+      }
+      base += encodeURIComponent(this.id);
+      return base;
+    }
+  };
+  Model.Ajax = {
+    ajax: function() {
+      return new Collection(this);
+    },
+    extended: function() {
+      this.change(function(record, type) {
+        return record.ajax()[type]();
+      });
+      this.fetch(function() {
+        var _ref;
+        return (_ref = this.ajax()).fetch.apply(_ref, arguments);
+      });
+      return this.include(Include);
+    },
+    url: function() {
+      return "" + Model.host + "/" + (this.className.toLowerCase()) + "s";
+    }
+  };
+  Spine.Ajax = Ajax;
+  if (typeof module !== "undefined" && module !== null) {
+    module.exports = Ajax;
+  }
+}).call(this);

data/app/assets/javascripts/spine/list.js

@@ -0,0 +1,61 @@
+(function() {
+  var $;
+  var __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;
+  };
+  if (typeof Spine === "undefined" || Spine === null) {
+    Spine = require("spine");
+  }
+  $ = Spine.$;
+  Spine.List = (function() {
+    __extends(List, Spine.Controller);
+    List.prototype.events = {
+      "click .item": "click"
+    };
+    List.prototype.selectFirst = false;
+    function List() {
+      this.change = __bind(this.change, this);      List.__super__.constructor.apply(this, arguments);
+      this.bind("change", this.change);
+    }
+    List.prototype.template = function() {
+      return arguments[0];
+    };
+    List.prototype.change = function(item) {
+      if (!item) {
+        return;
+      }
+      this.current = item;
+      this.children().removeClass("active");
+      return this.children().forItem(this.current).addClass("active");
+    };
+    List.prototype.render = function(items) {
+      if (items) {
+        this.items = items;
+      }
+      this.html(this.template(this.items));
+      this.change(this.current);
+      if (this.selectFirst) {
+        if (!this.children(".active").length) {
+          return this.children(":first").click();
+        }
+      }
+    };
+    List.prototype.children = function(sel) {
+      return this.el.children(sel);
+    };
+    List.prototype.click = function(e) {
+      var item;
+      item = $(e.target).item();
+      return this.trigger("change", item);
+    };
+    return List;
+  })();
+  if (typeof module !== "undefined" && module !== null) {
+    module.exports = Spine.List;
+  }
+}).call(this);

data/app/assets/javascripts/spine/local.js

@@ -0,0 +1,26 @@
+(function() {
+  if (typeof Spine === "undefined" || Spine === null) {
+    Spine = require("spine");
+  }
+  Spine.Model.Local = {
+    extended: function() {
+      this.change(this.saveLocal);
+      return this.fetch(this.loadLocal);
+    },
+    saveLocal: function() {
+      var result;
+      result = JSON.stringify(this);
+      return localStorage[this.className] = result;
+    },
+    loadLocal: function() {
+      var result;
+      result = localStorage[this.className];
+      return this.refresh(result || [], {
+        clear: true
+      });
+    }
+  };
+  if (typeof module !== "undefined" && module !== null) {
+    module.exports = Spine.Model.Local;
+  }
+}).call(this);

data/app/assets/javascripts/spine/manager.js

@@ -0,0 +1,86 @@
+(function() {
+  var $;
+  var __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;
+  }, __slice = Array.prototype.slice, __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+  if (typeof Spine === "undefined" || Spine === null) {
+    Spine = require('spine');
+  }
+  $ = Spine.$;
+  Spine.Manager = (function() {
+    __extends(Manager, Spine.Module);
+    Manager.include(Spine.Events);
+    function Manager() {
+      this.controllers = [];
+      this.add.apply(this, arguments);
+      this.bind('change', this.change);
+    }
+    Manager.prototype.add = function() {
+      var cont, controllers, _i, _len, _results;
+      controllers = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      _results = [];
+      for (_i = 0, _len = controllers.length; _i < _len; _i++) {
+        cont = controllers[_i];
+        _results.push(this.addOne(cont));
+      }
+      return _results;
+    };
+    Manager.prototype.addOne = function(controller) {
+      controller.bind('active', __bind(function() {
+        var args;
+        args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+        return this.trigger('change', controller, args);
+      }, this));
+      controller.bind('destroy', __bind(function() {
+        return this.controllers.splice(this.controllers.indexOf(controller), 1);
+      }, this));
+      return this.controllers.push(controller);
+    };
+    Manager.prototype.deactivate = function() {
+      return this.trigger('change', false, arguments);
+    };
+    Manager.prototype.change = function(current, args) {
+      var cont, _i, _len, _ref, _results;
+      _ref = this.controllers;
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        cont = _ref[_i];
+        _results.push(cont === current ? cont.activate.apply(cont, args) : cont.deactivate.apply(cont, args));
+      }
+      return _results;
+    };
+    return Manager;
+  })();
+  Spine.Controller.include({
+    active: function() {
+      var args;
+      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      if (typeof args[0] === 'function') {
+        this.bind('active', args[0]);
+      } else {
+        args.unshift('active');
+        this.trigger.apply(this, args);
+      }
+      return this;
+    },
+    isActive: function() {
+      return this.el.hasClass('active');
+    },
+    activate: function() {
+      this.el.addClass('active');
+      return this;
+    },
+    deactivate: function() {
+      this.el.removeClass('active');
+      return this;
+    }
+  });
+  if (typeof module !== "undefined" && module !== null) {
+    module.exports = Spine.Manager;
+  }
+}).call(this);

data/app/assets/javascripts/spine/relation.js

@@ -0,0 +1,145 @@
+(function() {
+  var Collection, Instance, singularize, underscore;
+  var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+  if (typeof Spine === "undefined" || Spine === null) {
+    Spine = require("spine");
+  }
+  Collection = (function() {
+    function Collection(options) {
+      var key, value;
+      if (options == null) {
+        options = {};
+      }
+      for (key in options) {
+        value = options[key];
+        this[key] = value;
+      }
+    }
+    Collection.prototype.all = function() {
+      return this.model.select(__bind(function(rec) {
+        return this.associated(rec);
+      }, this));
+    };
+    Collection.prototype.first = function() {
+      return this.all()[0];
+    };
+    Collection.prototype.last = function() {
+      var values;
+      values = this.all();
+      return values[values.length - 1];
+    };
+    Collection.prototype.find = function(id) {
+      var records;
+      records = this.model.select(__bind(function(rec) {
+        return this.associated(rec) && rec.id === id;
+      }, this));
+      if (!records[0]) {
+        throw "Unknown record";
+      }
+      return records[0];
+    };
+    Collection.prototype.select = function(cb) {
+      return this.model.select(__bind(function(rec) {
+        return this.associated(rec) && cb(rec);
+      }, this));
+    };
+    Collection.prototype.refresh = function(values) {
+      var record, records, value, _i, _j, _len, _len2;
+      records = this.all();
+      for (_i = 0, _len = records.length; _i < _len; _i++) {
+        record = records[_i];
+        delete this.model.records[record.id];
+      }
+      values = this.model.fromJSON(values);
+      for (_j = 0, _len2 = values.length; _j < _len2; _j++) {
+        value = values[_j];
+        value.newRecord = false;
+        value[this.fkey] = this.record.id;
+        this.model.records[value.id] = value;
+      }
+      return this.model.trigger("refresh");
+    };
+    Collection.prototype.create = function(record) {
+      record[this.fkey] = this.record.id;
+      return this.model.create(record);
+    };
+    Collection.prototype.associated = function(record) {
+      return record[this.fkey] === this.record.id;
+    };
+    return Collection;
+  })();
+  Instance = (function() {
+    function Instance(options) {
+      var key, value;
+      if (options == null) {
+        options = {};
+      }
+      for (key in options) {
+        value = options[key];
+        this[key] = value;
+      }
+    }
+    Instance.prototype.find = function() {
+      return this.record[this.fkey] && this.model.find(this.record[this.fkey]);
+    };
+    Instance.prototype.update = function(value) {
+      return this.record[this.fkey] = value && value.id;
+    };
+    return Instance;
+  })();
+  singularize = function(str) {
+    return str.replace(/s$/, '');
+  };
+  underscore = function(str) {
+    return str.replace(/::/g, '/').replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2').replace(/([a-z\d])([A-Z])/g, '$1_$2').replace(/-/g, '_').toLowerCase();
+  };
+  Spine.Model.extend({
+    many: function(name, model, fkey) {
+      var association;
+      if (fkey == null) {
+        fkey = "" + (underscore(this.className)) + "_id";
+      }
+      association = function(record) {
+        if (typeof model === "string") {
+          model = require(model);
+        }
+        return new Collection({
+          name: name,
+          model: model,
+          record: record,
+          fkey: fkey
+        });
+      };
+      this.prototype.__defineGetter__(name, function() {
+        return association(this);
+      });
+      return this.prototype.__defineSetter__(name, function(value) {
+        return association(this).refresh(value);
+      });
+    },
+    belongs: function(name, model, fkey) {
+      var association;
+      if (fkey == null) {
+        fkey = "" + (singularize(name)) + "_id";
+      }
+      association = function(record) {
+        if (typeof model === "string") {
+          model = require(model);
+        }
+        return new Instance({
+          name: name,
+          model: model,
+          record: record,
+          fkey: fkey
+        });
+      };
+      this.prototype.__defineGetter__(name, function() {
+        return association(this).find();
+      });
+      this.prototype.__defineSetter__(name, function(value) {
+        return association(this).update(value);
+      });
+      return this.attributes.push(fkey);
+    }
+  });
+}).call(this);