dojo-rails 0.9.9 → 0.9.10

data/vendor/assets/javascripts/dojo/_base/browser.js.uncompressed.js

@@ -12,10 +12,17 @@ define("dojo/_base/browser", [
 	"./NodeList",
 	"../query",
 	"./xhr",
-	"./fx"], function(dojo) {
+	"./fx"], function(dojo){
+
 	// module:
 	//		dojo/_base/browser
-	// summary:
-	//		This module causes the browser-only base modules to be loaded.
+
+	/*=====
+	return {
+		// summary:
+		//		This module causes the browser-only base modules to be loaded.
+	};
+	=====*/
+
 	return dojo;
 });

data/vendor/assets/javascripts/dojo/_base/config.js.uncompressed.js

@@ -1,23 +1,26 @@
 define("dojo/_base/config", ["../has", "require"], function(has, require){
 	// module:
 	//		dojo/_base/config
+
+/*=====
+return {
 	// summary:
 	//		This module defines the user configuration during bootstrap.
 	// description:
 	//		By defining user configuration as a module value, an entire configuration can be specified in a build,
-    //		thereby eliminating the need for sniffing and or explicitly setting in the global variable dojoConfig.
-    //		Also, when multiple instances of dojo exist in a single application, each will necessarily be located
+	//		thereby eliminating the need for sniffing and or explicitly setting in the global variable dojoConfig.
+	//		Also, when multiple instances of dojo exist in a single application, each will necessarily be located
 	//		at an unique absolute module identifier as given by the package configuration. Implementing configuration
 	//		as a module allows for specifying unique, per-instance configurations.
 	// example:
-	//		Create a second instance of dojo with a different, instance-uniqe configuration (assume the loader and
+	//		Create a second instance of dojo with a different, instance-unique configuration (assume the loader and
 	//		dojo.js are already loaded).
 	//		|	// specify a configuration that creates a new instance of dojo at the absolute module identifier "myDojo"
 	//		|	require({
 	//		|		packages:[{
 	//		|			name:"myDojo",
 	//		|			location:".", //assume baseUrl points to dojo.js
-	//		|	    }]
+	//		|		}]
 	//		|	});
 	//		|
 	//		|	// specify a configuration for the myDojo instance
@@ -27,49 +30,11 @@ define("dojo/_base/config", ["../has", "require"], function(has, require){
 	//		|	});
 	//		|
 	//		|	// load and use the new instance of dojo
-	//		|	require(["myDojo"], function(dojo) {
+	//		|	require(["myDojo"], function(dojo){
 	//		|		// dojo is the new instance of dojo
 	//		|		// use as required
 	//		|	});
 
-	var result = {};
-	if(1){
-		// must be the dojo loader; take a shallow copy of require.rawConfig
-		var src = require.rawConfig, p;
-		for(p in src){
-			result[p] = src[p];
-		}
-	}else{
-		var adviseHas = function(featureSet, prefix, booting){
-			for(p in featureSet){
-				p!="has" && has.add(prefix + p, featureSet[p], 0, booting);
-			}
-		};
-		result = 1 ?
-			// must be a built version of the dojo loader; all config stuffed in require.rawConfig
-			require.rawConfig :
-			// a foreign loader
-			this.dojoConfig || this.djConfig || {};
-		adviseHas(result, "config", 1);
-		adviseHas(result.has, "", 1);
-	}
-	return result;
-
-/*=====
-// note:
-//		'dojoConfig' does not exist under 'dojo.*' so that it can be set before the
-//		'dojo' variable exists.
-// note:
-//		Setting any of these variables *after* the library has loaded does
-//		nothing at all.
-
-// FIXME: can we document these on dojo.config object and explain they must be set via djConfig/dojoConfig global prior to loading dojo.js
-
-dojoConfig = {
-	// summary:
-	//		Application code can set the global 'dojoConfig' prior to loading
-	//		the library to control certain global settings for how dojo works.
-	//
 	// isDebug: Boolean
 	//		Defaults to `false`. If set to `true`, ensures that Dojo provides
 	//		extended debugging feedback via Firebug. If Firebug is not available
@@ -81,6 +46,7 @@ dojoConfig = {
 	//		`isDebug` is false and you are on a platform without Firebug, these
 	//		methods will be defined as no-ops.
 	isDebug: false,
+
 	// locale: String
 	//		The locale to assume for loading localized resources in this page,
 	//		specified according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt).
@@ -90,11 +56,13 @@ dojoConfig = {
 	//		Dojo assumes the locale of the user agent, according to `navigator.userLanguage`
 	//		or `navigator.language` properties.
 	locale: undefined,
+
 	// extraLocale: Array
 	//		No default value. Specifies additional locales whose
 	//		resources should also be loaded alongside the default locale when
 	//		calls to `dojo.requireLocalization()` are processed.
 	extraLocale: undefined,
+
 	// baseUrl: String
 	//		The directory in which `dojo.js` is located. Under normal
 	//		conditions, Dojo auto-detects the correct location from which it
@@ -105,70 +73,115 @@ dojoConfig = {
 	//		auto-detected root if not. Other modules are located relative to
 	//		this path. The path should end in a slash.
 	baseUrl: undefined,
-	// modulePaths: Object
+
+	// modulePaths: [deprecated] Object
 	//		A map of module names to paths relative to `dojo.baseUrl`. The
 	//		key/value pairs correspond directly to the arguments which
-	//		`dojo.registerModulePath` accepts. Specifiying
+	//		`dojo.registerModulePath` accepts. Specifying
 	//		`djConfig.modulePaths = { "foo": "../../bar" }` is the equivalent
 	//		of calling `dojo.registerModulePath("foo", "../../bar");`. Multiple
 	//		modules may be configured via `djConfig.modulePaths`.
 	modulePaths: {},
-	// afterOnLoad: Boolean
-	//		Indicates Dojo was added to the page after the page load. In this case
-	//		Dojo will not wait for the page DOMContentLoad/load events and fire
-	//		its dojo.addOnLoad callbacks after making sure all outstanding
-	//		dojo.required modules have loaded. Only works with a built dojo.js,
-	//		it does not work the dojo.js directly from source control.
-	afterOnLoad: false,
-	// addOnLoad: Function or Array
-	//		Adds a callback via dojo.addOnLoad. Useful when Dojo is added after
+
+	// addOnLoad: Function|Array
+	//		Adds a callback via dojo/ready. Useful when Dojo is added after
 	//		the page loads and djConfig.afterOnLoad is true. Supports the same
-	//		arguments as dojo.addOnLoad. When using a function reference, use
+	//		arguments as dojo/ready. When using a function reference, use
 	//		`djConfig.addOnLoad = function(){};`. For object with function name use
 	//		`djConfig.addOnLoad = [myObject, "functionName"];` and for object with
 	//		function reference use
 	//		`djConfig.addOnLoad = [myObject, function(){}];`
 	addOnLoad: null,
-	// require: Array
+
+	// parseOnLoad: Boolean
+	//		Run the parser after the page is loaded
+	parseOnLoad: false,
+
+	// require: String[]
 	//		An array of module names to be loaded immediately after dojo.js has been included
 	//		in a page.
 	require: [],
-	// defaultDuration: Array
+
+	// defaultDuration: Number
 	//		Default duration, in milliseconds, for wipe and fade animations within dijits.
 	//		Assigned to dijit.defaultDuration.
 	defaultDuration: 200,
+
 	// dojoBlankHtmlUrl: String
-	//		Used by some modules to configure an empty iframe. Used by dojo.io.iframe and
-	//		dojo.back, and dijit popup support in IE where an iframe is needed to make sure native
+	//		Used by some modules to configure an empty iframe. Used by dojo/io/iframe and
+	//		dojo/back, and dijit/popup support in IE where an iframe is needed to make sure native
 	//		controls do not bleed through the popups. Normally this configuration variable
 	//		does not need to be set, except when using cross-domain/CDN Dojo builds.
 	//		Save dojo/resources/blank.html to your domain and set `djConfig.dojoBlankHtmlUrl`
 	//		to the path on your domain your copy of blank.html.
 	dojoBlankHtmlUrl: undefined,
-	//	ioPublish: Boolean?
+
+	// ioPublish: Boolean?
 	//		Set this to true to enable publishing of topics for the different phases of
-	//		IO operations. Publishing is done via dojo.publish. See dojo.__IoPublish for a list
+	//		IO operations. Publishing is done via dojo/topic.publish(). See dojo/main.__IoPublish for a list
 	//		of topics that are published.
 	ioPublish: false,
-	//	useCustomLogger: Anything?
+
+	// useCustomLogger: Anything?
 	//		If set to a value that evaluates to true such as a string or array and
 	//		isDebug is true and Firebug is not available or running, then it bypasses
 	//		the creation of Firebug Lite allowing you to define your own console object.
 	useCustomLogger: undefined,
+
 	// transparentColor: Array
 	//		Array containing the r, g, b components used as transparent color in dojo.Color;
 	//		if undefined, [255,255,255] (white) will be used.
 	transparentColor: undefined,
-	// skipIeDomLoaded: Boolean
-	//		For IE only, skip the DOMContentLoaded hack used. Sometimes it can cause an Operation
-	//		Aborted error if the rest of the page triggers script defers before the DOM is ready.
-	//		If this is config value is set to true, then dojo.addOnLoad callbacks will not be
-	//		triggered until the page load event, which is after images and iframes load. If you
-	//		want to trigger the callbacks sooner, you can put a script block in the bottom of
-	//		your HTML that calls dojo._loadInit();. If you are using multiversion support, change
-	//		"dojo." to the appropriate scope name for dojo.
-	skipIeDomLoaded: false
-}
+	
+	// deps: Function|Array
+	//		Defines dependencies to be used before the loader has been loaded.
+	//		When provided, they cause the loader to execute require(deps, callback) 
+	//		once it has finished loading. Should be used with callback.
+	deps: undefined,
+	
+	// callback: Function|Array
+	//		Defines a callback to be used when dependencies are defined before 
+	//		the loader has been loaded. When provided, they cause the loader to 
+	//		execute require(deps, callback) once it has finished loading. 
+	//		Should be used with deps.
+	callback: undefined,
+	
+	// deferredInstrumentation: Boolean
+	//		Whether deferred instrumentation should be loaded or included
+	//		in builds.
+	deferredInstrumentation: true,
+
+	// useDeferredInstrumentation: Boolean|String
+	//		Whether the deferred instrumentation should be used.
+	//
+	//		* `"report-rejections"`: report each rejection as it occurs.
+	//		* `true` or `1` or `"report-unhandled-rejections"`: wait 1 second
+	//			in an attempt to detect unhandled rejections.
+	useDeferredInstrumentation: "report-unhandled-rejections"
+};
 =====*/
+
+	var result = {};
+	if( 1 ){
+		// must be the dojo loader; take a shallow copy of require.rawConfig
+		var src = require.rawConfig, p;
+		for(p in src){
+			result[p] = src[p];
+		}
+	}else{
+		var adviseHas = function(featureSet, prefix, booting){
+			for(p in featureSet){
+				p!="has" && has.add(prefix + p, featureSet[p], 0, booting);
+			}
+		};
+		result =  1  ?
+			// must be a built version of the dojo loader; all config stuffed in require.rawConfig
+			require.rawConfig :
+			// a foreign loader
+			this.dojoConfig || this.djConfig || {};
+		adviseHas(result, "config", 1);
+		adviseHas(result.has, "", 1);
+	}
+	return result;
 });
 

data/vendor/assets/javascripts/dojo/_base/configFirefoxExtension.js

@@ -78,14 +78,16 @@ if(typeof window != 'undefined'){
 		var hasBase = false;
 
 		dojo._getText = function(/*URI*/ uri, /*Boolean*/ fail_ok){
-			// summary: Read the contents of the specified uri and return those contents.
+			// summary:
+			//		Read the contents of the specified uri and return those contents.
 			// uri:
 			//		A relative or absolute uri. If absolute, it still must be in
 			//		the same "domain" as we are.
 			// fail_ok:
 			//		Default false. If fail_ok and loading fails, return null
 			//		instead of throwing.
-			// returns: The response text. null is returned when there is a
+			// returns:
+			//		The response text. null is returned when there is a
 			//		failure and failure is okay (an exception otherwise)
 
 			// alert("_getText: " + uri);
@@ -178,12 +180,12 @@ if(typeof window != 'undefined'){
 		dojo._defaultContext = [ window, document ];
 
 		dojo.pushContext = function(/*Object|String?*/g, /*MDocumentElement?*/d){
-			//	summary:
+			// summary:
 			//		causes subsequent calls to Dojo methods to assume the
 			//		passed object and, optionally, document as the default
 			//		scopes to use. A 2-element array of the previous global and
 			//		document are returned.
-			//	description:
+			// description:
 			//		dojo.pushContext treats contexts as a stack. The
 			//		auto-detected contexts which are initially provided using
 			//		dojo.setContext() require authors to keep state in order to
@@ -199,10 +201,10 @@ if(typeof window != 'undefined'){
 			//		the context to push. This means that iframes can be given
 			//		an ID and code can be executed in the scope of the iframe's
 			//		document in subsequent calls easily.
-			//	g:
+			// g:
 			//		The global context. If a string, the id of the frame to
 			//		search for a context and document.
-			//	d:
+			// d:
 			//		The document element to execute subsequent code with.
 			var old = [dojo.global, dojo.doc];
 			contexts.push(old);
@@ -224,7 +226,7 @@ if(typeof window != 'undefined'){
 		};
 
 		dojo.popContext = function(){
-			//	summary:
+			// summary:
 			//		If the context stack contains elements, ensure that
 			//		subsequent code executes in the *previous* context to the
 			//		current context. The current context set ([global,
@@ -286,17 +288,17 @@ if(typeof window != 'undefined'){
 		};
 		// FIXME: PORT
 		// FIXME: dojo.unloaded requires dojo scope, so using anon function wrapper.
-		_handleNodeEvent("onbeforeunload", function() { dojo.unloaded(); });
-		_handleNodeEvent("onunload", function() { dojo.windowUnloaded(); });
+		_handleNodeEvent("onbeforeunload", function(){ dojo.unloaded(); });
+		_handleNodeEvent("onunload", function(){ dojo.windowUnloaded(); });
 	})();
 	*/
 
 
 	//	FIXME: PORTME
-	// 		this event fires a lot, namely for all plugin XUL overlays and for
-	// 		all iframes (in addition to window navigations). We only want
-	// 		Dojo's to fire once..but we might care if pages navigate. We'll
-	// 		probably need an extension-specific API
+	//		this event fires a lot, namely for all plugin XUL overlays and for
+	//		all iframes (in addition to window navigations). We only want
+	//		Dojo's to fire once..but we might care if pages navigate. We'll
+	//		probably need an extension-specific API
 	if(!dojo.config.afterOnLoad){
 		window.addEventListener("DOMContentLoaded", function(e){
 			dojo._loadInit(e);

data/vendor/assets/javascripts/dojo/_base/configNode.js

@@ -1,5 +1,5 @@
 exports.config = function(config){
-	//	summary:
+	// summary:
 	//		This module provides bootstrap configuration for running dojo in node.js
 
 	// any command line arguments with the load flag are pushed into deps
@@ -15,7 +15,7 @@ exports.config = function(config){
 	var fs = require("fs");
 
 	// make sure global require exists
-	//if (typeof global.require=="undefined") {
+	//if (typeof global.require=="undefined"){
 	//	global.require= {};
 	//}
 
@@ -40,12 +40,12 @@ exports.config = function(config){
 		config.hasCache[p] = hasCache[p];
 	}
 
-	var vm = require('vm');
-
+	var vm = require('vm'),
+		path = require('path');
 
 	// reset some configuration switches with node-appropriate values
 	var nodeConfig = {
-		baseUrl: __dirname.match(/(.+)[\/\\]_base$/)[1],
+		baseUrl: path.dirname(process.argv[1]),
 		commandLineArgs:args,
 		deps:deps,
 		timeout:0,

data/vendor/assets/javascripts/dojo/_base/configRhino.js

@@ -1,5 +1,5 @@
 function rhinoDojoConfig(config, baseUrl, rhinoArgs){
-	//	summary:
+	// summary:
 	//		This module provides bootstrap configuration for running dojo in rhino.
 
 	// TODO: v1.6 tries to set dojo.doc and dojo.body in rhino; why?

data/vendor/assets/javascripts/dojo/_base/configSpidermonkey.js

@@ -1,9 +1,9 @@
 // TODO: this file needs to be converted to the v1.7 loader
 
-
-/*
- * SpiderMonkey host environment
- */
+// module:
+//		configSpidermonkey
+// summary:
+//		 SpiderMonkey host environment
 
 if(dojo.config["baseUrl"]){
 	dojo.baseUrl = dojo.config["baseUrl"];
@@ -13,11 +13,7 @@ if(dojo.config["baseUrl"]){
 
 dojo._name = 'spidermonkey';
 
-/*=====
-dojo.isSpidermonkey = {
-	// summary: Detect spidermonkey
-};
-=====*/
+
 
 dojo.isSpidermonkey = true;
 dojo.exit = function(exitcode){

data/vendor/assets/javascripts/dojo/_base/connect.js

@@ -72,7 +72,7 @@ return 0;
 _f=function(_18,_19){
 var _1a=on(_18,"keydown",function(evt){
 var k=evt.keyCode;
-var _1b=(k!=13||(_6("ie")>=9&&!_6("quirks")))&&k!=32&&(k!=27||!_6("ie"))&&(k<48||k>90)&&(k<96||k>111)&&(k<186||k>192)&&(k<219||k>222)&&k!=229;
+var _1b=(k!=13)&&k!=32&&(k!=27||!_6("ie"))&&(k<48||k>90)&&(k<96||k>111)&&(k<186||k>192)&&(k<219||k>222)&&k!=229;
 if(_1b||evt.ctrlKey){
 var c=_1b?0:k;
 if(evt.ctrlKey){

data/vendor/assets/javascripts/dojo/_base/connect.js.uncompressed.js

@@ -1,14 +1,7 @@
-define("dojo/_base/connect", ["./kernel", "../on", "../topic", "../aspect", "./event", "../mouse", "./sniff", "./lang", "../keys"], function(kernel, on, hub, aspect, eventModule, mouse, has, lang){
-//  module:
-//    dojo/_base/connect
-//  summary:
-//    This module defines the dojo.connect API.
-//		This modules also provides keyboard event handling helpers.
-//		This module exports an extension event for emulating Firefox's keypress handling.
-//		However, this extension event exists primarily for backwards compatibility and
-//		is not recommended. WebKit and IE uses an alternate keypress handling (only
-//		firing for printable characters, to distinguish from keydown events), and most
-//		consider the WebKit/IE behavior more desirable.
+define("dojo/_base/connect", ["./kernel", "../on", "../topic", "../aspect", "./event", "../mouse", "./sniff", "./lang", "../keys"], function(dojo, on, hub, aspect, eventModule, mouse, has, lang){
+// module:
+//		dojo/_base/connect
+
 has.add("events-keypress-typed", function(){ // keypresses should only occur a printable character is hit
 	var testKeyEvent = {charCode: 0};
 	try{
@@ -23,13 +16,13 @@ function connect_(obj, event, context, method, dontFix){
 	if(!obj || !(obj.addEventListener || obj.attachEvent)){
 		// it is a not a DOM node and we are using the dojo.connect style of treating a
 		// method like an event, must go right to aspect
-		return aspect.after(obj || kernel.global, event, method, true);
+		return aspect.after(obj || dojo.global, event, method, true);
 	}
 	if(typeof event == "string" && event.substring(0, 2) == "on"){
 		event = event.substring(2);
 	}
 	if(!obj){
-		obj = kernel.global;
+		obj = dojo.global;
 	}
 	if(!dontFix){
 		switch(event){
@@ -99,7 +92,7 @@ if(has("events-keypress-typed")){
 			var k=evt.keyCode;
 			// These are Windows Virtual Key Codes
 			// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/WinUI/WindowsUserInterface/UserInput/VirtualKeyCodes.asp
-			var unprintable = (k!=13 || (has("ie") >= 9 && !has("quirks"))) && k!=32 && (k!=27||!has("ie")) && (k<48||k>90) && (k<96||k>111) && (k<186||k>192) && (k<219||k>222) && k!=229;
+			var unprintable = (k!=13) && k!=32 && (k!=27||!has("ie")) && (k<48||k>90) && (k<96||k>111) && (k<186||k>192) && (k<219||k>222) && k!=229;
 			// synthesize keypress for most unprintables and CTRL-keys
 			if(unprintable||evt.ctrlKey){
 				var c = unprintable ? 0 : k;
@@ -164,9 +157,115 @@ if(has("events-keypress-typed")){
 }
 
 var connect = {
+	// summary:
+	//		This module defines the dojo.connect API.
+	//		This modules also provides keyboard event handling helpers.
+	//		This module exports an extension event for emulating Firefox's keypress handling.
+	//		However, this extension event exists primarily for backwards compatibility and
+	//		is not recommended. WebKit and IE uses an alternate keypress handling (only
+	//		firing for printable characters, to distinguish from keydown events), and most
+	//		consider the WebKit/IE behavior more desirable.
+
 	_keypress:keypress,
 
 	connect:function(obj, event, context, method, dontFix){
+		// summary:
+		//		`dojo.connect` is a deprecated event handling and delegation method in
+		//		Dojo. It allows one function to "listen in" on the execution of
+		//		any other, triggering the second whenever the first is called. Many
+		//		listeners may be attached to a function, and source functions may
+		//		be either regular function calls or DOM events.
+		//
+		// description:
+		//		Connects listeners to actions, so that after event fires, a
+		//		listener is called with the same arguments passed to the original
+		//		function.
+		//
+		//		Since `dojo.connect` allows the source of events to be either a
+		//		"regular" JavaScript function or a DOM event, it provides a uniform
+		//		interface for listening to all the types of events that an
+		//		application is likely to deal with though a single, unified
+		//		interface. DOM programmers may want to think of it as
+		//		"addEventListener for everything and anything".
+		//
+		//		When setting up a connection, the `event` parameter must be a
+		//		string that is the name of the method/event to be listened for. If
+		//		`obj` is null, `kernel.global` is assumed, meaning that connections
+		//		to global methods are supported but also that you may inadvertently
+		//		connect to a global by passing an incorrect object name or invalid
+		//		reference.
+		//
+		//		`dojo.connect` generally is forgiving. If you pass the name of a
+		//		function or method that does not yet exist on `obj`, connect will
+		//		not fail, but will instead set up a stub method. Similarly, null
+		//		arguments may simply be omitted such that fewer than 4 arguments
+		//		may be required to set up a connection See the examples for details.
+		//
+		//		The return value is a handle that is needed to
+		//		remove this connection with `dojo.disconnect`.
+		//
+		// obj: Object?
+		//		The source object for the event function.
+		//		Defaults to `kernel.global` if null.
+		//		If obj is a DOM node, the connection is delegated
+		//		to the DOM event manager (unless dontFix is true).
+		//
+		// event: String
+		//		String name of the event function in obj.
+		//		I.e. identifies a property `obj[event]`.
+		//
+		// context: Object|null
+		//		The object that method will receive as "this".
+		//
+		//		If context is null and method is a function, then method
+		//		inherits the context of event.
+		//
+		//		If method is a string then context must be the source
+		//		object object for method (context[method]). If context is null,
+		//		kernel.global is used.
+		//
+		// method: String|Function
+		//		A function reference, or name of a function in context.
+		//		The function identified by method fires after event does.
+		//		method receives the same arguments as the event.
+		//		See context argument comments for information on method's scope.
+		//
+		// dontFix: Boolean?
+		//		If obj is a DOM node, set dontFix to true to prevent delegation
+		//		of this connection to the DOM event manager.
+		//
+		// example:
+		//		When obj.onchange(), do ui.update():
+		//	|	dojo.connect(obj, "onchange", ui, "update");
+		//	|	dojo.connect(obj, "onchange", ui, ui.update); // same
+		//
+		// example:
+		//		Using return value for disconnect:
+		//	|	var link = dojo.connect(obj, "onchange", ui, "update");
+		//	|	...
+		//	|	dojo.disconnect(link);
+		//
+		// example:
+		//		When onglobalevent executes, watcher.handler is invoked:
+		//	|	dojo.connect(null, "onglobalevent", watcher, "handler");
+		//
+		// example:
+		//		When ob.onCustomEvent executes, customEventHandler is invoked:
+		//	|	dojo.connect(ob, "onCustomEvent", null, "customEventHandler");
+		//	|	dojo.connect(ob, "onCustomEvent", "customEventHandler"); // same
+		//
+		// example:
+		//		When ob.onCustomEvent executes, customEventHandler is invoked
+		//		with the same scope (this):
+		//	|	dojo.connect(ob, "onCustomEvent", null, customEventHandler);
+		//	|	dojo.connect(ob, "onCustomEvent", customEventHandler); // same
+		//
+		// example:
+		//		When globalEvent executes, globalHandler is invoked
+		//		with the same scope (this):
+		//	|	dojo.connect(null, "globalEvent", null, globalHandler);
+		//	|	dojo.connect("globalEvent", globalHandler); // same
+
 		// normalize arguments
 		var a=arguments, args=[], i=0;
 		// if a[0] is a String, obj was omitted
@@ -180,220 +279,95 @@ var connect = {
 	},
 
 	disconnect:function(handle){
+		// summary:
+		//		Remove a link created by dojo.connect.
+		// description:
+		//		Removes the connection between event and the method referenced by handle.
+		// handle: Handle
+		//		the return value of the dojo.connect call that created the connection.
+
 		if(handle){
 			handle.remove();
 		}
 	},
 
 	subscribe:function(topic, context, method){
+		// summary:
+		//		Attach a listener to a named topic. The listener function is invoked whenever the
+		//		named topic is published (see: dojo.publish).
+		//		Returns a handle which is needed to unsubscribe this listener.
+		// topic: String
+		//		The topic to which to subscribe.
+		// context: Object?
+		//		Scope in which method will be invoked, or null for default scope.
+		// method: String|Function
+		//		The name of a function in context, or a function reference. This is the function that
+		//		is invoked when topic is published.
+		// example:
+		//	|	dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); });
+		//	|	dojo.publish("alerts", [ "read this", "hello world" ]);
 		return hub.subscribe(topic, lang.hitch(context, method));
 	},
 
 	publish:function(topic, args){
+		// summary:
+		//		Invoke all listener method subscribed to topic.
+		// topic: String
+		//		The name of the topic to publish.
+		// args: Array?
+		//		An array of arguments. The arguments will be applied
+		//		to each topic subscriber (as first class parameters, via apply).
+		// example:
+		//	|	dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
+		//	|	dojo.publish("alerts", [ "read this", "hello world" ]);
 		return hub.publish.apply(hub, [topic].concat(args));
 	},
 
 	connectPublisher:function(topic, obj, event){
+		// summary:
+		//		Ensure that every time obj.event() is called, a message is published
+		//		on the topic. Returns a handle which can be passed to
+		//		dojo.disconnect() to disable subsequent automatic publication on
+		//		the topic.
+		// topic: String
+		//		The name of the topic to publish.
+		// obj: Object?
+		//		The source object for the event function. Defaults to kernel.global
+		//		if null.
+		// event: String
+		//		The name of the event function in obj.
+		//		I.e. identifies a property obj[event].
+		// example:
+		//	|	dojo.connectPublisher("/ajax/start", dojo, "xhrGet");
 		var pf = function(){ connect.publish(topic, arguments); };
 		return event ? connect.connect(obj, event, pf) : connect.connect(obj, pf); //Handle
 	},
 
 	isCopyKey: function(e){
+		// summary:
+		//		Checks an event for the copy key (meta on Mac, and ctrl anywhere else)
+		// e: Event
+		//		Event object to examine
 		return e[evtCopyKey];	// Boolean
 	}
 };
-connect.unsubscribe = connect.disconnect;
-
-1 && lang.mixin(kernel, connect);
-return connect;
-
-/*=====
-dojo.connect = function(obj, event, context, method, dontFix){
-	// summary:
-	//		`dojo.connect` is the core event handling and delegation method in
-	//		Dojo. It allows one function to "listen in" on the execution of
-	//		any other, triggering the second whenever the first is called. Many
-	//		listeners may be attached to a function, and source functions may
-	//		be either regular function calls or DOM events.
-	//
-	// description:
-	//		Connects listeners to actions, so that after event fires, a
-	//		listener is called with the same arguments passed to the original
-	//		function.
-	//
-	//		Since `dojo.connect` allows the source of events to be either a
-	//		"regular" JavaScript function or a DOM event, it provides a uniform
-	//		interface for listening to all the types of events that an
-	//		application is likely to deal with though a single, unified
-	//		interface. DOM programmers may want to think of it as
-	//		"addEventListener for everything and anything".
-	//
-	//		When setting up a connection, the `event` parameter must be a
-	//		string that is the name of the method/event to be listened for. If
-	//		`obj` is null, `kernel.global` is assumed, meaning that connections
-	//		to global methods are supported but also that you may inadvertently
-	//		connect to a global by passing an incorrect object name or invalid
-	//		reference.
-	//
-	//		`dojo.connect` generally is forgiving. If you pass the name of a
-	//		function or method that does not yet exist on `obj`, connect will
-	//		not fail, but will instead set up a stub method. Similarly, null
-	//		arguments may simply be omitted such that fewer than 4 arguments
-	//		may be required to set up a connection See the examples for details.
-	//
-	//		The return value is a handle that is needed to
-	//		remove this connection with `dojo.disconnect`.
-	//
-	// obj: Object|null:
-	//		The source object for the event function.
-	//		Defaults to `kernel.global` if null.
-	//		If obj is a DOM node, the connection is delegated
-	//		to the DOM event manager (unless dontFix is true).
-	//
-	// event: String:
-	//		String name of the event function in obj.
-	//		I.e. identifies a property `obj[event]`.
-	//
-	// context: Object|null
-	//		The object that method will receive as "this".
-	//
-	//		If context is null and method is a function, then method
-	//		inherits the context of event.
-	//
-	//		If method is a string then context must be the source
-	//		object object for method (context[method]). If context is null,
-	//		kernel.global is used.
-	//
-	// method: String|Function:
-	//		A function reference, or name of a function in context.
-	//		The function identified by method fires after event does.
-	//		method receives the same arguments as the event.
-	//		See context argument comments for information on method's scope.
-	//
-	// dontFix: Boolean?
-	//		If obj is a DOM node, set dontFix to true to prevent delegation
-	//		of this connection to the DOM event manager.
-	//
-	// example:
-	//		When obj.onchange(), do ui.update():
-	//	|	dojo.connect(obj, "onchange", ui, "update");
-	//	|	dojo.connect(obj, "onchange", ui, ui.update); // same
-	//
-	// example:
-	//		Using return value for disconnect:
-	//	|	var link = dojo.connect(obj, "onchange", ui, "update");
-	//	|	...
-	//	|	dojo.disconnect(link);
-	//
-	// example:
-	//		When onglobalevent executes, watcher.handler is invoked:
-	//	|	dojo.connect(null, "onglobalevent", watcher, "handler");
-	//
-	// example:
-	//		When ob.onCustomEvent executes, customEventHandler is invoked:
-	//	|	dojo.connect(ob, "onCustomEvent", null, "customEventHandler");
-	//	|	dojo.connect(ob, "onCustomEvent", "customEventHandler"); // same
-	//
-	// example:
-	//		When ob.onCustomEvent executes, customEventHandler is invoked
-	//		with the same scope (this):
-	//	|	dojo.connect(ob, "onCustomEvent", null, customEventHandler);
-	//	|	dojo.connect(ob, "onCustomEvent", customEventHandler); // same
-	//
-	// example:
-	//		When globalEvent executes, globalHandler is invoked
-	//		with the same scope (this):
-	//	|	dojo.connect(null, "globalEvent", null, globalHandler);
-	//	|	dojo.connect("globalEvent", globalHandler); // same
-}
-=====*/
-
-/*=====
-dojo.disconnect = function(handle){
-	// summary:
-	//		Remove a link created by dojo.connect.
-	// description:
-	//		Removes the connection between event and the method referenced by handle.
-	// handle: Handle:
-	//		the return value of the dojo.connect call that created the connection.
-}
-=====*/
-
-/*=====
-dojo.subscribe = function(topic, context, method){
-	//	summary:
-	//		Attach a listener to a named topic. The listener function is invoked whenever the
-	//		named topic is published (see: dojo.publish).
-	//		Returns a handle which is needed to unsubscribe this listener.
-	//	topic: String:
-	//		The topic to which to subscribe.
-	//	context: Object|null:
-	//		Scope in which method will be invoked, or null for default scope.
-	//	method: String|Function:
-	//		The name of a function in context, or a function reference. This is the function that
-	//		is invoked when topic is published.
-	//	example:
-	//	|	dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); });
-	//	|	dojo.publish("alerts", [ "read this", "hello world" ]);
-}
-=====*/
-
-/*=====
-dojo.unsubscribe = function(handle){
-	//	summary:
-	//		Remove a topic listener.
-	//	handle: Handle
-	//		The handle returned from a call to subscribe.
-	//	example:
-	//	|	var alerter = dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
-	//	|	...
-	//	|	dojo.unsubscribe(alerter);
-}
-=====*/
-
-/*=====
-dojo.publish = function(topic, args){
-	//	summary:
-	//		Invoke all listener method subscribed to topic.
-	//	topic: String:
-	//		The name of the topic to publish.
-	//	args: Array?
-	//		An array of arguments. The arguments will be applied
-	//		to each topic subscriber (as first class parameters, via apply).
-	//	example:
-	//	|	dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
-	//	|	dojo.publish("alerts", [ "read this", "hello world" ]);
-}
-=====*/
 
+connect.unsubscribe = connect.disconnect;
 /*=====
-dojo.connectPublisher = function(topic, obj, event){
-	//	summary:
-	//		Ensure that every time obj.event() is called, a message is published
-	//		on the topic. Returns a handle which can be passed to
-	//		dojo.disconnect() to disable subsequent automatic publication on
-	//		the topic.
-	//	topic: String:
-	//		The name of the topic to publish.
-	//	obj: Object|null:
-	//		The source object for the event function. Defaults to kernel.global
-	//		if null.
-	//	event: String:
-	//		The name of the event function in obj.
-	//		I.e. identifies a property obj[event].
-	//	example:
-	//	|	dojo.connectPublisher("/ajax/start", dojo, "xhrGet");
-}
-=====*/
+ connect.unsubscribe = function(handle){
+	 // summary:
+	 //		Remove a topic listener.
+	 // handle: Handle
+	 //		The handle returned from a call to subscribe.
+	 // example:
+	 //	|	var alerter = dojo.subscribe("alerts", null, function(caption, message){ alert(caption + "\n" + message); };
+	 //	|	...
+	 //	|	dojo.unsubscribe(alerter);
+ };
+ =====*/
 
-/*=====
-dojo.isCopyKey = function(e){
-	// summary:
-	//		Checks an event for the copy key (meta on Mac, and ctrl anywhere else)
-	// e: Event
-	//		Event object to examine
-}
-=====*/
+ 1  && lang.mixin(dojo, connect);
+return connect;
 
 });