RubyGems - javascriptmvc - Versions diffs - 3.0.0.pre15 - Mend

javascriptmvc 3.0.0.pre15

Files changed (550) hide show

data/lib/javascriptmvc/jquery/dom/dimensions/qunit.html ADDED

@@ -0,0 +1,22 @@
+<html>
+    <head>
+    	<title>Dimensions Test Suite</title>
+        <link rel="stylesheet" type="text/css" href="../../../funcunit/qunit/qunit.css" />
+        <style>
+            body  {
+                margin: 0px; padding: 0px;
+            }
+        </style>
+		<script type='text/javascript' src='../../../steal/steal.js?steal[app]=jquery/dom/dimensions/test/qunit'></script>
+    </head>
+    <body>
+        <h1 id="qunit-header">Dimensions Test Suite</h1>
+    	<h2 id="qunit-banner"></h2>
+    	<div id="qunit-testrunner-toolbar"></div>
+    	<h2 id="qunit-userAgent"></h2>
+		<div id="test-content"></div>
+        <ol id="qunit-tests"></ol>
+		<div id="qunit-test-area"></div>
+    </body>
+</html>

data/lib/javascriptmvc/jquery/dom/dimensions/test/qunit/curStyles.micro ADDED

@@ -0,0 +1,3 @@
+<div style='margin-top: 10px; padding-left: 5px; position: relative; float: left; border: solid 2px black;' id='styled'>
+Here is some content;
+</div>

data/lib/javascriptmvc/jquery/dom/dimensions/test/qunit/dimensions_test.js ADDED

@@ -0,0 +1,8 @@
+module("jquery/dom/dimensions");
+test("outerHeight and width",function(){
+	$("#qunit-test-area").html("//jquery/dom/dimensions/test/qunit/curStyles.micro",{})
+})

data/lib/javascriptmvc/jquery/dom/dimensions/test/qunit/outer.micro ADDED

File without changes

data/lib/javascriptmvc/jquery/dom/dimensions/test/qunit/qunit.js ADDED

@@ -0,0 +1,4 @@
+steal
+ .plugins("jquery/dom/dimensions",'jquery/view/micro')  //load your app
+ .plugins('funcunit/qunit')  //load qunit
+ .then("dimensions_test")

data/lib/javascriptmvc/jquery/dom/dom.js ADDED

@@ -0,0 +1,7 @@
+/**
+ * @page dom DOM Helpers
+ * @tag core
+ * JavaScriptMVC adds a bunch of useful jQuery extensions for the dom.  Check them out on the left.
+ *
+ */
+steal.plugins('jquery');

data/lib/javascriptmvc/jquery/dom/fixture/fixture.html ADDED

@@ -0,0 +1,143 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
+            "http://www.w3.org/TR/html4/strict.dtd">
+<html lang="en">
+    <head>
+        <title>Fixture Demo</title>
+        <style type='text/css'>
+            body {font-family: verdana}
+            #messages {height: 200px; overflow-y: auto;}
+			#content {height: 551px; overflow: hidden;}
+        </style>
+    </head>
+    <body>
+<div id="demo-html">
+<div id='content'></div>
+</div>
+<script type='text/javascript'
+        src='../../../steal/steal.js'></script>
+<script type='text/javascript'>
+steal.plugins('jquery/dom/fixture','jquery/dom/form_params').start()
+</script>
+<script type='text/javascript' id="demo-source">
+// gets content from a fixture
+$.get("/messages.php",
+  function(html){
+    // put the result in content
+    $('#content').html(html)
+  },
+  'text',
+  'fixtures/messages.html');
+// makes 20 messages in a fixture
+$.fixture.make(["messages","message"],20, function(i, messages){
+  return {
+    subject: "This is message "+i,
+    body: "Here is some text for this message",
+    user: "Justin",
+    createdAt: String(new Date( Math.random() *  new Date().getTime()   ))
+  }
+});
+// gets messages on submit
+$("#getMessages").live("submit",function(ev){
+  ev.preventDefault();
+  //get the limit and offset
+  var params = $(this).formParams().params;
+  //use -messages fixture created by make
+  $.ajax({
+    url: "/messages.json",
+    data: params,
+    success: function(json){
+      $("#messages").html( messagesHTML(json) )
+    },
+    dataType: "json",
+    fixture: "-messages"
+  })
+});
+// a fixture for creating messages
+$.fixture["-createMessage"] = function(settings, cbType){
+  // add to the message data what the server would add
+  var message = $.extend({
+    id: arguments.callee.count++,
+    user: "Justin",
+    createdAt: String(new Date())
+  }, settings.data);
+  message.id = $.fixture["~messages"].length;
+  // adds the message to the fixture data
+  $.fixture["~messages"].push(message);
+  // return the data for the callback
+  return [message];
+};
+// creates a message on submit
+$("#message").live("submit", function(ev){
+  ev.preventDefault();
+  // get message data
+  var message = $(this).formParams().message;
+  // uses -createMessage fixture
+  $.post("/message.json", message,function(json){
+    //clear the message form
+    $('[name*=message]').val("");
+    //show the new message
+    $('[name*=offset]').val(json.id)
+    $('[name*=limit]').val(1)
+    $("#getMessages").submit();
+  },'json',"-createMessage")
+})
+//creates the html from message data
+var messagesHTML = function(json){
+  var html = ["<h4>Messages (count=",
+              json.count,
+              ")</h4>",
+              "<table>",
+              "<tr>"],
+      cols = ["subject",
+	          "body",
+			  "user",
+			  "createdAt"];
+  // html for the column headers
+  $.each(cols, function(i, prop){
+    html.push("<th>"+prop+"</th>")
+  })
+  html.push("</tr>")
+  // html for the messages
+  $.each(json.data, function(m, message){
+    html.push("<tr>")
+    $.each(cols, function(i, prop){
+        html.push("<td>"+message[prop]+"</td>")
+    })
+    html.push("</tr>")
+  })
+  html.push("</table>");
+  return html.join("");
+}
+</script>
+    </body>
+</html>

data/lib/javascriptmvc/jquery/dom/fixture/fixture.js ADDED

@@ -0,0 +1,521 @@
+steal.plugins('jquery/dom').then(function( $ ) {
+	var ajax = $.ajax,
+		get = $.get,
+		post = $.post;
+	/**
+	 * @constructor jQuery.fixture
+	 * @plugin jquery/dom/fixture
+	 * @download jquery/dist/jquery.fixture.js
+	 * @test jquery/dom/fixture/qunit.html
+	 * @parent dom
+	 *
+	 * Fixtures simulate AJAX responses by overwriting
+	 * [jQuery.ajax $.ajax],
+	 * [jQuery.get $.get], and
+	 * [jQuery.post $.post].
+	 * Instead of making a request to a server, fixtures simulate
+	 * the repsonse with a file or function.
+	 *
+	 * They are a great technique when you want to develop JavaScript
+	 * independently of the backend.
+	 *
+	 * <h3>Quick Example</h3>
+	 * <p>Instead of making a request to <code>/tasks.json</code>,
+	 *    $.ajax will look in <code>fixtures/tasks.json</code>.
+	 *    It's expected that a static <code>fixtures/tasks.json</code>
+	 *    file exists relative to the current page.
+	 * </p>
+	 * @codestart
+	 * $.ajax({url: "/tasks.json",
+	 *   dataType: "json",
+	 *   type: "get",
+	 *   fixture: "fixtures/tasks.json",
+	 *   success: myCallback});
+	 * @codeend
+	 * <h2>Using Fixtures</h2>
+	 * To enable fixtures, you must add this plugin to your page and
+	 * set the fixture property.
+	 *
+	 * The fixture property is set as ...
+	 * @codestart
+	 * //... a property with $.ajax
+	 * $.ajax({fixture: FIXTURE_VALUE})
+	 *
+	 * //... a parameter in $.get and $.post
+	 * $.get (  url, data, callback, type, FIXTURE_VALUE )
+	 * $.post(  url, data, callback, type, FIXTURE_VALUE )
+	 * @codeend
+	 * <h3>Turning Off Fixtures</h3>
+	 * <p>To turn off fixtures, simply remove the fixture plugin from
+	 *  your page.  The Ajax methods will ignore <code>FIXTURE_VALUE</code>
+	 *  and revert to their normal behavior.  If you want to ignore a single
+	 *  fixture, we suggest commenting it out.
+	 * </p>
+	 * <div class='whisper'>
+	 * PRO TIP:  Don't worry about leaving the fixture values in your source.
+	 * They don't take up many characters and won't impact how jQuery makes
+	 * requests.  They can be useful even after the service they simulate
+	 * is created.
+	 * </div>
+	 * <h2>Types of Fixtures</h2>
+	 * <p>There are 2 types of fixtures</p>
+	 * <ul>
+	 * 	<li><b>Static</b> - the response is in a file.
+	 * 	</li>
+	 * 	<li>
+	 * 		<b>Dynamic</b> - the response is generated by a function.
+	 * 	</li>
+	 * </ul>
+	 * There are different ways to lookup static and dynamic fixtures.
+	 * <h3>Static Fixtures</h3>
+	 * Static fixture locations can be calculated:
+	 * @codestart
+	 * // looks in test/fixtures/tasks/1.get
+	 * $.ajax({type:"get",
+	 *        url: "tasks/1",
+	 *        fixture: true})
+	 * @codeend
+	 * Or provided:
+	 * @codestart
+	 * // looks in fixtures/tasks1.json relative to page
+	 * $.ajax({type:"get",
+	 *        url: "tasks/1",
+	 *        fixture: "fixtures/task1.json"})
+	 *
+	 * // looks in fixtures/tasks1.json relative to jmvc root
+	 * // this assumes you are using steal
+	 * $.ajax({type:"get",
+	 *        url: "tasks/1",
+	 *        fixture: "//fixtures/task1.json"})`
+	 * @codeend
+	 * <div class='whisper'>
+	 *   PRO TIP: Use provided fixtures.  It's easier to understand what it is going.
+	 *   Also, create a fixtures folder in your app to hold your fixtures.
+	 * </div>
+	 * <h3>Dynamic Fixtures</h3>
+	 * <p>Dynamic Fixtures are functions that return the arguments the $.ajax callbacks
+	 *   (<code>beforeSend</code>, <code>success</code>, <code>complete</code>,
+	 *    <code>error</code>) expect.  </p>
+	 * <p>For example, the "<code>success</code>" of a json request is called with
+	 * <code>[data, textStatus, XMLHttpRequest].</p>
+	 * <p>There are 2 ways to lookup dynamic fixtures.<p>
+	 * They can provided:
+	 * @codestart
+	 * //just use a function as the fixture property
+	 * $.ajax({
+	 *   type:     "get",
+	 *   url:      "tasks",
+	 *   data:     {id: 5},
+	 *   dataType: "json",
+	 *   fixture: function( settings, callbackType ) {
+	 *     var xhr = {responseText: "{id:"+settings.data.id+"}"}
+	 *     switch(callbackType){
+	 *       case "success":
+	 *         return [{id: settings.data.id},"success",xhr]
+	 *       case "complete":
+	 *         return [xhr,"success"]
+	 *     }
+	 *   }
+	 * })
+	 * @codeend
+	 * Or found by name on $.fixture:
+	 * @codestart
+	 * // add your function on $.fixture
+	 * // We use -FUNC by convention
+	 * $.fixture["-myGet"] = function(settings, cbType){...}
+	 *
+	 * // reference it
+	 * $.ajax({
+	 *   type:"get",
+	 *   url: "tasks/1",
+	 *   dataType: "json",
+	 *   fixture: "-myGet"})
+	 * @codeend
+	 * <p>Dynamic fixture functions are called with:</p>
+	 * <ul>
+	 * <li> settings - the settings data passed to <code>$.ajax()</code>
+	 * <li> calbackType - the type of callback about to be called:
+	 * 	<code>"beforeSend"</code>, <code>"success"</code>, <code>"complete"</code>,
+	 *    <code>"error"</code></li>
+	 * </ul>
+	 * and should return an array of arguments for the callback.<br/><br/>
+	 * <div class='whisper'>PRO TIP:
+	 * Dynamic fixtures are awesome for performance testing.  Want to see what
+	 * 10000 files does to your app's performance?  Make a fixture that returns 10000 items.
+	 *
+	 * What to see what the app feels like when a request takes 5 seconds to return?  Set
+	 * [jQuery.fixture.delay] to 5000.
+	 * </div>
+	 * <h2>Helpers</h2>
+	 * <p>The fixture plugin comes with a few ready-made dynamic fixtures and
+	 * fixture helpers:</p>
+	 * <ul>
+	 * <li>[jQuery.fixture.make] - creates fixtures for findAll, findOne.</li>
+	 * <li>[jQuery.fixture.-restCreate] - a fixture for restful creates.</li>
+	 * <li>[jQuery.fixture.-restDestroy] - a fixture for restful updates.</li>
+	 * <li>[jQuery.fixture.-restUpdate] - a fixture for restful destroys.</li>
+	 * </ul>
+	 * @demo jquery/dom/fixture/fixture.html
+	 * @init
+	 * Takes an ajax settings and returns a url to look for a fixture.  Overwrite this if you want a custom lookup method.
+	 * @param {Object} settings
+	 * @return {String} the url that will be used for the fixture
+	 */
+	$.fixture = function( settings ) {
+		var url = settings.url,
+			match, left, right;
+		url = url.replace(/%2F/g, "~").replace(/%20/g, "_");
+		if ( settings.data && settings.processData && typeof settings.data !== "string" ) {
+			settings.data = jQuery.param(settings.data);
+		}
+		if ( settings.data && settings.type.toLowerCase() == "get" ) {
+			url += ($.String.include(url, '?') ? '&' : '?') + settings.data;
+		}
+		match = url.match(/^(?:https?:\/\/[^\/]*)?\/?([^\?]*)\??(.*)?/);
+		left = match[1];
+		right = settings.type ? '.' + settings.type.toLowerCase() : '.post';
+		if ( match[2] ) {
+			left += '/';
+			right = match[2].replace(/\#|&/g, '-').replace(/\//g, '~') + right;
+		}
+		return left + right;
+	}
+	$.extend($.fixture, {
+		/**
+		 * Provides a rest update fixture function
+		 */
+		"-restUpdate": function( settings, cbType ) {
+			switch ( cbType ) {
+			case "success":
+				return [$.extend({
+					id: parseInt(settings.url)
+				}, settings.data), "success", $.fixture.xhr()]
+			case "complete":
+				return [$.fixture.xhr(), "success"]
+			}
+		},
+		/**
+		 * Provides a rest destroy fixture function
+		 */
+		"-restDestroy": function( settings, cbType ) {
+			switch ( cbType ) {
+			case "success":
+				return [true, "success", $.fixture.xhr()]
+			case "complete":
+				return [$.fixture.xhr(), "success"]
+			}
+		},
+		/**
+		 * Provides a rest create fixture function
+		 */
+		"-restCreate": function( settings, cbType ) {
+			switch ( cbType ) {
+			case "success":
+				return [{
+					id: parseInt(Math.random() * 1000)
+				}, "success", $.fixture.xhr()];
+			case "complete":
+				return [$.fixture.xhr({
+					getResponseHeader: function() {
+						return settings.url + "/" + parseInt(Math.random() * 1000)
+					}
+				}), "success"]
+			}
+		},
+		/**
+		 * Used to make fixtures for findAll / findOne style requests.
+		 * @codestart
+		 * //makes a threaded list of messages
+		 * $.fixture.make(["messages","message"],1000, function(i, messages){
+		 *   return {
+		 *     subject: "This is message "+i,
+		 *     body: "Here is some text for this message",
+		 *     date: Math.floor( new Date().getTime() ),
+		 *     parentId : i < 100 ? null : Math.floor(Math.random()*i)
+		 *   }
+		 * })
+		 * //uses the message fixture to return messages limited by offset, limit, order, etc.
+		 * $.ajax({
+		 *   url: "messages",
+		 *   data:{
+		 *      offset: 100,
+		 *      limit: 50,
+		 *      order: "date ASC",
+		 *      parentId: 5},
+		 *    },
+		 *    fixture: "-messages",
+		 *    success: function( messages ) {  ... }
+		 * });
+		 * @codeend
+		 * @param {Array} types An array of the fixture names
+		 * @param {Number} count the number of items to create
+		 * @param {Function} make a function that will return json data representing the object.
+		 */
+		make: function( types, count, make ) {
+			// make all items
+			var items = ($.fixture["~" + types[0]] = []);
+			for ( var i = 0; i < (count); i++ ) {
+				//call back provided make
+				var item = make(i, items)
+				if (!item.id ) {
+					item.id = i;
+				}
+				items.push(item)
+			}
+			//set plural fixture for findAll
+			$.fixture["-" + types[0]] = function( settings ) {
+				//copy array of items
+				var retArr = items.slice(0);
+				//sort using order
+				//order looks like ["age ASC","gender DESC"]
+				$.each((settings.data.order || []).slice(0).reverse(), function( i, name ) {
+					var split = name.split(" ");
+					retArr = retArr.sort(function( a, b ) {
+						if ( split[1].toUpperCase() != "ASC" ) return a[split[0]] < b[split[0]];
+						else return a[split[0]] > b[split[0]];
+					});
+				});
+				//group is just like a sort
+				$.each((settings.data.group || []).slice(0).reverse(), function( i, name ) {
+					var split = name.split(" ");
+					retArr = retArr.sort(function( a, b ) {
+						return a[split[0]] > b[split[0]]
+					});
+				});
+				var offset = parseInt(settings.data.offset) || 0,
+					limit = parseInt(settings.data.limit) || (count - offset),
+					i = 0;
+				//filter results if someone added an attr like parentId
+				for ( var param in settings.data ) {
+					if ( param.indexOf("Id") != -1 ) {
+						while ( i < retArr.length ) {
+							if ( settings.data[param] != retArr[i][param] ) {
+								retArr.splice(i, 1)
+							} else {
+								i++;
+							}
+						}
+					}
+				}
+				//return data spliced with limit and offset
+				return [{
+					"count": retArr.length,
+					"limit": settings.data.limit,
+					"offset": settings.data.offset,
+					"data": retArr.slice(offset, offset + limit)
+				}]
+			}
+			$.fixture["-" + types[1]] = function( settings ) {
+				for ( var i = 0; i < (count); i++ ) {
+					if ( settings.data.id == items[i].id ) {
+						return [items[i]]
+					}
+				}
+			}
+		},
+		/**
+		 * Use $.fixture.xhr to create an object that looks like an xhr object.
+		 * <h3>Example</h3>
+		 * The following example shows how the -restCreate fixture uses xhr to return
+		 * a simulated xhr object:
+		 * @codestart
+		 * "-restCreate" : function( settings, cbType ) {
+		 *   switch(cbType){
+		 *     case "success":
+		 *       return [
+		 *         {id: parseInt(Math.random()*1000)},
+		 *         "success",
+		 *         $.fixture.xhr()];
+		 *     case "complete":
+		 *       return [
+		 *         $.fixture.xhr({
+		 *           getResponseHeader: function() {
+		 *             return settings.url+"/"+parseInt(Math.random()*1000);
+		 *           }
+		 *         }),
+		 *         "success"];
+		 *   }
+		 * }
+		 * @codeend
+		 * @param {Object} [xhr] properties that you want to overwrite
+		 * @return {Object} an object that looks like a successful XHR object.
+		 */
+		xhr: function( xhr ) {
+			return $.extend({}, {
+				abort: $.noop,
+				getAllResponseHeaders: function() {
+					return "";
+				},
+				getResponseHeader: function() {
+					return "";
+				},
+				open: $.noop,
+				overrideMimeType: $.noop,
+				readyState: 4,
+				responseText: "",
+				responseXML: null,
+				send: $.noop,
+				setRequestHeader: $.noop,
+				status: 200,
+				statusText: "OK"
+			}, xhr);
+		}
+	})
+	/**
+	 * @attribute delay
+	 * Sets the delay in milliseconds between an ajax request is made and
+	 * the success and complete handlers are called.  This only sets
+	 * functional fixtures.  By default, the delay is 200ms.
+	 * @codestart
+	 * steal.plugins('jquery/dom/fixtures').then(function(){
+	 *   $.fixture.delay = 1000;
+	 * })
+	 * @codeend
+	 */
+	$.fixture.delay = 200
+	$.fixture["-handleFunction"] = function( settings ) {
+		if ( typeof settings.fixture == "string" && $.fixture[settings.fixture] ) {
+			settings.fixture = $.fixture[settings.fixture]
+		}
+		if ( typeof settings.fixture == "function" ) {
+			setTimeout(function() {
+				if ( settings.success ) {
+					settings.success.apply(null, settings.fixture(settings, "success"))
+				}
+				if ( settings.complete ) {
+					settings.complete.apply(null, settings.fixture(settings, "complete"))
+				}
+			}, $.fixture.delay);
+			return true;
+		}
+		return false;
+	}
+	/**
+	 *  @add jQuery
+	 */
+	// break
+	$.
+	/**
+	 * Adds the fixture option to settings. If present, loads from fixture location instead
+	 * of provided url.  This is useful for simulating ajax responses before the server is done.
+	 * @param {Object} settings
+	 */
+	ajax = function( settings ) {
+		var func = $.fixture
+		if (!settings.fixture ) {
+			return ajax.apply($, arguments);
+		}
+		if ( $.fixture["-handleFunction"](settings) ) {
+			return;
+		}
+		if ( typeof settings.fixture == "string" ) {
+			var url = settings.fixture;
+			if (/^\/\//.test(url) ) {
+				url = steal.root.join(settings.fixture.substr(2))
+			}
+			//@steal-remove-start
+			steal.dev.log("looking for fixture in " + url)
+			//@steal-remove-end
+			settings.url = url
+			settings.data = null;
+			settings.type = "GET"
+			if (!settings.error ) {
+				settings.error = function( xhr, error, message ) {
+					throw "fixtures.js Error " + error + " " + message;
+				}
+			}
+			return ajax(settings);
+		}
+		var settings = jQuery.extend(true, settings, jQuery.extend(true, {}, jQuery.ajaxSettings, settings));
+		settings.url = steal.root.join('test/fixtures/' + func(settings)); // convert settings
+		settings.data = null;
+		settings.type = 'GET';
+		return ajax(settings);
+	}
+	$.extend($.ajax, ajax)
+	$.
+	/**
+	 * Adds a fixture param.
+	 * @param {Object} url
+	 * @param {Object} data
+	 * @param {Object} callback
+	 * @param {Object} type
+	 * @param {Object} fixture
+	 */
+	get = function( url, data, callback, type, fixture ) {
+		// shift arguments if data argument was ommited
+		if ( jQuery.isFunction(data) ) {
+			fixture = type;
+			type = callback;
+			callback = data;
+			data = null;
+		}
+		return jQuery.ajax({
+			type: "GET",
+			url: url,
+			data: data,
+			success: callback,
+			dataType: type,
+			fixture: fixture
+		});
+	}
+	$.
+	/**
+	 * Adds a fixture param.
+	 * @param {Object} url
+	 * @param {Object} data
+	 * @param {Object} callback
+	 * @param {Object} type
+	 * @param {Object} fixture
+	 */
+	post = function( url, data, callback, type, fixture ) {
+		if ( jQuery.isFunction(data) ) {
+			fixture = type;
+			type = callback;
+			callback = data;
+			data = {};
+		}
+		return jQuery.ajax({
+			type: "POST",
+			url: url,
+			data: data,
+			success: callback,
+			dataType: type,
+			fixture: fixture
+		});
+	}
+});