flipper-ui 0.2.0.beta1

data/lib/flipper/ui/public/js/spine/relation.js

@@ -0,0 +1,260 @@
+(function() {
+  var Collection, Instance, Singleton, Spine, isArray, require, singularize, underscore,
+    __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; };
+
+  Spine = this.Spine || require('spine');
+
+  isArray = Spine.isArray;
+
+  require = this.require || (function(value) {
+    return eval(value);
+  });
+
+  Collection = (function(_super) {
+
+    __extends(Collection, _super);
+
+    function Collection(options) {
+      var key, value;
+      if (options == null) {
+        options = {};
+      }
+      for (key in options) {
+        value = options[key];
+        this[key] = value;
+      }
+    }
+
+    Collection.prototype.all = function() {
+      var _this = this;
+      return this.model.select(function(rec) {
+        return _this.associated(rec);
+      });
+    };
+
+    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,
+        _this = this;
+      records = this.select(function(rec) {
+        return ("" + rec.id) === ("" + id);
+      });
+      if (!records[0]) {
+        throw new Error("\"" + this.model.className + "\" model could not find a record for the ID \"" + id + "\"");
+      }
+      return records[0];
+    };
+
+    Collection.prototype.findAllByAttribute = function(name, value) {
+      var _this = this;
+      return this.model.select(function(rec) {
+        return _this.associated(rec) && rec[name] === value;
+      });
+    };
+
+    Collection.prototype.findByAttribute = function(name, value) {
+      return this.findAllByAttribute(name, value)[0];
+    };
+
+    Collection.prototype.select = function(cb) {
+      var _this = this;
+      return this.model.select(function(rec) {
+        return _this.associated(rec) && cb(rec);
+      });
+    };
+
+    Collection.prototype.refresh = function(values) {
+      var record, records, _i, _j, _len, _len1, _ref;
+      _ref = this.all();
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        record = _ref[_i];
+        delete this.model.records[record.id];
+      }
+      records = this.model.fromJSON(values);
+      if (!isArray(records)) {
+        records = [records];
+      }
+      for (_j = 0, _len1 = records.length; _j < _len1; _j++) {
+        record = records[_j];
+        record.newRecord = false;
+        record[this.fkey] = this.record.id;
+        this.model.records[record.id] = record;
+      }
+      return this.model.trigger('refresh', this.model.cloneArray(records));
+    };
+
+    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;
+
+  })(Spine.Module);
+
+  Instance = (function(_super) {
+
+    __extends(Instance, _super);
+
+    function Instance(options) {
+      var key, value;
+      if (options == null) {
+        options = {};
+      }
+      for (key in options) {
+        value = options[key];
+        this[key] = value;
+      }
+    }
+
+    Instance.prototype.exists = function() {
+      return this.record[this.fkey] && this.model.exists(this.record[this.fkey]);
+    };
+
+    Instance.prototype.update = function(value) {
+      if (!(value instanceof this.model)) {
+        value = new this.model(value);
+      }
+      if (value.isNew()) {
+        value.save();
+      }
+      return this.record[this.fkey] = value && value.id;
+    };
+
+    return Instance;
+
+  })(Spine.Module);
+
+  Singleton = (function(_super) {
+
+    __extends(Singleton, _super);
+
+    function Singleton(options) {
+      var key, value;
+      if (options == null) {
+        options = {};
+      }
+      for (key in options) {
+        value = options[key];
+        this[key] = value;
+      }
+    }
+
+    Singleton.prototype.find = function() {
+      return this.record.id && this.model.findByAttribute(this.fkey, this.record.id);
+    };
+
+    Singleton.prototype.update = function(value) {
+      if (!(value instanceof this.model)) {
+        value = this.model.fromJSON(value);
+      }
+      value[this.fkey] = this.record.id;
+      return value.save();
+    };
+
+    return Singleton;
+
+  })(Spine.Module);
+
+  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({
+    hasMany: 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
+        });
+      };
+      return this.prototype[name] = function(value) {
+        if (value != null) {
+          association(this).refresh(value);
+        }
+        return association(this);
+      };
+    },
+    belongsTo: 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[name] = function(value) {
+        if (value != null) {
+          association(this).update(value);
+        }
+        return association(this).exists();
+      };
+      return this.attributes.push(fkey);
+    },
+    hasOne: 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 Singleton({
+          name: name,
+          model: model,
+          record: record,
+          fkey: fkey
+        });
+      };
+      return this.prototype[name] = function(value) {
+        if (value != null) {
+          association(this).update(value);
+        }
+        return association(this).find();
+      };
+    }
+  });
+
+  Spine.Collection = Collection;
+
+  Spine.Singleton = Singleton;
+
+  Spine.Instance = Instance;
+
+}).call(this);

data/lib/flipper/ui/public/js/spine/route.js

@@ -0,0 +1,223 @@
+(function() {
+  var $, Spine, escapeRegExp, hashStrip, namedParam, splatParam,
+    __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; },
+    __slice = [].slice;
+
+  Spine = this.Spine || require('spine');
+
+  $ = Spine.$;
+
+  hashStrip = /^#*/;
+
+  namedParam = /:([\w\d]+)/g;
+
+  splatParam = /\*([\w\d]+)/g;
+
+  escapeRegExp = /[-[\]{}()+?.,\\^$|#\s]/g;
+
+  Spine.Route = (function(_super) {
+    var _ref;
+
+    __extends(Route, _super);
+
+    Route.extend(Spine.Events);
+
+    Route.historySupport = ((_ref = window.history) != null ? _ref.pushState : void 0) != null;
+
+    Route.routes = [];
+
+    Route.options = {
+      trigger: true,
+      history: false,
+      shim: false
+    };
+
+    Route.add = function(path, callback) {
+      var key, value, _results;
+      if (typeof path === 'object' && !(path instanceof RegExp)) {
+        _results = [];
+        for (key in path) {
+          value = path[key];
+          _results.push(this.add(key, value));
+        }
+        return _results;
+      } else {
+        return this.routes.push(new this(path, callback));
+      }
+    };
+
+    Route.setup = function(options) {
+      if (options == null) {
+        options = {};
+      }
+      this.options = $.extend({}, this.options, options);
+      if (this.options.history) {
+        this.history = this.historySupport && this.options.history;
+      }
+      if (this.options.shim) {
+        return;
+      }
+      if (this.history) {
+        $(window).bind('popstate', this.change);
+      } else {
+        $(window).bind('hashchange', this.change);
+      }
+      return this.change();
+    };
+
+    Route.unbind = function() {
+      if (this.options.shim) {
+        return;
+      }
+      if (this.history) {
+        return $(window).unbind('popstate', this.change);
+      } else {
+        return $(window).unbind('hashchange', this.change);
+      }
+    };
+
+    Route.navigate = function() {
+      var args, lastArg, options, path;
+      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      options = {};
+      lastArg = args[args.length - 1];
+      if (typeof lastArg === 'object') {
+        options = args.pop();
+      } else if (typeof lastArg === 'boolean') {
+        options.trigger = args.pop();
+      }
+      options = $.extend({}, this.options, options);
+      path = args.join('/');
+      if (this.path === path) {
+        return;
+      }
+      this.path = path;
+      this.trigger('navigate', this.path);
+      if (options.trigger) {
+        this.matchRoute(this.path, options);
+      }
+      if (options.shim) {
+        return;
+      }
+      if (this.history) {
+        return history.pushState({}, document.title, this.path);
+      } else {
+        return window.location.hash = this.path;
+      }
+    };
+
+    Route.getPath = function() {
+      var path;
+      path = window.location.pathname;
+      if (path.substr(0, 1) !== '/') {
+        path = '/' + path;
+      }
+      return path;
+    };
+
+    Route.getHash = function() {
+      return window.location.hash;
+    };
+
+    Route.getFragment = function() {
+      return this.getHash().replace(hashStrip, '');
+    };
+
+    Route.getHost = function() {
+      return (document.location + '').replace(this.getPath() + this.getHash(), '');
+    };
+
+    Route.change = function() {
+      var path;
+      path = this.history ? this.getPath() : this.getFragment();
+      if (path === this.path) {
+        return;
+      }
+      this.path = path;
+      return this.matchRoute(this.path);
+    };
+
+    Route.matchRoute = function(path, options) {
+      var route, _i, _len, _ref1;
+      _ref1 = this.routes;
+      for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+        route = _ref1[_i];
+        if (!(route.match(path, options))) {
+          continue;
+        }
+        this.trigger('change', route, path);
+        return route;
+      }
+    };
+
+    function Route(path, callback) {
+      var match;
+      this.path = path;
+      this.callback = callback;
+      this.names = [];
+      if (typeof path === 'string') {
+        namedParam.lastIndex = 0;
+        while ((match = namedParam.exec(path)) !== null) {
+          this.names.push(match[1]);
+        }
+        splatParam.lastIndex = 0;
+        while ((match = splatParam.exec(path)) !== null) {
+          this.names.push(match[1]);
+        }
+        path = path.replace(escapeRegExp, '\\$&').replace(namedParam, '([^\/]*)').replace(splatParam, '(.*?)');
+        this.route = new RegExp("^" + path + "$");
+      } else {
+        this.route = path;
+      }
+    }
+
+    Route.prototype.match = function(path, options) {
+      var i, match, param, params, _i, _len;
+      if (options == null) {
+        options = {};
+      }
+      match = this.route.exec(path);
+      if (!match) {
+        return false;
+      }
+      options.match = match;
+      params = match.slice(1);
+      if (this.names.length) {
+        for (i = _i = 0, _len = params.length; _i < _len; i = ++_i) {
+          param = params[i];
+          options[this.names[i]] = param;
+        }
+      }
+      return this.callback.call(null, options) !== false;
+    };
+
+    return Route;
+
+  })(Spine.Module);
+
+  Spine.Route.change = Spine.Route.proxy(Spine.Route.change);
+
+  Spine.Controller.include({
+    route: function(path, callback) {
+      return Spine.Route.add(path, this.proxy(callback));
+    },
+    routes: function(routes) {
+      var key, value, _results;
+      _results = [];
+      for (key in routes) {
+        value = routes[key];
+        _results.push(this.route(key, value));
+      }
+      return _results;
+    },
+    navigate: function() {
+      return Spine.Route.navigate.apply(Spine.Route, arguments);
+    }
+  });
+
+  if (typeof module !== "undefined" && module !== null) {
+    module.exports = Spine.Route;
+  }
+
+}).call(this);