jabs 0.1.1 → 0.2.0

data/lib/jquery/jquery.event.drag-1.5.js

@@ -0,0 +1,137 @@
+/*! 
+jquery.event.drag.js ~ v1.5 ~ Copyright (c) 2008, Three Dub Media (http://threedubmedia.com)  
+Liscensed under the MIT License ~ http://threedubmedia.googlecode.com/files/MIT-LICENSE.txt
+*/
+;(function($){ // secure $ jQuery alias
+/*******************************************************************************************/
+// Created: 2008-06-04 | Updated: 2009-03-24
+/*******************************************************************************************/
+// Events: drag, dragstart, dragend
+/*******************************************************************************************/
+
+// jquery method
+$.fn.drag = function( fn1, fn2, fn3 ){
+	if ( fn2 ) this.bind('dragstart', fn1 ); // 2+ args
+	if ( fn3 ) this.bind('dragend', fn3 ); // 3 args
+	return !fn1 ? this.trigger('drag') // 0 args
+		: this.bind('drag', fn2 ? fn2 : fn1 ); // 1+ args
+	};
+
+// local refs
+var $event = $.event, $special = $event.special,
+
+// special event configuration
+drag = $special.drag = {
+	not: ':input', // don't begin to drag on event.targets that match this selector
+	distance: 0, // distance dragged before dragstart
+	which: 1, // mouse button pressed to start drag sequence
+	dragging: false, // hold the active target element
+	setup: function( data ){
+		data = $.extend({ 
+			distance: drag.distance, 
+			which: drag.which, 
+			not: drag.not
+			}, data || {});
+		data.distance = squared( data.distance ); //  x� + y� = distance�
+		$event.add( this, "mousedown", handler, data );
+		if ( this.attachEvent ) this.attachEvent("ondragstart", dontStart ); // prevent image dragging in IE...
+		},
+	teardown: function(){
+		$event.remove( this, "mousedown", handler );
+		if ( this === drag.dragging ) drag.dragging = drag.proxy = false; // deactivate element
+		selectable( this, true ); // enable text selection
+		if ( this.detachEvent ) this.detachEvent("ondragstart", dontStart ); // prevent image dragging in IE...
+		}
+	};
+	
+// prevent normal event binding...
+$special.dragstart = $special.dragend = { setup:function(){}, teardown:function(){} };
+
+// handle drag-releatd DOM events
+function handler ( event ){ 
+	var elem = this, returned, data = event.data || {};
+	// mousemove or mouseup
+	if ( data.elem ){ 
+		// update event properties...
+		elem = event.dragTarget = data.elem; // drag source element
+		event.dragProxy = drag.proxy || elem; // proxy element or source
+		event.cursorOffsetX = data.pageX - data.left; // mousedown offset
+		event.cursorOffsetY = data.pageY - data.top; // mousedown offset
+		event.offsetX = event.pageX - event.cursorOffsetX; // element offset
+		event.offsetY = event.pageY - event.cursorOffsetY; // element offset
+		}
+	// mousedown, check some initial props to avoid the switch statement
+	else if ( drag.dragging || ( data.which>0 && event.which!=data.which ) || 
+		$( event.target ).is( data.not ) ) return;
+	// handle various events
+	switch ( event.type ){
+		// mousedown, left click, event.target is not restricted, init dragging
+		case 'mousedown':
+			$.extend( data, $( elem ).offset(), { 
+				elem: elem, target: event.target,
+				pageX: event.pageX, pageY: event.pageY
+				}); // store some initial attributes
+			$event.add( document, "mousemove mouseup", handler, data );
+			selectable( elem, false ); // disable text selection
+			drag.dragging = null; // pending state
+			return false; // prevents text selection in safari 
+		// mousemove, check distance, start dragging
+		case !drag.dragging && 'mousemove': 
+			if ( squared( event.pageX-data.pageX ) 
+				+ squared( event.pageY-data.pageY ) //  x� + y� = distance�
+				< data.distance ) break; // distance tolerance not reached
+			event.target = data.target; // force target from "mousedown" event (fix distance issue)
+			returned = hijack( event, "dragstart", elem ); // trigger "dragstart", return proxy element
+			if ( returned !== false ){ // "dragstart" not rejected
+				drag.dragging = elem; // activate element
+				drag.proxy = event.dragProxy = $( returned || elem )[0]; // set proxy
+				}
+		// mousemove, dragging
+		case 'mousemove': 
+			if ( drag.dragging ){
+				returned = hijack( event, "drag", elem ); // trigger "drag"		
+				if ( $special.drop ){ // manage drop events
+					$special.drop.allowed = ( returned !== false ); // prevent drop
+					$special.drop.handler( event ); // "dropstart", "dropend"
+					}
+				if ( returned !== false ) break; // "drag" not rejected, stop		
+				event.type = "mouseup"; // helps "drop" handler behave
+				}
+		// mouseup, stop dragging
+		case 'mouseup': 
+			$event.remove( document, "mousemove mouseup", handler ); // remove page events
+			if ( drag.dragging ){
+				if ( $special.drop ) $special.drop.handler( event ); // "drop"
+				hijack( event, "dragend", elem ); // trigger "dragend"	
+				}
+			selectable( elem, true ); // enable text selection
+			drag.dragging = drag.proxy = data.elem = false; // deactivate element
+			break;
+		} 
+	return true;
+	};
+
+// set event type to custom value, and handle it
+function hijack ( event, type, elem ){
+	event.type = type; // force the event type
+	var result = $.event.handle.call( elem, event );
+	return result===false ? false : result || event.result;
+	};
+	
+// return the value squared	
+function squared ( value ){ return Math.pow( value, 2 ); };
+
+// suppress default dragstart IE events...
+function dontStart(){ return ( drag.dragging === false ); };	
+
+// toggles text selection attributes	
+function selectable ( elem, bool ){ 
+	if ( !elem ) return; // maybe element was removed ? 
+	elem.unselectable = bool ? "off" : "on"; // IE
+	elem.onselectstart = function(){ return bool; }; // IE
+	//if ( document.selection && document.selection.empty ) document.selection.empty(); // IE
+	if ( elem.style ) elem.style.MozUserSelect = bool ? "" : "none"; // FF
+	};	
+	
+/*******************************************************************************************/
+})( jQuery ); // confine scope

data/lib/jquery/jquery.event.drop-1.2.js

@@ -0,0 +1,157 @@
+/*! jquery.event.drop.js * v1.2
+Copyright (c) 2008-2009, Three Dub Media (http://threedubmedia.com)  
+Liscensed under the MIT License (http://threedubmedia.googlecode.com/files/MIT-LICENSE.txt)
+*/;(function($){ // secure $ jQuery alias
+// Created: 2008-06-04 | Updated: 2009-03-16
+/*******************************************************************************************/
+// Events: drop, dropstart, dropend
+/*******************************************************************************************/
+
+// JQUERY METHOD
+$.fn.drop = function( fn1, fn2, fn3 ){
+	if ( fn2 ) this.bind('dropstart', fn1 ); // 2+ args
+	if ( fn3 ) this.bind('dropend', fn3 ); // 3 args
+	return !fn1 ? this.trigger('drop') // 0 args
+		: this.bind('drop', fn2 ? fn2 : fn1 ); // 1+ args
+	};
+
+// DROP MANAGEMENT UTILITY
+$.dropManage = function( opts ){ // return filtered drop target elements, cache their positions
+	opts = opts || {};
+	// safely set new options...
+	drop.data = [];
+	drop.filter = opts.filter || '*';
+	drop.delay = opts.delay || drop.delay;
+	drop.tolerance = opts.tolerance || null;
+	drop.mode = opts.mode || drop.mode || 'intersect';
+	// return the filtered set of drop targets
+	return drop.$targets.filter( drop.filter ).each(function(){ 
+		// locate and store the filtered drop targets
+		drop.data[ drop.data.length ] = drop.locate( this ); 
+		});
+	};
+
+// local refs
+var $event = $.event, $special = $event.special,
+
+// SPECIAL EVENT CONFIGURATION
+drop = $special.drop = {
+	delay: 100, // default frequency to track drop targets
+	mode: 'intersect', // default mode to determine valid drop targets 
+	$targets: $([]), data: [], // storage of drop targets and locations
+	setup: function(){
+		drop.$targets = drop.$targets.add( this );
+		drop.data[ drop.data.length ] = drop.locate( this );
+		},
+	teardown: function(){ var elem = this;
+		drop.$targets = drop.$targets.not( this ); 
+		drop.data = $.grep( drop.data, function( obj ){ 
+			return ( obj.elem !== elem ); 
+			});
+		},
+	// shared handler
+	handler: function( event ){ 
+		var dropstart = null, dropped;
+		event.dropTarget = drop.dropping || undefined; // dropped element
+		if ( drop.data.length && event.dragTarget ){ 
+			// handle various events
+			switch ( event.type ){
+				// drag/mousemove, from $.event.special.drag
+				case 'drag': // TOLERATE >>
+					drop.event = event; // store the mousemove event
+					if ( !drop.timer ) // monitor drop targets
+						drop.timer = setTimeout( tolerate, 20 ); 
+					break;			
+				// dragstop/mouseup, from $.event.special.drag
+				case 'mouseup': // DROP >> DROPEND >>
+					drop.timer = clearTimeout( drop.timer ); // delete timer	
+					if ( !drop.dropping ) break; // stop, no drop
+					if ( drop.allowed )	
+						dropped = hijack( event, "drop", drop.dropping ); // trigger "drop"
+					dropstart = false;
+				// activate new target, from tolerate (async)
+				case drop.dropping && 'dropstart': // DROPSTART >> ( new target )
+					dropstart = dropstart===null && drop.allowed ? true : false;
+				// deactivate active target, from tolerate (async)
+				case drop.dropping && 'dropend': // DROPEND >> 
+					hijack( event, "dropend", drop.dropping ); // trigger "dropend"
+					drop.dropping = null; // empty dropper
+					if ( dropped === false ) event.dropTarget = undefined;
+					if ( !dropstart ) break; // stop
+				// activate target, from tolerate (async)
+				case drop.allowed && 'dropstart': // DROPSTART >> 
+					event.dropTarget = this;
+					drop.dropping = hijack( event, "dropstart", this )!==false ? this : null;  // trigger "dropstart"
+					break;
+				}
+			}
+		},
+	// returns the location positions of an element
+	locate: function( elem ){ // return { L:left, R:right, T:top, B:bottom, H:height, W:width }
+		var $el = $(elem), pos = $el.offset(), h = $el.outerHeight(), w = $el.outerWidth();
+		return { elem: elem, L: pos.left, R: pos.left+w, T: pos.top, B: pos.top+h, W: w, H: h };
+		},
+	// test the location positions of an element against another OR an X,Y coord
+	contains: function( target, test ){ // target { L,R,T,B,H,W } contains test [x,y] or { L,R,T,B,H,W }
+		return ( ( test[0] || test.L ) >= target.L && ( test[0] || test.R ) <= target.R 
+			&& ( test[1] || test.T ) >= target.T && ( test[1] || test.B ) <= target.B ); 
+		},
+	// stored tolerance modes
+	modes: { // fn scope: "$.event.special.drop" object 
+		// target with mouse wins, else target with most overlap wins
+		'intersect': function( event, proxy, target ){
+			return this.contains( target, [ event.pageX, event.pageY ] ) ? // check cursor
+				target : this.modes['overlap'].apply( this, arguments ); // check overlap
+			},
+		// target with most overlap wins	
+		'overlap': function( event, proxy, target ){
+			// calculate the area of overlap...
+			target.overlap = Math.max( 0, Math.min( target.B, proxy.B ) - Math.max( target.T, proxy.T ) )
+				* Math.max( 0, Math.min( target.R, proxy.R ) - Math.max( target.L, proxy.L ) );
+			if ( target.overlap > ( ( this.best || {} ).overlap || 0 ) ) // compare overlap
+				this.best = target; // set as the best match so far
+			return null; // no winner
+			},
+		// proxy is completely contained within target bounds	
+		'fit': function( event, proxy, target ){
+			return this.contains( target, proxy ) ? target : null;
+			},
+		// center of the proxy is contained within target bounds	
+		'middle': function( event, proxy, target ){
+			return this.contains( target, [ proxy.L+proxy.W/2, proxy.T+proxy.H/2 ] ) ? target : null;
+			}
+		} 	 
+	};
+
+// set event type to custom value, and handle it
+function hijack ( event, type, elem ){
+	event.type = type; // force the event type
+	try { var result = $event.handle.call( elem, event );
+		} catch ( ex ){ /* catch IE error with async event handling */ }	 
+	return result===false ? false : result || event.result;
+	};
+	
+// async, recursive tolerance execution
+function tolerate (){ 
+	var i = 0, drp, winner, // local variables 
+	xy = [ drop.event.pageX, drop.event.pageY ], // mouse location
+	drg = drop.locate( drop.event.dragProxy ); // drag proxy location
+	drop.tolerance = drop.tolerance || drop.modes[ drop.mode ]; // custom or stored tolerance fn
+	do if ( drp = drop.data[i] ){ // each drop target location
+		// tolerance function is defined, or mouse contained
+		winner = drop.tolerance ? drop.tolerance.call( drop, drop.event, drg, drp ) 
+			: drop.contains( drp, xy ) ? drp : null; // mouse is always fallback
+		} 
+	while ( ++i<drop.data.length && !winner ); // loop
+	drop.event.type = ( winner = winner || drop.best ) ? 'dropstart' : 'dropend'; // start ? stop 
+	if ( drop.event.type=='dropend' || winner.elem!=drop.dropping ) // don't dropstart on active drop target
+		drop.handler.call( winner ? winner.elem : drop.dropping, drop.event ); // handle events
+	if ( drop.last && xy[0] == drop.last.pageX && xy[1] == drop.last.pageY ) // no movement
+		delete drop.timer; // idle, don't recurse
+	else drop.timer = setTimeout( tolerate, drop.delay ); // recurse
+	drop.last = drop.event; // to compare idleness
+	drop.best = null; // reset comparitors
+	};
+
+/*******************************************************************************************/
+})(jQuery); // confine scope

data/lib/jquery/jquery.focus_and_blur.js

@@ -0,0 +1,81 @@
+(function(){
+
+    var special = jQuery.event.special,
+        uid1 = 'D' + (+new Date()),
+        uid2 = 'D' + (+new Date() + 1);
+
+    jQuery.event.special.focus = {
+        setup: function() {
+            var _self = this,
+                handler = function(e) {
+                    e = jQuery.event.fix(e);
+                    e.type = 'focus';
+                    if (_self === document) {
+                        jQuery.event.handle.call(_self, e);
+                    }
+                };
+
+            jQuery(this).data(uid1, handler);
+
+            if (_self === document) {
+                /* Must be live() */
+                if (_self.addEventListener) {
+                    _self.addEventListener('focus', handler, true);
+                } else {
+                    _self.attachEvent('onfocusin', handler);
+                }
+            } else {
+                return false;
+            }
+
+        },
+        teardown: function() {
+            var handler = jQuery(this).data(uid1);
+            if (this === document) {
+                if (this.removeEventListener) {
+                    this.removeEventListener('focus', handler, true);
+                } else {
+                    this.detachEvent('onfocusin', handler);
+                }
+            }
+        }
+    };
+
+    jQuery.event.special.blur = {
+        setup: function() {
+            var _self = this,
+                handler = function(e) {
+                    e = jQuery.event.fix(e);
+                    e.type = 'blur';
+                    if (_self === document) {
+                        jQuery.event.handle.call(_self, e);
+                    }
+                };
+
+            jQuery(this).data(uid2, handler);
+
+            if (_self === document) {
+                /* Must be live() */
+                if (_self.addEventListener) {
+                    _self.addEventListener('blur', handler, true);
+                } else {
+                    _self.attachEvent('onfocusout', handler);
+                }
+            } else {
+                return false;
+            }
+
+        },
+        teardown: function() {
+            var handler = jQuery(this).data(uid2);
+            if (this === document) {
+                if (this.removeEventListener) {
+                    this.removeEventListener('blur', handler, true);
+                } else {
+                    this.detachEvent('onfocusout', handler);
+                }
+            }
+        }
+    };
+
+})();

data/rspec/jabs/jabs_engine_spec.rb

@@ -4,6 +4,7 @@ require 'colored'
 
 describe Jabs::Engine do
   def assert_jabs src, target
+    target = "(function(){#{target}})()"
     jabsed = Jabs::Engine.new(src).render
     src = Johnson::Parser.parse(jabsed).to_ecma
     target = Johnson::Parser.parse(target).to_ecma
@@ -119,7 +120,7 @@ def sets_default_value
 }, %{
 jQuery.fn.sets_default_value = function() {
   var $this = this;
-  (function($this) {})($this.find('[default_value]'))
+  return (function($this) {return $this})($this.find('[default_value]'))
 }
 }
     end
@@ -131,11 +132,11 @@ jQuery.fn.sets_default_value = function() {
     end
 
     it "makes a query" do
-      assert_jabs "$#{@css}", "(function($this) {})(jQuery('#{@css}'));"
+      assert_jabs "$#{@css}", "return (function($this) { return $this})(jQuery('#{@css}'));"
     end
 
     it "renders iterator" do
-      assert_jabs "$#{@css}\n  this.rules();", "(function($this) {this.rules();})(jQuery('#{@css}'));"
+      assert_jabs "$#{@css}\n  this.rules();", "return (function($this) {this.rules(); return $this})(jQuery('#{@css}'));"
     end
 
 #     it "wraps with document.ready if not already wrapped" do
@@ -145,22 +146,35 @@ jQuery.fn.sets_default_value = function() {
 
   describe "events" do
     it "has a special :ready event" do
-      assert_jabs(":ready", "jQuery(function() {\n  (function($this) {  })(jQuery(window));\n});")
+      assert_jabs(":ready", "jQuery(function() {\n  return (function($this) {  return $this})(jQuery(window));\n});")
     end
 
     it "has it's own $this" do
-      assert_jabs ":click", "var $this = jQuery(this);"
+      assert_jabs %{
+$element
+  :click
+    .hide
+}, 
+%{
+return (function($this) {
+  $this.live("click", function(event) {
+    var $this = jQuery(this);
+    $this.hide();
+  });
+  return $this
+})(jQuery("element"))
+}
     end
 
     it "binds events to 'this' and preserves namespace" do
-      assert_jabs ":click.awesomely", "$this.live(\"click.awesomely\", function(e){var $this = jQuery(this);});"
+      assert_jabs ":click.awesomely", "$this.live(\"click.awesomely\", function(event){var $this = jQuery(this);});"
     end
 
     it "renders callback" do
-      assert_jabs ":click.awesomely\n  a()\n  b()", "$this.live(\"click.awesomely\", function(e){var $this = jQuery(this);a();b();});"
+      assert_jabs ":click.awesomely\n  a()\n  b()", "$this.live(\"click.awesomely\", function(event){var $this = jQuery(this);a();b();});"
     end
 
-    it "compiles nested with anything with arbitraty javascript inbetween" do
+    it "compiles nested with anything with arbitrary javascript in between" do
       assert_jabs %{
 fun test
   var cat = yum
@@ -168,7 +182,7 @@ fun test
 },%{ 
 function test() {
   var cat = yum;
-  $this.live( 'click', function(e) {var $this = jQuery(this);});
+  $this.live( 'click', function(event) {var $this = jQuery(this);});
 }
 }
     end
@@ -180,12 +194,13 @@ $document
   :click
     var cool = "beans"
 },%{
-(function($this) {
+return (function($this) {
   cars++;
-  $this.live('click', function(e) {
+  $this.live('click', function(event) {
     var $this = jQuery(this);
     var cool = "beans"
   });
+  return $this
 })(jQuery("document"));
 }
     end
@@ -197,7 +212,7 @@ var cat = poo
   slot++
 }, %{
 var cat = poo;
-$this.live('click', function(e) {
+$this.live('click', function(event) {
   var $this = jQuery(this);
   slot++;
 });
@@ -208,11 +223,11 @@ $this.live('click', function(e) {
   describe "sub selections" do
     before(:each) {@css= "#some.convoluted:selector"}
     it "queries against this" do
-      assert_jabs "&#{@css}", "(function($this) {})($this.find(\"#{@css}\"));"
+      assert_jabs "&#{@css}", "return (function($this) {return $this})($this.find(\"#{@css}\"));"
     end
 
     it "renders iterator" do
-      assert_jabs "&#{@css}\n  a()\n  b()", "(function($this) {a();b();})($this.find(\"#{@css}\"));"
+      assert_jabs "&#{@css}\n  a()\n  b()", "return (function($this) {a();b(); return $this})($this.find(\"#{@css}\"));"
     end
   end
 
@@ -342,15 +357,62 @@ else unless 3 == 4
     end  
   end
 
+  describe "hash literals" do
+    it "works for method calls" do
+      assert_jabs %{
+def sortable parent_selector
+  $#selector
+    .clone
+      .css
+        position: 'absolute'
+        top: 5
+},
+      %{
+jQuery.fn.sortable = function(parent_selector) {
+  var $this = this;
+  return (function($this){
+    return (function($this){
+      $this.css({
+        'position': 'absolute',
+        'top': 5
+      })
+      return $this
+    })($this.clone())
+    return $this
+  })(jQuery('#selector'))  
+}
+      }
+    end
+  end
+
   describe "nested function calls" do
-    it "assumes previous line returns jquery object" do
+    it "assumes previous line returns jquery object without implied self" do
+      assert_jabs %{
+:ready
+  object.targetElement
+    .call 'awesomely'
+      },
+      %{
+jQuery(function() {
+  return (function($this) {
+    return (function($this) {
+      $this.call("awesomely");
+      return $this
+})(jQuery(object.targetElement));
+return $this
+})(jQuery(window));
+});
+      }
+    end
+    it "assumes previous line returns jquery object for implied self" do
       assert_jabs %{
 .methodA :val
   .methodB :name
       },
       %{
-(function($this){
+return (function($this){
   $this.methodB('name')
+  return $this
 })($this.methodA('val'))
       }
     end