sudojs-rails 0.2.9 → 0.3.0

data/README.md

@@ -75,33 +75,40 @@ and directories (with your shiny new `Spam` namespace).
 
 #### sudojs:install USAGE
 
-		Description:
-			Install sudo.js along with it's particular directory hierarchy.
-
-		Example:
-			rails g sudojs:install namespace [which_sudo] [which_markup] [use_coffee]
-
-			The only mandatory argument is the initial `namespace`.
-
-			The install generator uses these optional arguments to expand the values in the sudo_js.yml file:
-				1. `which_sudo` => which version of sudo.js are you loading? As sudo.js can be rebuilt into any number
-					 of custom configurations, indicate here what name should be placed into the application manifest.
-					 Defaults to 'sudo-x' if omitted.
-				2. `which_markup` => defaults to `erb`.
-				3. `use_coffee` => defaults to `false` pass `true` if you are of the coffee persuasion.
-
-			This will create:
-			app/
-				assets/
-					javascripts/
-						application/
-							yourNamespace.js
-							model.js
-						manifests/
-							application.js
-						views/
-			config/
-				sudo_js.yml
+Description:
+    Install sudo.js along with it's particular directory hierarchy.
+
+Example:
+    rails g sudojs:install namespace [which_sudo] [html_extension] [js_extension] [css_extension] [--skip-css=true/false]
+
+    The only mandatory argument is the initial `namespace`.
+
+    The install generator uses these optional arguments to expand the values in the sudo_js.yml file:
+      1. `which_sudo` => which version of sudo.js are you loading? As sudo.js can be rebuilt into any number
+         of custom configurations, indicate here what name should be placed into the application manifest.
+         Defaults to 'sudo-x' if omitted.
+      2. `html_extension` => Use the full extension, i.e. `.haml`. defaults to `.erb`.
+      3. `js_extension` => defaults to `.js` pass `.js.coffee` if you are of the coffee persuasion.
+      4. `css_extension` => defaults to `.css`. Sass for example would need `.css.scss`
+
+    NOTE: to skip any and all generating of css files pass the option `--skip-css=true` when invoking the install generator.
+    Obviously, you could then leave the `css_extension` argument out. The option defaults to false.
+
+    This will create:
+    app/
+      assets/
+        stylesheets/
+          manifests/
+            application.css
+        javascripts/
+          application/
+            yourNamespace.js
+            model.js
+          manifests/
+            application.js
+          views/
+    config/
+      sudo_js.yml
 
 #### sudojs:class USAGE
 
@@ -109,53 +116,63 @@ After installing a second generator becomes available, run `rails g` again and `
 The reason for this is that `:class` depends on a yaml file to be placed in `config/` to function. Executing the command
 `rails g sudojs:class -h` would reveal this:
 
-		Description:
-			Create a skeletal sudo.js Class and place the files correctly for a given controller#name.
-
-		Example:
-			`rails g sudojs:class View foo#baz`
-
-			Where `View` is a Class Object that this new Object will inherit from. Sudo.js itself
-			will recognize 5 types:
-
-				1. 'Base'
-				2. 'Container'
-				3. 'View'
-				4. 'ViewController'
-				5. 'Dataview'
-
-			The inheritance for any of these will be set as `_.<Name>` as we assume sudo has taken the 
-			global `_` char as an alias. If the argument is any other string we assume you are inheriting
-			from a custom class and pass it through as is.
-
-
-			Where `foo#baz` *can* match a controller#action (like `home#show`) it does not
-			have to. The controller argument (`foo`) allows the generator to place the file correctly and 
-			create/modify the correct manifest file. The name argument will be the proper name of the 
-			Class Object itself
-
-			If a corresponding views/controller/name.html.* is found, a skeletal instantiation of the newly 
-			created View will be placed there
-
-			This will create:
-				app/
-					assests/
-						javascripts/
-							manifests/
-								foo.js
-							views/
-								foo/
-									baz.js
-
-			And modify (if found):
-				app/
-					views/
-						foo/
-							baz.html.*
-
-		Note:
-			If the `route` is application level (application#baz) the file will be placed
-			in the application level directory and the manifests/application file will be modified
+Description:
+    Create a skeletal sudo.js Class and place the files correctly for a given controller#name.
+
+Example:
+    `rails g sudojs:class View foo#baz`
+
+    Where `View` is a Class Object that this new Object will inherit from. Sudo.js itself
+    will recognize 6 types:
+
+      1. 'Base'
+      2. 'Model'
+      3. 'Container'
+      4. 'View'
+      5. 'ViewController'
+      6. 'Dataview'
+
+    The inheritance for any of these will be set as `_.<Name>` as we assume sudo has taken the 
+    global `_` char as an alias. If the argument is any other string we assume you are inheriting
+    from a custom class and pass it through as is.
+
+    Where `foo#baz` *can* match a controller#action (like `home#show`) it does not
+    have to. The controller argument (`foo`) allows the generator to place the file correctly and 
+    create/modify the correct manifest file. The name argument will be the proper name of the 
+    Class Object itself.
+
+    If a corresponding views/controller/name.html* is found, a skeletal instantiation of the newly 
+    created View will be placed there.
+
+    This will create (or modify):
+      app/
+        assests/
+          stylesheets/
+            manifests/
+              foo.css
+            views/
+              foo/
+                baz.css(*)
+          javascripts/
+            manifests/
+              foo.js
+            views/
+              foo/
+                baz.js(*)
+
+    And modify (if found):
+      app/
+        views/
+          foo/
+            baz.html(*)
+
+Note:
+    If the `route` is application level (application#baz) the file will be placed
+    in the application level directory and the manifests/application file will be modified
+
+    Note:
+      If the `route` is application level (application#baz) the file will be placed
+      in the application level directory and the manifests/application file will be modified
 
 ## Contributing
 

data/lib/sudojs/version.rb

@@ -1,3 +1,3 @@
 module Sudojs
-  VERSION = '0.2.9'
+  VERSION = '0.3.0'
 end

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

@@ -6,11 +6,11 @@ var sudo = {
 	//
 	// `namespace`
 	delegates: {},
-	// The sudo.ext namespace holds the `extensions` which are stand alone `modules` that
-	// can be `implemented` (mixed-in) to sudo Class Objects
+	// The sudo.extensions namespace holds the objects that are stand alone `modules` which
+	// can be `implemented` (mixed-in) in sudo Class Objects
 	//
 	// `namespace`
-	ext: {},
+	extensions: {},
 	// ###getPath
 	// Extract a value located at `path` relative to the passed in object
 	//
@@ -433,9 +433,9 @@ sudo.Container.prototype.removeFromParent = function removeFromParent() {
 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
+// If this Object is part of a `sudo.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
+// What this does is allow children of a `sudo.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. 
@@ -820,7 +820,7 @@ sudo.template = function template(str, data, scope) {
 //		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
+// 5. Handles event binding/unbinding by implementing the sudo.extensions.listener
 //		extension object
 //
 //`constructor`
@@ -828,9 +828,9 @@ sudo.Dataview = function(el, data) {
 	var d = data || {}, t;
 	sudo.View.call(this, el, d);
 	// implements the listener extension
-	$.extend(this, sudo.ext.listener);
+	$.extend(this, sudo.extensions.listener);
 	// dataview's models are observable
-	$.extend(this.model, sudo.ext.observable);
+	$.extend(this.model, sudo.extensions.observable);
 	// dont autoRender on the setting of events,
 	// add to this to prevent others if needed
 	this.autoRenderBlacklist = {event: true, events: true};
@@ -888,11 +888,182 @@ sudo.Dataview.prototype.render = function render(change) {
 };
 // `private`
 sudo.Dataview.prototype.role = 'dataview';
+// ##Navigator Class Object
+
+// Abstracts location and history events, parsing their information into a 
+// normalized object that is then set to an Observable class instance
+//
+// `constructor`
+sudo.Navigator = function(data) {
+	this.started = false;
+	this.slashStripper = /^\/+|\/+$/g;
+	this.leadingStripper = /^[#\/]|\s+$/g;
+	this.trailingStripper = /\/$/;
+	this.construct(data);
+};
+// Navigator inherits from `sudo.Model`
+sudo.Navigator.prototype = Object.create(sudo.Model.prototype);
+// ###getFragment
+// 'Fragment' is defined as any URL information after the 'root' path
+// including the `search` or `hash`
+//
+// `returns` {String} `fragment`
+// `returns` {String} the normalized current fragment
+sudo.Navigator.prototype.getFragment = function getFragment(fragment) {
+	var root = this.data.root;
+	if(!fragment) {
+			// intentional use of coersion
+		if (this.isPushState) {
+			fragment = window.location.pathname;
+			root = root.replace(this.trailingStripper, '');
+			if(!fragment.indexOf(root)) fragment = fragment.substr(root.length);
+		} else {
+			fragment = this.getHash();
+		}
+	}
+	return decodeURIComponent(fragment.replace(this.leadingStripper, ''));
+};
+// `returns` {String} the normalized current `hash`
+sudo.Navigator.prototype.getHash = function getHash(fragment) {
+	fragment || (fragment = window.location.href);
+	var match = fragment.match(/#(.*)$/);
+	return match ? match[1] : '';
+};
+// `returns` {String} the normalized current `search`
+sudo.Navigator.prototype.getSearch = function getSearch(fragment) {
+	fragment || (fragment = window.location.href);
+	var match = fragment.match(/\?(.*)$/);
+	return match ? match[1] : '';
+};
+// ###getUrl
+// fetch the URL in the form <root + fragment>
+//
+// `returns` {String}
+sudo.Navigator.prototype.getUrl = function getUrl() {
+	// note that delegate(_role_) returns the deleagte
+	return this.data.root + this.data.fragment;
+};
+// ###go
+// If the passed in 'fragment' is different than the currently stored one,
+// push a new state entry / hash event and set the data where specified
+//
+// `param` {string} `fragment`
+// `returns` {*} call to `setData`
+sudo.Navigator.prototype.go = function go(fragment) {
+	if(!this.started) return false;
+	if(!this.urlChanged(fragment)) return;
+	// TODO ever use replaceState?
+	if(this.isPushState) {
+		window.history.pushState({}, document.title, this.getUrl());
+	} else if(this.isHashChange) {
+		window.location.hash = '#' + this.data.fragment;
+	}
+	return this.setData();
+};
+// ###handleChange
+// Bound to either the `popstate` or `hashchange` events, if the
+// URL has indeed changed then parse the relevant data and set it -
+// triggering change observers
+//
+// `returns` {*} call to `setData` or undefined
+sudo.Navigator.prototype.handleChange = function handleChange(e) {
+	if(this.urlChanged()) {
+		return this.setData();
+	}
+};
+// ###parseQuery
+// Parse and return a hash of the key value pairs contained in 
+// the current `query`
+//
+// `returns` {object}
+sudo.Navigator.prototype.parseQuery = function parseQuery() {
+	var obj = {}, seg = this.data.query,
+		i, s;
+	if(seg) {
+		seg = seg.split('&');
+		for(i = 0; i < seg.length; i++) {
+			if(!seg[i]) continue;
+			s = seg[i].split('=');
+			obj[s[0]] = s[1];
+		}
+		return obj;
+	}
+};
+// ###setData
+// Using the current `fragment` (minus any search or hash data) as a key,
+// use `parseQuery` as the value for the key, setting it into the specified
+// model (a stated `Observable` or `this.data`)
+//
+// `returns` {object} `this`
+sudo.Navigator.prototype.setData = function setData() {
+	var frag = this.data.fragment,
+		// data is set in a specified model or in self
+		observable = this.data.observable || this;
+	if(this.data.query) {
+		// we want to set the key minus any search/hash
+		frag = frag.indexOf('?') !== -1 ? frag.split('?')[0] : frag.split('#')[0];
+	}
+	observable.set(frag, this.parseQuery());
+	return this;
+};
+// ###start
+// Gather the necessary information about the current environment and 
+// bind to either (push|pop)state or hashchange
+//
+// `returns` {object} `this`
+sudo.Navigator.prototype.start = function start() {
+	var hasPushState, atRoot, loc, tmp;
+	if(this.started) return;
+	hasPushState = window.history && window.history.pushState;
+	this.started = true;
+	// setup the initial configuration
+	this.isHashChange = this.data.useHashChange && 'onhashchange' in window || 
+		(!hasPushState && 'onhashchange' in window);
+	this.isPushState = !this.isHashChange && !!hasPushState;
+	// normalize the root to always contain a leading and trailing slash
+	this.data['root'] = ('/' + this.data['root'] + '/').replace(this.slashStripper, '/');
+	// Get a snapshot of the current fragment
+	this.urlChanged();
+	// monitor URL changes via popState or hashchange
+	if (this.isPushState) {
+		$(window).on('popstate', this.handleChange.bind(this));
+	} else if (this.isHashChange) {
+		$(window).on('hashchange', this.handleChange.bind(this));
+	} else return;
+	// Does the current URL need to changed? (hashchange vs popstate)
+	atRoot = window.location.pathname.replace(/[^\/]$/, '$&/') === this.data['root'];
+	// somehow a pushstate URL got here (and here is hashchange)
+	if(this.isHashChange && !atRoot) {
+		window.location.replace(this.data['root'] + window.location.search + '#' + 
+			this.data.fragment);
+		// return early as browser will redirect
+		return true;
+		// the converse of the above
+	} else if(this.isPushState && atRoot && window.location.hash) {
+		tmp = this.getHash().replace(this.leadingStripper, '');
+		window.history.replaceState({}, document.title, this.data['root'] + 
+			tmp + window.location.search);
+	}
+	// TODO provide option to `go` from inital `start` state?
+	return this;
+};
+// Is a passed in fragment different from the currently set one?
+//
+// `param` {String} `fragment`
+sudo.Navigator.prototype.urlChanged = function urlChanged(fragment) {
+	var current = this.getFragment(fragment);
+	// nothing has changed
+	if (current === this.data.fragment) return false;
+	this.data.fragment = current;
+	this.data.query = this.getSearch(current) || this.getHash(current);
+	return true;
+};
 // ## Observable Extension Object
+//
 // Implementaion of the ES6 Harmony Observer pattern.
 // Extend a `sudo.Model` class with this object if
 // data-mutation-observation is required
-sudo.ext.observable = {
+sudo.extensions.observable = {
 	// ###_deliver_
 	// Called from deliverChangeRecords when ready to send
 	// changeRecords to observers.
@@ -1120,7 +1291,7 @@ sudo.ext.observable = {
 // in a changeRecord recieved via observe().
 //
 // `namespace`
-sudo.ext.bindable = {
+sudo.extensions.bindable = {
 	// List of attributes - $.attr() to be used.
 	//
 	// `private`
@@ -1233,14 +1404,6 @@ sudo.ext.bindable = {
 		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.model.data.binding);
-	},
 	// ###_setBinding_
 	// Given a single explicit binding, create it. Called from
 	// _setbindings_ as a convenience for normalizing the
@@ -1299,7 +1462,7 @@ sudo.ext.bindable = {
 //	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 = {
+sudo.extensions.listener = {
 	// ###bindEvents
 	// Bind the events in the data store to this object's $el
 	//
@@ -1343,6 +1506,137 @@ sudo.ext.listener = {
 		return this;
 	}
 };
+// ##sudo persistable extension
+//
+// A mixin providing restful CRUD operations for a sudo.Model instance.
+//
+//	create : POST
+//	read : GET
+//	update : PUT or PATCH (configurable)
+//	destroy : DELETE
+//
+// Before use be sure to set an `ajax` property {object} with at least
+// a `baseUrl: ...` key. The model's id (if present -- indicating a persisted model)
+// is appended to the baseUrl (baseUrl/id) by default. You can override this behavior
+// by simply setting a `url: ...` in the `ajax` options hash or pass in the same when 
+// calling any of the methods (or override the model.url() method).
+//
+// Place any other default options in the `ajax` hash
+// that you would want sent to a $.ajax({...}) call. Again, you can also override those
+// defaults by passing in a hash of options to any method:
+//	`this.model.update({patch: true})` etc...
+sudo.extensions.persistable = {
+	// ###create 
+	//
+	// Save this model on the server. If a subset of this model's attributes
+	// has not been stated (ajax:{data:{...}}) send all of the model's data.
+	// Anticipate that the server response will send back the 
+	// state of the model on the server and set it here (via a success callback).
+	//
+	// `param` {object} `params` Hash of options for the XHR call
+	// `returns` {object} The jQuery XHR object
+	create: function create(params) {
+		return this._sendData_('POST', params);
+	},
+	// ###destroy
+	//
+	// (because `delete` is reserved)
+	//
+	// `param` {object} `params` Optional hash of options for the XHR
+	// `returns` {object} jqXhr
+	destroy: function _delete(params) {
+		return this._sendData_('DELETE', params);
+	},
+	// ###_normalizeParams_
+	// Abstracted logic for preparing the options object. This looks at 
+	// the set `ajax` property, allowing any passed in params to override.
+	//
+	// Sets defaults: JSON dataType and a success callback that simply `sets()` the 
+	// data returned from the server
+	//
+	// `returns` {object} A normalized params object for the XHR call
+	_normalizeParams_: function _normalizeParams_(meth, opts, params) {
+		opts || (opts = this.data.ajax);
+		opts.url || (opts.url = this.url(opts.baseUrl));
+		opts.type || (opts.type = meth);
+		opts.dataType || (opts.dataType = 'json');
+		// the default success callback is to set the data returned from the server
+    // or just the status as `ajaxStatus` if no data was returned
+		opts.success || (opts.success = function(data, status, jqXhr) {
+			data ? this.sets(data) : this.set('ajaxStatus', status);
+		}.bind(this));
+		// allow the passed in params to override any set in this model's `ajax` options
+		return params ? $.extend(opts, params) : opts;
+	},
+	// ###read
+	//
+	// Fetch this models state from the server and set it here. The 
+	// `Model.sets()` method is used with the returned data (we are 
+	// asssuming the default json dataType). Pass in (via the params arg)
+	// a success function to override this default.
+	//
+	// Maps to the http GET method.
+	//
+	// `param` {object} `params`. Optional info for the XHR call. If
+	// present will override any set in this model's `ajax` options object.
+	// `returns` {object} The jQuery XHR object
+	read: function post(params) {
+		return $.ajax(this._normalizeParams_('GET', null, params));
+	},
+	// ###save
+	//
+	// Convenience method removing the need to know if a model is new (not yet persisted)
+	// or has been loaded/refreshed from the server. 
+	//
+	// `param` {object} `params` Hash of options for the XHR call
+	// `returns` {object} The jQuery XHR object
+	save: function save(params) {
+		return ('id' in this.data) ? this.update(params) : this.create(params);
+	},
+	// ###_sendData_
+	// The Create, Update and Patch methods all send data to the server,
+	// varying only in their HTTP method. Abstracted logic is here.
+	//
+	// `returns` {object} jqXhr
+	_sendData_: function _sendData_(meth, params) {
+		opts = this.data.ajax;
+		opts.contentType || (opts.contentType = 'application/json');
+		opts.data || (opts.data = this.data);
+		// non GET requests do not 'processData'
+		if(!('processData' in opts)) opts.processData = false;
+		return $.ajax(this._normalizeParams_(meth, opts, params));
+	},
+	// ###update
+	//
+	// If this model has been persisted to/from the server (it has an `id` attribute)
+	// send the specified data (or all the model's data) to the server at `url` via
+	// the `PUT` http verb or `PATCH` if {patch: true} is in the ajax options (or the
+	// passed in params)
+	//
+	// NOTE: update does not check is this is a new model or not, do that yourself
+	// or use the `save()` method (that does check).
+	//
+	// `param` {object} `params` Optional hash of options for the XHR
+	// `returns` {object|bool} the jqXhr if called false if not
+	update: function update(params) {
+		return this._sendData_((this.data.ajax.patch || params && params.patch) ? 
+			'PATCH' : 'PUT', params);
+	},
+	// ###url
+	//
+	// Takes the base url and appends this models id if present
+	// (narmalizing the trailong slash if needed).
+	// Override if you need to change the format of the calculated url.
+	//
+	// `param` {string} `base` the baseUrl set in this models ajax options
+	url: function url(base) {
+		// could possibly be 0...
+		if('id' in this.data) {
+			return base + (base.charAt(base.length - 1) === '/' ? 
+				'' : '/') + encodeURIComponent(this.data.id);
+		} else return base;
+	}
+};
 //##Change Delegate
 
 // Delegates, if present, can override or extend the behavior
@@ -1373,7 +1667,7 @@ sudo.delegates.Change.prototype.filter = function(change) {
 		// assemble the object to return to the method
 		obj.type = change.type;
 		obj.value = name.indexOf('.') === -1 ? change.object[change.name] :
-			this.getPath(name, change.object);
+			sudo.getPath(name, change.object);
 		obj.oldValue = change.oldValue;
 		return this.delegator[filters[name]].call(this.delegator, obj);
 	}
@@ -1401,28 +1695,28 @@ sudo.delegates.Data.prototype = Object.create(sudo.Model.prototype);
 //
 // `param` {Object} `obj`
 sudo.delegates.Data.prototype.filter = function(obj) {
-	var filters = this.data.filters, key, o, k;
-	for(key in filters) {
-		if(filters.hasOwnProperty(key)) {
-			// keys and paths need different handling
-			if(key.indexOf('.') === -1) {
-				if(key in obj) this.delegator[filters[key]].call(
-					this.delegator, obj[key]);	
-			} else {
-				// the chars after the last refinement are the key we need to check for
-				k = key.slice(key.lastIndexOf('.') + 1);
-				// and the ones prior are the object
-				o = sudo.getPath(key.slice(0, key.lastIndexOf('.')), obj);
-				if(o && k in o) this.delegator[filters[key]].call(
-					this.delegator, o[k]);
-			}
+	var filters = this.data.filters,
+		ary = Object.keys(filters), key, i, o, k;
+	for(i = 0; i < ary.length; i++) {
+		key = ary[i];
+		// keys and paths need different handling
+		if(key.indexOf('.') === -1) {
+			if(key in obj) this.delegator[filters[key]].call(
+				this.delegator, obj[key]);	
+		} else {
+			// the chars after the last refinement are the key we need to check for
+			k = key.slice(key.lastIndexOf('.') + 1);
+			// and the ones prior are the object
+			o = sudo.getPath(key.slice(0, key.lastIndexOf('.')), obj);
+			if(o && k in o) this.delegator[filters[key]].call(
+				this.delegator, o[k]);
 		}
 	}
 };
 // `private`
 sudo.delegates.Data.prototype.role = 'data';
 
-sudo.version = "0.9.1";
+sudo.version = "0.9.2";
 window.sudo = sudo;
 if(typeof window._ === "undefined") window._ = sudo;
 }).call(this, this);

data/vendor/assets/javascripts/sudo.js

@@ -6,11 +6,11 @@ var sudo = {
 	//
 	// `namespace`
 	delegates: {},
-	// The sudo.ext namespace holds the `extensions` which are stand alone `modules` that
-	// can be `implemented` (mixed-in) to sudo Class Objects
+	// The sudo.extensions namespace holds the objects that are stand alone `modules` which
+	// can be `implemented` (mixed-in) in sudo Class Objects
 	//
 	// `namespace`
-	ext: {},
+	extensions: {},
 	// ###getPath
 	// Extract a value located at `path` relative to the passed in object
 	//
@@ -433,9 +433,9 @@ sudo.Container.prototype.removeFromParent = function removeFromParent() {
 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
+// If this Object is part of a `sudo.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
+// What this does is allow children of a `sudo.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. 
@@ -584,10 +584,11 @@ sudo.View.prototype.$ = function(sel) {
 	return this.$el.find(sel);
 };
 // ## Observable Extension Object
+//
 // Implementaion of the ES6 Harmony Observer pattern.
 // Extend a `sudo.Model` class with this object if
 // data-mutation-observation is required
-sudo.ext.observable = {
+sudo.extensions.observable = {
 	// ###_deliver_
 	// Called from deliverChangeRecords when ready to send
 	// changeRecords to observers.
@@ -808,7 +809,7 @@ sudo.ext.observable = {
 		return this.deliverChangeRecords();	
 	}
 };
-sudo.version = "0.9.1";
+sudo.version = "0.9.2";
 window.sudo = sudo;
 if(typeof window._ === "undefined") window._ = sudo;
 }).call(this, this);

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sudojs-rails
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-14 00:00:00.000000000 Z
+date: 2013-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -78,7 +78,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1612881101538659310
+      hash: -2092482263484943963
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -87,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1612881101538659310
+      hash: -2092482263484943963
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24