sudojs-rails 0.1.7

data/vendor/assets/javascripts/sudo.js

@@ -0,0 +1,778 @@
+(function(window) {
+// #Sudo Namespace
+var sudo = {
+	// Namespace for `Delegate` Class Objects used to delegate functionality
+	// from a `delegator`
+	//
+	// `namespace`
+	delegates: {},
+	// The sudo.ext namespace holds the `extensions` which are stand alone `modules` that
+	// can be `implemented` (mixed-in) to sudo Class Objects
+	//
+	// `namespace`
+	ext: {},
+	// ###_inherit_
+	// Inherit the prototype from a parent to a child.
+	// Set the childs constructor for subclasses of child.
+	// A _private_ method as subclasses of the library base classes will not 
+	// want to use this function in *most* use-cases. Why? User Sudo Class Objects
+	// possess their own constructors and any call back to a `superclass` constructor
+	// will generally be looking for the library Object's constructor.
+	//
+	// `param` {function} `parent`
+	// `param` {function} `child`
+	//
+	// `private`
+	_inherit_: function _inherit_(parent, child) {
+		child.prototype = Object.create(parent.prototype);
+		child.prototype.constructor = child;
+	},
+	// ###makeMeASandwich
+	// Notice there is no need to extrinsically instruct *how* to
+	// make the sandwich, just the elegant single command.
+	//
+	// `returns` {string}
+	makeMeASandwich: function makeMeASandwich() {return 'Okay.';},
+	// ###namespace
+	// Convenience method for assuring a Namespace is defined. Uses
+	// the optional `obj` arg with the Base objects `setPath` method.
+	//
+	// `param` {string} `path`. The path that leads to a blank Object.
+	namespace: function namespace(path) {
+		if (!sudo.Base.prototype.getPath.call(this, path, window)) {
+			sudo.Base.prototype.setPath.call(this, path, {}, window);
+		}
+	},
+	// ###premier
+	// The premier object takes precedence over all others so define it at the topmost level.
+	//
+	// `type` {Object}
+	premier: null,
+	// ####_uid_
+	// Some sudo Objects use a unique integer as a `tag` for identification.
+	// (Views for example). This ensures they are indeed unique.
+	//
+	// `private`
+	_uid_: 0,
+	// ####_unique_
+	// An integer used as 'tags' by some sudo Objects as well
+	// as a unique string for views when needed
+	//
+	// `param` {string} prefix. Optional string identifier
+	// 
+	// `private`
+	_unique_: function _unique_(prefix) {
+		return prefix ? prefix + this._uid_++ : this._uid_++;
+	}
+};
+// ##Base Class Object
+//
+// All sudo.js objects inherit base
+//
+// `param` {Object} data. An optional data object for this instance.
+//
+// `constructor`
+sudo.Base = function(data) {
+	this._data_ = data || {};
+	// can delegate
+	this._delegates_ = [];
+	// may implement `observable`
+	this._callbacks_ = [];
+	this._changeRecords_ = [];
+	// a beautiful and unique snowflake
+	this._uid_ = sudo._unique_();
+};
+// ###addDelegate
+// Push an instance of a Class Object into this object's `_delegates_` list.
+//
+// `param` {Object} an instance of a sudo.delegates Class Object
+// `returns` {Object} `this`
+sudo.Base.prototype.addDelegate = function addDelegate(del) {
+	del._delegator_ = this;
+	this._delegates_.push(del);
+	return this;
+};
+// ###base
+// Lookup the function matching the name passed in  and call it with
+// any passed in argumets scoped to the calling object.
+// This method will avoid the recursive-loop problem by making sure
+// that the first match is not the function that called `base`.
+//
+// `params` {*} any other number of arguments to be passed to the looked up method
+sudo.Base.prototype.base = function base() {
+	var args = Array.prototype.slice.call(arguments),
+		name = args.shift(), 
+		found = false,
+		obj = this,
+		curr;
+	// find method on the prototype, excluding the caller
+	while(!found) {
+		curr = Object.getPrototypeOf(obj);
+		if(curr[name] && curr[name] !== this[name]) found = true;
+		// keep digging
+		else obj = curr;
+	}
+	return curr[name].apply(this, args);
+};
+// ###construct
+// A convenience method that alleviates the need to place:
+// `Object.getPrototypeOf(this).consturctor.apply(this, arguments)`
+// in every constructor
+sudo.Base.prototype.construct = function construct() {
+	Object.getPrototypeOf(this).constructor.apply(this, arguments || []);
+};
+// ###delegate
+// From this object's list of delegates find the object whose `_role_` matches
+// the passed `name` and:
+// 1. if `meth` is falsy return the delegate.
+// 2 if `meth` is truthy bind its method (to the delegate) and return the method
+//
+// `param` {String} `role` The _role_ property to match in this object's delegates list
+// `param` {String} `meth` Optional method to bind to the action this delegate is being used for
+// `returns`
+sudo.Base.prototype.delegate = function delegate(role, meth) {
+	var del = this._delegates_, i;
+	for(i = 0; i < del.length; i++) {
+		if(del[i]._role_ === role) {
+			if(!meth) return del[i];
+			return del[i][meth].bind(del[i]);
+		}
+	}
+};
+// ###get
+// Returns the value associated with a key in this object's data store.
+//
+// `param` {String} `key`. The name of the key
+// `returns` {*}. The value associated with the key or false if not found.
+sudo.Base.prototype.get = function get(key) {
+	return this._data_[key];
+};
+// ###getDelegate
+// Fetch a delegate whose _role_ property matches the passed in argument.
+// Uses the `delegate` method in its 'single argument' form, included for 
+// API consistency
+//
+// `param` {String} `role`
+// 'returns' {Object|undefined}
+sudo.Base.prototype.getDelegate = function getDelegate(role) {
+	return this.delegate(role);
+};
+// ###getPath
+// Extract a value located at `path` relative to this objects data store
+//
+// `param` {String} `path`. The key in the form of a dot-delimited path.
+// `param` {boolean} `obj`. Optional override, forcing getPath to operate on the passed in `obj`
+// argument rather than the default data store owned by `this` Object.
+// `returns` {*|undefined}. The value at keypath or undefined if not found.
+sudo.Base.prototype.getPath = function getPath(path, obj) {
+	var key, curr = obj || this._data_, p;
+	p = path.split('.');
+	for (key; p.length && (key = p.shift());) {
+		if(!p.length) {
+			return curr[key];
+		} else {
+			curr = curr[key] || {};
+		}
+	}
+	return curr;
+};
+// ###gets
+// Assembles and returns an object of key:value pairs for each key
+// contained in the passed in Array.
+//
+// `param` {array} `ary`. An array of keys.
+// `returns` {object}
+sudo.Base.prototype.gets = function gets(ary) {
+	var i, obj = {};
+	for (i = 0; i < ary.length; i++) {
+		obj[ary[i]] = ary[i].indexOf('.') === -1 ? this._data_[ary[i]] :
+			this.getPath(ary[i]);
+	}
+	return obj;
+};
+// ###removeDelegate
+// From this objects `delegates` list remove the object (there should only ever be 1)
+// whose _role_ matches the passed in argument
+//
+// `param` {String} `role`
+// `returns` {Object} `this`
+sudo.Base.prototype.removeDelegate = function removeDelegate(role) {
+	var del = this._delegates_, i;
+	for(i = 0; i < del.length; i++) {
+		if(del[i]._role_ === role) {
+			// no _delegator_ for you
+			del[i]._delegator_ = void 0;
+			del.splice(i, 1);
+			return this;
+		}
+	}
+	return this;
+};
+// `private`
+sudo.Base.prototype._role_ = 'base';
+// ###set
+// Set a key:value pair in `this` object's data store.
+//
+// `param` {String} `key`. The name of the key.
+// `param` {*} `value`. The value associated with the key.
+// `returns` {Object} `this`
+sudo.Base.prototype.set = function set(key, value) {
+	// _NOTE: intentional possibilty of setting a falsy value_
+	this._data_[key] = value;
+	return this;
+};
+// ###setPath
+// Traverse the keypath and get each object 
+// (or make blank ones) eventually setting the value 
+// at the end of the path
+//
+// `param` {string} `path`. The path to traverse when setting a value.
+// `param` {*} `value`. What to set.
+// `param` {Object} `obj`. Optional flag to force setPath to operate on the passed object.
+// `returns` {Object} `this`
+sudo.Base.prototype.setPath = function setPath(path, value, obj) {
+	var curr = obj || this._data_, p = path.split('.'), key;
+	for (key; p.length && (key = p.shift());) {
+		if(!p.length) {
+			curr[key] = value;
+		} else if (curr[key]) {
+			curr = curr[key];
+		} else {
+			curr = curr[key] = {};
+		}
+	}
+	return this;
+};
+// ###sets
+// Invokes `set()` or `setPath()` for each key value pair in `obj`.
+// Any listeners for those keys or paths will be called.
+//
+// `param` {Object} `obj`. The keys and values to set.
+// `returns` {Object} `this`
+sudo.Base.prototype.sets = function sets(obj) {
+	var i, k = Object.keys(obj);
+	for(i = 0; i < k.length; i++) {
+		k[i].indexOf('.') === -1 ? this.set(k[i], obj[k[i]]) :
+			this.setPath(k[i], obj[k[i]]);
+	}
+	return this;
+};
+// ###unset
+// Remove a key:value pair from this object's data store
+//
+// `param` {String} key
+// `returns` {Object} `this`
+sudo.Base.prototype.unset = function unset(key) {
+	delete this._data_[key];
+	return this;
+};
+// ###unsetPath
+// Remove a key:value pair from this object's data store
+// located at <path>
+//
+// `param` {String} path
+// `returns` {Object} `this`
+sudo.Base.prototype.unsetPath = function unsetPath(path) {
+	var curr = this._data_, p = path.split('.'), key;
+	for (key; p.length && (key = p.shift());) {
+		if(!p.length) {
+			delete curr[key];
+		} else {
+			// this can fail if a faulty path is passed.
+			// using getPath beforehand can prevent that
+			curr = curr[key];
+		}
+	}
+	return this;
+};
+// ###unsets
+// Deletes a number of keys or paths from this object's data store
+//
+// `param` {array} `ary`. An array of keys or paths.
+// `returns` {Objaect} `this`
+sudo.Base.prototype.unsets = function unsets(ary) {
+	var i;
+	for(i = 0; i < ary.length; i++) {
+		ary[i].indexOf('.') === -1 ? this.unset(ary[i]) :
+			this.unsetPath(ary[i]);
+	}
+	return this;
+};
+// ##Container Class Object
+//
+// A container is any object that can both contain other objects and
+// itself be contained
+//
+// `constructor`
+sudo.Container = function(data) {
+	sudo.Base.call(this, data);
+	this._children_ = [];
+	this._childNames_ = {};
+};
+// `private`
+sudo._inherit_(sudo.Base, sudo.Container);
+// ###addChild
+// Adds a View to this container's list of children.
+// Also adds an 'index' property and an entry in the childNames hash.
+// If `addedToParent` if found on the child, call it, sending `this` as an argument.
+//
+// `param` {Object} `child`. View (or View subclass) instance.
+// `param` {String} `name`. An optional name for the child that will go in the childNames hash.
+// `returns` {Object} `this`
+sudo.Container.prototype.addChild = function addChild(child, name) {
+	var c = this._children_;
+	child._parent_ = this;
+	child._index_ = c.length;
+	if(name) {
+		child._name_ = name;
+		this._childNames_[name] = child._index_;
+	}
+	c.push(child);
+	if('addedToParent' in child) child.addedToParent(this);
+	return this;
+};
+// ###bubble
+// By default, `bubble` returns the current view's parent (if it has one)
+//
+// `returns` {Object|undefined}
+sudo.Container.prototype.bubble = function bubble() {return this._parent_;};
+// ###getChild
+// If a child was added with a name, via `addChild`,
+// that object can be fetched by name. This prevents us from having to reference a 
+// containers children by index. That is possible however, though not preferred.
+//
+// `param` {String|Number} `id`. The string `name` or numeric `index` of the child to fetch.
+// `returns` {Object|undefined} The found child
+sudo.Container.prototype.getChild = function getChild(id) {
+	return typeof id === 'string' ? this._children_[this._childNames_[id]] :
+		this._children_[id];
+};
+// ###_indexChildren_
+// Method is called with the `index` property of a subview that is being removed.
+// Beginning at <i> decrement subview indices.
+// `param` {Number} `i`
+// `private`
+sudo.Container.prototype._indexChildren_ = function _indexChildren_(i) {
+	var c = this._children_, obj = this._childNames_, len;
+	for (len = c.length; i < len; i++) {
+		c[i]._index_--;
+		// adjust any entries in childNames
+		if(c[i]._name_ in obj) obj[c[i]._name_] = c[i]._index_; 
+	}
+};
+// ###removeChild
+// Find the intended child from my list of children and remove it, removing the name reference and re-indexing
+// remaining children. This method does not remove the child's DOM.
+// Override this method, doing whatever you want to the child's DOM, then call `base('removeChild')` to do so.
+//
+// `param` {String|Number|Object} `arg`. Children will always have an `index` number, and optionally a `name`.
+// If passed a string `name` is assumed, so be sure to pass an actual number if expecting to use index.
+// An object will be assumed to be an actual sudo Class Object.
+// `returns` {Object} `this`
+sudo.Container.prototype.removeChild = function removeChild(arg) {
+	var t = typeof arg, c;
+	// passed an object (or an array - which will fail so don't do that), proceed
+	if(t === 'object') this._removeChild_(arg); 
+	else {
+		c = t === 'string' ? this._children_[this._childNames_[arg]] : this._children_[arg];
+		this._removeChild_(c);
+	}
+	return this;
+};
+// ###_removeChild_
+// Helper method for 'public' removeChild
+// `param` {Object} `child`. The view that is going to be removed.
+// `private`
+sudo.Container.prototype._removeChild_ = function _removeChild_(child) {
+	var i = child._index_;
+	// remove from the children Array
+	this._children_.splice(i, 1);
+	// remove from the named child hash if present
+	delete this._childNames_[child._name_];
+	// child is now an `orphan`
+	delete child._parent_;
+	this._indexChildren_(i);
+};
+// ###removeFromParent
+// Remove this object from its parents list of children.
+// Does not alter the dom - do that yourself by overriding this method
+// or chaining method calls
+sudo.Container.prototype.removeFromParent = function removeFromParent() {
+	// will error without a parent, but that would be your fault...
+	this._parent_._removeChild_(this);
+	return this;
+};
+sudo.Container.prototype._role_ = 'container';
+// ###send
+// The call to the specific method on a (un)specified target happens here.
+// If this Object is part of a `sudo.ext.container` maintained hierarchy
+// the 'target' may be left out, causing the `bubble()` method to be called.
+// What this does is allow children of a `sudo.ext.container` to simply pass
+// events  upward, delegating the responsibility of deciding what to do to the parent.
+//
+// `param` {*} Any number of arguments is supported, but the first is the only one searched for info. 
+// A sendMethod will be located by:
+//   1. using the first argument if it is a string
+//   2. looking for a `sendMethod` property if it is an object
+// In the case a specified target exists at `this.get('sendTarget')` it will be used
+// Any other args will be passed to the sendMethod after `this`
+// `returns` {Object} `this`
+sudo.Container.prototype.send = function send(/*args*/) {
+	var args = Array.prototype.slice.call(arguments),
+		meth, targ, fn;
+	// normalize the input, common use cases first
+	if('sendMethod' in this._data_) meth = this._data_.sendMethod;
+	else if(typeof args[0] === 'string') meth = args.shift();
+	// less common but viable options
+	if(!meth) {
+		// passed as a jquery custom data attr bound in events
+		meth = 'data' in args[0] ? args[0].data.sendMethod :
+			// passed in a hash from something or not passed at all
+			args[0].sendMethod || void 0;
+	}
+	// target is either specified or my parent
+	targ = this._data_['sendTarget'] || this._parent_;
+	// obvious chance for errors here, don't be dumb
+	fn = targ[meth];
+	while(!fn && (targ = targ.bubble())) {
+		fn = targ[meth];
+	}
+	// sendMethods expect a signature (sender, ...)
+	if(fn) {
+		args.unshift(this);
+		fn.apply(targ, args);
+	}
+	return this;
+};
+// ##View Class Object
+
+// Create an instance of a sudo.View object. A view is any object
+// that maintains its own `el`, that being some type of DOM element.
+// Pass in a string selector or an actual dom node reference to have the object
+// set that as its `el`. If no `el` is specified one will be created upon instantiation
+// based on the `tagName` (`div` by default). Specify `className`, `id` (or other attributes if desired)
+// as an (optional) `attributes` object literal on the `data` arg.
+//
+// The view object uses jquery for dom manipulation
+// and event delegation etc... A jquerified `this` reference is located
+// at `this.$el` and `this.$` scopes queries to this objects `el`, i.e it's
+// a shortcut for `this.$el.find(selector)`
+//
+// `param` {string|element|jQuery} `el`. Otional el for the View instance.
+// `param` {Object} `data`. Optional data object.
+//
+// `constructor`
+sudo.View = function(el, data) {
+	sudo.Container.call(this, data);
+	this.setEl(el);
+	if(this._role_ === 'view') this.init();
+};
+// View inherits from Container
+// `private`
+sudo._inherit_(sudo.Container, sudo.View);
+// ###becomePremier
+// Premier functionality provides hooks for behavioral differentiation
+// among elements or class objects.
+//
+// `returns` {Object} `this`
+sudo.View.prototype.becomePremier = function becomePremier() {
+	var p, f = function() {
+			this._isPremier_ = true;
+			sudo.premier = this;
+		}.bind(this);
+	// is there an existing premier that isn't me?
+	if((p = sudo.premier) && p._uid_ !== this._uid_) {
+		// ask it to resign and call the cb
+		p.resignPremier(f);
+	} else f(); // no existing premier
+	return this;
+};
+// ###init
+// A 'contruction-time' hook to call for further initialization needs in 
+// View objects (and their subclasses). A noop by default child classes should override.
+sudo.View.prototype.init = $.noop;
+// the el needs to be normalized before use
+// `private`
+sudo.View.prototype._normalizedEl_ = function _normalizedEl_(el) {
+	if(typeof el === 'string') {
+		return $(el);
+	} else {
+		// Passed an already `jquerified` Element?
+		// It will have a length of 1 if so.
+		return el.length ? el : $(el);
+	}	
+};
+// ### resignPremier
+// Resign premier status
+//
+// `param` {Function} `cb`. An optional callback to execute
+// after resigning premier status.
+// `returns` {Object} `this`
+sudo.View.prototype.resignPremier = function resignPremier(cb) {
+	var p;
+	this._isPremier_ = false;
+	// only remove the global premier if it is me
+	if((p = sudo.premier) && p._uid_ === this._uid_) {
+		sudo.premier = null;
+	}
+	// fire the cb if passed
+	if(cb) cb();
+	return this;
+};
+// `private`
+sudo.View.prototype._role_ = 'view';
+// ###setEl
+// A view must have an element, set that here.
+// Stores a jquerified object as `this.$el` the raw
+// node is always then available as `this.$el[0]`.
+//
+// `param` {string=|element} `el`
+// `returns` {Object} `this`
+sudo.View.prototype.setEl = function setEl(el) {
+	var a, t;
+	if(!el) {
+		// normalize any relevant data
+		t = this._data_['tagName'] || 'div';
+		this.$el = $(document.createElement(t));
+		if((a = this._data_['attributes'])) this.$el.attr(a);
+	} else {
+		this.$el = this._normalizedEl_(el);
+	}
+	return this;
+};
+// ###this.$
+// Return a single Element matching `sel` scoped to this View's el.
+// This is an alias to `this.$el.find(sel)`.
+//
+// `param` {string} `sel`. A jQuery compatible selector
+// `returns` {jQuery} A 'jquerified' result matching the selector
+sudo.View.prototype.$ = function(sel) {
+	return this.$el.find(sel);
+};
+// ## Observable Extension Object
+// Implementaion of the ES6 Harmony Observer pattern
+sudo.ext.observable = {
+	// ###_deliver_
+	// Called from deliverChangeRecords when ready to send
+	// changeRecords to observers.
+	//
+	// `private`
+	_deliver_: function _deliver_(obj) {
+		var i, cb = this._callbacks_;
+		for(i = 0; i < cb.length; i++) {
+			cb[i](obj);
+		}
+	},
+	// ###deliverChangeRecords
+	// Iterate through the changeRecords array(emptying it as you go), delivering them to the
+	// observers. You can override this method to change the standard delivery behavior.
+	//
+	// `returns` {Object} `this`
+	deliverChangeRecords: function deliverChangeRecords() {
+		var rec, cr = this._changeRecords_;
+		// FIFO
+		for(rec; cr.length && (rec = cr.shift());) {
+			this._deliver_(rec);
+		}
+		return this;
+	},
+	// ###observe
+	// In a quasi-ES6 Object.observe pattern, calling observe on an `observable` and 
+	// passing a callback will cause that callback to be called whenever any
+	// property on the observable's data store is set, changed or deleted 
+	// via set, unset, setPath or unsetPath with an object containing:
+	//     {
+	//	     type: <new, updated, deleted>,
+	//	     object: <the object being observed>,
+	//	     name: <the key that was modified>,
+	//	     oldValue: <if a previous value existed for this key>
+	//     }
+	// For ease of 'unobserving' the same Function passed in is returned.
+	//
+	// `param` {Function} `fn` The callback to be called with changeRecord(s)
+	// `returns` {Function} the Function passed in as an argument
+	observe: function observe(fn) {
+		// this will fail if mixed-in and no `callbacks` created so don't do that.
+		// Per the spec, do not allow the same callback to be added
+		var d = this._callbacks_;
+		if(d.indexOf(fn) === -1) d.push(fn);
+		return fn;
+	},
+	// ###observes
+	// Allow an array of callbacks to be registered as changeRecord recipients
+	//
+	// `param` {Array} ary
+	// `returns` {Object} `this`
+	observes: function observes(ary) {
+		var i;
+		for(i = 0; i < ary.length; i++) {
+			this.observe(ary[i]);
+		}
+		return this;
+	},
+	// ###set
+	// Overrides sudo.Base.set to check for observers
+	//
+	// `param` {String} `key`. The name of the key
+	// `param` {*} `value`
+	// `param` {Bool} `hold` Call _deliver_ (falsy) or store the change notification
+	// to be delivered upon a call to deliverChangeRecords (truthy)
+	//
+	// `returns` {Object|*} `this` or calls deliverChangeRecords
+	set: function set(key, value, hold) {
+		var obj = {name: key, object: this._data_};
+		// did this key exist already
+		if(key in this._data_) {
+			obj.type = 'updated';
+			// then there is an oldValue
+			obj.oldValue = this._data_[key];
+		} else obj.type = 'new';
+		// now actually set the value
+		this._data_[key] = value;
+		this._changeRecords_.push(obj);
+		// call the observers or not
+		if(hold) return this;
+		return this.deliverChangeRecords();
+	},
+	// ###setPath
+	// Overrides sudo.Base.setPath to check for observers.
+	// Change records originating from a `setPath` operation
+	// send back the passed in `path` as `name` as well as the
+	// top level object being observed (this observable's _data_).
+	// this allows for easy filtering either manually or via a 
+	// `change delegate`
+	//
+	// `param` {String} `path`
+	// `param` {*} `value`
+	// `param` {Bool} `hold` Call _deliver_ (falsy) or store the change notification
+	// to be delivered upon a call to deliverChangeRecords (truthy)
+	// `returns` {Object|*} `this` or calls deliverChangeRecords
+	setPath: function setPath(path, value, hold) {
+		var curr = this._data_, obj = {name: path, object: this._data_},
+			p = path.split('.'), key;
+		for (key; p.length && (key = p.shift());) {
+			if(!p.length) {
+				// reached the last refinement, pre-existing?
+				if (key in curr) {
+					obj.type = 'updated';
+					obj.oldValue = curr[key];
+				} else obj.type = 'new';
+				curr[key] = value;
+			} else if (curr[key]) {
+				curr = curr[key];
+			} else {
+				curr = curr[key] = {};
+			}
+		}
+		this._changeRecords_.push(obj);
+		// call all observers or not
+		if(hold) return this;
+		return this.deliverChangeRecords();
+	}, 
+	// ###sets
+	// Overrides Base.sets to hold the call to _deliver_ until
+	// all operations are done
+	//
+	// `returns` {Object|*} `this` or calls deliverChangeRecords
+	sets: function sets(obj, hold) {
+		var i, k = Object.keys(obj);
+		for(i = 0; i < k.length; i++) {
+			k[i].indexOf('.') === -1 ? this.set(k[i], obj[k[i]], true) :
+				this.setPath(k[i], obj[k[i]], true);
+		}
+		if(hold) return this;
+		return this.deliverChangeRecords();
+	},
+	// ###unobserve
+	// Remove a particular callback from this observable
+	//
+	// `param` {Function} the function passed in to `observe`
+	// `returns` {Object} `this`
+	unobserve: function unobserve(fn) {
+		var cb = this._callbacks_, i = cb.indexOf(fn);
+		if(i !== -1) cb.splice(i, 1);
+		return this;
+	},
+	// ###unobserves
+	// Allow an array of callbacks to be unregistered as changeRecord recipients
+	//
+	// `param` {Array} ary
+	// `returns` {Object} `this`
+	unobserves: function unobserves(ary) {
+		var i;
+		for(i = 0; i < ary.length; i++) {
+			this.unobserve(ary[i]);
+		}
+		return this;
+	},
+	// ###unset
+	// Overrides sudo.Base.unset to check for observers
+	//
+	// `param` {String} `key`. The name of the key
+	// `param` {Bool} `hold`
+	//
+	// `returns` {Object|*} `this` or calls deliverChangeRecords
+	unset: function unset(key, hold) {
+		var obj = {name: key, object: this._data_, type: 'deleted'}, 
+			val = !!this._data_[key];
+		delete this._data_[key];
+		// call the observers if there was a val to delete
+		return this._unset_(obj, val, hold);
+	},
+	// ###_unset_
+	// Helper for the unset functions
+	//
+	// `private`
+	_unset_: function _unset_(o, v, h) {
+		if(v) {
+			this._changeRecords_.push(o);
+			if(h) return this;
+			return this.deliverChangeRecords();
+		}
+		return this;
+	},
+	// ###setPath
+	// Overrides sudo.Base.unsetPath to check for observers
+	//
+	// `param` {String} `path`
+	// `param` {*} `value`
+	// `param` {bool} `hold`
+	//
+	// `returns` {Object|*} `this` or calls deliverChangeRecords
+	unsetPath: function unsetPath(path, hold) {
+		var obj = {name: path, object: this._data_, type: 'deleted'}, 
+			curr = this._data_, p = path.split('.'), 
+			key, val;
+		for (key; p.length && (key = p.shift());) {
+			if(!p.length) {
+				// reached the last refinement
+				val = !!curr[key];
+				delete curr[key];
+			} else {
+				// this can obviously fail, but can be prevented by checking
+				// with `getPath` first.
+				curr = curr[key];
+			}
+		}
+		return this._unset_(obj, val, hold);
+	},
+	// ###unsets
+	// Override of Base.unsets to hold the call to _deliver_ until done
+	//
+	// `param` ary 
+	// `param` hold
+	// `returns` {Object|*} `this` or calls deliverChangeRecords
+	unsets: function unsets(ary, hold) {
+		var i;
+		for(i = 0; i < ary.length; i++) {
+			ary[i].indexOf('.') === -1 ? this.unset(k[i], true) :
+				this.unsetPath(k[i], true);
+		}
+		if(hold) return this;
+		return this.deliverChangeRecords();	
+	}
+};
+sudo.version = "0.8.0";
+window.sudo = sudo;
+if(typeof window._ === "undefined") window._ = sudo;
+}).call(this, this);