/**
                            * A Button Plugin
                            *
                            * @module button-plugin
                            * @since 3.5.0
                            */
                            
                            /**
                            * @class Button
                            * @param config {Object} Configuration object
                            * @extends ButtonCore
                            * @constructor
                            * @namespace Plugin
                            */
                            function ButtonPlugin() {
                                ButtonPlugin.superclass.constructor.apply(this, arguments);
                            }
                            
                            Y.extend(ButtonPlugin, Y.ButtonCore, {
                            
                                /**
                                * @method _afterNodeGet
                                * @param name {string}
                                * @private
                                */
                                _afterNodeGet: function (name) {
                                    // TODO: point to method (_uiSetLabel, etc) instead of getter/setter
                                    var ATTRS = this.constructor.ATTRS,
                                        fn = ATTRS[name] && ATTRS[name].getter && this[ATTRS[name].getter];
                            
                                    if (fn) {
                                        return new Y.Do.AlterReturn('get ' + name, fn.call(this));
                                    }
                                },
                            
                                /**
                                * @method _afterNodeSet
                                * @param name {String}
                                * @param val {String}
                                * @private
                                */
                                _afterNodeSet: function (name, val) {
                                    var ATTRS = this.constructor.ATTRS,
                                        fn = ATTRS[name] && ATTRS[name].setter && this[ATTRS[name].setter];
                            
                                    if (fn) {
                                        fn.call(this, val);
                                    }
                                },
                            
                                /**
                                * @method _initNode
                                * @param config {Object}
                                * @private
                                */
                                _initNode: function(config) {
                                    var node = config.host;
                                    this._host = node;
                            
                                    Y.Do.after(this._afterNodeGet, node, 'get', this);
                                    Y.Do.after(this._afterNodeSet, node, 'set', this);
                                },
                            
                                /**
                                * @method destroy
                                * @private
                                */
                                destroy: function(){
                                    // Nothing to do, but things are happier with it here
                                }
                            
                            }, {
                            
                                /**
                                * Attribute configuration.
                                *
                                * @property ATTRS
                                * @type {Object}
                                * @private
                                * @static
                                */
                                ATTRS: Y.merge(Y.ButtonCore.ATTRS),
                            
                                /**
                                * Name of this component.
                                *
                                * @property NAME
                                * @type String
                                * @static
                                */
                                NAME: 'buttonPlugin',
                            
                                /**
                                * Namespace of this component.
                                *
                                * @property NS
                                * @type String
                                * @static
                                */
                                NS: 'button'
                            
                            });
                            
                            /**
                            * @method createNode
                            * @description A factory that plugs a Y.Node instance with Y.Plugin.Button
                            * @param node {Object}
                            * @param config {Object}
                            * @return {Object} A plugged Y.Node instance
                            * @public
                            */
                            ButtonPlugin.createNode = function(node, config) {
                                var template;
                            
                                if (node && !config) {
                                    if (! (node.nodeType || node.getDOMNode || typeof node === 'string')) {
                                        config = node;
                                        node = config.srcNode;
                                    }
                                }
                            
                                config   = config || {};
                                template = config.template || Y.Plugin.Button.prototype.TEMPLATE;
                                node     = node || config.srcNode || Y.DOM.create(template);
                            
                                return Y.one(node).plug(Y.Plugin.Button, config);
                            };
                            
                            Y.namespace('Plugin').Button = ButtonPlugin;