qunit_for_rails 0.0.6 → 0.0.7

data/Gemfile

@@ -5,4 +5,4 @@ source "http://rubygems.org"
 # gem 'ruby-debug19'
 
 #gem "rails", "3.0.10"
-gem "haml", ">= 3.1.2"
+gem "haml", "3.1.2"

data/Gemfile.lock

@@ -1,10 +1,10 @@
 GEM
   remote: http://rubygems.org/
   specs:
-    haml (3.1.4)
+    haml (3.1.2)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  haml (>= 3.1.2)
+  haml (= 3.1.2)

data/app/views/qunit_for_rails/qunit_tests/index.html.haml

@@ -7,6 +7,7 @@
   %script{:type => "text/javascript", :src  => "#{root_url}/javascripts/qunit_for_rails/qunit.js"}
   %script{:type => "text/javascript", :src  => "#{root_url}/javascripts/qunit_for_rails/qunit.test_loader.js"}
   %script{:type => "text/javascript", :src  => "#{root_url}/javascripts/qunit_for_rails/qunit_for_rails.js"}
+  %script{:type => "text/javascript", :src  => "#{root_url}/javascripts/qunit_for_rails/jquery.mockjax.js"}
 
   :javascript
     var QFR = {};

data/lib/qunit_for_rails/version.rb

@@ -1,3 +1,3 @@
 module QunitForRails
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
 end

data/public/javascripts/qunit_for_rails/jquery.mockjax.js

@@ -0,0 +1,409 @@
+/*!
+ * MockJax - jQuery Plugin to Mock Ajax requests
+ *
+ * Version:  1.5.0pre
+ * Released:
+ * Home:   http://github.com/appendto/jquery-mockjax
+ * Author:   Jonathan Sharp (http://jdsharp.com)
+ * License:  MIT,GPL
+ *
+ * Copyright (c) 2011 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(url, origSettings) {
+			// If url is an object, simulate pre-1.5 signature
+			if ( typeof url === "object" ) {
+				origSettings = url;
+				url = undefined;
+			} else {
+				// work around to support 1.5 signature
+				origSettings.url = url;
+			}
+			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 !== s.url && star === -1 || !new RegExp(m.url.replace(/[-[\]{}()+?.,\\^$|#\s]/g, "\\$&").replace('*', '.+')).test(s.url)) {
+							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.toLowerCase() != s.type.toLowerCase() ) {
+							// 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;
+					}
+
+					m.data = s.data;
+				  m.cache = s.cache;
+				  m.timeout = s.timeout;
+				  m.global = s.global;
+
+					mock = _ajax.call($, $.extend(true, {}, origSettings, {
+						// Mock the XHR object
+						xhr: function() {
+							// Extend with our default mockjax settings
+							m = $.extend({}, $.mockjaxSettings, m);
+
+							if (typeof m.headers === 'undefined') {
+								m.headers = {};
+							}
+							if ( m.contentType ) {
+								m.headers['content-type'] = m.contentType;
+							}
+
+							// Return our mock xhr object
+							return {
+								status: m.status,
+								readyState: 1,
+								open: function() { },
+								send: function() {
+
+								  mockHandlers[k].fired = true;
+
+									// 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;
+												}
+												if( typeof m.status == 'number' || typeof m.status == 'string' ) {
+												  this.status = m.status;
+												}
+												// 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;
+												m.status = xhr.status;
+												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(header, value) {
+									m.headers[header] = value;
+								},
+								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 = [];
+		}
+	};
+	$.mockjax.handler = function(i) {
+	  if ( arguments.length == 1 ) {
+			return mockHandlers[i];
+		}
+	};
+})(jQuery);

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: qunit_for_rails
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: 
   segments: 
   - 0
   - 0
-  - 6
-  version: 0.0.6
+  - 7
+  version: 0.0.7
 platform: ruby
 authors: 
 - Michael Krisher
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-12-15 00:00:00 Z
+date: 2011-12-16 00:00:00 Z
 dependencies: []
 
 description: Helper to integrate QUnit JavaScript testing into any Rails app
@@ -51,6 +51,7 @@ files:
 - public/javascripts/qunit_for_rails/index.js
 - public/javascripts/qunit_for_rails/inject.js
 - public/javascripts/qunit_for_rails/jquery-1.6.4.min.js
+- public/javascripts/qunit_for_rails/jquery.mockjax.js
 - public/javascripts/qunit_for_rails/qunit.js
 - public/javascripts/qunit_for_rails/qunit.page_load.js
 - public/javascripts/qunit_for_rails/qunit.test_loader.js
@@ -131,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: qunit_for_rails
-rubygems_version: 1.8.11
+rubygems_version: 1.7.2
 signing_key: 
 specification_version: 3
 summary: ""