javascriptmvc 3.0.0.pre15

data/lib/javascriptmvc/funcunit/test/protodrag/scriptaculous.js

@@ -0,0 +1,68 @@
+// script.aculo.us scriptaculous.js v1.8.3, Thu Oct 08 11:23:33 +0200 2009
+
+// Copyright (c) 2005-2009 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+// For details, see the script.aculo.us web site: http://script.aculo.us/
+
+var Scriptaculous = {
+  Version: '1.8.3',
+  require: function(libraryName) {
+    try{
+      // inserting via DOM fails in Safari 2.0, so brute force approach
+      document.write('<script type="text/javascript" src="'+libraryName+'"><\/script>');
+    } catch(e) {
+      // for xhtml+xml served content, fall back to DOM methods
+      var script = document.createElement('script');
+      script.type = 'text/javascript';
+      script.src = libraryName;
+      document.getElementsByTagName('head')[0].appendChild(script);
+    }
+  },
+  REQUIRED_PROTOTYPE: '1.6.0.3',
+  load: function() {
+    function convertVersionString(versionString) {
+      var v = versionString.replace(/_.*|\./g, '');
+      v = parseInt(v + '0'.times(4-v.length));
+      return versionString.indexOf('_') > -1 ? v-1 : v;
+    }
+
+    if((typeof Prototype=='undefined') ||
+       (typeof Element == 'undefined') ||
+       (typeof Element.Methods=='undefined') ||
+       (convertVersionString(Prototype.Version) <
+        convertVersionString(Scriptaculous.REQUIRED_PROTOTYPE)))
+       throw("script.aculo.us requires the Prototype JavaScript framework >= " +
+        Scriptaculous.REQUIRED_PROTOTYPE);
+
+    var js = /scriptaculous\.js(\?.*)?$/;
+    $$('head script[src]').findAll(function(s) {
+      return s.src.match(js);
+    }).each(function(s) {
+      var path = s.src.replace(js, ''),
+      includes = s.src.match(/\?.*load=([a-z,]*)/);
+      (includes ? includes[1] : 'builder,effects,dragdrop,controls,slider,sound').split(',').each(
+       function(include) { Scriptaculous.require(path+include+'.js') });
+    });
+  }
+};
+
+Scriptaculous.load();

data/lib/javascriptmvc/funcunit/update

@@ -0,0 +1,5 @@
+load('steal/rhino/steal.js')
+
+steal('//steal/get/get', function(s){
+	s.get("http://github.com/jupiterjs/funcunit/","funcunit");
+})

data/lib/javascriptmvc/jquery/README

@@ -0,0 +1,24 @@
+TOC:
+  A.  How to get (and contribute) to JMVC
+
+
+A.  How to get (and contribute) JMVC
+
+  1.  Start a new project in git.
+  
+  2.  Fork ....
+           http://github.com/jupiterjs/steal     and 
+           http://github.com/jupiterjs/javascriptmvc
+  
+  3.  Add steal and javascriptmvc as submodules of your project...
+           git submodule add git@github.com:_YOU_/steal.git steal
+           git submodule add git@github.com:_YOU_/javascriptmvc.git jquery
+           
+      * Notice javascriptmvc is under the jquery folder
+  
+  4.  Learn a little more about submodules ...
+           http://johnleach.co.uk/words/archives/2008/10/12/323/git-submodules-in-n-easy-steps
+           
+  5.  Make changes in steal or jmvc, and push them back to your fork.
+  
+  6.  Make a pull request to your fork.

data/lib/javascriptmvc/jquery/build.js

@@ -0,0 +1,73 @@
+load('steal/file/file.js')
+
+var i, fileName, cmd, 
+	plugins = [
+	"class", 
+	"controller",
+	{
+		plugin: "controller/subscribe", 
+		exclude: ["jquery/controller/controller.js",
+				  "jquery/class/class.js",
+				  "jquery/lang/lang.js",
+				  "jquery/event/destroyed/destroyed.js",
+				  "jquery/controller/controller.js"]},
+	"event/default",
+	"event/destroyed",
+	"event/drag",
+	{
+		plugin: "event/drag/limit", 
+		exclude: ["jquery/lang/vector/vector.js", "jquery/event/livehack/livehack.js", "jquery/event/drag/drag.js"]},
+	{
+		plugin: "event/drag/scroll", 
+		exclude: ["jquery/dom/within/within.js", "jquery/dom/compare/compare.js", "jquery/event/drop/drop.js","jquery/lang/vector/vector.js", "jquery/event/livehack/livehack.js", "jquery/event/drag/drag.js"]},
+	{
+		plugin: "event/drop",
+		exclude: ["jquery/lang/vector/vector.js", "jquery/event/livehack/livehack.js", "jquery/event/drag/drag.js"]},
+	"event/hover",
+	{
+		plugin: "model", 
+		exclude: ["jquery/class/class.js",
+				  "jquery/lang/lang.js",
+				  "jquery/event/destroyed/destroyed.js",
+				  "jquery/lang/openajax/openajax.js"]},
+	"view/ejs", 
+	"dom/closest",
+	"dom/compare",
+	{
+		plugin: "dom/dimensions",
+		fileName: "jquery.dimensions.etc.js"
+	},
+	"dom/fixture",
+	"dom/form_params",
+	"dom/within", 
+	"dom/cur_styles"
+]
+
+
+var plugin, exclude, fileDest, fileName;
+for(i=0; i<plugins.length; i++){
+	plugin = plugins[i];
+	exclude = [];
+	fileName = null;
+	if (typeof plugin != "string") {
+		fileName = plugin.fileName;
+		exclude = plugin.exclude || [];
+		plugin = plugin.plugin;
+	}
+	fileName = fileName || "jquery."+plugin.replace(/\//g, ".").replace(/dom\./, "").replace(/\_/, "")+".js";
+	fileDest = "jquery/dist/"+fileName
+	cmd = "js steal/scripts/pluginify.js jquery/"+plugin+" -destination "+fileDest;
+	if(exclude.length)
+		cmd += " -exclude "+exclude;
+	runCommand(	"cmd", "/C", cmd)
+	
+	// compress 
+	var outBaos = new java.io.ByteArrayOutputStream();
+	var output = new java.io.PrintStream(outBaos);
+	runCommand("java", "-jar", "steal/rhino/compiler.jar", "--compilation_level",
+    	"SIMPLE_OPTIMIZATIONS", "--warning_level","QUIET",  "--js", fileDest, {output: output});
+	
+    var minFileDest = fileDest.replace(".js", ".min.js")
+	new steal.File(minFileDest).save(outBaos.toString());
+	print("***"+fileName+" pluginified and compressed")
+}

data/lib/javascriptmvc/jquery/class/class.html

@@ -0,0 +1,109 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
+            "http://www.w3.org/TR/html4/strict.dtd">
+<html lang="en">
+    <head>
+        <title>jQuery.Class Demo</title>
+        <style type='text/css'>
+            body {font-family: verdana}
+            .tabs, .history_tabs {
+                
+                padding: 0px; margin: 20px 0 0 0;
+            }
+            li {
+                float: left;
+                padding: 10px;
+                background-color: #F6F6F6;
+                list-style: none;
+                margin-left: 10px;
+            }
+            li a {
+                color: #1C94C4;
+                font-weight: bold;
+                text-decoration: none;
+            }
+            li.active a {
+                color: #F6A828;
+                cursor: default;
+            }
+            .tab {
+                border: solid 1px #F6A828;
+            }
+            /* clearfix from jQueryUI */
+            .ui-helper-clearfix:after { content: "."; display: block; height: 0; clear: both; visibility: hidden; }
+            .ui-helper-clearfix { display: inline-block; }
+            /* required comment for clearfix to work in Opera \*/
+            * html .ui-helper-clearfix { height:1%; }
+            .ui-helper-clearfix { display:block; }
+            /* end clearfix */
+        </style>
+    </head>
+    <body>
+<p>jQuery.Class Demo shows a tabs controller extended to work with history.</p>
+<div id="demo-html">
+<h2>Basic Tabs</h2>
+<ul id='tabs1' class='ui-helper-clearfix''>
+    <li><a href='#tab1'>Tab 1</a></li>
+    <li><a href='#tab2'>Tab 2</a></li>
+    <li><a href='#tab3'>Tab 3</a></li>
+</ul>
+<div id='tab1' class='tab'>Tab 1 Content</div>
+<div id='tab2' class='tab'>Tab 2 Content</div>
+<div id='tab3' class='tab'>Tab 3 Content</div>
+<h2>History Tabs</h2>
+<ul id='tabs2' class='ui-helper-clearfix''>
+    <li><a href='#tab4'>Tab 4</a></li>
+    <li><a href='#tab5'>Tab 5</a></li>
+    <li><a href='#tab6'>Tab 6</a></li>
+</ul>
+<div id='tab4' class='tab'>Tab 4 Content</div>
+<div id='tab5' class='tab'>Tab 5 Content</div>
+<div id='tab6' class='tab'>Tab 6 Content</div>
+</div>
+<script type='text/javascript'>DEMO_HTML = document.getElementById('demo-html').innerHTML</script>
+<script type='text/javascript' src='../../steal/steal.js'></script>
+<script type='text/javascript'>
+	steal.plugins('jquery/controller/history').start();
+</script>
+<script type='text/javascript' id="demo-source">
+$.Controller.extend("Tabs",{
+  init : function(){
+    this.element.children("li:first").addClass('active')
+    var tab = this.tab;
+    this.element.children("li:gt(0)").each(function(){
+      tab($(this)).hide()
+    })
+  },
+  tab : function(li){
+    return $(li.find("a").attr("href"))
+  },
+  "li click" : function(el, ev){
+    ev.preventDefault();
+    this.activate(el)
+  },
+  activate : function(el){
+    this.tab(this.find('.active').removeClass('active')).hide()
+    this.tab(el.addClass('active')).show();
+  }
+})
+
+//inherit from tabs
+Tabs.extend("HistoryTabs",{
+  // ignore clicks
+  "li click" : function(){},
+  
+  // listen for history changes
+  "history.** subscribe" : function(called){
+	var hash = window.location.hash;
+	this.activate(hash === '' || hash === '#' ?
+      this.element.find("li:first") : 
+      this.element.find("a[href="+hash+"]").parent()
+    )
+  }
+})
+
+//adds the controller to the element
+$("#tabs1").tabs();
+$("#tabs2").history_tabs();
+</script>
+    </body>
+</html>

data/lib/javascriptmvc/jquery/class/class.js

@@ -0,0 +1,627 @@
+//jQuery.Class 
+// This is a modified version of John Resig's class
+// http://ejohn.org/blog/simple-javascript-inheritance/
+// It provides class level inheritance and callbacks.
+steal.plugin("jquery").then(function( $ ) {
+
+	// if we are initializing a new class
+	var initializing = false,
+
+		// tests if we can get super in .toString()
+		fnTest = /xyz/.test(function() {
+			xyz;
+		}) ? /\b_super\b/ : /.*/,
+
+		// overwrites an object with methods, sets up _super
+		inheritProps = function( newProps, oldProps, addTo ) {
+			addTo = addTo || newProps
+			for ( var name in newProps ) {
+				// Check if we're overwriting an existing function
+				addTo[name] = typeof newProps[name] == "function" && typeof oldProps[name] == "function" && fnTest.test(newProps[name]) ? (function( name, fn ) {
+					return function() {
+						var tmp = this._super,
+							ret;
+
+						// Add a new ._super() method that is the same method
+						// but on the super-class
+						this._super = oldProps[name];
+
+						// The method only need to be bound temporarily, so we
+						// remove it when we're done executing
+						ret = fn.apply(this, arguments);
+						this._super = tmp;
+						return ret;
+					};
+				})(name, newProps[name]) : newProps[name];
+			}
+		};
+
+
+	/**
+	 * @constructor jQuery.Class
+	 * @plugin jquery/class
+	 * @tag core
+	 * @download dist/jquery/jquery.class.js
+	 * @test jquery/class/qunit.html
+	 * Class provides simulated inheritance in JavaScript. Use $.Class to bridge the gap between
+	 * jQuery's functional programming style and Object Oriented Programming.
+	 * It is based off John Resig's [http://ejohn.org/blog/simple-javascript-inheritance/|Simple Class]
+	 * Inheritance library.  Besides prototypal inheritance, it includes a few important features:
+	 * <ul>
+	 *     <li>Static inheritance</li>
+	 *     <li>Introspection</li>
+	 *     <li>Namespaces</li>
+	 *     <li>Setup and initialization methods</li>
+	 *     <li>Easy callback function creation</li>
+	 * </ul>
+	 * <h2>Static v. Prototype</h2>
+	 * <p>Before learning about Class, it's important to
+	 * understand the difference between
+	 * a class's <b>static</b> and <b>prototype</b> properties.
+	 * </p>
+	 * @codestart
+	 * //STATIC
+	 * MyClass.staticProperty  //shared property
+	 *
+	 * //PROTOTYPE
+	 * myclass = new MyClass()
+	 * myclass.prototypeMethod() //instance method
+	 * @codeend
+	 * <p>A static (or class) property is on the Class constructor
+	 * function itself
+	 * and can be thought of being shared by all instances of the Class.
+	 * Prototype propertes are available only on instances of the Class.
+	 * </p>
+	 * <h2>A Basic Class</h2>
+	 * <p>The following creates a Monster class with a
+	 * name (for introspection), static, and prototype members.
+	 * Every time a monster instance is created, the static
+	 * count is incremented.
+	 *
+	 * </p>
+	 * @codestart
+	 * $.Class.extend('Monster',
+	 * /* @static *|
+	 * {
+	 *   count: 0
+	 * },
+	 * /* @prototype *|
+	 * {
+	 *   init: function( name ) {
+	 *
+	 *     // saves name on the monster instance
+	 *     this.name = name;
+	 *
+	 *     // sets the health
+	 *     this.health = 10;
+	 *
+	 *     // increments count
+	 *     this.Class.count++;
+	 *   },
+	 *   eat: function( smallChildren ){
+	 *     this.health += smallChildren;
+	 *   },
+	 *   fight: function() {
+	 *     this.health -= 2;
+	 *   }
+	 * });
+	 *
+	 * hydra = new Monster('hydra');
+	 *
+	 * dragon = new Monster('dragon');
+	 *
+	 * hydra.name        // -> hydra
+	 * Monster.count     // -> 2
+	 * Monster.shortName // -> 'Monster'
+	 *
+	 * hydra.eat(2);     // health = 12
+	 *
+	 * dragon.fight();   // health = 8
+	 *
+	 * @codeend
+	 *
+	 * <p>
+	 * Notice that the prototype <b>init</b> function is called when a new instance of Monster is created.
+	 * </p>
+	 * <h2>Inheritance</h2>
+	 * <p>When a class is extended, all static and prototype properties are available on the new class.
+	 * If you overwrite a function, you can call the base class's function by calling
+	 * <code>this._super</code>.  Lets create a SeaMonster class.  SeaMonsters are less
+	 * efficient at eating small children, but more powerful fighters.
+	 * </p>
+	 * @codestart
+	 * Monster.extend("SeaMonster",{
+	 *   eat: function( smallChildren ) {
+	 *     this._super(smallChildren / 2);
+	 *   },
+	 *   fight: function() {
+	 *     this.health -= 1;
+	 *   }
+	 * });
+	 *
+	 * lockNess = new SeaMonster('Lock Ness');
+	 * lockNess.eat(4);   //health = 12
+	 * lockNess.fight();  //health = 11
+	 * @codeend
+	 * <h3>Static property inheritance</h3>
+	 * You can also inherit static properties in the same way:
+	 * @codestart
+	 * $.Class.extend("First",
+	 * {
+	 *     staticMethod: function() { return 1;}
+	 * },{})
+	 *
+	 * First.extend("Second",{
+	 *     staticMethod: function() { return this._super()+1;}
+	 * },{})
+	 *
+	 * Second.staticMethod() // -> 2
+	 * @codeend
+	 * <h2>Namespaces</h2>
+	 * <p>Namespaces are a good idea! We encourage you to namespace all of your code.
+	 * It makes it possible to drop your code into another app without problems.
+	 * Making a namespaced class is easy:
+	 * </p>
+	 * @codestart
+	 * $.Class.extend("MyNamespace.MyClass",{},{});
+	 *
+	 * new MyNamespace.MyClass()
+	 * @codeend
+	 * <h2 id='introspection'>Introspection</h2>
+	 * Often, it's nice to create classes whose name helps determine functionality.  Ruby on
+	 * Rails's [http://api.rubyonrails.org/classes/ActiveRecord/Base.html|ActiveRecord] ORM class
+	 * is a great example of this.  Unfortunately, JavaScript doesn't have a way of determining
+	 * an object's name, so the developer must provide a name.  Class fixes this by taking a String name for the class.
+	 * @codestart
+	 * $.Class.extend("MyOrg.MyClass",{},{})
+	 * MyOrg.MyClass.shortName //-> 'MyClass'
+	 * MyOrg.MyClass.fullName //->  'MyOrg.MyClass'
+	 * @codeend
+	 * The fullName (with namespaces) and the shortName (without namespaces) are added to the Class's
+	 * static properties.
+	 *
+	 *
+	 * <h2>Setup and initialization methods</h2>
+	 * <p>
+	 * Class provides static and prototype initialization functions.
+	 * These come in two flavors - setup and init.
+	 * Setup is called before init and
+	 * can be used to 'normalize' init's arguments.
+	 * </p>
+	 * <div class='whisper'>PRO TIP: Typically, you don't need setup methods in your classes. Use Init instead.
+	 * Reserve setup methods for when you need to do complex pre-processing of your class before init is called.
+	 *
+	 * </div>
+	 * @codestart
+	 * $.Class.extend("MyClass",
+	 * {
+	 *   setup: function() {} //static setup
+	 *   init: function() {} //static constructor
+	 * },
+	 * {
+	 *   setup: function() {} //prototype setup
+	 *   init: function() {} //prototype constructor
+	 * })
+	 * @codeend
+	 *
+	 * <h3>Setup</h3>
+	 * <p>Setup functions are called before init functions.  Static setup functions are passed
+	 * the base class followed by arguments passed to the extend function.
+	 * Prototype static functions are passed the Class constructor function arguments.</p>
+	 * <p>If a setup function returns an array, that array will be used as the arguments
+	 * for the following init method.  This provides setup functions the ability to normalize
+	 * arguments passed to the init constructors.  They are also excellent places
+	 * to put setup code you want to almost always run.</p>
+	 * <p>
+	 * The following is similar to how [jQuery.Controller.prototype.setup]
+	 * makes sure init is always called with a jQuery element and merged options
+	 * even if it is passed a raw
+	 * HTMLElement and no second parameter.
+	 * </p>
+	 * @codestart
+	 * $.Class.extend("jQuery.Controller",{
+	 *   ...
+	 * },{
+	 *   setup: function( el, options ) {
+	 *     ...
+	 *     return [$(el),
+	 *             $.extend(true,
+	 *                this.Class.defaults,
+	 *                options || {} ) ]
+	 *   }
+	 * })
+	 * @codeend
+	 * Typically, you won't need to make or overwrite setup functions.
+	 * <h3>Init</h3>
+	 *
+	 * <p>Init functions are called after setup functions.
+	 * Typically, they receive the same arguments
+	 * as their preceding setup function.  The Foo class's <code>init</code> method
+	 * gets called in the following example:
+	 * </p>
+	 * @codestart
+	 * $.Class.Extend("Foo", {
+	 *   init: function( arg1, arg2, arg3 ) {
+	 *     this.sum = arg1+arg2+arg3;
+	 *   }
+	 * })
+	 * var foo = new Foo(1,2,3);
+	 * foo.sum //-> 6
+	 * @codeend
+	 * <h2>Callbacks</h2>
+	 * <p>Similar to jQuery's proxy method, Class provides a
+	 * [jQuery.Class.static.callback callback]
+	 * function that returns a callback to a method that will always
+	 * have
+	 * <code>this</code> set to the class or instance of the class.
+	 * </p>
+	 * The following example uses this.callback to make sure
+	 * <code>this.name</code> is available in <code>show</code>.
+	 * @codestart
+	 * $.Class.extend("Todo",{
+	 *   init: function( name ) { this.name = name }
+	 *   get: function() {
+	 *     $.get("/stuff",this.callback('show'))
+	 *   },
+	 *   show: function( txt ) {
+	 *     alert(this.name+txt)
+	 *   }
+	 * })
+	 * new Todo("Trash").get()
+	 * @codeend
+	 * <p>Callback is available as a static and prototype method.</p>
+	 * <h2>Demo</h2>
+	 * @demo jquery/class/class.html
+	 *
+	 * @init Creating a new instance of an object that has extended jQuery.Class
+	 *     calls the init prototype function and returns a new instance of the class.
+	 *
+	 */
+
+	jQuery.Class = function() {
+		if ( arguments.length ) this.extend.apply(this, arguments)
+	};
+
+	/* @Static*/
+	$.extend($.Class, {
+		/**
+		 * @function callback
+		 * Returns a callback function for a function on this Class.
+		 * The callback function ensures that 'this' is set appropriately.  
+		 * @codestart
+		 * $.Class.extend("MyClass",{
+		 *     getData: function() {
+		 *         this.showing = null;
+		 *         $.get("data.json",this.callback('gotData'),'json')
+		 *     },
+		 *     gotData: function( data ) {
+		 *         this.showing = data;
+		 *     }
+		 * },{});
+		 * MyClass.showData();
+		 * @codeend
+		 * <h2>Currying Arguments</h2>
+		 * Additional arguments to callback will fill in arguments on the returning function.
+		 * @codestart
+		 * $.Class.extend("MyClass",{
+		 *    getData: function( <b>callback</b> ) {
+		 *      $.get("data.json",this.callback('process',<b>callback</b>),'json');
+		 *    },
+		 *    process: function( <b>callback</b>, jsonData ) { //callback is added as first argument
+		 *        jsonData.processed = true;
+		 *        callback(jsonData);
+		 *    }
+		 * },{});
+		 * MyClass.getData(showDataFunc)
+		 * @codeend
+		 * <h2>Nesting Functions</h2>
+		 * Callback can take an array of functions to call as the first argument.  When the returned callback function
+		 * is called each function in the array is passed the return value of the prior function.  This is often used
+		 * to eliminate currying initial arguments.
+		 * @codestart
+		 * $.Class.extend("MyClass",{
+		 *    getData: function( callback ) {
+		 *      //calls process, then callback with value from process
+		 *      $.get("data.json",this.callback(['process2',callback]),'json') 
+		 *    },
+		 *    process2: function( type,jsonData ) {
+		 *        jsonData.processed = true;
+		 *        return [jsonData];
+		 *    }
+		 * },{});
+		 * MyClass.getData(showDataFunc);
+		 * @codeend
+		 * @param {String|Array} fname If a string, it represents the function to be called.  
+		 * If it is an array, it will call each function in order and pass the return value of the prior function to the
+		 * next function.
+		 * @return {Function} the callback function.
+		 */
+		callback: function( funcs ) {
+
+			//args that should be curried
+			var args = jQuery.makeArray(arguments),
+				self;
+
+			funcs = args.shift();
+
+			if (!jQuery.isArray(funcs) ) {
+				funcs = [funcs];
+			}
+
+			self = this;
+
+			return function class_cb() {
+				var cur = args.concat(jQuery.makeArray(arguments)),
+					isString, length = funcs.length,
+					f = 0,
+					func;
+
+				for (; f < length; f++ ) {
+					func = funcs[f];
+					if (!func ) {
+						continue;
+					}
+
+					isString = typeof func == "string";
+					if ( isString && self._set_called ) {
+						self.called = func;
+					}
+					cur = (isString ? self[func] : func).apply(self, cur || []);
+					if ( f < length - 1 ) {
+						cur = !jQuery.isArray(cur) || cur._use_call ? [cur] : cur
+					}
+				}
+				return cur;
+			}
+		},
+		/**
+		 *   @function getObject 
+		 *   Gets an object from a String.
+		 *   If the object or namespaces the string represent do not
+		 *   exist it will create them.  
+		 *   @codestart
+		 *   Foo = {Bar: {Zar: {"Ted"}}}
+		 *   $.Class.getobject("Foo.Bar.Zar") //-> "Ted"
+		 *   @codeend
+		 *   @param {String} objectName the object you want to get
+		 *   @param {Object} [current=window] the object you want to look in.
+		 *   @return {Object} the object you are looking for.
+		 */
+		getObject: function( objectName, current ) {
+			var current = current || window,
+				parts = objectName ? objectName.split(/\./) : [],
+				i = 0;
+			for (; i < parts.length; i++ ) {
+				current = current[parts[i]] || (current[parts[i]] = {})
+			}
+			return current;
+		},
+		/**
+		 * @function newInstance
+		 * Creates a new instance of the class.  This method is useful for creating new instances
+		 * with arbitrary parameters.
+		 * <h3>Example</h3>
+		 * @codestart
+		 * $.Class.extend("MyClass",{},{})
+		 * var mc = MyClass.newInstance.apply(null, new Array(parseInt(Math.random()*10,10))
+		 * @codeend
+		 * @return {class} instance of the class
+		 */
+		newInstance: function() {
+			var inst = this.rawInstance(),
+				args;
+			if ( inst.setup ) {
+				args = inst.setup.apply(inst, arguments);
+			}
+			if ( inst.init ) {
+				inst.init.apply(inst, $.isArray(args) ? args : arguments);
+			}
+			return inst;
+		},
+		/**
+		 * Copy and overwrite options from old class
+		 * @param {Object} oldClass
+		 * @param {String} fullName
+		 * @param {Object} staticProps
+		 * @param {Object} protoProps
+		 */
+		setup: function( oldClass, fullName ) {
+			this.defaults = $.extend(true, {}, oldClass.defaults, this.defaults);
+			return arguments;
+		},
+		rawInstance: function() {
+			initializing = true;
+			var inst = new this();
+			initializing = false;
+			return inst;
+		},
+		/**
+		 * Extends a class with new static and prototype functions.  There are a variety of ways
+		 * to use extend:
+		 * @codestart
+		 * //with className, static and prototype functions
+		 * $.Class.extend('Task',{ STATIC },{ PROTOTYPE })
+		 * //with just classname and prototype functions
+		 * $.Class.extend('Task',{ PROTOTYPE })
+		 * //With just a className
+		 * $.Class.extend('Task')
+		 * @codeend
+		 * @param {String} [fullName]  the classes name (used for classes w/ introspection)
+		 * @param {Object} [klass]  the new classes static/class functions
+		 * @param {Object} [proto]  the new classes prototype functions
+		 * @return {jQuery.Class} returns the new class
+		 */
+		extend: function( fullName, klass, proto ) {
+			// figure out what was passed
+			if ( typeof fullName != 'string' ) {
+				proto = klass;
+				klass = fullName;
+				fullName = null;
+			}
+			if (!proto ) {
+				proto = klass;
+				klass = null;
+			}
+
+			proto = proto || {};
+			var _super_class = this,
+				_super = this.prototype,
+				name, shortName, namespace, prototype;
+
+			// Instantiate a base class (but only create the instance,
+			// don't run the init constructor)
+			initializing = true;
+			prototype = new this();
+			initializing = false;
+			// Copy the properties over onto the new prototype
+			inheritProps(proto, _super, prototype);
+
+			// The dummy class constructor
+
+			function Class() {
+				// All construction is actually done in the init method
+				if ( initializing ) return;
+
+				if ( this.constructor !== Class && arguments.length ) { //we are being called w/o new
+					return this.extend.apply(this, arguments)
+				} else { //we are being called w/ new
+					return this.Class.newInstance.apply(this.Class, arguments)
+				}
+			}
+			// Copy old stuff onto class
+			for ( name in this ) {
+				if ( this.hasOwnProperty(name) && $.inArray(name, ['prototype', 'defaults', 'getObject']) == -1 ) {
+					Class[name] = this[name];
+				}
+			}
+
+			// do static inheritance
+			inheritProps(klass, this, Class);
+
+			// do namespace stuff
+			if ( fullName ) {
+
+				var parts = fullName.split(/\./),
+					shortName = parts.pop(),
+					current = $.Class.getObject(parts.join('.')),
+					namespace = current;
+
+				//@steal-remove-start
+				steal.dev.isHappyName(fullName)
+				//@steal-remove-end
+				current[shortName] = Class;
+			}
+
+			// set things that can't be overwritten
+			$.extend(Class, {
+				prototype: prototype,
+				namespace: namespace,
+				shortName: shortName,
+				constructor: Class,
+				fullName: fullName
+			});
+
+			//make sure our prototype looks nice
+			Class.prototype.Class = Class.prototype.constructor = Class;
+
+
+			/**
+			 * @attribute fullName 
+			 * The full name of the class, including namespace, provided for introspection purposes.
+			 * @codestart
+			 * $.Class.extend("MyOrg.MyClass",{},{})
+			 * MyOrg.MyClass.shortName //-> 'MyClass'
+			 * MyOrg.MyClass.fullName //->  'MyOrg.MyClass'
+			 * @codeend
+			 */
+
+			var args = Class.setup.apply(Class, [_super_class].concat($.makeArray(arguments)));
+
+			if ( Class.init ) {
+				Class.init.apply(Class, args || []);
+			}
+
+			/* @Prototype*/
+			return Class;
+			/** 
+			 * @function setup
+			 * Called with the same arguments as new Class(arguments ...) when a new instance is created.
+			 * @codestart
+			 * $.Class.extend("MyClass",
+			 * {
+			 *    setup: function( val ) {
+			 *       this.val = val;
+			 *    }
+			 * })
+			 * var mc = new MyClass("Check Check")
+			 * mc.val //-> 'Check Check'
+			 * @codeend
+			 * 
+			 * <div class='whisper'>PRO TIP: 
+			 * Setup functions are used to normalize constructor arguments and provide a place for
+			 * setup code that extending classes don't have to remember to call _super to
+			 * run.
+			 * </div>
+			 * 
+			 * @return {Array|undefined} If an array is return, [jQuery.Class.prototype.init] is 
+			 * called with those arguments; otherwise, the original arguments are used.
+			 */
+			//break up
+			/** 
+			 * @function init
+			 * Called with the same arguments as new Class(arguments ...) when a new instance is created.
+			 * @codestart
+			 * $.Class.extend("MyClass",
+			 * {
+			 *    init: function( val ) {
+			 *       this.val = val;
+			 *    }
+			 * })
+			 * var mc = new MyClass("Check Check")
+			 * mc.val //-> 'Check Check'
+			 * @codeend
+			 */
+			//Breaks up code
+			/**
+			 * @attribute Class
+			 * References the static properties of the instance's class.
+			 * <h3>Quick Example</h3>
+			 * @codestart
+			 * // a class with a static classProperty property
+			 * $.Class.extend("MyClass", {classProperty : true}, {});
+			 * 
+			 * // a new instance of myClass
+			 * var mc1 = new MyClass();
+			 * 
+			 * //
+			 * mc1.Class.classProperty = false;
+			 * 
+			 * // creates a new MyClass
+			 * var mc2 = new mc.Class();
+			 * @codeend
+			 * Getting static properties via the Class property, such as it's 
+			 * [jQuery.Class.static.fullName fullName] is very common.
+			 */
+		}
+
+	})
+
+
+
+
+
+	jQuery.Class.prototype.
+	/**
+	 * @function callback
+	 * Returns a callback function.  This does the same thing as and is described better in [jQuery.Class.static.callback].
+	 * The only difference is this callback works
+	 * on a instance instead of a class.
+	 * @param {String|Array} fname If a string, it represents the function to be called.  
+	 * If it is an array, it will call each function in order and pass the return value of the prior function to the
+	 * next function.
+	 * @return {Function} the callback function
+	 */
+	callback = jQuery.Class.callback;
+
+
+})();