laces 0.1.0

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

@@ -0,0 +1,291 @@
+// Backbone.Model
+// --------------
+
+// Create a new model, with defined attributes. A client id (`cid`)
+// is automatically generated and assigned for you.
+Backbone.Model = function(attributes, options) {
+  var defaults;
+  attributes || (attributes = {});
+  if (defaults = this.defaults) {
+    if (_.isFunction(defaults)) defaults = defaults.call(this);
+    attributes = _.extend({}, defaults, attributes);
+  }
+  this.attributes = {};
+  this._escapedAttributes = {};
+  this.cid = _.uniqueId('c');
+  this.set(attributes, {silent : true});
+  this._changed = false;
+  this._previousAttributes = _.clone(this.attributes);
+  if (options && options.collection) this.collection = options.collection;
+  this.initialize(attributes, options);
+};
+
+// Attach all inheritable methods to the Model prototype.
+_.extend(Backbone.Model.prototype, Backbone.Events, {
+
+  // Has the item been changed since the last `"change"` event?
+  _changed : false,
+
+  // The default name for the JSON `id` attribute is `"id"`. MongoDB and
+  // CouchDB users may want to set this to `"_id"`.
+  idAttribute : 'id',
+
+  // Initialize is an empty function by default. Override it with your own
+  // initialization logic.
+  initialize : function(){},
+
+  // Return a copy of the model's `attributes` object.
+  toJSON : function() {
+    return _.clone(this.attributes);
+  },
+
+  // Get the value of an attribute.
+  get : function(attr) {
+    return this.attributes[attr];
+  },
+
+  // Get the HTML-escaped value of an attribute.
+  escape : function(attr) {
+    var html;
+    if (html = this._escapedAttributes[attr]) return html;
+    var val = this.attributes[attr];
+    return this._escapedAttributes[attr] = _.escape(val == null ? '' : '' + val);
+  },
+
+  // Returns `true` if the attribute contains a value that is not null
+  // or undefined.
+  has : function(attr) {
+    return this.attributes[attr] != null;
+  },
+
+  // Set a hash of model attributes on the object, firing `"change"` unless you
+  // choose to silence it.
+  set : function(attrs, options) {
+
+    // Extract attributes and options.
+    options || (options = {});
+    if (!attrs) return this;
+    if (attrs.attributes) attrs = attrs.attributes;
+    var now = this.attributes, escaped = this._escapedAttributes;
+
+    // Run validation.
+    if (!options.silent && this.validate && !this._performValidation(attrs, options)) return false;
+
+    // Check for changes of `id`.
+    if (this.idAttribute in attrs) this.id = attrs[this.idAttribute];
+
+    // We're about to start triggering change events.
+    var alreadyChanging = this._changing;
+    this._changing = true;
+
+    // Update attributes.
+    for (var attr in attrs) {
+      var val = attrs[attr];
+      if (!_.isEqual(now[attr], val)) {
+        now[attr] = val;
+        delete escaped[attr];
+        this._changed = true;
+        if (!options.silent) this.trigger('change:' + attr, this, val, options);
+      }
+    }
+
+    // Fire the `"change"` event, if the model has been changed.
+    if (!alreadyChanging && !options.silent && this._changed) this.change(options);
+    this._changing = false;
+    return this;
+  },
+
+  // Remove an attribute from the model, firing `"change"` unless you choose
+  // to silence it. `unset` is a noop if the attribute doesn't exist.
+  unset : function(attr, options) {
+    if (!(attr in this.attributes)) return this;
+    options || (options = {});
+    var value = this.attributes[attr];
+
+    // Run validation.
+    var validObj = {};
+    validObj[attr] = void 0;
+    if (!options.silent && this.validate && !this._performValidation(validObj, options)) return false;
+
+    // changedAttributes needs to know if an attribute has been unset.
+    (this._unsetAttributes || (this._unsetAttributes = [])).push(attr);
+
+    // Remove the attribute.
+    delete this.attributes[attr];
+    delete this._escapedAttributes[attr];
+    if (attr == this.idAttribute) delete this.id;
+    this._changed = true;
+    if (!options.silent) {
+      this.trigger('change:' + attr, this, void 0, options);
+      this.change(options);
+    }
+    return this;
+  },
+
+  // Clear all attributes on the model, firing `"change"` unless you choose
+  // to silence it.
+  clear : function(options) {
+    options || (options = {});
+    var attr;
+    var old = this.attributes;
+
+    // Run validation.
+    var validObj = {};
+    for (attr in old) validObj[attr] = void 0;
+    if (!options.silent && this.validate && !this._performValidation(validObj, options)) return false;
+
+    this.attributes = {};
+    this._escapedAttributes = {};
+    this._changed = true;
+    if (!options.silent) {
+      for (attr in old) {
+        this.trigger('change:' + attr, this, void 0, options);
+      }
+      this.change(options);
+    }
+    return this;
+  },
+
+  // Fetch the model from the server. If the server's representation of the
+  // model differs from its current attributes, they will be overriden,
+  // triggering a `"change"` event.
+  fetch : function(options) {
+    options || (options = {});
+    var model = this;
+    var success = options.success;
+    options.success = function(resp, status, xhr) {
+      if (!model.set(model.parse(resp, xhr), options)) return false;
+      if (success) success(model, resp);
+    };
+    options.error = wrapError(options.error, model, options);
+    return (this.sync || Backbone.sync).call(this, 'read', this, options);
+  },
+
+  // Set a hash of model attributes, and sync the model to the server.
+  // If the server returns an attributes hash that differs, the model's
+  // state will be `set` again.
+  save : function(attrs, options) {
+    options || (options = {});
+    if (attrs && !this.set(attrs, options)) return false;
+    var model = this;
+    var success = options.success;
+    options.success = function(resp, status, xhr) {
+      if (!model.set(model.parse(resp, xhr), options)) return false;
+      if (success) success(model, resp, xhr);
+    };
+    options.error = wrapError(options.error, model, options);
+    var method = this.isNew() ? 'create' : 'update';
+    return (this.sync || Backbone.sync).call(this, method, this, options);
+  },
+
+  // Destroy this model on the server if it was already persisted. Upon success, the model is removed
+  // from its collection, if it has one.
+  destroy : function(options) {
+    options || (options = {});
+    if (this.isNew()) return this.trigger('destroy', this, this.collection, options);
+    var model = this;
+    var success = options.success;
+    options.success = function(resp) {
+      model.trigger('destroy', model, model.collection, options);
+      if (success) success(model, resp);
+    };
+    options.error = wrapError(options.error, model, options);
+    return (this.sync || Backbone.sync).call(this, 'delete', this, options);
+  },
+
+  // Default URL for the model's representation on the server -- if you're
+  // using Backbone's restful methods, override this to change the endpoint
+  // that will be called.
+  url : function() {
+    var base = getUrl(this.collection) || this.urlRoot || urlError();
+    if (this.isNew()) return base;
+    return base + (base.charAt(base.length - 1) == '/' ? '' : '/') + encodeURIComponent(this.id);
+  },
+
+  // **parse** converts a response into the hash of attributes to be `set` on
+  // the model. The default implementation is just to pass the response along.
+  parse : function(resp, xhr) {
+    return resp;
+  },
+
+  // Create a new model with identical attributes to this one.
+  clone : function() {
+    return new this.constructor(this);
+  },
+
+  // A model is new if it has never been saved to the server, and lacks an id.
+  isNew : function() {
+    return this.id == null;
+  },
+
+  // Call this method to manually fire a `change` event for this model.
+  // Calling this will cause all objects observing the model to update.
+  change : function(options) {
+    this.trigger('change', this, options);
+    this._previousAttributes = _.clone(this.attributes);
+    this._unsetAttributes = null;
+    this._changed = false;
+  },
+
+  // Determine if the model has changed since the last `"change"` event.
+  // If you specify an attribute name, determine if that attribute has changed.
+  hasChanged : function(attr) {
+    if (attr) return this._previousAttributes[attr] != this.attributes[attr];
+    return this._changed;
+  },
+
+  // Return an object containing all the attributes that have changed, or false
+  // if there are no changed attributes. Useful for determining what parts of a
+  // view need to be updated and/or what attributes need to be persisted to
+  // the server. Unset attributes will be set to undefined.
+  changedAttributes : function(now) {
+    now || (now = this.attributes);
+    var old = this._previousAttributes, unset = this._unsetAttributes;
+
+    var changed = false;
+    for (var attr in now) {
+      if (!_.isEqual(old[attr], now[attr])) {
+        changed || (changed = {});
+        changed[attr] = now[attr];
+      }
+    }
+
+    if (unset) {
+      changed || (changed = {});
+      var len = unset.length;
+      while (len--) changed[unset[len]] = void 0;
+    }
+
+    return changed;
+  },
+
+  // Get the previous value of an attribute, recorded at the time the last
+  // `"change"` event was fired.
+  previous : function(attr) {
+    if (!attr || !this._previousAttributes) return null;
+    return this._previousAttributes[attr];
+  },
+
+  // Get all of the attributes of the model at the time of the previous
+  // `"change"` event.
+  previousAttributes : function() {
+    return _.clone(this._previousAttributes);
+  },
+
+  // Run validation against a set of incoming attributes, returning `true`
+  // if all is well. If a specific `error` callback has been passed,
+  // call that instead of firing the general `"error"` event.
+  _performValidation : function(attrs, options) {
+    var error = this.validate(attrs);
+    if (error) {
+      if (options.error) {
+        options.error(this, error, options);
+      } else {
+        this.trigger('error', this, error, options);
+      }
+      return false;
+    }
+    return true;
+  }
+
+});

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

@@ -0,0 +1,45 @@
+Backbone.Router = (options) ->
+  options or (options = {})
+  @routes = options.routes if options.routes
+  @_bindRoutes()
+  @initialize.apply this, arguments
+
+namedParam   = /:([\w\d]+)/g
+splatParam   = /\*([\w\d]+)/g
+escapeRegExp = /[-[\]{}()+?.,\\^$|#\s]/g
+_.extend Backbone.Router::, Backbone.Events,
+  initialize: ->
+  route: (route, name, callback) ->
+    Backbone.history or (Backbone.history = new Backbone.History)
+    route = @_routeToRegExp route unless _.isRegExp(route)
+    Backbone.history.route route, _.bind((fragment) ->
+      args = @_extractParameters(route, fragment)
+      callback and callback.apply(this, args)
+      @trigger.apply this, [ "route:" + name ].concat(args)
+    , this)
+
+  navigate: (fragment, triggerRoute) ->
+    Backbone.history.navigate fragment, triggerRoute
+
+  _bindRoutes: ->
+    return  unless @routes
+    routes = []
+    for route of @routes
+      routes.unshift [ route, @routes[route] ]
+    i = 0
+    l = routes.length
+
+    while i < l
+      @route routes[i][0],
+             routes[i][1],
+             this[routes[i][1]]
+      i++
+
+  _routeToRegExp: (route) ->
+    route  = route.replace escapeRegExp, "\\$&"
+    route  = route.replace namedParam  , "([^/]*)"
+    route  = route.replace splatParam  , "(.*?)"
+    new RegExp("^" + route + "$")
+
+  _extractParameters: (route, fragment) ->
+    route.exec(fragment).slice 1

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

@@ -0,0 +1,38 @@
+Backbone.sync = (method, model, options) ->
+  type = methodMap[method]
+  params =
+    type: type
+    dataType: "json"
+
+  params.url = getUrl(model) or urlError()  unless options.url
+
+  if not options.data and model and (method is 'create' or method is 'update')
+    extra              = options.extra
+    data               = model.toJSON()
+    data               = _.extend data, extra  unless extra is undefined
+    params.contentType = "application/json"
+    params.data        = JSON.stringify data
+
+  if method is 'delete'
+    param              = $("meta[name= 'csrf-param']").attr 'content'
+    token              = $("meta[name= 'csrf-token']").attr 'content'
+    data               = authenticity_token: token
+    params.contentType = 'application/json'
+    params.data        = JSON.stringify data
+
+  emulate_json = Backbone.emulateJSON
+  if emulate_json
+    params.contentType = 'application/x-www-form-urlencoded'
+    params.data        = if params.data then model: params.data else {}
+
+  if Backbone.emulateHTTP
+    if type is 'PUT' or type is 'DELETE'
+      params.data._method = type  if emulate_json
+      params.type         = 'POST'
+      params.beforeSend   = (xhr) -> xhr.setRequestHeader "X-HTTP-Method-Override", type
+
+  if params.type isnt 'GET' and not emulate_json
+    params.processData = false
+
+  params = _.extend params, options
+  $.ajax params

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

@@ -0,0 +1,150 @@
+// Backbone.View
+// -------------
+
+// Creating a Backbone.View creates its initial element outside of the DOM,
+// if an existing element is not provided...
+Backbone.View = function(options) {
+  this.cid = _.uniqueId('view');
+  this._configure(options || {});
+  this._ensureElement();
+  this.delegateEvents();
+  this.initialize.apply(this, arguments);
+};
+
+// Element lookup, scoped to DOM elements within the current view.
+// This should be prefered to global lookups, if you're dealing with
+// a specific view.
+var selectorDelegate = function(selector) {
+  return $(selector, this.el);
+};
+
+// Cached regex to split keys for `delegate`.
+var eventSplitter = /^(\S+)\s*(.*)$/;
+
+// List of view options to be merged as properties.
+var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName'];
+
+// Set up all inheritable **Backbone.View** properties and methods.
+_.extend(Backbone.View.prototype, Backbone.Events, {
+
+  // The default `tagName` of a View's element is `"div"`.
+  tagName : 'div',
+
+  // Attach the `selectorDelegate` function as the `$` property.
+  $       : selectorDelegate,
+
+  // Initialize is an empty function by default. Override it with your own
+  // initialization logic.
+  initialize : function(){},
+
+  // **render** is the core function that your view should override, in order
+  // to populate its element (`this.el`), with the appropriate HTML. The
+  // convention is for **render** to always return `this`.
+  render : function() {
+    return this;
+  },
+
+  // Remove this view from the DOM. Note that the view isn't present in the
+  // DOM by default, so calling this method may be a no-op.
+  remove : function() {
+    $(this.el).remove();
+    return this;
+  },
+
+  // For small amounts of DOM Elements, where a full-blown template isn't
+  // needed, use **make** to manufacture elements, one at a time.
+  //
+  //     var el = this.make('li', {'class': 'row'}, this.model.escape('title'));
+  //
+  make : function(tagName, attributes, content) {
+    var el = document.createElement(tagName);
+    if (attributes) $(el).attr(attributes);
+    if (content) $(el).html(content);
+    return el;
+  },
+
+  // Set callbacks, where `this.events` is a hash of
+  //
+  // *{"event selector": "callback"}*
+  //
+  //     {
+  //       'mousedown .title':  'edit',
+  //       'click .button':     'save'
+  //     }
+  //
+  // pairs. Callbacks will be bound to the view, with `this` set properly.
+  // Uses event delegation for efficiency.
+  // Omitting the selector binds the event to `this.el`.
+  // This only works for delegate-able events: not `focus`, `blur`, and
+  // not `change`, `submit`, and `reset` in Internet Explorer.
+  delegateEvents : function(events) {
+    if (!(events || (events = this.events))) return;
+    if (_.isFunction(events)) events = events.call(this);
+    this.undelegateEvents();
+    for (var key in events) {
+      var method = this[events[key]];
+      if (!method) throw new Error('Event "' + events[key] + '" does not exist');
+      var match = key.match(eventSplitter);
+      var eventName = match[1], selector = match[2];
+      method = _.bind(method, this);
+      eventName += '.delegateEvents' + this.cid;
+      if (selector === '') {
+        $(this.el).bind(eventName, method);
+      } else {
+        $(this.el).delegate(selector, eventName, method);
+      }
+    }
+  },
+
+  // Clears all callbacks previously bound to the view with `delegateEvents`.
+  undelegateEvents: function() {
+    $(this.el).unbind('.delegateEvents' + this.cid);
+  },
+
+  // Performs the initial configuration of a View with a set of options.
+  // Keys with special meaning *(model, collection, id, className)*, are
+  // attached directly to the view.
+  _configure : function(options) {
+    if (this.options) options = _.extend({}, this.options, options);
+    for (var i = 0, l = viewOptions.length; i < l; i++) {
+      var attr = viewOptions[i];
+      if (options[attr]) this[attr] = options[attr];
+    }
+    this.options = options;
+  },
+
+  // Ensure that the View has a DOM element to render into.
+  // If `this.el` is a string, pass it through `$()`, take the first
+  // matching element, and re-assign it to `el`. Otherwise, create
+  // an element from the `id`, `className` and `tagName` properties.
+  _ensureElement : function() {
+    if (!this.el) {
+      var attrs = this.attributes || {};
+      if (this.id) attrs.id = this.id;
+      if (this.className) attrs['class'] = this.className;
+      this.el = this.make(this.tagName, attrs);
+    } else if (_.isString(this.el)) {
+      this.el = $(this.el).get(0);
+    }
+  }
+
+});
+
+// The self-propagating extend function that Backbone classes use.
+var extend = function (protoProps, classProps) {
+  var child = inherits(this, protoProps, classProps);
+  child.extend = this.extend;
+  return child;
+};
+
+// Set up inheritance for the model, collection, and view.
+Backbone.Model.extend = Backbone.Collection.extend =
+  Backbone.Router.extend = Backbone.View.extend = extend;
+
+// Map from CRUD to HTTP for our default `Backbone.sync` implementation.
+var methodMap = {
+  'create': 'POST',
+  'update': 'PUT',
+  'delete': 'DELETE',
+  'read'  : 'GET'
+};