sudojs-rails 0.1.7

data/lib/generators/sudojs/install/templates/app_manifest.js.erb

@@ -0,0 +1,4 @@
+//= require jquery_ujs
+//= require <%= which_sudo_arg %>
+//= require application/<%= name %>
+//= require application/model

data/lib/generators/sudojs/install/templates/model.coffee.erb

@@ -0,0 +1,9 @@
+# Global model is a sudo.Observable
+class <%= name %>.Model extends _.Base
+  constructor: (data) ->
+    super data
+    $.extend @, _.ext.observable
+
+# attach the model to the <%= name %> namespace
+<%= name %>.model = new <%= name %>.Model()
+

data/lib/generators/sudojs/install/templates/model.js.erb

@@ -0,0 +1,9 @@
+// Global model is a sudo.Observable
+<%= name %>.Model = function(data) {
+  this.construct(data);
+  $.extend(this, _.ext.observable);
+};
+// `private`
+<%= name %>.Model.prototype = Object.create(sudo.Base.prototype);
+// attach the model to the <%= name %> namespace
+<%= name %>.model = new <%= name %>.Model();

data/lib/generators/sudojs/install/templates/namespace.coffee.erb

@@ -0,0 +1,8 @@
+# Define the top-level app namespace as defined in the sudo_js yaml file.
+
+# The `descriptors` array is a global necessity that solves the issue of
+# child objects being parsed on a _partial before their parent ViewControllers
+# (who are declared on a containing view file)
+window.<%= name %> = 
+  descriptors: []
+

data/lib/generators/sudojs/install/templates/namespace.js.erb

@@ -0,0 +1,8 @@
+// Define the top-level app namespace as defined in the sudo_js yaml file.
+
+// The `descriptors` array is a global necessity that solves the issue of
+// child objects being parsed on a _partial before their parent ViewControllers
+// (who are declared on a containing view file)
+window.<%= name %> = {
+  descriptors: []
+};

data/lib/generators/sudojs/install/templates/sudo_js.erb.yml

@@ -0,0 +1,11 @@
+# What is the applications top level namespace?
+js_namespace: <%= name %>
+
+# sudo.js with templating or without?
+which_sudo: <%= which_sudo_arg %>
+
+# erb or haml or ...?
+which_markup: <%= which_markup_arg %>
+
+# coffee?
+use_coffee: <%= use_coffee_arg %>

data/lib/sudojs/engine.rb

@@ -0,0 +1,4 @@
+module Sudojs
+  class Engine < Rails::Engine
+  end
+end

data/lib/sudojs/version.rb

@@ -0,0 +1,3 @@
+module Sudojs
+  VERSION = '0.1.7'
+end

data/lib/sudojs-rails.rb

@@ -0,0 +1,2 @@
+require 'sudojs/version'
+require 'sudojs/engine'

data/sudojs-rails.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'sudojs/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "sudojs-rails"
+  gem.version       = Sudojs::VERSION
+  gem.authors       = ["robrobbins"]
+  gem.email         = ["rob.robb.ns@gmail.com"]
+  gem.description   = "Install the latest versions of sudo.js and provide generators for fast and easy use."
+  gem.summary       = "Install and use sudo.js quickly and easily with rails 3.2+."
+  gem.homepage      = "https://github.com/robrobbins/sudojs-rails"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "rspec", "~> 2.6"
+end

data/vendor/assets/javascripts/README.md

@@ -0,0 +1,3 @@
+## Versions
+
+Publicly released versions of sudo.js downloaded to here

data/vendor/assets/javascripts/sudo-x.js

@@ -0,0 +1,1344 @@
+(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);
+};
+// ##ViewController Class Object
+
+// ViewControllers were designed for Rails projects for 2 specific use-cases:
+//
+// 1. ViewControllers can instantiate any `descriptors` found in their model
+// when constructing, adding them as `child` objects. Why? Sometimes a 'partial' will
+// need to define a javascript object that should, by design, be the child of a parent View
+// that is itself defined on the Rails view that owns the 'partial'. Since any JS introduced
+// by a partial will be parsed before the JS on its parent Rails View this usually isn't possible.
+// Our solution? Pushing `Descriptor objects` (see docs) into an array (somewhere in your namespace) from a 
+// 'partial' and then passing a reference to that array into the ViewController as 'descriptors'
+// in its optional data argument when instantiated. The ViewController will then iterate over those 
+// and instantiate them, adding them as children as it goes (also setting up any stated observers)
+//
+// 2. ViewControllers also abstract away connecting UJS style events by allowing the developer to
+// pass in the name(s) of any desired UJS events to observe: `ujsEvent: ajax:success` for example, 
+// and expect that a method named onAjaxSuccess, if present on the ViewController, will be called
+// with the arguments returned by the UJS plugin*
+//
+// `param` {string|element} `el`. Otional el for the View instance.
+// `param` {object} `data`. Optional data object.
+//
+// `see` sudo.View.
+//
+// `constructor`
+sudo.ViewController = function(el, data) {
+	sudo.View.call(this, el, data);
+	// map the names of events to methods we expect to proxy to
+	this.eventMap = {
+		'ajax:before': 'onAjaxBefore',
+		'ajax:beforeSend': 'onAjaxBeforeSend',
+		'ajax:success': 'onAjaxSuccess',
+		'ajax:error': 'onAjaxError',
+		'ajax:complete': 'onAjaxComplete',
+		'ajax:aborted:required': 'onAjaxAbortedRequired',
+		'ajax:aborted:file': 'onAjaxAbortedFile'
+	};
+	// can be called again if mapping changes... 
+	this.doMapping();
+	if('descriptor' in this._data_) this.instantiateChildren([this._data_.descriptor]);
+	if('descriptors' in this._data_) this.instantiateChildren();
+	if(this._role_ === 'viewController') this.init();
+};
+// ViewController inherits from View.
+// `private`
+sudo._inherit_(sudo.View, sudo.ViewController);
+// ###doMapping
+//
+// assign the proxy mapping for events. This can be called at any time
+// if the listened for events change
+//
+// `returns` {Object} `this`
+sudo.ViewController.prototype.doMapping = function() {
+	// either a single event or an array of them
+	var i,
+		toMap = this._data_['ujsEvent'] || this._data_['ujsEvents'];
+	if(toMap) {
+		if(typeof toMap === 'string') this._mapEvent(toMap);
+		else {
+			for(i = 0; i < toMap.length; i++) {
+				this._mapEvent(toMap[i]);
+			}
+		}
+	}
+	return this;
+};
+// ###_handleObserve_
+// Helper for instantiateChildren
+// `private`
+sudo.ViewController.prototype._handleObserve_ = function _handleObserve_(obs, c) {
+	var obj = obs.object ? this._objectForPath_(obs.object) : this;
+		obj.observe(c[obs.cb].bind(c));
+};
+// ###instantiateChildren
+// instantiate the children described in the passed in array or the `descriptors` array
+// set in this object's data store
+//
+// `returns` {object} `this`
+sudo.ViewController.prototype.instantiateChildren = function instantiateChildren(ary) {
+	var i, j, curr, c, d = ary || this._data_.descriptors;
+	for(i = 0; i < d.length; i++) {
+		curr = d[i]; 
+		c = new curr.is_a(curr.el, curr.data);
+		this.addChild(c, curr.name);
+		// handle any observe(s)
+		if('observe' in curr) {
+			this._handleObserve_(curr.observe, c);
+		}
+		else if('observes' in curr) {
+			for(j = 0; j < curr.observes.length; j++) {
+				this._handleObserve_(curr.observes[j], c);
+			}
+		}
+	}
+	return this;
+};
+// ###_mapEvent
+// Maps the ajax:event names to methods
+// `private`
+sudo.ViewController.prototype._mapEvent = function(name) {
+		// because the signatures vary we need specific methods
+		this.$el.on(name, this[this.eventMap[name]].bind(this));
+};
+// ###_objectForPath_
+// The objects used for callbacks and connections need to be
+// looked-up via a key-path like address as they likely will not exist
+// when viewController's are instantiated.
+// `private`
+sudo.ViewController.prototype._objectForPath_ = function _objectForPath_(path) {
+	return sudo.Base.prototype.getPath.call(this, path, window);
+};
+// Virtual methods to override in your child classes for
+// any events you chose to listen for
+sudo.ViewController.prototype.onAjaxAbortedFile = $.noop;
+sudo.ViewController.prototype.onAjaxAbortedRequired = $.noop;
+sudo.ViewController.prototype.onAjaxBefore = $.noop;
+sudo.ViewController.prototype.onAjaxBeforeSend = $.noop;
+sudo.ViewController.prototype.onAjaxComplete = $.noop;
+sudo.ViewController.prototype.onAjaxSuccess = $.noop;
+sudo.ViewController.prototype.onAjaxError = $.noop;
+// `private`
+sudo.ViewController.prototype._role_ = 'viewController';
+// ###Templating
+
+// Allow the default {{ js code }}, {{= key }}, and {{- escape stuff }} 
+// micro templating delimiters to be overridden if desired
+//
+// `type` {Object}
+sudo.templateSettings = {
+	evaluate: /\{\{([\s\S]+?)\}\}/g,
+	interpolate: /\{\{=([\s\S]+?)\}\}/g,
+	escape: /\{\{-([\s\S]+?)\}\}/g
+};
+// Certain characters need to be escaped so that they can be put 
+// into a string literal when templating.
+//
+// `type` {Object}
+sudo.escapes = {};
+(function(s) {
+	var e = {
+		'\\': '\\',
+		"'": "'",
+		r: '\r',
+		n: '\n',
+		t: '\t',
+		u2028: '\u2028',
+		u2029: '\u2029'
+	};
+	for (var key in e) s.escapes[e[key]] = key;
+}(sudo));
+// lookup hash for `escape`
+//
+// `type` {Object}
+sudo.htmlEscapes = {
+	'&': '&amp;',
+	'<': '&lt;',
+	'>': '&gt;',
+	'"': '&quot;',
+	"'": '&#x27;',
+	'/': '&#x2F;'
+};
+// Escapes certain characters for templating
+//
+// `type` {regexp}
+sudo.escaper = /\\|'|\r|\n|\t|\u2028|\u2029/g;
+// Escape unsafe HTML
+//
+// `type` {regexp}
+sudo.htmlEscaper = /[&<>"'\/]/g;
+// Unescapes certain characters for templating
+//
+// `type` {regexp}
+sudo.unescaper = /\\(\\|'|r|n|t|u2028|u2029)/g;
+// ###escape
+// Remove unsafe characters from a string
+//
+// `param` {String} str
+sudo.escape = function(str) {
+	return str.replace(sudo.htmlEscaper, function(match) {
+		return sudo.htmlEscapes[match];
+	});
+};
+// ###unescape
+// Within an interpolation, evaluation, or escaping,
+// remove HTML escaping that had been previously added.
+//
+// `param` {string} str
+sudo.unescape = function unescape(str) {
+	return str.replace(sudo.unescaper, function(match, escape) {
+		return sudo.escapes[escape];
+	});
+};
+// ###template
+// JavaScript micro-templating, similar to John Resig's (and it's offspring) implementation.
+// sudo templating preserves whitespace, and correctly escapes quotes within interpolated code.
+// Unlike others sudo.template requires a scope name (to avoid the use of `with`) and will spit at you
+// if it is not present.
+//
+// `param` {string} `str`. The 'templated' string.
+// `param` {Object} `data`. Optional hash of key:value pairs.
+// `param` {string} `scope`. Optional context name of your `data object`, set to 'data' if falsy.
+sudo.template = function template(str, data, scope) {
+	scope || (scope = 'data');
+	var settings = sudo.templateSettings, render, template,
+	// Compile the template source, taking care to escape characters that
+	// cannot be included in a string literal and then unescape them in code blocks.
+	source = "_p+='" + str.replace(sudo.escaper, function(match) {
+		return '\\' + sudo.escapes[match];
+	}).replace(settings.escape, function(match, code) {
+		return "'+\n((_t=(" + sudo.unescape(code) + "))==null?'':sudo.escape(_t))+\n'";
+	}).replace(settings.interpolate, function(match, code) {
+		return "'+\n((_t=(" + sudo.unescape(code) + "))==null?'':_t)+\n'";
+	}).replace(settings.evaluate, function(match, code) {
+		return "';\n" + sudo.unescape(code) + "\n_p+='";
+	}) + "';\n";
+	source = "var _t,_p='';" + source + "return _p;\n";
+	render = new Function(scope, source);
+	if (data) return render(data);
+	template = function(data) {
+		return render.call(this, data);
+	};
+	// Provide the compiled function source as a convenience for reflection/compilation
+	template.source = 'function(' + scope + '){\n' + source + '}';
+	return template;
+};
+// ##Dataview Class Object
+
+// Create an instance of an Object, inheriting from sudo.View that:
+// 1. Expects to have a template located in its internal data Store accessible via `this.get('template')`.
+// 2. Can have a `renderTarget` property in its data store. If so this will be the location
+//		the child injects itself into (if not already in) the DOM
+// 3. Can have a 'renderMethod' property in its data store. If so this is the jQuery method
+//		that the child will use to place itself in it's `renderTarget`.
+// 4. Has a `render` method that when called re-hydrates it's $el by passing its
+//		internal data store to its template
+// 5. Handles event binding/unbinding by implementing the sudo.ext.listener
+//		extension object
+//
+//`constructor`
+sudo.Dataview = function(el, data) {
+	var d, t;
+	sudo.View.call(this, el, data);
+	// implements the listener extension
+	$.extend(this, sudo.ext.listener);
+	d = this._data_;
+	// dont autoRender on the setting of events
+	// add to this to prevent others if needed
+	d.autoRenderBlacklist = {event: true, events: true};
+	// compile my template if not already done
+	if((t = d.template)) {
+		if(typeof t === 'string') d.template = sudo.template(t);
+	}
+	if(this._role_ === 'dataview') {
+		// as all events are delegated to this.$el binding can take place here
+		this.bindEvents();
+		this.init();
+	}
+};
+// `private`
+sudo._inherit_(sudo.View, sudo.Dataview);
+// ###addedToParent
+// Container's will check for the presence of this method and call it if it is present
+// after adding a child - essentially, this will auto render the dataview when added to a parent
+sudo.Dataview.prototype.addedToParent = function() {
+	return this.render();
+};
+// ###removeFromParent
+// Remove this object from the DOM and its parent's list of children.
+// Overrides `sudo.View.removeFromParent` to actually remove the DOM as well
+//
+// `returns` {Object} `this`
+sudo.Dataview.prototype.removeFromParent = function removeFromParent() {
+	this._parent_._removeChild_(this);
+	this.$el.remove();
+	return this;
+};
+// ###render
+// (Re)hydrate the innerHTML of this object via its template and internal data store.
+// If a `renderTarget` is present this Object will inject itself into the target via
+// `this.get('renderMethod')` or defualt to `$.append`. After injection, the `renderTarget`
+// is deleted from this Objects data store.
+// Event unbinding/rebinding is generally not necessary for the Objects innerHTML as all events from the
+// Object's list of events (`this.get('event(s)'))` are delegated to the $el on instantiation.
+//
+// `returns` {Object} `this`
+sudo.Dataview.prototype.render = function render() {
+	var d = this._data_;
+	this.$el.html(d.template(d));
+	if(d.renderTarget) {
+		this._normalizedEl_(d.renderTarget)[d.renderMethod || 'append'](this.$el);
+		delete d.renderTarget;
+	}
+	return this;
+};
+// `private`
+sudo.Dataview.prototype._role_ = 'dataview';
+// ###set
+// Override `sudo.Base.set` to provide auto rendering if desired
+//
+// `returns` {Object|*} `this` or call to `render`
+sudo.Dataview.prototype.set = function set(key, value) {
+	this._data_[key] = value;
+	if(this._data_['autoRender'] && !this._data_.autoRenderBlacklist[key]) return this.render();
+	return this;
+};
+// ###setPath
+// Override `sudo.Base.setPath` to provide auto rendering if desired
+//
+// `returns` {Object|*} `this` or call to `render`
+sudo.Dataview.prototype.setPath = function setPath(path, value) {
+	sudo.Base.prototype.setPath.call(this, path, value);
+	// the blacklist has no paths
+	if(this._data_['autoRender']) return this.render();
+	return this;
+};
+// ###sets
+// Override `sudo.Base.sets` in case of autoRender.being true
+// Temporarily sets `autoRender` to false (if true) to avoid unnecessary
+// rendering, calling `render` when finished with all `set` type operations,
+// returning `autoRender` to true (if appropriate)
+//
+// `returns` {Object|*} `this` or call to `render`
+sudo.Dataview.prototype.sets = function sets(obj) {
+	var a;
+	if(this._data_['autoRender']) {
+		this._data_['autoRender'] = false;
+		a = true;
+	}	
+	sudo.Base.prototype.sets.call(this, obj);
+	if(a) {
+		this._data_['autoRender'] = true;
+		return this.render();
+	}
+	return this;
+};
+// ## 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();	
+	}
+};
+// ##Bindable Extension Object
+
+// Bindable methods allow various properties and attributes of
+// a sudo Class Object to be synchronized with the data contained
+// in a changeRecord recieved via observe().
+//
+// `namespace`
+sudo.ext.bindable = {
+	// List of attributes - $.attr() to be used.
+	//
+	// `private`
+	_attr_: {
+		accesskey: true,
+		align: true,
+		alt: true,
+		contenteditable: true,
+		draggable: true,
+		href: true,
+		label: true,
+		name: true,
+		rel: true,
+		src: true,
+		tabindex: true,
+		title: true
+	},
+	// Some bindings defer to jQuery.css() to be bound.
+	//
+	// `private`
+	_css_: {
+		display: true,
+		visibility: true
+	},
+	// ###_handleAttr_
+	// bind the jQuery prop() method to this object, now exposed
+	// by this name, matching passed `bindings` arguments.
+	//
+	// `param` {string} `meth` The name of the method to be bound
+  // `returns` {Object} `this`
+	// `private`
+	_handleAttr_: function _handleAttr_(meth) {
+		this[meth] = function(obj) {
+			if(obj.name === meth) this.$el.attr(meth, obj.object[obj.name]);
+			return this;
+		};
+		return this;
+	},
+	// ###_handleCss_
+	// bind the jQuery css() method to this object, now exposed
+	// by this name, matching passed `bindings` arguments.
+	//
+	// `param` {string} `meth` The name of the method to be bound
+	// `returns` {Object} `this`
+	// `private`
+	_handleCss_: function _handleCss_(meth) {
+		this[meth] = function(obj) {
+			if(obj.name === meth) this.$el.css(meth, obj.object[obj.name]);
+			return this;
+		};
+		return this;
+	},
+	// ###_handleData_
+	// bind the jQuery data() method to this object, now exposed
+	// by this name, matching passed `bindings` arguments.
+	//
+	// `param` {string} `meth` The name of the method to be bound
+	// `returns` {Object} `this`
+	// `private`
+	_handleData_: function _handleData_(meth) {
+		this[meth] = function(obj) {
+			if(obj.name === meth) {
+				this.$el.data(obj.object[obj.name].key, obj.object[obj.name].value);
+				return this;
+			}
+		};
+		return this;
+	},
+	// ###_handleProp_
+	// bind the jQuery attr() method to this object, now exposed
+	// by this name, matching passed `bindings` arguments.
+	//
+	// NOTE: If more than 1 data-* attribute is desired you must
+	// set those up manually as <obj>.data({..}) is what will be
+	// constructed via this method.
+	//
+	// `param` {string} `meth` The name of the method to be bound.
+	// `returns` {Object} `this`
+	// `private`
+	_handleProp_: function _handleProp_(meth) {
+		this[meth] = function(obj) {
+			if(obj.name === meth) this.$el.prop(meth, obj.object[obj.name]);
+			return this;
+		};
+		return this;
+	},
+	// ###_handleSpec_
+	// bind the jQuery shorthand methods to this object matching
+	// passed `bindings` arguments.
+	//
+	// `param` {string} `meth` The name of the method to be bound.
+	// `returns` {Object} `this`
+	// `private`
+	_handleSpec_: function _handleSpec_(meth) {
+		this[meth] = function(obj) {
+			if(obj.name === meth) this.$el[meth](obj.object[obj.name]);
+			return this;
+		};
+		return this;
+	},
+	// List of properties - $.prop() to be used.
+	//
+	// `private`
+	_prop_: {
+		checked: true,
+		defaultValue: true,
+		disabled: true,
+		location: true,
+		multiple: true,
+		readOnly: true,
+		selected: true
+	},
+	// ###setBinding
+	// Use case when you know there is only a single binding,
+	// create the expected methods and return
+	//
+	// `returns` {Object} `this`
+	setBinding: function setBinding() {
+		return this._setBinding_(this._data_.binding);
+	},
+	// ###_setBinding_
+	// Given a single explicit binding, create it. Called from
+	// _setbindings_ as a convenience for normalizing the
+	// single vs. multiple bindings scenario
+	//
+	// `param` {string} `b` The binding.
+	// `private`
+	_setBinding_: function _setBinding_(b) {
+		if(b in this._spec_) return this[this._spec_[b]](b);
+		if(b in this._css_) return this._handleCss_(b);
+		if(b in this._attr_) return this._handleAttr_(b);
+		if(b in this._prop_) return this._handleProp_(b);
+	},
+	// ###setBindings
+	// Inspect the binding (in the single-bound use case), or the 
+	// bindings Array in this Object's data store and
+	// create the bound functions expected.
+	//
+	// `returns` {Object} `this`
+	setBindings: function setBindings() {
+		var b, i;
+		// handle the single binding use case
+		if((b = this._data_.binding)) return this._setBinding_(b);
+		if(!(b = this._data_.bindings)) return this;
+		for(i = 0; i < b.length; i++) {
+			this._setBinding_(b[i]);
+		}
+		return this;
+	},
+	// `Special` binding cases. jQuery shorthand methods to be used.
+	//
+	// `private`
+	_spec_: {
+		data: '_handleData_',
+		html: '_handleSpec_',
+		text: '_handleSpec_',
+		val: '_handleSpec_'
+	}
+};
+// ##Listener Extension Object
+
+// Handles event binding/unbinding via an events array in the form:
+// events: [{
+//	name: `eventName`,
+//	sel: `an_optional_delegator`,
+//	data: an_optional_hash_of_data
+//	fn: `function name`
+// }, {...
+//	This array will be searched for via `this.get('events')`. There is a 
+//	single-event use case as well, pass a single object literal in the above form.
+//	with the key `event`:
+//	event: {...same as above}
+//	Details about the hashes in the array:
+//	A. name -> jQuery compatible event name
+//	B. sel -> Optional jQuery compatible selector used to delegate events
+//	C. data: A hash that will be passed as the custom jQuery Event.data object
+//	D. fn -> If a {String} bound to the named function on this object, if a 
+//		function assumed to be anonymous and called with no scope manipulation
+sudo.ext.listener = {
+	// ###bindEvents
+	// Bind the events in the data store to this object's $el
+	//
+	// `returns` {Object} `this`
+	bindEvents: function bindEvents() {
+		var e;
+		if((e = this._data_.event || this._data_.events)) this._handleEvents_(e, 1);
+		return this;
+	},
+	// Use the jQuery `on` or 'off' method, optionally delegating to a selector if present
+	// `private`
+	_handleEvents_: function _handleEvents_(e, which) {
+		var i;
+		if(Array.isArray(e)) {
+			for(i = 0; i < e.length; i++) {
+				this._handleEvent_(e[i], which);
+			}
+		} else {
+			this._handleEvent_(e, which);
+		}
+	},
+	// helper for binding and unbinding an individual event
+	// `param` {Object} e. An event descriptor
+	// `param` {String} which. `on` or `off`
+	// `private`
+	_handleEvent_: function _handleEvent_(e, which) {
+		if(which) {
+			this.$el.on(e.name, e.sel, e.data, typeof e.fn === 'string' ? this[e.fn].bind(this) : e.fn);
+		} else {
+			// do not re-bind the fn going to off otherwise the unbind will fail
+			this.$el.off(e.name, e.sel);
+		}
+	},
+	// ###unbindEvents
+	// Unbind the events in the data store from this object's $el
+	//
+	// `returns` {Object} `this`
+	unbindEvents: function unbindEvents() {
+		var e;
+		if((e = this._data_.event || this._data_.events)) this._handleEvents_(e);
+		return this;
+	}
+};
+
+sudo.version = "0.8.0";
+window.sudo = sudo;
+if(typeof window._ === "undefined") window._ = sudo;
+}).call(this, this);