// SpryXML.js - version 0.4 - Spry Pre-Release 1.6
//
// Copyright (c) 2006. Adobe Systems Incorporated.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//   * Redistributions of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//   * Redistributions in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//   * Neither the name of Adobe Systems Incorporated nor the names of its
//     contributors may be used to endorse or promote products derived from this
//     software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.

var Spry; if (!Spry) Spry = {}; if (!Spry.XML) Spry.XML = {}; if (!Spry.XML.Schema) Spry.XML.Schema = {};

Spry.XML.Schema.Node = function(nodeName)
{
	this.nodeName = nodeName;
	this.isAttribute = false;
	this.appearsMoreThanOnce = false;
	this.children = new Array;
};

Spry.XML.Schema.Node.prototype.toString = function (indentStr)
{
	if (!indentStr)
		indentStr = "";

	var str = indentStr + this.nodeName;

	if (this.appearsMoreThanOnce)
		str += " (+)";

	str += "\n";

	var newIndentStr = indentStr + "    ";

	for (var $childName in this.children)
	{
		var child = this.children[$childName];
		if (child.isAttribute)
			str += newIndentStr + child.nodeName + "\n";
		else
			str += child.toString(newIndentStr);
	}

	return str;
};

Spry.XML.Schema.mapElementIntoSchemaNode = function(ele, schemaNode)
{
	if (!ele || !schemaNode)
		return;

	// Add all attributes as children to schemaNode!

	var i = 0;
	for (i = 0; i < ele.attributes.length; i++)
	{
		var attr = ele.attributes.item(i);
		if (attr && attr.nodeType == 2 /* Node.ATTRIBUTE_NODE */)
		{
			var attrName = "@" + attr.name;

			// We don't track the number of times an attribute appears
			// in a given element so we only handle the case where the
			// attribute doesn't already exist in the schemaNode.children array.

			if (!schemaNode.children[attrName])
			{
				var attrObj = new Spry.XML.Schema.Node(attrName);
				attrObj.isAttribute = true;
				schemaNode.children[attrName] = attrObj;
			}
		}
	}

	// Now add all of element's element children as children of schemaNode!

	var child = ele.firstChild;
	var namesSeenSoFar = new Array;
  
	while (child)
	{
		if (child.nodeType == 1 /* Node.ELEMENT_NODE */)
		{
			var childSchemaNode = schemaNode.children[child.nodeName];

			if (!childSchemaNode)
			{
				childSchemaNode = new Spry.XML.Schema.Node(child.nodeName);
				if (childSchemaNode)
					schemaNode.children[child.nodeName] = childSchemaNode;
			}

			if (childSchemaNode)
			{
				if (namesSeenSoFar[childSchemaNode.nodeName])
					childSchemaNode.appearsMoreThanOnce = true;
				else
					namesSeenSoFar[childSchemaNode.nodeName] = true;
			}

			Spry.XML.Schema.mapElementIntoSchemaNode(child, childSchemaNode);
		}

		child = child.nextSibling;
	} 
};

Spry.XML.getSchemaForElement = function(ele)
{
	if (!ele)
		return null;

	schemaNode = new Spry.XML.Schema.Node(ele.nodeName);
	Spry.XML.Schema.mapElementIntoSchemaNode(ele, schemaNode);

	return schemaNode;
};

Spry.XML.getSchema = function(xmlDoc)
{
	if (!xmlDoc)
		return null;

	// Find the first element in the document that doesn't start with "xml".
	// According to the XML spec tags with names that start with "xml" are reserved
	// for future use.

	var node = xmlDoc.firstChild;

	while (node)
	{
		if (node.nodeType == 1 /* Node.ELEMENT_NODE */)
			break;

		node = node.nextSibling;
	}

	return Spry.XML.getSchemaForElement(node);
};

Spry.XML.nodeHasValue = function(node)
{
	if (node)
	{
		var child = node.firstChild;
		if (child && child.nextSibling == null && (child.nodeType == 3 /* Node.TEXT_NODE */ || child.nodeType == 4 /* CDATA_SECTION_NODE */))
			return true;
	}
	return false;
};

Spry.XML.XObject = function()
{
};

Spry.XML.XObject.prototype._value = function()
{
	var val = this["#text"];
	if (val != undefined)
		return val;
	return this["#cdata-section"];
};

Spry.XML.XObject.prototype._hasValue = function()
{
	return this._value() != undefined;
};

Spry.XML.XObject.prototype._valueIsText = function()
{
	return this["#text"] != undefined;
};

Spry.XML.XObject.prototype._valueIsCData = function()
{
	return this["#cdata-section"] != undefined;
};

Spry.XML.XObject.prototype._propertyIsArray = function(prop)
{
	var val = this[prop];
	if (val == undefined)
		return false;
	return (typeof val == "object" && val.constructor == Array);
};

Spry.XML.XObject.prototype._getPropertyAsArray = function(prop)
{
	var arr = [];
	var val = this[prop];
	if (val != undefined)
	{
		if (typeof val == "object" && val.constructor == Array)
			return val;
		arr.push(val);
	}
	return arr;
};

Spry.XML.XObject.prototype._getProperties = function()
{
	var props = [];
	for (var p in this)
	{
		if (!/^_/.test(p))
			props.push(p);
	}
	return props;
};

Spry.XML.nodeToObject = function(node)
{
	if (!node)
		return null;

	var obj = new Spry.XML.XObject();

	// Add all attributes as properties of the object.

	for (var i = 0; i < node.attributes.length; i++)
	{
		var attr = node.attributes[i];
		var attrName = "@" + attr.name;
		obj[attrName] = attr.value;
	}

	var child;

	if (Spry.XML.nodeHasValue(node))
	{	
		try
		{
			child = node.firstChild;

			if (child.nodeType == 3 /* TEXT_NODE */)
				obj[child.nodeName] = Spry.Utils.encodeEntities(child.data);
			else if (child.nodeType == 4 /* CDATA_SECTION_NODE */)
				obj[child.nodeName] = child.data;
		} catch (e) { Spry.Debug.reportError("Spry.XML.nodeToObject() exception caught: " + e + "\n"); }
	}
	else
	{
		// The node has no value, so run through any element children
		// it may have and add them as properties.

		child = node.firstChild;
		while (child)
		{
			if (child.nodeType == 1 /* Node.ELEMENT_NODE */)
			{
				var isArray = false;
				var tagName = child.nodeName;
				if (obj[tagName])
				{
					if (obj[tagName].constructor != Array)
					{
						var curValue = obj[tagName];
						obj[tagName] = new Array;
						obj[tagName].push(curValue);
					}
					isArray = true;
				}

				var childObj = Spry.XML.nodeToObject(child);
				
				if (isArray)
					obj[tagName].push(childObj);
				else
					obj[tagName] = childObj;
			}
			child = child.nextSibling;
		}
	}
	return obj;
};

// Spry.XML.documentToObject - Utility method for creating a
// JavaScript object with properties and nested objects that
// mirror an XML document tree structure.
//
// Sample XML:
//
//		<employees>
//			<employee id="1000">
//				<name>John Doe</name>
//			</employee>
//			<employee id="2000">
//				<name><![CDATA[Jane Smith]]></name>
//			</employee>
//		</employees>
//
// Object returned by documentToObject():
//
//		{
//			employees:
//				{
//					employee:
//						[
//							{
//								@id: "1000",
//								name: { "#text": "John Doe" }
//							},
//							{
//								@id: "2000",
//								name: { "#cdata-section": "Jane Smith" }
//							}
//						]
//				}
//		}

Spry.XML.documentToObject = function(xmlDoc)
{
	var obj = null;
	if (xmlDoc && xmlDoc.firstChild)
	{
		var child = xmlDoc.firstChild;
		while (child)
		{
			if (child.nodeType == 1 /* Node.ELEMENT_NODE */)
			{
				obj = new Spry.XML.XObject();
				obj[child.nodeName] = Spry.XML.nodeToObject(child);
				break;
			}
			child = child.nextSibling;
		}
	}
	return obj;
};
