iqjax 0.1.0

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2011 innoQ Deutschland GmbH
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,41 @@
+iQjax
+=====
+
+This is an unobtrusive JavaScript component for doing Ajax in conformity 
+with the [ROCA-Style](http://roca-style.org). It enables your web application 
+to do Ajax without bigger impacts to your server side. 
+
+An iQjax enabled DOM node loads the target of annotated links it contains into a 
+specific container DOM node. This is done asynchronously via Ajax. If the 
+content contains a form, the form handling (especially error handling) will be 
+automatically done in the container too. After a form was successfully submitted, 
+iQjax provides methods to update the iQjax container without reloading the whole 
+page.
+
+E.g. given a iQjax enabled list of person names with links pointing to a
+form to edit the respective person name. Clicking on such a link will
+load the form to a given container DOM node. After submitting the form 
+with a changed name, the user would expect the list of names to be updated.
+iQjax can do this by searching the new list entry in the response of
+the form POST. Then it replaces the old node with the new one.
+
+Documentation
+-------------
+
+We distinguish six API parts of ROCA-Style JavaScript components:
+
+# The socket HTML markup the component initializes upon,
+# the constructor method together with it's parameters,
+# methods callable upon the component,
+# events triggered by the component,
+# HTML markup the component generates and
+# Ajax-Requests the component fires.
+
+### Socket markup
+
+iQjax must be initialized on a DOM node with a `data-iqjax` attribute set. 
+The attribute must contain a selector for the container the Ajax-response 
+should be put in.
+
+
+... TO BE DONE ...

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+require 'rake/testtask'
+
+Bundler::GemHelper.install_tasks
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*.rb']
+end
+
+task :default => [:test]

data/iqjax.gemspec

@@ -0,0 +1,21 @@
+require File.expand_path('../lib/iqjax/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "iqjax"
+  s.version     = Iqjax::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["FND", "Till Schulte-Coerne"]
+  s.email       = ["", "till.schulte-coerne@innoq.com"]
+  s.homepage    = "http://github.com/innoq/iqjax"
+  s.summary     = "iQjax - a JS library for real unobtrusive Ajax"
+  s.description = s.summary
+  s.extra_rdoc_files = ['README.md', 'LICENSE']
+
+  s.add_dependency "bundler"
+  s.add_dependency "railties", ">= 3.2.0", "< 5.0"
+
+  s.files = %w(LICENSE README.md Rakefile iqjax.gemspec iqjax.js) + Dir.glob("{lib,vendor,test}/**/*")
+  s.test_files = Dir.glob("{test}/**/*")
+  
+   s.require_path = 'lib'
+end

data/iqjax.js

@@ -0,0 +1,200 @@
+/*jslint vars: true, unparam: true, browser: true, white: true */
+/*global jQuery */
+
+/* Copyright 2012 innoQ Deutschland GmbH
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// dynamic loading of content
+// inspired by https://github.com/defunkt/jquery-iqjax - though minus the
+// History API and based on Rails's data-remote functionality and error handling
+(function($) {
+
+"use strict";
+
+var iqjax_uri, requestMethod;
+
+var IQjax = function(context, target) {
+	// NB: context and target must not be descendants of each other
+	this.context = context;
+	this.target = target;
+	this.indicator = $(".indicator", target);
+	if(!this.indicator.length) {
+		this.indicator = $('<div class="indicator hidden"></div>');
+	}
+
+	// NB: redefining `this` in event handlers (via `proxy`) is dangerously
+	// misleading, but avoids non-standard function signatures for event
+	// handlers - plus for instance methods, it's actually more intuitive
+
+	// cancel buttons
+	var uri = document.location.toString().split("#")[0]; // XXX: use as selector makes for brittle heuristic?
+	this.target.on("click", 'a[href="' + uri + '"]', $.proxy(this.onCancel, this));
+
+	var selector = "a[data-remote], form[data-remote]";
+	var handlers = {
+		"ajax:beforeSend": $.proxy(this.beforeSend, this),
+		"ajax:success": $.proxy(this.onSuccess, this),
+		"ajax:error": $.proxy(this.onError, this)
+	};
+	this.context.add(this.target).on(handlers, selector);
+
+	// dirty state: protect against accidental dismissal
+	var self = this;
+	this.target.on("change", "input, textarea, select", function(ev) {
+		self.dirty = true;
+	});
+};
+$.extend(IQjax.prototype, {
+	onCancel: function(ev) {
+		if(!this.checkDirty(ev)) {
+			this.reset();
+		}
+		ev.preventDefault();
+	},
+	beforeSend: function(ev, xhr, settings) {
+		if(this.checkDirty(ev)) {
+			return false;
+		}
+
+		var contextAction = $.contains(this.context[0], ev.currentTarget); // TODO: rename -- XXX: hacky?
+		if(contextAction) {
+			this.reset();
+		}
+		$(ev.currentTarget).addClass("active");
+		this.target.prepend(this.indicator);
+		this.indicator.show();
+		settings.url = iqjax_uri(settings.url);
+		this.target.children().not(this.indicator).css("opacity", 0.5);
+	},
+	onSuccess: function(ev, data, status, xhr) {
+		if(!ev.currentTarget.parentNode) {
+			// FIXME: it's not clear under what circumstances this occurs;
+			// apparently, for reasons yet unknown, this event is erroneously
+			// triggered twice (and not all such duplicate events are
+			// intercepted by this hack, e.g. DELETE operations)
+			return;
+		}
+
+		var targetAction = $.contains(this.target[0], ev.currentTarget), // TODO: rename -- XXX: hacky?
+			el = $(ev.currentTarget),
+			reqMethod = "GET",
+			origin;
+
+		if(el.is("form")) {
+			if(targetAction) {
+				this.onUpdate.call(this, data, status, xhr); // TODO: should trigger event
+				return;
+			} else {
+				reqMethod = requestMethod(el);
+				origin = el.closest(".iqjax-entity"); // TODO: document
+			}
+		}
+
+		if(origin && reqMethod === "DELETE") {
+			this.indicator.hide();
+			origin.slideUp($.proxy(origin.remove, origin));
+		} else {
+			this.display(data);
+		}
+	},
+	onError: function(ev, xhr, error, exc) {
+		var cType = xhr.getResponseHeader("Content-Type"),
+			isHTML = cType ? cType.match(/\btext\/html\b/) : false;
+		this.display(xhr.responseText || error, !isHTML);
+	},
+	onUpdate: function(data, status, xhr) {
+		var src = xhr.getResponseHeader("X-IQJAX"), // TODO: document
+			item = $("<div />").html(data).find("#" + src),
+			origin = $(".active", this.context),
+			container = origin.closest("[data-iqjax-collection]"), // TODO: document
+			form = $("form.active", this.target),
+			reqMethod = requestMethod(form);
+
+		this.target.empty();
+
+		container = container.jquery ? container : $(container);
+		// account for nested update targets -- XXX: hacky!?
+		if(reqMethod === "PUT" && origin.closest(".iqjax-entity")[0] === container[0]) {
+			container = container.parent().closest("[data-iqjax-collection]");
+		}
+		container = $(container.data("iqjax-collection"));
+
+		if(reqMethod === "GET") { // multi-step forms
+			this.display(data);
+		} else {
+			this.reset();
+		}
+
+		var el = $("#" + src, self.context);
+		if(el.length) {
+			el.replaceWith(item);
+		} else { // new
+			container.append(item);
+		}
+
+		item.addClass("success").removeClass("success", "glacial");
+		this.context.trigger("iqjax:update", { item: item, doc: data });
+	},
+	reset: function() {
+		this.target.empty();
+		this.dirty = false;
+		$(".active", this.context).removeClass("active");
+	},
+	display: function(txt, plain) {
+		this.indicator.hide();
+		this.target[plain ? "text" : "html"](txt).prepend(this.indicator);
+		// intercept interactions to prevent full page reload
+		$("form", this.target).attr("data-remote", true);
+		this.context.trigger("iqjax:content", { iqjax: this });
+	},
+	// dirty state: protect against accidental dismissal
+	dirtyMsg: "Es gibt ungespeicherte Änderungen - fortfahren (Änderungen werden verworfen)?", // TODO: rephrase
+	checkDirty: function(ev) {
+		var isSubmit = $(ev.currentTarget).is("form");
+		if(this.dirty && !isSubmit) {
+			if(confirm(this.dirtyMsg)) {
+				this.dirty = false;
+			} else {
+				return true;
+			}
+		}
+	}
+});
+
+// hack to prevent cache confusion (browser caches should distinguish between
+// iQjax and non-iQjax requests) - it'd be more elegant to modify the jqXHR's
+// `data` property here, but it appears that's being overridden by jQuery later
+iqjax_uri = function(uri) {
+	return uri + (uri.indexOf("?") === -1 ? "?" : "&") + "_iqjax=1";
+};
+
+requestMethod = function(form) {
+	var m = $("input[name=_method]", form).val() || form.attr("method") || "GET";
+	return m.toUpperCase();
+};
+
+// uses dynamic in-page loading for child elements matching `a[data-remote]`
+// options.target is the DOM element within which contents are to be displayed
+// (defaults to selector contained in context element's `data-iqjax` attribute)
+$.fn.iqjax = function(options) {
+	options = options || {};
+	return this.each(function(i, node) {
+		var context = $(this),
+			target = $(options.target || context.data("iqjax")); // TODO: document
+		new IQjax(context, target);
+	});
+};
+
+}(jQuery));

data/lib/iqjax.rb

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

data/lib/iqjax/engine.rb

@@ -0,0 +1,5 @@
+module Iqjax
+  class Engine < ::Rails::Engine
+  end
+end
+

data/lib/iqjax/version.rb

@@ -0,0 +1,4 @@
+module Iqjax
+  VERSION = "0.1.0"
+end
+

data/test/index.html

@@ -0,0 +1,55 @@
+<!DOCTYPE html>
+<html>
+
+  <head>
+    <meta charset="utf-8">
+    <title>iQjax QUnit Test Suite</title>
+    <link rel="stylesheet" href="lib/qunit.css">
+  </head>
+
+  <body>
+    <h1 id="qunit-header">QUnit Test Suite</h1>
+    <h2 id="qunit-banner"></h2>
+    <div id="qunit-testrunner-toolbar"></div>
+    <h2 id="qunit-userAgent"></h2>
+    <ol id="qunit-tests"></ol>
+    <div id="qunit-fixture">
+
+      <div id="basic" data-iqjax-collection="#other-item-list">
+
+        <div data-iqjax-collection="#item-list">
+          <p><a href="/items/new" id="new" data-remote="true">New</a></p>
+          <ul id="item-list">
+            <li id="item1">
+              <a href="/items/1/edit" data-remote="true">Edit</a>
+            </li>
+            <li id="item2">
+              <a href="/items/2/edit" data-remote="true">Edit</a>
+            </li>
+            <li id="dummy-item-pointing-to-item3">
+              <a href="/items/3/edit" data-remote="true">Edit</a>
+            </li>
+          </ul>
+        </div>
+
+        <ul id="other-item-list">
+          <li id="item3">Change me!</li>
+        </ul>
+
+      </div>
+
+      <div id="my-container1"></div>
+
+    </div>
+
+    <script src="lib/qunit.js"></script>
+    <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min.js"></script>
+    <script src="lib/jquery.mockjax.js"></script>
+
+    <script src="../vendor/jquery_ujs.js"></script>
+
+    <script src="../iqjax.js"></script>
+    <script src="tests.js"></script>
+  </body>
+
+</html>

data/test/lib/jquery.mockjax.js

@@ -0,0 +1,382 @@
+/*!
+ * MockJax - jQuery Plugin to Mock Ajax requests
+ *
+ * Version:  1.4.0
+ * Released: 2011-02-04
+ * Source:   http://github.com/appendto/jquery-mockjax
+ * Docs:     http://enterprisejquery.com/2010/07/mock-your-ajax-requests-with-mockjax-for-rapid-development
+ * Plugin:   mockjax
+ * Author:   Jonathan Sharp (http://jdsharp.com)
+ * License:  MIT,GPL
+ *
+ * Copyright (c) 2010 appendTo LLC.
+ * Dual licensed under the MIT or GPL licenses.
+ * http://appendto.com/open-source-licenses
+ */
+(function($) {
+	var _ajax = $.ajax,
+		mockHandlers = [];
+
+	function parseXML(xml) {
+		if ( window['DOMParser'] == undefined && window.ActiveXObject ) {
+			DOMParser = function() { };
+			DOMParser.prototype.parseFromString = function( xmlString ) {
+				var doc = new ActiveXObject('Microsoft.XMLDOM');
+		        doc.async = 'false';
+		        doc.loadXML( xmlString );
+				return doc;
+			};
+		}
+
+		try {
+			var xmlDoc 	= ( new DOMParser() ).parseFromString( xml, 'text/xml' );
+			if ( $.isXMLDoc( xmlDoc ) ) {
+				var err = $('parsererror', xmlDoc);
+				if ( err.length == 1 ) {
+					throw('Error: ' + $(xmlDoc).text() );
+				}
+			} else {
+				throw('Unable to parse XML');
+			}
+		} catch( e ) {
+			var msg = ( e.name == undefined ? e : e.name + ': ' + e.message );
+			$(document).trigger('xmlParseError', [ msg ]);
+			return undefined;
+		}
+		return xmlDoc;
+	}
+
+	$.extend({
+		ajax: function(origSettings) {
+			var s = jQuery.extend(true, {}, jQuery.ajaxSettings, origSettings),
+			    mock = false;
+			// Iterate over our mock handlers (in registration order) until we find
+			// one that is willing to intercept the request
+			$.each(mockHandlers, function(k, v) {
+				if ( !mockHandlers[k] ) {
+					return;
+				}
+				var m = null;
+				// If the mock was registered with a function, let the function decide if we
+				// want to mock this request
+				if ( $.isFunction(mockHandlers[k]) ) {
+					m = mockHandlers[k](s);
+				} else {
+					m = mockHandlers[k];
+					// Inspect the URL of the request and check if the mock handler's url
+					// matches the url for this ajax request
+					if ( $.isFunction(m.url.test) ) {
+						// The user provided a regex for the url, test it
+						if ( !m.url.test( s.url ) ) {
+							m = null;
+						}
+					} else {
+						// Look for a simple wildcard '*' or a direct URL match
+						var star = m.url.indexOf('*');
+						if ( ( m.url != '*' && m.url != s.url && star == -1 ) ||
+							( star > -1 && m.url.substr(0, star) != s.url.substr(0, star) ) ) {
+							 // The url we tested did not match the wildcard *
+							 m = null;
+						}
+					}
+					if ( m ) {
+						// Inspect the data submitted in the request (either POST body or GET query string)
+						if ( m.data && s.data ) {
+							var identical = false;
+							// Deep inspect the identity of the objects
+							(function ident(mock, live) {
+								// Test for situations where the data is a querystring (not an object)
+								if (typeof live === 'string') {
+									// Querystring may be a regex
+									identical = $.isFunction( mock.test ) ? mock.test(live) : mock == live;
+									return identical;
+								}
+								$.each(mock, function(k, v) {
+									if ( live[k] === undefined ) {
+										identical = false;
+										return false;
+									} else {
+										identical = true;
+										if ( typeof live[k] == 'object' ) {
+											return ident(mock[k], live[k]);
+										} else {
+											if ( $.isFunction( mock[k].test ) ) {
+												identical = mock[k].test(live[k]);
+											} else {
+												identical = ( mock[k] == live[k] );
+											}
+											return identical;
+										}
+									}
+								});
+							})(m.data, s.data);
+							// They're not identical, do not mock this request
+							if ( identical == false ) {
+								m = null;
+							}
+						}
+						// Inspect the request type
+						if ( m && m.type && m.type != s.type ) {
+							// The request type doesn't match (GET vs. POST)
+							m = null;
+						}
+					}
+				}
+				if ( m ) {
+					mock = true;
+
+					// Handle console logging
+					var c = $.extend({}, $.mockjaxSettings, m);
+					if ( c.log && $.isFunction(c.log) ) {
+						c.log('MOCK ' + s.type.toUpperCase() + ': ' + s.url, $.extend({}, s));
+					}
+
+					var jsre = /=\?(&|$)/, jsc = (new Date()).getTime();
+
+					// Handle JSONP Parameter Callbacks, we need to replicate some of the jQuery core here
+					// because there isn't an easy hook for the cross domain script tag of jsonp
+					if ( s.dataType === "jsonp" ) {
+						if ( s.type.toUpperCase() === "GET" ) {
+							if ( !jsre.test( s.url ) ) {
+								s.url += (rquery.test( s.url ) ? "&" : "?") + (s.jsonp || "callback") + "=?";
+							}
+						} else if ( !s.data || !jsre.test(s.data) ) {
+							s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";
+						}
+						s.dataType = "json";
+					}
+
+					// Build temporary JSONP function
+					if ( s.dataType === "json" && (s.data && jsre.test(s.data) || jsre.test(s.url)) ) {
+						jsonp = s.jsonpCallback || ("jsonp" + jsc++);
+
+						// Replace the =? sequence both in the query string and the data
+						if ( s.data ) {
+							s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
+						}
+
+						s.url = s.url.replace(jsre, "=" + jsonp + "$1");
+
+						// We need to make sure
+						// that a JSONP style response is executed properly
+						s.dataType = "script";
+
+						// Handle JSONP-style loading
+						window[ jsonp ] = window[ jsonp ] || function( tmp ) {
+							data = tmp;
+							success();
+							complete();
+							// Garbage collect
+							window[ jsonp ] = undefined;
+
+							try {
+								delete window[ jsonp ];
+							} catch(e) {}
+
+							if ( head ) {
+								head.removeChild( script );
+							}
+						};
+					}
+
+					var rurl = /^(\w+:)?\/\/([^\/?#]+)/,
+						parts = rurl.exec( s.url ),
+						remote = parts && (parts[1] && parts[1] !== location.protocol || parts[2] !== location.host);
+
+					// Test if we are going to create a script tag (if so, intercept & mock)
+					if ( s.dataType === "script" && s.type.toUpperCase() === "GET" && remote ) {
+						// Synthesize the mock request for adding a script tag
+						var callbackContext = origSettings && origSettings.context || s;
+
+						function success() {
+							// If a local callback was specified, fire it and pass it the data
+							if ( s.success ) {
+								s.success.call( callbackContext, ( m.response ? m.response.toString() : m.responseText || ''), status, {} );
+							}
+
+							// Fire the global callback
+							if ( s.global ) {
+								trigger( "ajaxSuccess", [{}, s] );
+							}
+						}
+
+						function complete() {
+							// Process result
+							if ( s.complete ) {
+								s.complete.call( callbackContext, {} , status );
+							}
+
+							// The request was completed
+							if ( s.global ) {
+								trigger( "ajaxComplete", [{}, s] );
+							}
+
+							// Handle the global AJAX counter
+							if ( s.global && ! --jQuery.active ) {
+								jQuery.event.trigger( "ajaxStop" );
+							}
+						}
+
+						function trigger(type, args) {
+							(s.context ? jQuery(s.context) : jQuery.event).trigger(type, args);
+						}
+
+						if ( m.response && $.isFunction(m.response) ) {
+							m.response(origSettings);
+						} else {
+							$.globalEval(m.responseText);
+						}
+						success();
+						complete();
+						return false;
+					}
+					mock = _ajax.call($, $.extend(true, {}, origSettings, {
+						// Mock the XHR object
+						xhr: function() {
+							// Extend with our default mockjax settings
+							m = $.extend({}, $.mockjaxSettings, m);
+
+							if ( m.contentType ) {
+								m.headers['content-type'] = m.contentType;
+							}
+
+							// Return our mock xhr object
+							return {
+								status: m.status,
+								readyState: 1,
+								open: function() { },
+								send: function() {
+									// This is a substitute for < 1.4 which lacks $.proxy
+									var process = (function(that) {
+										return function() {
+											return (function() {
+												// The request has returned
+											 	this.status 		= m.status;
+												this.readyState 	= 4;
+
+												// We have an executable function, call it to give
+												// the mock handler a chance to update it's data
+												if ( $.isFunction(m.response) ) {
+													m.response(origSettings);
+												}
+												// Copy over our mock to our xhr object before passing control back to
+												// jQuery's onreadystatechange callback
+												if ( s.dataType == 'json' && ( typeof m.responseText == 'object' ) ) {
+													this.responseText = JSON.stringify(m.responseText);
+												} else if ( s.dataType == 'xml' ) {
+													if ( typeof m.responseXML == 'string' ) {
+														this.responseXML = parseXML(m.responseXML);
+													} else {
+														this.responseXML = m.responseXML;
+													}
+												} else {
+													this.responseText = m.responseText;
+												}
+												// jQuery < 1.4 doesn't have onreadystate change for xhr
+												if ( $.isFunction(this.onreadystatechange) ) {
+													this.onreadystatechange( m.isTimeout ? 'timeout' : undefined );
+												}
+											}).apply(that);
+										};
+									})(this);
+
+									if ( m.proxy ) {
+										// We're proxying this request and loading in an external file instead
+										_ajax({
+											global: false,
+											url: m.proxy,
+											type: m.proxyType,
+											data: m.data,
+											dataType: s.dataType,
+											complete: function(xhr, txt) {
+												m.responseXML = xhr.responseXML;
+												m.responseText = xhr.responseText;
+												this.responseTimer = setTimeout(process, m.responseTime || 0);
+											}
+										});
+									} else {
+										// type == 'POST' || 'GET' || 'DELETE'
+										if ( s.async === false ) {
+											// TODO: Blocking delay
+											process();
+										} else {
+											this.responseTimer = setTimeout(process, m.responseTime || 50);
+										}
+									}
+								},
+								abort: function() {
+									clearTimeout(this.responseTimer);
+								},
+								setRequestHeader: function() { },
+								getResponseHeader: function(header) {
+									// 'Last-modified', 'Etag', 'content-type' are all checked by jQuery
+									if ( m.headers && m.headers[header] ) {
+										// Return arbitrary headers
+										return m.headers[header];
+									} else if ( header.toLowerCase() == 'last-modified' ) {
+										return m.lastModified || (new Date()).toString();
+									} else if ( header.toLowerCase() == 'etag' ) {
+										return m.etag || '';
+									} else if ( header.toLowerCase() == 'content-type' ) {
+										return m.contentType || 'text/plain';
+									}
+								},
+								getAllResponseHeaders: function() {
+									var headers = '';
+									$.each(m.headers, function(k, v) {
+										headers += k + ': ' + v + "\n";
+									});
+									return headers;
+								}
+							};
+						}
+					}));
+					return false;
+				}
+			});
+			// We don't have a mock request, trigger a normal request
+			if ( !mock ) {
+				return _ajax.apply($, arguments);
+			} else {
+				return mock;
+			}
+		}
+	});
+
+	$.mockjaxSettings = {
+		//url:        null,
+		//type:       'GET',
+		log:          function(msg) {
+		              	window['console'] && window.console.log && window.console.log(msg);
+		              },
+		status:       200,
+		responseTime: 500,
+		isTimeout:    false,
+		contentType:  'text/plain',
+		response:     '',
+		responseText: '',
+		responseXML:  '',
+		proxy:        '',
+		proxyType:    'GET',
+
+		lastModified: null,
+		etag:         '',
+		headers: {
+			etag: 'IJF@H#@923uf8023hFO@I#H#',
+			'content-type' : 'text/plain'
+		}
+	};
+
+	$.mockjax = function(settings) {
+		var i = mockHandlers.length;
+		mockHandlers[i] = settings;
+		return i;
+	};
+	$.mockjaxClear = function(i) {
+		if ( arguments.length == 1 ) {
+			mockHandlers[i] = null;
+		} else {
+			mockHandlers = [];
+		}
+	};
+})(jQuery);