activeadmin 1.4.3 → 2.9.0

data/lib/generators/active_admin/webpacker/templates/active_admin.scss

@@ -0,0 +1,17 @@
+// Sass variable overrides must be declared before loading up Active Admin's styles.
+//
+// To view the variables that Active Admin provides, take a look at
+// `app/assets/stylesheets/active_admin/mixins/_variables.scss` in the
+// Active Admin source.
+//
+// For example, to change the sidebar width:
+// $sidebar-width: 242px;
+
+// Active Admin's got SASS!
+@import "~@activeadmin/activeadmin/src/scss/mixins";
+@import "~@activeadmin/activeadmin/src/scss/base";
+
+// Overriding any non-variable Sass must be done after the fact.
+// For example, to change the default status-tag color:
+//
+//   .status_tag { background: #6090DB; }

data/lib/generators/active_admin/webpacker/templates/print.scss

@@ -0,0 +1,2 @@
+/* Active Admin Print Stylesheet */
+@import "~@activeadmin/activeadmin/src/scss/print";

data/lib/generators/active_admin/webpacker/webpacker_generator.rb

@@ -0,0 +1,26 @@
+module ActiveAdmin
+  module Generators
+    class WebpackerGenerator < Rails::Generators::Base
+
+      source_root File.expand_path("templates", __dir__)
+
+      def install_assets
+        template "active_admin.js", "app/javascript/packs/active_admin.js"
+        template "active_admin.scss", "app/javascript/stylesheets/active_admin.scss"
+        template "print.scss", "app/javascript/packs/active_admin/print.scss"
+
+        copy_file "#{__dir__}/plugins/jquery.js", Rails.root.join("config/webpack/plugins/jquery.js").to_s
+
+        insert_into_file Rails.root.join("config/webpack/environment.js").to_s,
+                         "const jquery = require('./plugins/jquery')\n",
+                         after: /require\(('|")@rails\/webpacker\1\);?\n/
+
+        insert_into_file Rails.root.join("config/webpack/environment.js").to_s,
+                         "environment.plugins.prepend('jquery', jquery)\n",
+                         before: "module.exports"
+
+        run "yarn add @activeadmin/activeadmin"
+      end
+    end
+  end
+end

data/lib/ransack_ext.rb

@@ -2,19 +2,19 @@
 # identically to the versions given in Ransack.
 #
 Ransack.configure do |config|
-  {'contains'=>'cont', 'starts_with'=>'start', 'ends_with'=>'end'}.each do |old, current|
-    config.add_predicate old, Ransack::Constants::DERIVED_PREDICATES.detect{ |q, _| q == current }[1]
+  { "contains" => "cont", "starts_with" => "start", "ends_with" => "end" }.each do |old, current|
+    config.add_predicate old, Ransack::Constants::DERIVED_PREDICATES.detect { |q, _| q == current }[1]
   end
 
-  {'equals'=>'eq', 'greater_than'=>'gt', 'less_than'=>'lt'}.each do |old, current|
+  { "equals" => "eq", "greater_than" => "gt", "less_than" => "lt" }.each do |old, current|
     config.add_predicate old, arel_predicate: current
   end
 
-  config.add_predicate 'gteq_datetime',
-    arel_predicate: 'gteq',
-    formatter: ->(v) { v.beginning_of_day }
+  config.add_predicate "gteq_datetime",
+                       arel_predicate: "gteq",
+                       formatter: ->(v) { v.beginning_of_day }
 
-  config.add_predicate 'lteq_datetime',
-  	arel_predicate: 'lt',
-  	formatter: ->(v) { v + 1.day }
+  config.add_predicate "lteq_datetime",
+                       arel_predicate: "lt",
+                       formatter: ->(v) { v + 1.day }
 end

data/vendor/assets/javascripts/jquery-ui/form-reset-mixin.js

@@ -0,0 +1,80 @@
+//= require jquery-ui/form
+//= require jquery-ui/version
+
+/*!
+ * jQuery UI Form Reset Mixin 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+//>>label: Form Reset Mixin
+//>>group: Core
+//>>description: Refresh input widgets when their form is reset
+//>>docs: http://api.jqueryui.com/form-reset-mixin/
+
+( function( factory ) {
+  if ( typeof define === "function" && define.amd ) {
+
+    // AMD. Register as an anonymous module.
+    define( [
+      "jquery",
+      "./form",
+      "./version"
+    ], factory );
+  } else {
+
+    // Browser globals
+    factory( jQuery );
+  }
+}( function( $ ) {
+
+  return $.ui.formResetMixin = {
+    _formResetHandler: function() {
+      var form = $( this );
+
+      // Wait for the form reset to actually happen before refreshing
+      setTimeout( function() {
+        var instances = form.data( "ui-form-reset-instances" );
+        $.each( instances, function() {
+          this.refresh();
+        } );
+      } );
+    },
+
+    _bindFormResetHandler: function() {
+      this.form = this.element.form();
+      if ( !this.form.length ) {
+        return;
+      }
+
+      var instances = this.form.data( "ui-form-reset-instances" ) || [];
+      if ( !instances.length ) {
+
+        // We don't use _on() here because we use a single event handler per form
+        this.form.on( "reset.ui-form-reset", this._formResetHandler );
+      }
+      instances.push( this );
+      this.form.data( "ui-form-reset-instances", instances );
+    },
+
+    _unbindFormResetHandler: function() {
+      if ( !this.form.length ) {
+        return;
+      }
+
+      var instances = this.form.data( "ui-form-reset-instances" );
+      instances.splice( $.inArray( this, instances ), 1 );
+      if ( instances.length ) {
+        this.form.data( "ui-form-reset-instances", instances );
+      } else {
+        this.form
+            .removeData( "ui-form-reset-instances" )
+            .off( "reset.ui-form-reset" );
+      }
+    }
+  };
+
+} ) );

data/vendor/assets/javascripts/jquery-ui/form.js

@@ -0,0 +1,22 @@
+//= require jquery-ui/version
+
+( function( factory ) {
+  if ( typeof define === "function" && define.amd ) {
+
+    // AMD. Register as an anonymous module.
+    define( [ "jquery", "./version" ], factory );
+  } else {
+
+    // Browser globals
+    factory( jQuery );
+  }
+} ( function( $ ) {
+
+// Support: IE8 Only
+// IE8 does not support the form attribute and when it is supplied. It overwrites the form prop
+// with a string, so we need to find the proper form.
+  return $.fn.form = function() {
+    return typeof this[ 0 ].form === "string" ? this.closest( "form" ) : $( this[ 0 ].form );
+  };
+
+} ) );

data/vendor/assets/javascripts/jquery-ui/labels.js

@@ -0,0 +1,65 @@
+//= require jquery-ui/version
+//= require jquery-ui/escape-selector
+
+/*!
+ * jQuery UI Labels 1.12.1
+ * http://jqueryui.com
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+//>>label: labels
+//>>group: Core
+//>>description: Find all the labels associated with a given input
+//>>docs: http://api.jqueryui.com/labels/
+
+( function( factory ) {
+  if ( typeof define === "function" && define.amd ) {
+
+    // AMD. Register as an anonymous module.
+    define( [ "jquery", "./version", "./escape-selector" ], factory );
+  } else {
+
+    // Browser globals
+    factory( jQuery );
+  }
+} ( function( $ ) {
+
+  return $.fn.labels = function() {
+    var ancestor, selector, id, labels, ancestors;
+
+    // Check control.labels first
+    if ( this[ 0 ].labels && this[ 0 ].labels.length ) {
+      return this.pushStack( this[ 0 ].labels );
+    }
+
+    // Support: IE <= 11, FF <= 37, Android <= 2.3 only
+    // Above browsers do not support control.labels. Everything below is to support them
+    // as well as document fragments. control.labels does not work on document fragments
+    labels = this.eq( 0 ).parents( "label" );
+
+    // Look for the label based on the id
+    id = this.attr( "id" );
+    if ( id ) {
+
+      // We don't search against the document in case the element
+      // is disconnected from the DOM
+      ancestor = this.eq( 0 ).parents().last();
+
+      // Get a full set of top level ancestors
+      ancestors = ancestor.add( ancestor.length ? ancestor.siblings() : this.siblings() );
+
+      // Create a selector for the label based on the id
+      selector = "label[for='" + $.ui.escapeSelector( id ) + "']";
+
+      labels = labels.add( ancestors.find( selector ).addBack( selector ) );
+
+    }
+
+    // Return whatever we have found for labels
+    return this.pushStack( labels );
+  };
+
+} ) );

data/vendor/assets/javascripts/jquery-ui/widgets/checkboxradio.js

@@ -1,7 +1,10 @@
+//= require jquery-ui/escape-selector
+//= require jquery-ui/form-reset-mixin
+//= require jquery-ui/labels
 //= require jquery-ui/widget
 
 /*!
- * jQuery UI Controlgroup 1.12.1
+ * jQuery UI Checkboxradio 1.12.1
  * http://jqueryui.com
  *
  * Copyright jQuery Foundation and other contributors
@@ -9,292 +12,280 @@
  * http://jquery.org/license
  */
 
-//>>label: Controlgroup
+//>>label: Checkboxradio
 //>>group: Widgets
-//>>description: Visually groups form control widgets
-//>>docs: http://api.jqueryui.com/controlgroup/
-//>>demos: http://jqueryui.com/controlgroup/
+//>>description: Enhances a form with multiple themeable checkboxes or radio buttons.
+//>>docs: http://api.jqueryui.com/checkboxradio/
+//>>demos: http://jqueryui.com/checkboxradio/
 //>>css.structure: ../../themes/base/core.css
-//>>css.structure: ../../themes/base/controlgroup.css
+//>>css.structure: ../../themes/base/button.css
+//>>css.structure: ../../themes/base/checkboxradio.css
 //>>css.theme: ../../themes/base/theme.css
 
 ( function( factory ) {
-	if ( typeof define === "function" && define.amd ) {
-
-		// AMD. Register as an anonymous module.
-		define( [
-			"jquery",
-			"../widget"
-		], factory );
-	} else {
-
-		// Browser globals
-		factory( jQuery );
-	}
+  if ( typeof define === "function" && define.amd ) {
+
+    // AMD. Register as an anonymous module.
+    define( [
+      "jquery",
+      "../escape-selector",
+      "../form-reset-mixin",
+      "../labels",
+      "../widget"
+    ], factory );
+  } else {
+
+    // Browser globals
+    factory( jQuery );
+  }
 }( function( $ ) {
-var controlgroupCornerRegex = /ui-corner-([a-z]){2,6}/g;
-
-return $.widget( "ui.controlgroup", {
-	version: "1.12.1",
-	defaultElement: "<div>",
-	options: {
-		direction: "horizontal",
-		disabled: null,
-		onlyVisible: true,
-		items: {
-			"button": "input[type=button], input[type=submit], input[type=reset], button, a",
-			"controlgroupLabel": ".ui-controlgroup-label",
-			"checkboxradio": "input[type='checkbox'], input[type='radio']",
-			"selectmenu": "select",
-			"spinner": ".ui-spinner-input"
-		}
-	},
-
-	_create: function() {
-		this._enhance();
-	},
-
-	// To support the enhanced option in jQuery Mobile, we isolate DOM manipulation
-	_enhance: function() {
-		this.element.attr( "role", "toolbar" );
-		this.refresh();
-	},
-
-	_destroy: function() {
-		this._callChildMethod( "destroy" );
-		this.childWidgets.removeData( "ui-controlgroup-data" );
-		this.element.removeAttr( "role" );
-		if ( this.options.items.controlgroupLabel ) {
-			this.element
-				.find( this.options.items.controlgroupLabel )
-				.find( ".ui-controlgroup-label-contents" )
-				.contents().unwrap();
-		}
-	},
-
-	_initWidgets: function() {
-		var that = this,
-			childWidgets = [];
-
-		// First we iterate over each of the items options
-		$.each( this.options.items, function( widget, selector ) {
-			var labels;
-			var options = {};
-
-			// Make sure the widget has a selector set
-			if ( !selector ) {
-				return;
-			}
-
-			if ( widget === "controlgroupLabel" ) {
-				labels = that.element.find( selector );
-				labels.each( function() {
-					var element = $( this );
-
-					if ( element.children( ".ui-controlgroup-label-contents" ).length ) {
-						return;
-					}
-					element.contents()
-						.wrapAll( "<span class='ui-controlgroup-label-contents'></span>" );
-				} );
-				that._addClass( labels, null, "ui-widget ui-widget-content ui-state-default" );
-				childWidgets = childWidgets.concat( labels.get() );
-				return;
-			}
-
-			// Make sure the widget actually exists
-			if ( !$.fn[ widget ] ) {
-				return;
-			}
-
-			// We assume everything is in the middle to start because we can't determine
-			// first / last elements until all enhancments are done.
-			if ( that[ "_" + widget + "Options" ] ) {
-				options = that[ "_" + widget + "Options" ]( "middle" );
-			} else {
-				options = { classes: {} };
-			}
-
-			// Find instances of this widget inside controlgroup and init them
-			that.element
-				.find( selector )
-				.each( function() {
-					var element = $( this );
-					var instance = element[ widget ]( "instance" );
-
-					// We need to clone the default options for this type of widget to avoid
-					// polluting the variable options which has a wider scope than a single widget.
-					var instanceOptions = $.widget.extend( {}, options );
-
-					// If the button is the child of a spinner ignore it
-					// TODO: Find a more generic solution
-					if ( widget === "button" && element.parent( ".ui-spinner" ).length ) {
-						return;
-					}
-
-					// Create the widget if it doesn't exist
-					if ( !instance ) {
-						instance = element[ widget ]()[ widget ]( "instance" );
-					}
-					if ( instance ) {
-						instanceOptions.classes =
-							that._resolveClassesValues( instanceOptions.classes, instance );
-					}
-					element[ widget ]( instanceOptions );
-
-					// Store an instance of the controlgroup to be able to reference
-					// from the outermost element for changing options and refresh
-					var widgetElement = element[ widget ]( "widget" );
-					$.data( widgetElement[ 0 ], "ui-controlgroup-data",
-						instance ? instance : element[ widget ]( "instance" ) );
-
-					childWidgets.push( widgetElement[ 0 ] );
-				} );
-		} );
-
-		this.childWidgets = $( $.unique( childWidgets ) );
-		this._addClass( this.childWidgets, "ui-controlgroup-item" );
-	},
-
-	_callChildMethod: function( method ) {
-		this.childWidgets.each( function() {
-			var element = $( this ),
-				data = element.data( "ui-controlgroup-data" );
-			if ( data && data[ method ] ) {
-				data[ method ]();
-			}
-		} );
-	},
-
-	_updateCornerClass: function( element, position ) {
-		var remove = "ui-corner-top ui-corner-bottom ui-corner-left ui-corner-right ui-corner-all";
-		var add = this._buildSimpleOptions( position, "label" ).classes.label;
-
-		this._removeClass( element, null, remove );
-		this._addClass( element, null, add );
-	},
-
-	_buildSimpleOptions: function( position, key ) {
-		var direction = this.options.direction === "vertical";
-		var result = {
-			classes: {}
-		};
-		result.classes[ key ] = {
-			"middle": "",
-			"first": "ui-corner-" + ( direction ? "top" : "left" ),
-			"last": "ui-corner-" + ( direction ? "bottom" : "right" ),
-			"only": "ui-corner-all"
-		}[ position ];
-
-		return result;
-	},
-
-	_spinnerOptions: function( position ) {
-		var options = this._buildSimpleOptions( position, "ui-spinner" );
-
-		options.classes[ "ui-spinner-up" ] = "";
-		options.classes[ "ui-spinner-down" ] = "";
-
-		return options;
-	},
-
-	_buttonOptions: function( position ) {
-		return this._buildSimpleOptions( position, "ui-button" );
-	},
-
-	_checkboxradioOptions: function( position ) {
-		return this._buildSimpleOptions( position, "ui-checkboxradio-label" );
-	},
-
-	_selectmenuOptions: function( position ) {
-		var direction = this.options.direction === "vertical";
-		return {
-			width: direction ? "auto" : false,
-			classes: {
-				middle: {
-					"ui-selectmenu-button-open": "",
-					"ui-selectmenu-button-closed": ""
-				},
-				first: {
-					"ui-selectmenu-button-open": "ui-corner-" + ( direction ? "top" : "tl" ),
-					"ui-selectmenu-button-closed": "ui-corner-" + ( direction ? "top" : "left" )
-				},
-				last: {
-					"ui-selectmenu-button-open": direction ? "" : "ui-corner-tr",
-					"ui-selectmenu-button-closed": "ui-corner-" + ( direction ? "bottom" : "right" )
-				},
-				only: {
-					"ui-selectmenu-button-open": "ui-corner-top",
-					"ui-selectmenu-button-closed": "ui-corner-all"
-				}
-
-			}[ position ]
-		};
-	},
-
-	_resolveClassesValues: function( classes, instance ) {
-		var result = {};
-		$.each( classes, function( key ) {
-			var current = instance.options.classes[ key ] || "";
-			current = $.trim( current.replace( controlgroupCornerRegex, "" ) );
-			result[ key ] = ( current + " " + classes[ key ] ).replace( /\s+/g, " " );
-		} );
-		return result;
-	},
-
-	_setOption: function( key, value ) {
-		if ( key === "direction" ) {
-			this._removeClass( "ui-controlgroup-" + this.options.direction );
-		}
-
-		this._super( key, value );
-		if ( key === "disabled" ) {
-			this._callChildMethod( value ? "disable" : "enable" );
-			return;
-		}
-
-		this.refresh();
-	},
-
-	refresh: function() {
-		var children,
-			that = this;
-
-		this._addClass( "ui-controlgroup ui-controlgroup-" + this.options.direction );
-
-		if ( this.options.direction === "horizontal" ) {
-			this._addClass( null, "ui-helper-clearfix" );
-		}
-		this._initWidgets();
-
-		children = this.childWidgets;
-
-		// We filter here because we need to track all childWidgets not just the visible ones
-		if ( this.options.onlyVisible ) {
-			children = children.filter( ":visible" );
-		}
-
-		if ( children.length ) {
-
-			// We do this last because we need to make sure all enhancment is done
-			// before determining first and last
-			$.each( [ "first", "last" ], function( index, value ) {
-				var instance = children[ value ]().data( "ui-controlgroup-data" );
-
-				if ( instance && that[ "_" + instance.widgetName + "Options" ] ) {
-					var options = that[ "_" + instance.widgetName + "Options" ](
-						children.length === 1 ? "only" : value
-					);
-					options.classes = that._resolveClassesValues( options.classes, instance );
-					instance.element[ instance.widgetName ]( options );
-				} else {
-					that._updateCornerClass( children[ value ](), value );
-				}
-			} );
-
-			// Finally call the refresh method on each of the child widgets.
-			this._callChildMethod( "refresh" );
-		}
-	}
-} );
+
+  $.widget( "ui.checkboxradio", [ $.ui.formResetMixin, {
+    version: "1.12.1",
+    options: {
+      disabled: null,
+      label: null,
+      icon: true,
+      classes: {
+        "ui-checkboxradio-label": "ui-corner-all",
+        "ui-checkboxradio-icon": "ui-corner-all"
+      }
+    },
+
+    _getCreateOptions: function() {
+      var disabled, labels;
+      var that = this;
+      var options = this._super() || {};
+
+      // We read the type here, because it makes more sense to throw a element type error first,
+      // rather then the error for lack of a label. Often if its the wrong type, it
+      // won't have a label (e.g. calling on a div, btn, etc)
+      this._readType();
+
+      labels = this.element.labels();
+
+      // If there are multiple labels, use the last one
+      this.label = $( labels[ labels.length - 1 ] );
+      if ( !this.label.length ) {
+        $.error( "No label found for checkboxradio widget" );
+      }
+
+      this.originalLabel = "";
+
+      // We need to get the label text but this may also need to make sure it does not contain the
+      // input itself.
+      this.label.contents().not( this.element[ 0 ] ).each( function() {
+
+        // The label contents could be text, html, or a mix. We concat each element to get a
+        // string representation of the label, without the input as part of it.
+        that.originalLabel += this.nodeType === 3 ? $( this ).text() : this.outerHTML;
+      } );
+
+      // Set the label option if we found label text
+      if ( this.originalLabel ) {
+        options.label = this.originalLabel;
+      }
+
+      disabled = this.element[ 0 ].disabled;
+      if ( disabled != null ) {
+        options.disabled = disabled;
+      }
+      return options;
+    },
+
+    _create: function() {
+      var checked = this.element[ 0 ].checked;
+
+      this._bindFormResetHandler();
+
+      if ( this.options.disabled == null ) {
+        this.options.disabled = this.element[ 0 ].disabled;
+      }
+
+      this._setOption( "disabled", this.options.disabled );
+      this._addClass( "ui-checkboxradio", "ui-helper-hidden-accessible" );
+      this._addClass( this.label, "ui-checkboxradio-label", "ui-button ui-widget" );
+
+      if ( this.type === "radio" ) {
+        this._addClass( this.label, "ui-checkboxradio-radio-label" );
+      }
+
+      if ( this.options.label && this.options.label !== this.originalLabel ) {
+        this._updateLabel();
+      } else if ( this.originalLabel ) {
+        this.options.label = this.originalLabel;
+      }
+
+      this._enhance();
+
+      if ( checked ) {
+        this._addClass( this.label, "ui-checkboxradio-checked", "ui-state-active" );
+        if ( this.icon ) {
+          this._addClass( this.icon, null, "ui-state-hover" );
+        }
+      }
+
+      this._on( {
+        change: "_toggleClasses",
+        focus: function() {
+          this._addClass( this.label, null, "ui-state-focus ui-visual-focus" );
+        },
+        blur: function() {
+          this._removeClass( this.label, null, "ui-state-focus ui-visual-focus" );
+        }
+      } );
+    },
+
+    _readType: function() {
+      var nodeName = this.element[ 0 ].nodeName.toLowerCase();
+      this.type = this.element[ 0 ].type;
+      if ( nodeName !== "input" || !/radio|checkbox/.test( this.type ) ) {
+        $.error( "Can't create checkboxradio on element.nodeName=" + nodeName +
+            " and element.type=" + this.type );
+      }
+    },
+
+    // Support jQuery Mobile enhanced option
+    _enhance: function() {
+      this._updateIcon( this.element[ 0 ].checked );
+    },
+
+    widget: function() {
+      return this.label;
+    },
+
+    _getRadioGroup: function() {
+      var group;
+      var name = this.element[ 0 ].name;
+      var nameSelector = "input[name='" + $.ui.escapeSelector( name ) + "']";
+
+      if ( !name ) {
+        return $( [] );
+      }
+
+      if ( this.form.length ) {
+        group = $( this.form[ 0 ].elements ).filter( nameSelector );
+      } else {
+
+        // Not inside a form, check all inputs that also are not inside a form
+        group = $( nameSelector ).filter( function() {
+          return $( this ).form().length === 0;
+        } );
+      }
+
+      return group.not( this.element );
+    },
+
+    _toggleClasses: function() {
+      var checked = this.element[ 0 ].checked;
+      this._toggleClass( this.label, "ui-checkboxradio-checked", "ui-state-active", checked );
+
+      if ( this.options.icon && this.type === "checkbox" ) {
+        this._toggleClass( this.icon, null, "ui-icon-check ui-state-checked", checked )
+            ._toggleClass( this.icon, null, "ui-icon-blank", !checked );
+      }
+
+      if ( this.type === "radio" ) {
+        this._getRadioGroup()
+            .each( function() {
+              var instance = $( this ).checkboxradio( "instance" );
+
+              if ( instance ) {
+                instance._removeClass( instance.label,
+                    "ui-checkboxradio-checked", "ui-state-active" );
+              }
+            } );
+      }
+    },
+
+    _destroy: function() {
+      this._unbindFormResetHandler();
+
+      if ( this.icon ) {
+        this.icon.remove();
+        this.iconSpace.remove();
+      }
+    },
+
+    _setOption: function( key, value ) {
+
+      // We don't allow the value to be set to nothing
+      if ( key === "label" && !value ) {
+        return;
+      }
+
+      this._super( key, value );
+
+      if ( key === "disabled" ) {
+        this._toggleClass( this.label, null, "ui-state-disabled", value );
+        this.element[ 0 ].disabled = value;
+
+        // Don't refresh when setting disabled
+        return;
+      }
+      this.refresh();
+    },
+
+    _updateIcon: function( checked ) {
+      var toAdd = "ui-icon ui-icon-background ";
+
+      if ( this.options.icon ) {
+        if ( !this.icon ) {
+          this.icon = $( "<span>" );
+          this.iconSpace = $( "<span> </span>" );
+          this._addClass( this.iconSpace, "ui-checkboxradio-icon-space" );
+        }
+
+        if ( this.type === "checkbox" ) {
+          toAdd += checked ? "ui-icon-check ui-state-checked" : "ui-icon-blank";
+          this._removeClass( this.icon, null, checked ? "ui-icon-blank" : "ui-icon-check" );
+        } else {
+          toAdd += "ui-icon-blank";
+        }
+        this._addClass( this.icon, "ui-checkboxradio-icon", toAdd );
+        if ( !checked ) {
+          this._removeClass( this.icon, null, "ui-icon-check ui-state-checked" );
+        }
+        this.icon.prependTo( this.label ).after( this.iconSpace );
+      } else if ( this.icon !== undefined ) {
+        this.icon.remove();
+        this.iconSpace.remove();
+        delete this.icon;
+      }
+    },
+
+    _updateLabel: function() {
+
+      // Remove the contents of the label ( minus the icon, icon space, and input )
+      var contents = this.label.contents().not( this.element[ 0 ] );
+      if ( this.icon ) {
+        contents = contents.not( this.icon[ 0 ] );
+      }
+      if ( this.iconSpace ) {
+        contents = contents.not( this.iconSpace[ 0 ] );
+      }
+      contents.remove();
+
+      this.label.append( this.options.label );
+    },
+
+    refresh: function() {
+      var checked = this.element[ 0 ].checked,
+          isDisabled = this.element[ 0 ].disabled;
+
+      this._updateIcon( checked );
+      this._toggleClass( this.label, "ui-checkboxradio-checked", "ui-state-active", checked );
+      if ( this.options.label !== null ) {
+        this._updateLabel();
+      }
+
+      if ( isDisabled !== this.options.disabled ) {
+        this._setOptions( { "disabled": isDisabled } );
+      }
+    }
+
+  } ] );
+
+  return $.ui.checkboxradio;
+
 } ) );