FEATURE: better mobile upload experience (upload the picture right away)

app/assets/javascripts/discourse/mixins/upload.js.es6

@@ -11,7 +11,9 @@ export default Em.Mixin.create({
   },
 
   _initializeUploader: function() {
-    var $upload = this.$('input[type=file]'),   // note: we can't cache this as fileupload replaces the input after upload
+    // NOTE: we can't cache this as fileupload replaces the input after upload
+    // cf. https://github.com/blueimp/jQuery-File-Upload/wiki/Frequently-Asked-Questions#why-is-the-file-input-field-cloned-and-replaced-after-each-selection
+    var $upload = this.$('input[type=file]'),
        self = this;
 
     $upload.fileupload({
@@ -27,10 +29,12 @@ export default Em.Mixin.create({
       self.setProperties({ uploadProgress: 0, uploading: result });
       return result;
     });
+
     $upload.on("fileuploadprogressall", function(e, data) {
       var progress = parseInt(data.loaded / data.total * 100, 10);
       self.set("uploadProgress", progress);
     });
+
     $upload.on("fileuploaddone", function(e, data) {
       if(data.result.url) {
         self.uploadDone(data);
@@ -38,9 +42,11 @@ export default Em.Mixin.create({
         bootbox.alert(I18n.t('post.errors.upload'));
       }
     });
+
     $upload.on("fileuploadfail", function(e, data) {
       Discourse.Utilities.displayErrorForUpload(data);
     });
+
     $upload.on("fileuploadalways", function() {
       self.setProperties({ uploading: false, uploadProgress: 0});
     });

app/assets/javascripts/discourse/templates/composer.js.handlebars

@@ -67,14 +67,12 @@
           </div>
           <div class="composer-bottom-right">
             <a href="#" {{action togglePreview}} class='toggle-preview'>{{{model.toggleText}}}</a>
-            {{#if view.isUploading}}
+            <div id="file-uploading" {{bind-attr class="view.isUploading::hidden"}}>
-              <div id="file-uploading">
+              {{i18n upload_selector.uploading}} {{view.uploadProgress}}% <a id="cancel-file-upload">{{i18n cancel}}</a>
-                {{i18n upload_selector.uploading}} {{view.uploadProgress}}% <a id="cancel-file-upload">{{i18n cancel}}</a>
+            </div>
-              </div>
+            {{#if Discourse.Mobile.mobileView}}
-            {{else}}
+              <a {{bind-attr class=":mobile-file-upload view.isUploading:hidden"}}>{{i18n upload}}</a>
-              {{#if Discourse.Mobile.mobileView}}
+              <input type="file" id="mobile-uploader" />
-                <a {{action showUploadSelector view}} class='mobile-file-upload'>{{i18n upload}}</a>
-              {{/if}}
             {{/if}}
             <div id='draft-status'>{{model.draftStatus}}</div>
           </div>

app/assets/javascripts/discourse/views/composer.js.es6

@@ -268,7 +268,7 @@ var ComposerView = Discourse.View.extend(Ember.Evented, {
 
     $uploadTarget.fileupload({
       url: Discourse.getURL('/uploads'),
-      dataType: 'json'
+      dataType: 'json',
     });
 
     // submit - this event is triggered for each upload
@@ -411,6 +411,13 @@ var ComposerView = Discourse.View.extend(Ember.Evented, {
       });
     }
 
+    if (Discourse.Mobile.mobileView) {
+      $(".mobile-file-upload").on("click", function () {
+        // redirect the click on the hidden file input
+        $("#mobile-uploader").click();
+      });
+    }
+
     // need to wait a bit for the "slide up" transition of the composer
     // we could use .on("transitionend") but it's not firing when the transition isn't completed :(
     Em.run.later(function() {
@@ -508,7 +515,8 @@ var ComposerView = Discourse.View.extend(Ember.Evented, {
 
   _unbindUploadTarget: function() {
     var $uploadTarget = $('#reply-control');
-    $uploadTarget.fileupload('destroy');
+    try { $uploadTarget.fileupload('destroy'); }
+    catch (e) { /* wasn't initialized yet */ }
     $uploadTarget.off();
   }
 });

app/assets/stylesheets/mobile/compose.scss

@@ -24,13 +24,11 @@ display: none;
   .mobile-file-upload {
     text-decoration: underline;
   }
+  #mobile-uploader { display: none; }
   #draft-status, #file-uploading, .mobile-file-upload {
     float: right;
     margin-right: 8px;
   }
-  .mobile-file-upload {
-    text-decoration: underline;
-  }
   #file-uploading {
     left: 51%;
     font-size: 12px;

vendor/assets/javascripts/jquery.ui.widget.js

@@ -1,12 +1,12 @@
-/*
+/*!
- * jQuery UI Widget 1.8.18+amd
+ * jQuery UI Widget 1.10.4+amd
  * https://github.com/blueimp/jQuery-File-Upload
  *
- * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
+ * Copyright 2014 jQuery Foundation and other contributors
- * Dual licensed under the MIT or GPL Version 2 licenses.
+ * Released under the MIT license.
  * http://jquery.org/license
  *
- * http://docs.jquery.com/UI/Widget
+ * http://api.jqueryui.com/jQuery.widget/
  */
 
 (function (factory) {
@@ -19,43 +19,26 @@
     }
 }(function( $, undefined ) {
 
-// jQuery 1.4+
+var uuid = 0,
-// See: https://github.com/blueimp/jQuery-File-Upload/issues/3013#issuecomment-37067816
+	slice = Array.prototype.slice,
-/*
+	_cleanData = $.cleanData;
-if ( $.cleanData ) {
+$.cleanData = function( elems ) {
-	var _cleanData = $.cleanData;
+	for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
-	$.cleanData = function( elems ) {
+		try {
-		for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
+			$( elem ).triggerHandler( "remove" );
-			try {
+		// http://bugs.jquery.com/ticket/8235
-				$( elem ).triggerHandler( "remove" );
+		} catch( e ) {}
-			// http://bugs.jquery.com/ticket/8235
+	}
-			} catch( e ) {}
+	_cleanData( elems );
-		}
+};
-		_cleanData( elems );
-	};
-} else {
-	var _remove = $.fn.remove;
-	$.fn.remove = function( selector, keepData ) {
-		return this.each(function() {
-			if ( !keepData ) {
-				if ( !selector || $.filter( selector, [ this ] ).length ) {
-					$( "*", this ).add( [ this ] ).each(function() {
-						try {
-							$( this ).triggerHandler( "remove" );
-						// http://bugs.jquery.com/ticket/8235
-						} catch( e ) {}
-					});
-				}
-			}
-			return _remove.call( $(this), selector, keepData );
-		});
-	};
-}
-*/
 
 $.widget = function( name, base, prototype ) {
-	var namespace = name.split( "." )[ 0 ],
+	var fullName, existingConstructor, constructor, basePrototype,
-		fullName;
+		// proxiedPrototype allows the provided prototype to remain unmodified
+		// so that it can be used as a mixin for multiple widgets (#8876)
+		proxiedPrototype = {},
+		namespace = name.split( "." )[ 0 ];
+
 	name = name.split( "." )[ 1 ];
 	fullName = namespace + "-" + name;
 
@@ -65,81 +48,167 @@ $.widget = function( name, base, prototype ) {
 	}
 
 	// create selector for plugin
-	$.expr[ ":" ][ fullName ] = function( elem ) {
+	$.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
-		return !!$.data( elem, name );
+		return !!$.data( elem, fullName );
 	};
 
 	$[ namespace ] = $[ namespace ] || {};
-	$[ namespace ][ name ] = function( options, element ) {
+	existingConstructor = $[ namespace ][ name ];
+	constructor = $[ namespace ][ name ] = function( options, element ) {
+		// allow instantiation without "new" keyword
+		if ( !this._createWidget ) {
+			return new constructor( options, element );
+		}
+
 		// allow instantiation without initializing for simple inheritance
+		// must use "new" keyword (the code above always passes args)
 		if ( arguments.length ) {
 			this._createWidget( options, element );
 		}
 	};
+	// extend with the existing constructor to carry over any static properties
+	$.extend( constructor, existingConstructor, {
+		version: prototype.version,
+		// copy the object used to create the prototype in case we need to
+		// redefine the widget later
+		_proto: $.extend( {}, prototype ),
+		// track widgets that inherit from this widget in case this widget is
+		// redefined after a widget inherits from it
+		_childConstructors: []
+	});
 
-	var basePrototype = new base();
+	basePrototype = new base();
 	// we need to make the options hash a property directly on the new instance
 	// otherwise we'll modify the options hash on the prototype that we're
 	// inheriting from
-//	$.each( basePrototype, function( key, val ) {
+	basePrototype.options = $.widget.extend( {}, basePrototype.options );
-//		if ( $.isPlainObject(val) ) {
+	$.each( prototype, function( prop, value ) {
-//			basePrototype[ key ] = $.extend( {}, val );
+		if ( !$.isFunction( value ) ) {
-//		}
+			proxiedPrototype[ prop ] = value;
-//	});
+			return;
-	basePrototype.options = $.extend( true, {}, basePrototype.options );
+		}
-	$[ namespace ][ name ].prototype = $.extend( true, basePrototype, {
+		proxiedPrototype[ prop ] = (function() {
+			var _super = function() {
+					return base.prototype[ prop ].apply( this, arguments );
+				},
+				_superApply = function( args ) {
+					return base.prototype[ prop ].apply( this, args );
+				};
+			return function() {
+				var __super = this._super,
+					__superApply = this._superApply,
+					returnValue;
+
+				this._super = _super;
+				this._superApply = _superApply;
+
+				returnValue = value.apply( this, arguments );
+
+				this._super = __super;
+				this._superApply = __superApply;
+
+				return returnValue;
+			};
+		})();
+	});
+	constructor.prototype = $.widget.extend( basePrototype, {
+		// TODO: remove support for widgetEventPrefix
+		// always use the name + a colon as the prefix, e.g., draggable:start
+		// don't prefix for widgets that aren't DOM-based
+		widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name
+	}, proxiedPrototype, {
+		constructor: constructor,
 		namespace: namespace,
 		widgetName: name,
-		widgetEventPrefix: $[ namespace ][ name ].prototype.widgetEventPrefix || name,
+		widgetFullName: fullName
-		widgetBaseClass: fullName
+	});
-	}, prototype );
 
-	$.widget.bridge( name, $[ namespace ][ name ] );
+	// If this widget is being redefined then we need to find all widgets that
+	// are inheriting from it and redefine all of them so that they inherit from
+	// the new version of this widget. We're essentially trying to replace one
+	// level in the prototype chain.
+	if ( existingConstructor ) {
+		$.each( existingConstructor._childConstructors, function( i, child ) {
+			var childPrototype = child.prototype;
+
+			// redefine the child widget using the same prototype that was
+			// originally used, but inherit from the new version of the base
+			$.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
+		});
+		// remove the list of existing child constructors from the old constructor
+		// so the old child constructors can be garbage collected
+		delete existingConstructor._childConstructors;
+	} else {
+		base._childConstructors.push( constructor );
+	}
+
+	$.widget.bridge( name, constructor );
+};
+
+$.widget.extend = function( target ) {
+	var input = slice.call( arguments, 1 ),
+		inputIndex = 0,
+		inputLength = input.length,
+		key,
+		value;
+	for ( ; inputIndex < inputLength; inputIndex++ ) {
+		for ( key in input[ inputIndex ] ) {
+			value = input[ inputIndex ][ key ];
+			if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
+				// Clone objects
+				if ( $.isPlainObject( value ) ) {
+					target[ key ] = $.isPlainObject( target[ key ] ) ?
+						$.widget.extend( {}, target[ key ], value ) :
+						// Don't extend strings, arrays, etc. with objects
+						$.widget.extend( {}, value );
+				// Copy everything else by reference
+				} else {
+					target[ key ] = value;
+				}
+			}
+		}
+	}
+	return target;
 };
 
 $.widget.bridge = function( name, object ) {
+	var fullName = object.prototype.widgetFullName || name;
 	$.fn[ name ] = function( options ) {
 		var isMethodCall = typeof options === "string",
-			args = Array.prototype.slice.call( arguments, 1 ),
+			args = slice.call( arguments, 1 ),
 			returnValue = this;
 
 		// allow multiple hashes to be passed on init
 		options = !isMethodCall && args.length ?
-			$.extend.apply( null, [ true, options ].concat(args) ) :
+			$.widget.extend.apply( null, [ options ].concat(args) ) :
 			options;
 
-		// prevent calls to internal methods
-		if ( isMethodCall && options.charAt( 0 ) === "_" ) {
-			return returnValue;
-		}
-
 		if ( isMethodCall ) {
 			this.each(function() {
-				var instance = $.data( this, name ),
+				var methodValue,
-					methodValue = instance && $.isFunction( instance[options] ) ?
+					instance = $.data( this, fullName );
-						instance[ options ].apply( instance, args ) :
+				if ( !instance ) {
-						instance;
+					return $.error( "cannot call methods on " + name + " prior to initialization; " +
-				// TODO: add this back in 1.9 and use $.error() (see #5972)
+						"attempted to call method '" + options + "'" );
-//				if ( !instance ) {
+				}
-//					throw "cannot call methods on " + name + " prior to initialization; " +
+				if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
-//						"attempted to call method '" + options + "'";
+					return $.error( "no such method '" + options + "' for " + name + " widget instance" );
-//				}
+				}
-//				if ( !$.isFunction( instance[options] ) ) {
+				methodValue = instance[ options ].apply( instance, args );
-//					throw "no such method '" + options + "' for " + name + " widget instance";
-//				}
-//				var methodValue = instance[ options ].apply( instance, args );
 				if ( methodValue !== instance && methodValue !== undefined ) {
-					returnValue = methodValue;
+					returnValue = methodValue && methodValue.jquery ?
+						returnValue.pushStack( methodValue.get() ) :
+						methodValue;
 					return false;
 				}
 			});
 		} else {
 			this.each(function() {
-				var instance = $.data( this, name );
+				var instance = $.data( this, fullName );
 				if ( instance ) {
 					instance.option( options || {} )._init();
 				} else {
-					$.data( this, name, new object( options, this ) );
+					$.data( this, fullName, new object( options, this ) );
 				}
 			});
 		}
@@ -148,74 +217,123 @@ $.widget.bridge = function( name, object ) {
 	};
 };
 
-$.Widget = function( options, element ) {
+$.Widget = function( /* options, element */ ) {};
-	// allow instantiation without initializing for simple inheritance
+$.Widget._childConstructors = [];
-	if ( arguments.length ) {
-		this._createWidget( options, element );
-	}
-};
 
 $.Widget.prototype = {
 	widgetName: "widget",
 	widgetEventPrefix: "",
+	defaultElement: "<div>",
 	options: {
-		disabled: false
+		disabled: false,
+
+		// callbacks
+		create: null
 	},
 	_createWidget: function( options, element ) {
-		// $.widget.bridge stores the plugin instance, but we do it anyway
+		element = $( element || this.defaultElement || this )[ 0 ];
-		// so that it's stored even before the _create function runs
-		$.data( element, this.widgetName, this );
 		this.element = $( element );
-		this.options = $.extend( true, {},
+		this.uuid = uuid++;
+		this.eventNamespace = "." + this.widgetName + this.uuid;
+		this.options = $.widget.extend( {},
 			this.options,
 			this._getCreateOptions(),
 			options );
 
-		var self = this;
+		this.bindings = $();
-		this.element.bind( "remove." + this.widgetName, function() {
+		this.hoverable = $();
-			self.destroy();
+		this.focusable = $();
-		});
+
+		if ( element !== this ) {
+			$.data( element, this.widgetFullName, this );
+			this._on( true, this.element, {
+				remove: function( event ) {
+					if ( event.target === element ) {
+						this.destroy();
+					}
+				}
+			});
+			this.document = $( element.style ?
+				// element within the document
+				element.ownerDocument :
+				// element is window or document
+				element.document || element );
+			this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
+		}
 
 		this._create();
-		this._trigger( "create" );
+		this._trigger( "create", null, this._getCreateEventData() );
 		this._init();
 	},
-	_getCreateOptions: function() {
+	_getCreateOptions: $.noop,
-		return $.metadata && $.metadata.get( this.element[0] )[ this.widgetName ];
+	_getCreateEventData: $.noop,
-	},
+	_create: $.noop,
-	_create: function() {},
+	_init: $.noop,
-	_init: function() {},
 
 	destroy: function() {
+		this._destroy();
+		// we can probably remove the unbind calls in 2.0
+		// all event bindings should go through this._on()
 		this.element
-			.unbind( "." + this.widgetName )
+			.unbind( this.eventNamespace )
-			.removeData( this.widgetName );
+			// 1.9 BC for #7810
+			// TODO remove dual storage
+			.removeData( this.widgetName )
+			.removeData( this.widgetFullName )
+			// support: jquery <1.6.3
+			// http://bugs.jquery.com/ticket/9413
+			.removeData( $.camelCase( this.widgetFullName ) );
 		this.widget()
-			.unbind( "." + this.widgetName )
+			.unbind( this.eventNamespace )
 			.removeAttr( "aria-disabled" )
 			.removeClass(
-				this.widgetBaseClass + "-disabled " +
+				this.widgetFullName + "-disabled " +
 				"ui-state-disabled" );
+
+		// clean up events and states
+		this.bindings.unbind( this.eventNamespace );
+		this.hoverable.removeClass( "ui-state-hover" );
+		this.focusable.removeClass( "ui-state-focus" );
 	},
+	_destroy: $.noop,
 
 	widget: function() {
 		return this.element;
 	},
 
 	option: function( key, value ) {
-		var options = key;
+		var options = key,
+			parts,
+			curOption,
+			i;
 
 		if ( arguments.length === 0 ) {
 			// don't return a reference to the internal hash
-			return $.extend( {}, this.options );
+			return $.widget.extend( {}, this.options );
 		}
 
-		if  (typeof key === "string" ) {
+		if ( typeof key === "string" ) {
-			if ( value === undefined ) {
+			// handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
-				return this.options[ key ];
-			}
 			options = {};
-			options[ key ] = value;
+			parts = key.split( "." );
+			key = parts.shift();
+			if ( parts.length ) {
+				curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
+				for ( i = 0; i < parts.length - 1; i++ ) {
+					curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
+					curOption = curOption[ parts[ i ] ];
+				}
+				key = parts.pop();
+				if ( arguments.length === 1 ) {
+					return curOption[ key ] === undefined ? null : curOption[ key ];
+				}
+				curOption[ key ] = value;
+			} else {
+				if ( arguments.length === 1 ) {
+					return this.options[ key ] === undefined ? null : this.options[ key ];
+				}
+				options[ key ] = value;
+			}
 		}
 
 		this._setOptions( options );
@@ -223,10 +341,11 @@ $.Widget.prototype = {
 		return this;
 	},
 	_setOptions: function( options ) {
-		var self = this;
+		var key;
-		$.each( options, function( key, value ) {
+
-			self._setOption( key, value );
+		for ( key in options ) {
-		});
+			this._setOption( key, options[ key ] );
+		}
 
 		return this;
 	},
@@ -235,10 +354,10 @@ $.Widget.prototype = {
 
 		if ( key === "disabled" ) {
 			this.widget()
-				[ value ? "addClass" : "removeClass"](
+				.toggleClass( this.widgetFullName + "-disabled ui-state-disabled", !!value )
-					this.widgetBaseClass + "-disabled" + " " +
-					"ui-state-disabled" )
 				.attr( "aria-disabled", value );
+			this.hoverable.removeClass( "ui-state-hover" );
+			this.focusable.removeClass( "ui-state-focus" );
 		}
 
 		return this;
@@ -251,6 +370,97 @@ $.Widget.prototype = {
 		return this._setOption( "disabled", true );
 	},
 
+	_on: function( suppressDisabledCheck, element, handlers ) {
+		var delegateElement,
+			instance = this;
+
+		// no suppressDisabledCheck flag, shuffle arguments
+		if ( typeof suppressDisabledCheck !== "boolean" ) {
+			handlers = element;
+			element = suppressDisabledCheck;
+			suppressDisabledCheck = false;
+		}
+
+		// no element argument, shuffle and use this.element
+		if ( !handlers ) {
+			handlers = element;
+			element = this.element;
+			delegateElement = this.widget();
+		} else {
+			// accept selectors, DOM elements
+			element = delegateElement = $( element );
+			this.bindings = this.bindings.add( element );
+		}
+
+		$.each( handlers, function( event, handler ) {
+			function handlerProxy() {
+				// allow widgets to customize the disabled handling
+				// - disabled as an array instead of boolean
+				// - disabled class as method for disabling individual parts
+				if ( !suppressDisabledCheck &&
+						( instance.options.disabled === true ||
+							$( this ).hasClass( "ui-state-disabled" ) ) ) {
+					return;
+				}
+				return ( typeof handler === "string" ? instance[ handler ] : handler )
+					.apply( instance, arguments );
+			}
+
+			// copy the guid so direct unbinding works
+			if ( typeof handler !== "string" ) {
+				handlerProxy.guid = handler.guid =
+					handler.guid || handlerProxy.guid || $.guid++;
+			}
+
+			var match = event.match( /^(\w+)\s*(.*)$/ ),
+				eventName = match[1] + instance.eventNamespace,
+				selector = match[2];
+			if ( selector ) {
+				delegateElement.delegate( selector, eventName, handlerProxy );
+			} else {
+				element.bind( eventName, handlerProxy );
+			}
+		});
+	},
+
+	_off: function( element, eventName ) {
+		eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
+		element.unbind( eventName ).undelegate( eventName );
+	},
+
+	_delay: function( handler, delay ) {
+		function handlerProxy() {
+			return ( typeof handler === "string" ? instance[ handler ] : handler )
+				.apply( instance, arguments );
+		}
+		var instance = this;
+		return setTimeout( handlerProxy, delay || 0 );
+	},
+
+	_hoverable: function( element ) {
+		this.hoverable = this.hoverable.add( element );
+		this._on( element, {
+			mouseenter: function( event ) {
+				$( event.currentTarget ).addClass( "ui-state-hover" );
+			},
+			mouseleave: function( event ) {
+				$( event.currentTarget ).removeClass( "ui-state-hover" );
+			}
+		});
+	},
+
+	_focusable: function( element ) {
+		this.focusable = this.focusable.add( element );
+		this._on( element, {
+			focusin: function( event ) {
+				$( event.currentTarget ).addClass( "ui-state-focus" );
+			},
+			focusout: function( event ) {
+				$( event.currentTarget ).removeClass( "ui-state-focus" );
+			}
+		});
+	},
+
 	_trigger: function( type, event, data ) {
 		var prop, orig,
 			callback = this.options[ type ];
@@ -275,11 +485,46 @@ $.Widget.prototype = {
 		}
 
 		this.element.trigger( event, data );
-
+		return !( $.isFunction( callback ) &&
-		return !( $.isFunction(callback) &&
+			callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
-			callback.call( this.element[0], event, data ) === false ||
 			event.isDefaultPrevented() );
 	}
 };
 
+$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
+	$.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
+		if ( typeof options === "string" ) {
+			options = { effect: options };
+		}
+		var hasOptions,
+			effectName = !options ?
+				method :
+				options === true || typeof options === "number" ?
+					defaultEffect :
+					options.effect || defaultEffect;
+		options = options || {};
+		if ( typeof options === "number" ) {
+			options = { duration: options };
+		}
+		hasOptions = !$.isEmptyObject( options );
+		options.complete = callback;
+		if ( options.delay ) {
+			element.delay( options.delay );
+		}
+		if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
+			element[ method ]( options );
+		} else if ( effectName !== method && element[ effectName ] ) {
+			element[ effectName ]( options.duration, options.easing, callback );
+		} else {
+			element.queue(function( next ) {
+				$( this )[ method ]();
+				if ( callback ) {
+					callback.call( element[ 0 ] );
+				}
+				next();
+			});
+		}
+	};
+});
+
 }));