/*

YUI 3.10.3 (build 2fb5187)

Copyright 2013 Yahoo! Inc. All rights reserved.

Licensed under the BSD License.

http://yuilibrary.com/license/

*/

YUI.add('dom-base', function (Y, NAME) {

/**

* @for DOM

* @module dom

*/

var documentElement = Y.config.doc.documentElement,

    Y_DOM = Y.DOM,

    TAG_NAME = 'tagName',

    OWNER_DOCUMENT = 'ownerDocument',

    EMPTY_STRING = '',

    addFeature = Y.Features.add,

    testFeature = Y.Features.test;

Y.mix(Y_DOM, {

    /**

     * Returns the text content of the HTMLElement. 

     * @method getText         

     * @param {HTMLElement} element The html element. 

     * @return {String} The text content of the element (includes text of any descending elements).

     */

    getText: (documentElement.textContent !== undefined) ?

        function(element) {

            var ret = '';

            if (element) {

                ret = element.textContent;

            }

            return ret || '';

        } : function(element) {

            var ret = '';

            if (element) {

                ret = element.innerText || element.nodeValue; // might be a textNode

            }

            return ret || '';

        },

    /**

     * Sets the text content of the HTMLElement. 

     * @method setText         

     * @param {HTMLElement} element The html element. 

     * @param {String} content The content to add. 

     */

    setText: (documentElement.textContent !== undefined) ?

        function(element, content) {

            if (element) {

                element.textContent = content;

            }

        } : function(element, content) {

            if ('innerText' in element) {

                element.innerText = content;

            } else if ('nodeValue' in element) {

                element.nodeValue = content;

            }

    },

    CUSTOM_ATTRIBUTES: (!documentElement.hasAttribute) ? { // IE < 8

        'for': 'htmlFor',

        'class': 'className'

    } : { // w3c

        'htmlFor': 'for',

        'className': 'class'

    },

    /**

     * Provides a normalized attribute interface. 

     * @method setAttribute

     * @param {HTMLElement} el The target element for the attribute.

     * @param {String} attr The attribute to set.

     * @param {String} val The value of the attribute.

     */

    setAttribute: function(el, attr, val, ieAttr) {

        if (el && attr && el.setAttribute) {

            attr = Y_DOM.CUSTOM_ATTRIBUTES[attr] || attr;

            el.setAttribute(attr, val, ieAttr);

        }

    },

    /**

     * Provides a normalized attribute interface. 

     * @method getAttribute

     * @param {HTMLElement} el The target element for the attribute.

     * @param {String} attr The attribute to get.

     * @return {String} The current value of the attribute. 

     */

    getAttribute: function(el, attr, ieAttr) {

        ieAttr = (ieAttr !== undefined) ? ieAttr : 2;

        var ret = '';

        if (el && attr && el.getAttribute) {

            attr = Y_DOM.CUSTOM_ATTRIBUTES[attr] || attr;

            ret = el.getAttribute(attr, ieAttr);

            if (ret === null) {

                ret = ''; // per DOM spec

            }

        }

        return ret;

    },

    VALUE_SETTERS: {},

    VALUE_GETTERS: {},

    getValue: function(node) {

        var ret = '', // TODO: return null?

            getter;

        if (node && node[TAG_NAME]) {

            getter = Y_DOM.VALUE_GETTERS[node[TAG_NAME].toLowerCase()];

            if (getter) {

                ret = getter(node);

            } else {

                ret = node.value;

            }

        }

        // workaround for IE8 JSON stringify bug

        // which converts empty string values to null

        if (ret === EMPTY_STRING) {

            ret = EMPTY_STRING; // for real

        }

        return (typeof ret === 'string') ? ret : '';

    },

    setValue: function(node, val) {

        var setter;

        if (node && node[TAG_NAME]) {

            setter = Y_DOM.VALUE_SETTERS[node[TAG_NAME].toLowerCase()];

            if (setter) {

                setter(node, val);

            } else {

                node.value = val;

            }

        }

    },

    creators: {}

});

addFeature('value-set', 'select', {

    test: function() {

        var node = Y.config.doc.createElement('select');

        node.innerHTML = '<option>1</option><option>2</option>';

        node.value = '2';

        return (node.value && node.value === '2');

    }

});

if (!testFeature('value-set', 'select')) {

    Y_DOM.VALUE_SETTERS.select = function(node, val) {

        for (var i = 0, options = node.getElementsByTagName('option'), option;

                option = options[i++];) {

            if (Y_DOM.getValue(option) === val) {

                option.selected = true;

                //Y_DOM.setAttribute(option, 'selected', 'selected');

                break;

            }

        }

    };

}

Y.mix(Y_DOM.VALUE_GETTERS, {

    button: function(node) {

        return (node.attributes && node.attributes.value) ? node.attributes.value.value : '';

    }

});

Y.mix(Y_DOM.VALUE_SETTERS, {

    // IE: node.value changes the button text, which should be handled via innerHTML

    button: function(node, val) {

        var attr = node.attributes.value;

        if (!attr) {

            attr = node[OWNER_DOCUMENT].createAttribute('value');

            node.setAttributeNode(attr);

        }

        attr.value = val;

    }

});

Y.mix(Y_DOM.VALUE_GETTERS, {

    option: function(node) {

        var attrs = node.attributes;

        return (attrs.value && attrs.value.specified) ? node.value : node.text;

    },

    select: function(node) {

        var val = node.value,

            options = node.options;

        if (options && options.length) {

            // TODO: implement multipe select

            if (node.multiple) {

            } else if (node.selectedIndex > -1) {

                val = Y_DOM.getValue(options[node.selectedIndex]);

            }

        }

        return val;

    }

});

var addClass, hasClass, removeClass;

Y.mix(Y.DOM, {

    /**

     * Determines whether a DOM element has the given className.

     * @method hasClass

     * @for DOM

     * @param {HTMLElement} element The DOM element. 

     * @param {String} className the class name to search for

     * @return {Boolean} Whether or not the element has the given class. 

     */

    hasClass: function(node, className) {

        var re = Y.DOM._getRegExp('(?:^|\\s+)' + className + '(?:\\s+|$)');

        return re.test(node.className);

    },

    /**

     * Adds a class name to a given DOM element.

     * @method addClass         

     * @for DOM

     * @param {HTMLElement} element The DOM element. 

     * @param {String} className the class name to add to the class attribute

     */

    addClass: function(node, className) {

        if (!Y.DOM.hasClass(node, className)) { // skip if already present 

            node.className = Y.Lang.trim([node.className, className].join(' '));

        }

    },

    /**

     * Removes a class name from a given element.

     * @method removeClass         

     * @for DOM

     * @param {HTMLElement} element The DOM element. 

     * @param {String} className the class name to remove from the class attribute

     */

    removeClass: function(node, className) {

        if (className && hasClass(node, className)) {

            node.className = Y.Lang.trim(node.className.replace(Y.DOM._getRegExp('(?:^|\\s+)' +

                            className + '(?:\\s+|$)'), ' '));

            if ( hasClass(node, className) ) { // in case of multiple adjacent

                removeClass(node, className);

            }

        }                 

    },

    /**

     * Replace a class with another class for a given element.

     * If no oldClassName is present, the newClassName is simply added.

     * @method replaceClass  

     * @for DOM

     * @param {HTMLElement} element The DOM element 

     * @param {String} oldClassName the class name to be replaced

     * @param {String} newClassName the class name that will be replacing the old class name

     */

    replaceClass: function(node, oldC, newC) {

        removeClass(node, oldC); // remove first in case oldC === newC

        addClass(node, newC);

    },

    /**

     * If the className exists on the node it is removed, if it doesn't exist it is added.

     * @method toggleClass  

     * @for DOM

     * @param {HTMLElement} element The DOM element

     * @param {String} className the class name to be toggled

     * @param {Boolean} addClass optional boolean to indicate whether class

     * should be added or removed regardless of current state

     */

    toggleClass: function(node, className, force) {

        var add = (force !== undefined) ? force :

                !(hasClass(node, className));

        if (add) {

            addClass(node, className);

        } else {

            removeClass(node, className);

        }

    }

});

hasClass = Y.DOM.hasClass;

removeClass = Y.DOM.removeClass;

addClass = Y.DOM.addClass;

var re_tag = /<([a-z]+)/i,

    Y_DOM = Y.DOM,

    addFeature = Y.Features.add,

    testFeature = Y.Features.test,

    creators = {},

    createFromDIV = function(html, tag) {

        var div = Y.config.doc.createElement('div'),

            ret = true;

        div.innerHTML = html;

        if (!div.firstChild || div.firstChild.tagName !== tag.toUpperCase()) {

            ret = false;

        }

        return ret;

    },

    re_tbody = /(?:\/(?:thead|tfoot|tbody|caption|col|colgroup)>)+\s*<tbody/,

    TABLE_OPEN = '<table>',

    TABLE_CLOSE = '</table>';

Y.mix(Y.DOM, {

    _fragClones: {},

    _create: function(html, doc, tag) {

        tag = tag || 'div';

        var frag = Y_DOM._fragClones[tag];

        if (frag) {

            frag = frag.cloneNode(false);

        } else {

            frag = Y_DOM._fragClones[tag] = doc.createElement(tag);

        }

        frag.innerHTML = html;

        return frag;

    },

    _children: function(node, tag) {

            var i = 0,

            children = node.children,

            childNodes,

            hasComments,

            child;

        if (children && children.tags) { // use tags filter when possible

            if (tag) {

                children = node.children.tags(tag);

            } else { // IE leaks comments into children

                hasComments = children.tags('!').length;

            }

        }

        if (!children || (!children.tags && tag) || hasComments) {

            childNodes = children || node.childNodes;

            children = [];

            while ((child = childNodes[i++])) {

                if (child.nodeType === 1) {

                    if (!tag || tag === child.tagName) {

                        children.push(child);

                    }

                }

            }

        }

        return children || [];

    },

    /**

     * Creates a new dom node using the provided markup string. 

     * @method create

     * @param {String} html The markup used to create the element

     * @param {HTMLDocument} doc An optional document context 

     * @return {HTMLElement|DocumentFragment} returns a single HTMLElement 

     * when creating one node, and a documentFragment when creating

     * multiple nodes.