/**
+ * The NodeList module provides support for managing collections of Nodes.
+ * @module node
+ * @submodule nodelist
+ */
+
+/**
+ * The NodeList class provides a wrapper for manipulating DOM NodeLists.
+ * NodeList properties can be accessed via the set/get methods.
+ * Use Y.all() to retrieve NodeList instances.
+ *
+ * @class NodeList
+ * @constructor
+ */
+
+var NodeList = function(nodes) {
+ if (typeof nodes === 'string') {
+ this._query = nodes;
+ nodes = Y.Selector.query(nodes);
+ } else {
+ nodes = Y.Array(nodes, 0, true);
+ }
+
+ NodeList._instances[Y.stamp(this)] = this;
+ this._nodes = nodes;
+};
+// end "globals"
+
+NodeList.NAME = 'NodeList';
+
+/**
+ * Retrieves the DOM nodes bound to a NodeList instance
+ * @method NodeList.getDOMNodes
+ * @static
+ *
+ * @param {Y.NodeList} node The NodeList instance
+ * @return {Array} The array of DOM nodes bound to the NodeList
+ */
+NodeList.getDOMNodes = function(nodeList) {
+ return nodeList._nodes;
+};
+
+NodeList._instances = [];
+
+NodeList.each = function(instance, fn, context) {
+ var nodes = instance._nodes;
+ if (nodes && nodes.length) {
+ Y.Array.each(nodes, fn, context || instance);
+ } else {
+ Y.log('no nodes bound to ' + this, 'warn', 'NodeList');
+ }
+};
+
+NodeList.addMethod = function(name, fn, context) {
+ if (name && fn) {
+ NodeList.prototype[name] = function() {
+ var ret = [],
+ args = arguments;
+
+ Y.Array.each(this._nodes, function(node) {
+ var UID = '_yuid',
+ instance = Y.Node._instances[node[UID]],
+ ctx,
+ result;
+
+ if (!instance) {
+ instance = NodeList._getTempNode(node);
+ }
+ ctx = context || instance;
+ result = fn.apply(ctx, args);
+ if (result !== undefined && result !== instance) {
+ ret[ret.length] = result;
+ }
+ });
+
+ // TODO: remove tmp pointer
+ return ret.length ? ret : this;
+ };
+ } else {
+ Y.log('unable to add method: ' + name, 'warn', 'Node');
+ }
+};
+
+NodeList.importMethod = function(host, name, altName) {
+ if (typeof name === 'string') {
+ altName = altName || name;
+ NodeList.addMethod(name, host[name]);
+ } else {
+ Y.each(name, function(n) {
+ NodeList.importMethod(host, n);
+ });
+ }
+};
+
+NodeList._getTempNode = function(node) {
+ var tmp = NodeList._tempNode;
+ if (!tmp) {
+ tmp = Y.Node.create('<div></div>');
+ NodeList._tempNode = tmp;
+ }
+
+ tmp._node = node;
+ tmp._stateProxy = node;
+ return tmp;
+};
+
+Y.mix(NodeList.prototype, {
+ /**
+ * Retrieves the Node instance at the given index.
+ * @method item
+ *
+ * @param {Number} index The index of the target Node.
+ * @return {Node} The Node instance at the given index.
+ */
+ item: function(index) {
+ return Y.one((this._nodes || [])[index]);
+ },
+
+ /**
+ * Applies the given function to each Node in the NodeList.
+ * @method each
+ * @param {Function} fn The function to apply. It receives 3 arguments:
+ * the current node instance, the node's index, and the NodeList instance
+ * @param {Object} context optional An optional context to apply the function with
+ * Default context is the current Node instance
+ * @chainable
+ */
+ each: function(fn, context) {
+ var instance = this;
+ Y.Array.each(this._nodes, function(node, index) {
+ node = Y.one(node);
+ return fn.call(context || node, node, index, instance);
+ });
+ return instance;
+ },
+
+ batch: function(fn, context) {
+ var nodelist = this;
+
+ Y.Array.each(this._nodes, function(node, index) {
+ var instance = Y.Node._instances[node[UID]];
+ if (!instance) {
+ instance = NodeList._getTempNode(node);
+ }
+
+ return fn.call(context || instance, instance, index, nodelist);
+ });
+ return nodelist;
+ },
+
+ /**
+ * Executes the function once for each node until a true value is returned.
+ * @method some
+ * @param {Function} fn The function to apply. It receives 3 arguments:
+ * the current node instance, the node's index, and the NodeList instance
+ * @param {Object} context optional An optional context to execute the function from.
+ * Default context is the current Node instance
+ * @return {Boolean} Whether or not the function returned true for any node.
+ */
+ some: function(fn, context) {
+ var instance = this;
+ return Y.Array.some(this._nodes, function(node, index) {
+ node = Y.one(node);
+ context = context || node;
+ return fn.call(context, node, index, instance);
+ });
+ },
+
+ /**
+ * Creates a documenFragment from the nodes bound to the NodeList instance
+ * @method toDocFrag
+ * @return Node a Node instance bound to the documentFragment
+ */
+ toFrag: function() {
+ return Y.one(Y.DOM._nl2frag(this._nodes));
+ },
+
+ /**
+ * Returns the index of the node in the NodeList instance
+ * or -1 if the node isn't found.
+ * @method indexOf
+ * @param {Y.Node || DOMNode} node the node to search for
+ * @return {Int} the index of the node value or -1 if not found
+ */
+ indexOf: function(node) {
+ return Y.Array.indexOf(this._nodes, Y.Node.getDOMNode(node));
+ },
+
+ /**
+ * Filters the NodeList instance down to only nodes matching the given selector.
+ * @method filter
+ * @param {String} selector The selector to filter against
+ * @return {NodeList} NodeList containing the updated collection
+ * @see Selector
+ */
+ filter: function(selector) {
+ return Y.all(Y.Selector.filter(this._nodes, selector));
+ },
+
+
+ /**
+ * Creates a new NodeList containing all nodes at every n indices, where
+ * remainder n % index equals r.
+ * (zero-based index).
+ * @method modulus
+ * @param {Int} n The offset to use (return every nth node)
+ * @param {Int} r An optional remainder to use with the modulus operation (defaults to zero)
+ * @return {NodeList} NodeList containing the updated collection
+ */
+ modulus: function(n, r) {
+ r = r || 0;
+ var nodes = [];
+ NodeList.each(this, function(node, i) {
+ if (i % n === r) {
+ nodes.push(node);
+ }
+ });
+
+ return Y.all(nodes);
+ },
+
+ /**
+ * Creates a new NodeList containing all nodes at odd indices
+ * (zero-based index).
+ * @method odd
+ * @return {NodeList} NodeList containing the updated collection
+ */
+ odd: function() {
+ return this.modulus(2, 1);
+ },
+
+ /**
+ * Creates a new NodeList containing all nodes at even indices
+ * (zero-based index), including zero.
+ * @method even
+ * @return {NodeList} NodeList containing the updated collection
+ */
+ even: function() {
+ return this.modulus(2);
+ },
+
+ destructor: function() {
+ delete NodeList._instances[this[UID]];
+ },
+
+ /**
+ * Reruns the initial query, when created using a selector query
+ * @method refresh
+ * @chainable
+ */
+ refresh: function() {
+ var doc,
+ nodes = this._nodes;
+ if (this._query) {
+ if (nodes && nodes[0] && nodes[0].ownerDocument) {
+ doc = nodes[0].ownerDocument;
+ }
+
+ this._nodes = Y.Selector.query(this._query, doc || Y.config.doc);
+ }
+
+ return this;
+ },
+
+ /**
+ * Applies an event listener to each Node bound to the NodeList.
+ * @method on
+ * @param {String} type The event being listened for
+ * @param {Function} fn The handler to call when the event fires
+ * @param {Object} context The context to call the handler with.
+ * Default is the NodeList instance.
+ * @return {Object} Returns an event handle that can later be use to detach().
+ * @see Event.on
+ */
+ on: function(type, fn, context) {
+ var args = Y.Array(arguments, 0, true);
+ args.splice(2, 0, this._nodes);
+ args[3] = context || this;
+ return Y.on.apply(Y, args);
+ },
+
+ /**
+ * Applies an event listener to each Node bound to the NodeList.
+ * The handler is called only after all on() handlers are called
+ * and the event is not prevented.
+ * @method after
+ * @param {String} type The event being listened for
+ * @param {Function} fn The handler to call when the event fires
+ * @param {Object} context The context to call the handler with.
+ * Default is the NodeList instance.
+ * @return {Object} Returns an event handle that can later be use to detach().
+ * @see Event.on
+ */
+ after: function(type, fn, context) {
+ var args = Y.Array(arguments, 0, true);
+ args.splice(2, 0, this._nodes);
+ args[3] = context || this;
+ return Y.after.apply(Y, args);
+ },
+
+ /**
+ * Returns the current number of items in the NodeList.
+ * @method size
+ * @return {Int} The number of items in the NodeList.
+ */
+ size: function() {
+ return this._nodes.length;
+ },
+
+ toString: function() {
+ var str = '',
+ errorMsg = this[UID] + ': not bound to any nodes',
+ nodes = this._nodes,
+ node;
+
+ if (nodes && nodes[0]) {
+ node = nodes[0];
+ str += node[NODE_NAME];
+ if (node.id) {
+ str += '#' + node.id;
+ }
+
+ if (node.className) {
+ str += '.' + node.className.replace(' ', '.');
+ }
+
+ if (nodes.length > 1) {
+ str += '...[' + nodes.length + ' items]';
+ }
+ }
+ return str || errorMsg;
+ }
+
+}, true);
+
+NodeList.importMethod(Y.Node.prototype, [
+ /**
+ * Called on each Node instance
+ * @for NodeList
+ * @method append
+ * @see Node.append
+ */
+ 'append',
+
+ /**
+ * Called on each Node instance
+ * @method detach
+ * @see Node.detach
+ */
+ 'detach',
+
+ /** Called on each Node instance
+ * @method detachAll
+ * @see Node.detachAll
+ */
+ 'detachAll',
+
+ /** Called on each Node instance
+ * @method insert
+ * @see NodeInsert
+ */
+ 'insert',
+
+ /** Called on each Node instance
+ * @method prepend
+ * @see Node.prepend
+ */
+ 'prepend',
+
+ /** Called on each Node instance
+ * @method remove
+ * @see Node.remove
+ */
+ 'remove',
+
+ /** Called on each Node instance
+ * @method set
+ * @see Node.set
+ */
+ 'set',
+
+ /** Called on each Node instance
+ * @method setContent
+ * @see Node.setContent
+ */
+ 'setContent'
+]);
+
+// one-off implementation to convert array of Nodes to NodeList
+// e.g. Y.all('input').get('parentNode');
+
+/** Called on each Node instance
+ * @method get
+ * @see Node
+ */
+NodeList.prototype.get = function(attr) {
+ var ret = [],
+ nodes = this._nodes,
+ isNodeList = false,
+ getTemp = NodeList._getTempNode,
+ instance,
+ val;
+
+ if (nodes[0]) {
+ instance = Y.Node._instances[nodes[0]._yuid] || getTemp(nodes[0]);
+ val = instance._get(attr);
+ if (val && val.nodeType) {
+ isNodeList = true;
+ }
+ }
+
+ Y.Array.each(nodes, function(node) {
+ instance = Y.Node._instances[node._yuid];
+
+ if (!instance) {
+ instance = getTemp(node);
+ }
+
+ val = instance._get(attr);
+ if (!isNodeList) { // convert array of Nodes to NodeList
+ val = Y.Node.scrubVal(val, instance);
+ }
+
+ ret.push(val);
+ });
+
+ return (isNodeList) ? Y.all(ret) : ret;
+};
+
+Y.NodeList = NodeList;
+
+Y.all = function(nodes) {
+ return new NodeList(nodes);
+};
+
+Y.Node.all = Y.all;
+