<?php
/**
 * @package     Joomla.Platform
 * @subpackage  Utilities
 *
 * @copyright   Copyright (C) 2005 - 2014 Open Source Matters, Inc. All rights reserved.
 * @license     GNU General Public License version 2 or later; see LICENSE
 */

defined('JPATH_PLATFORM') or die;

/**
 * SimpleXML implementation.
 *
 * The XML Parser extension (expat) is required to use JSimpleXML.
 *
 * The class provides a pure PHP4 implementation of the PHP5
 * interface SimpleXML. As with PHP5's SimpleXML it is what it says:
 * simple. Nevertheless, it is an easy way to deal with XML data,
 * especially for read only access.
 *
 * Because it's not possible to use the PHP5 ArrayIterator interface
 * with PHP4 there are some differences between this implementation
 * and that of PHP5:
 *
 * 		The access to the root node has to be explicit in
 * 		JSimpleXML, not implicit as with PHP5. Write
 * 		$xml->document->node instead of $xml->node
 * 		You cannot access CDATA using array syntax. Use the method data() instead
 * 		You cannot access attributes directly with array syntax. Use attributes()
 * 		to read them.
 * 		Comments are ignored.
 * 		Last and least, this is not as fast as PHP5 SimpleXML--it is pure PHP4.
 *
 * Example:
 * <code>
 * :simple.xml:
 * <?xml version="1.0" encoding="utf-8" standalone="yes"?>
 * <document>
 *   <node>
 *	<child gender="m">Tom Foo</child>
 *	<child gender="f">Tamara Bar</child>
 *   <node>
 * </document>
 *
 * ---
 *
 * // read and write a document
 * $xml = new JSimpleXML;
 * $xml->loadFile('simple.xml');
 * print $xml->document->toString();
 *
 * // access a given node's CDATA
 * print $xml->root->node->child[0]->data(); // Tom Foo
 *
 * // access attributes
 * $attr = $xml->root->node->child[1]->attributes();
 * print $attr['gender']; // f
 *
 * // access children
 * foreach($xml->root->node->children() as $child) {
 *   print $child->data();
 * }
 * </code>
 *
 * Note: JSimpleXML cannot be used to access sophisticated XML doctypes
 * using datatype ANY (e.g. XHTML). With a DOM implementation you can
 * handle this.
 *
 * @package     Joomla.Platform
 * @subpackage  Utilities
 * @see         http://www.php.net/manual/en/book.simplexml.php
 * @since       11.1
 * @deprecated  12.1  Use SimpleXML instead
 */
class JSimpleXML extends JObject
{
	/**
	 * The XML parser
	 *
	 * @var     resource
	 * @since   11.1
	 */
	private $_parser = null;

	/**
	 * Document element
	 *
	 * @var     object
	 * @since   11.1
	 */
	public $document = null;

	/**
	 * Current object depth
	 *
	 * @var      array
	 * @since   11.1
	 */
	private $_stack = array();

	/**
	 * Constructor.
	 *
	 * @param   array  $options  Options
	 *
	 * @deprecated    12.1   Use SimpleXML instead.
	 * @see           http://www.php.net/manual/en/book.simplexml.php
	 * @since    11.1
	 */
	public function __construct($options = null)
	{
		// Deprecation warning.
		JLog::add('JSimpleXML::__construct() is deprecated.', JLog::WARNING, 'deprecated');

		if (! function_exists('xml_parser_create'))
		{
			// TODO throw warning
			return false;
		}

		// Create the parser resource and make sure both versions of PHP autodetect the format.
		$this->_parser = xml_parser_create('');

		// Check parser resource
		xml_set_object($this->_parser, $this);
		xml_parser_set_option($this->_parser, XML_OPTION_CASE_FOLDING, 0);
		if (is_array($options))
		{
			foreach ($options as $option => $value)
			{
				xml_parser_set_option($this->_parser, $option, $value);
			}
		}

		// Set the handlers
		xml_set_element_handler($this->_parser, '_startElement', '_endElement');
		xml_set_character_data_handler($this->_parser, '_characterData');
	}

	/**
	 * Interprets a string of XML into an object
	 *
	 * This function will take the well-formed XML string data and return an object of class
	 * JSimpleXMLElement with properties containing the data held within the XML document.
	 * If any errors occur, it returns FALSE.
	 *
	 * @param   string  $string     Well-formed XML string data
	 * @param   string  $classname  currently ignored
	 *
	 * @return  object  JSimpleXMLElement
	 *
	 * @since   11.1
	 *
	 * @deprecated    12.1  Use simpleXML_load_string
	 * @see           http://www.php.net/manual/en/function.simplexml-load-string.php
	 */
	public function loadString($string, $classname = null)
	{
		// Deprecation warning.
		JLog::add('JSimpleXML::loadString() is deprecated.', JLog::WARNING, 'deprecated');

		$this->_parse($string);

		return true;
	}

	/**
	 * Interprets an XML file into an object
	 *
	 * This function will convert the well-formed XML document in the file specified by filename
	 * to an object  of class JSimpleXMLElement. If any errors occur during file access or
	 * interpretation, the function returns FALSE.
	 *
	 * @param   string  $path       Path to XML file containing a well-formed XML document
	 * @param   string  $classname  currently ignored
	 *
	 * @return  boolean  True if successful, false if file empty
	 *
	 * @deprecated     12.1  Use simplexml_load_file instead
	 * @see            http://www.php.net/manual/en/function.simplexml-load-file.php
	 * @since   11.1
	 */
	public function loadFile($path, $classname = null)
	{
		// Deprecation warning.
		JLog::add('JSimpleXML::loadfile() is deprecated.', JLog::WARNING, 'deprecated');

		//Check to see of the path exists
		if (!file_exists($path))
		{

			return false;
		}

		//Get the XML document loaded into a variable
		$xml = trim(file_get_contents($path));
		if ($xml == '')
		{
			return false;
		}
		else
		{
			$this->_parse($xml);

			return true;
		}
	}

	/**
	 * Get a JSimpleXMLElement object from a DOM node.
	 *
	 * This function takes a node of a DOM  document and makes it into a JSimpleXML node.
	 * This new object can then be used as a native JSimpleXML element. If any errors occur,
	 * it returns FALSE.
	 *
	 * @param   string  $node       DOM  document
	 * @param   string  $classname  currently ignored
	 *
	 * @return  mixed  JSimpleXMLElement or false if any errors occur
	 *
	 * @deprecated    12.1    use simplexml_import_dom instead.
	 * @see           http://www.php.net/manual/en/function.simplexml-import-dom.php
	 * @since   11.1
	 */
	public function importDOM($node, $classname = null)
	{
		// Deprecation warning.
		JLog::add('JSimpleXML::importDOM() is deprecated.', JLog::WARNING, 'deprecated');

		return false;
	}

	/**
	 * Get the parser
	 *
	 * @return  resource  XML parser resource handle
	 *
	 * @deprecated    12.1   Use SimpleXMLElement
	 * @see           http://www.php.net/manual/en/class.simplexmlelement.php
	 * @since   11.1
	 */
	public function getParser()
	{
		// Deprecation warning.
		JLog::add('JSimpleXML::getParser() is deprecated.', JLog::WARNING, 'deprecated');

		return $this->_parser;
	}

	/**
	 * Set the parser
	 *
	 * @param   resource  $parser  XML parser resource handle.
	 *
	 * @return  void
	 *
	 * @deprecated    12.1  Use SimpleXML
	 * @see     http://www.php.net/manual/en/class.simplexml.php
	 * @since   11.1
	 */
	public function setParser($parser)
	{
		// Deprecation warning.
		JLog::add('JSimpleXML::setParser() is deprecated.', JLog::WARNING, 'deprecated');

		$this->_parser = $parser;
	}

	/**
	 * Start parsing an XML document
	 *
	 * Parses an XML document. The handlers for the configured events are called as many times as necessary.
	 *
	 * @param   string  $data  data to parse
	 *
	 * @return  void
	 *
	 * @deprecated    12.1
	 * @see     http://www.php.net/manual/en/class.simplexml.php
	 * @since   11.1
	 */
	protected function _parse($data = '')
	{
		// Deprecation warning.
		JLog::add('JSimpleXML::_parse() is deprecated.', JLog::WARNING, 'deprecated');

		//Error handling
		if (!xml_parse($this->_parser, $data))
		{
			$this->_handleError(
				xml_get_error_code($this->_parser), xml_get_current_line_number($this->_parser),
				xml_get_current_column_number($this->_parser)
			);
		}

		//Free the parser
		xml_parser_free($this->_parser);
	}

	/**
	 * Handles an XML parsing error
	 *
	 * @param   integer  $code  XML Error Code.
	 * @param   integer  $line  Line on which the error happened.
	 * @param   integer  $col   Column on which the error happened.
	 *
	 * @return  void
	 *
	 * @deprecated  12.1
	 * @since   11.1
	 *
	 * @deprecated   12.1   Use PHP Exception
	 */
	protected function _handleError($code, $line, $col)
	{
		// Deprecation warning.
		JLog::add('JSimpleXML::_handleError() is deprecated.', JLog::WARNING, 'deprecated');

		JError::raiseWarning('SOME_ERROR_CODE', 'XML Parsing Error at ' . $line . ':' . $col . '. Error ' . $code . ': ' . xml_error_string($code));

	}

	/**
	 * Gets the reference to the current direct parent
	 *
	 * @return  object
	 *
	 * @since   11.1
	 *
	 * @deprecated   12.1
	 */
	protected function _getStackLocation()
	{
		// Deprecation warning.
		JLog::add('JSimpleXML::_getStackLocation() is deprecated.', JLog::WARNING, 'deprecated');

		$return = '';
		foreach ($this->_stack as $stack)
		{
			$return .= $stack . '->';
		}

		return rtrim($return, '->');
	}

	/**
	 * Handler function for the start of a tag
	 *
	 * @param   resource  $parser  The XML parser.
	 * @param   string    $name    The name of the element.
	 * @param   array     $attrs   A key-value array (optional) of the attributes for the element.
	 *
	 * @return  void
	 *
	 * @since   11.1
	 *
	 * @deprecated  12.1
	 */
	protected function _startElement($parser, $name, $attrs = array())
	{
		// Deprecation warning.
		JLog::add('JSimpleXML::startElement() is deprecated.', JLog::WARNING, 'deprecated');

		//  Check to see if tag is root-level
		$count = count($this->_stack);
		if ($count == 0)
		{
			// If so, set the document as the current tag
			$classname = get_class($this) . 'Element';
			$this->document = new $classname($name, $attrs);

			// And start out the stack with the document tag
			$this->_stack = array('document');
		}
		// If it isn't root level, use the stack to find the parent
		else
		{
			// Get the name which points to the current direct parent, relative to $this
			$parent = $this->_getStackLocation();

			// Add the child
			eval('$this->' . $parent . '->addChild($name, $attrs, ' . $count . ');');

			// Update the stack
			eval('$this->_stack[] = $name.\'[\'.(count($this->' . $parent . '->' . $name . ') - 1).\']\';');
		}
	}

	/**
	 * Handler function for the end of a tag
	 *
	 * @param   resource  $parser  The XML parser.
	 * @param   string    $name    The name of the element.
	 *
	 * @return  void
	 *
	 * @deprecated  12.1
	 * @since   11.1
	 */
	protected function _endElement($parser, $name)
	{
		// Deprecation warning.
		JLog::add('JSimpleXML::endElement() is deprecated.', JLog::WARNING, 'deprecated');

		//Update stack by removing the end value from it as the parent
		array_pop($this->_stack);
	}

	/**
	 * Handler function for the character data within a tag
	 *
	 * @param   resource  $parser  The XML parser.
	 * @param   string    $data    The CDATA for the element.
	 *
	 * @return  void
	 *
	 * @deprecated  12.1
	 * @since   11.1
	 */
	protected function _characterData($parser, $data)
	{
		// Deprecation warning.
		JLog::add('JSimpleXML::_characterData() is deprecated.', JLog::WARNING, 'deprecated');

		// Get the reference to the current parent object
		$tag = $this->_getStackLocation();

		// Assign data to it
		eval('$this->' . $tag . '->_data .= $data;');
	}
}

/**
 * SimpleXML Element
 *
 * This object stores all of the direct children of itself in the $children array.
 * They are also stored by type as arrays. So, if, for example, this tag had 2 <font>
 * tags as children, there would be a class member called $font created as an array.
 * $font[0] would be the first font tag, and $font[1] would be the second.
 *
 * To loop through all of the direct children of this object, the $children member
 *  should be used.
 *
 * To loop through all of the direct children of a specific tag for this object, it
 * is probably easier to use the arrays of the specific tag names, as explained above.
 *
 * @package     Joomla.Platform
 * @subpackage  Utilities
 * @see         http://www.php.net/manual/en/class.simplexmlelement.php
 * @since       11.1
 * @deprecated  12.1   Use SimpleXMLElement instead
 */
class JSimpleXMLElement extends JObject
{
	/**
	 * Array with the attributes of this XML element
	 *
	 * @var array
	 * @since   11.1
	 */
	public $_attributes = array();

	/**
	 * The name of the element
	 *
	 * @var     string
	 * @since   11.1
	 */
	public $_name = '';

	/**
	 * The data the element contains
	 *
	 * @var     string
	 * @since   11.1
	 */
	public $_data = '';

	/**
	 * Array of references to the objects of all direct children of this XML object
	 *
	 * @var     array
	 * @since   11.1
	 */
	public $_children = array();

	/**
	 * The level of this XML element
	 *
	 * @var     int
	 * @since   11.1
	 */
	public $_level = 0;

	/**
	 * Constructor, sets up all the default values
	 *
	 * @param   string   $name   The name of the element.
	 * @param   array    $attrs  A key-value array (optional) of the attributes for the element.
	 * @param   integer  $level  The level (optional) of the element.
	 *
	 * @deprecated  12.1 Use SimpleXMLElement
	 * @since   11.1
	 */
	public function __construct($name, $attrs = array(), $level = 0)
	{
		// Deprecation warning.
		JLog::add('JSimpleXMLElement::__construct() is deprecated.', JLog::WARNING, 'deprecated');

		//Make the keys of the attr array lower case, and store the value
		$this->_attributes = array_change_key_case($attrs, CASE_LOWER);

		//Make the name lower case and store the value
		$this->_name = strtolower($name);

		//Set the level
		$this->_level = $level;
	}

	/**
	 * Get the name of the element
	 *
	 * @return  string
	 *
	 * @deprecated   12.1
	 * @since   11.1
	 */

	public function name()
	{
		// Deprecation warning.
		JLog::add('JSimpleXMLElement::name() is deprecated.', JLog::WARNING, 'deprecated');

		return $this->_name;
	}

	/**
	 * Get the an attribute of the element
	 *
	 * @param   string  $attribute  The name of the attribute
	 *
	 * @return  mixed   If an attribute is given will return the attribute if it exist.
	 *                  If no attribute is given will return the complete attributes array
	 *
	 * @deprecated  12.1
	 * @since   11.1
	 */
	public function attributes($attribute = null)
	{
		// Deprecation warning.
		JLog::add('JSimpleXMLElement::attributes() is deprecated.', JLog::WARNING, 'deprecated');

		if (!isset($attribute))
		{
			return $this->_attributes;
		}

		return isset($this->_attributes[$attribute]) ? $this->_attributes[$attribute] : null;
	}

	/**
	 * Get the data of the element
	 *
	 * @return  string
	 *
	 * @deprecated   12.1  Use SimpleXMLElement
	 * @since   11.1
	 */

	public function data()
	{
		// Deprecation warning.
		JLog::add('JSimpleXMLElement::data() is deprecated.', JLog::WARNING, 'deprecated');

		return $this->_data;
	}

	/**
	 * Set the data of the element
	 *
	 * @param   string  $data  The CDATA for the element.
	 *
	 * @return  string
	 *
	 * @deprecated  12.1  Use SimpleXMLElement
	 * @since   11.1
	 */

	public function setData($data)
	{
		// Deprecation warning.
		JLog::add('JSimpleXMLElement::data() is deprecated.', JLog::WARNING, 'deprecated');

		$this->_data = $data;
	}

	/**
	 * Get the children of the element
	 *
	 * @return  array
	 *
	 * @deprecated   12.1
	 * @since   11.1
	 */

	public function children()
	{
		// Deprecation warning.
		JLog::add('JSimpleXMLElement::children() is deprecated.', JLog::WARNING, 'deprecated');

		return $this->_children;
	}

	/**
	 * Get the level of the element
	 *
	 * @return       integer
	 *
	 * @since   11.1
	 * @deprecated   12.1
	 */
	public function level()
	{
		// Deprecation warning.
		JLog::add('JSimpleXMLElement::level() is deprecated.', JLog::WARNING, 'deprecated');

		return $this->_level;
	}

	/**
	 * Adds an attribute to the element
	 *
	 * @param   string  $name   The key
	 * @param   array   $value  The value for the key
	 *
	 * @return  void
	 *
	 * @deprecated  12.1
	 * @since   11.1
	 */
	public function addAttribute($name, $value)
	{
		// Deprecation warning.
		JLog::add('JSimpleXMLElement::addAttribute() is deprecated.', JLog::WARNING, 'deprecated');

		// Add the attribute to the element, override if it already exists
		$this->_attributes[$name] = $value;
	}

	/**
	 * Removes an attribute from the element
	 *
	 * @param   string  $name  The name of the attribute.
	 *
	 * @return  void
	 *
	 * @deprecated  12.1
	 * @since   11.1
	 */
	public function removeAttribute($name)
	{
		// Deprecation warning.
		JLog::add('JSimpleXMLElement::removeAttribute() is deprecated.', JLog::WARNING, 'deprecated');

		unset($this->_attributes[$name]);
	}

	/**
	 * Adds a direct child to the element
	 *
	 * @param   string   $name   The name of the element.
	 * @param   array    $attrs  An key-value array of the element attributes.
	 * @param   integer  $level  The level of the element (optional).
	 *
	 * @return  JSimpleXMLElement  The added child object
	 *
	 * @deprecated   12.1
	 * @since   11.1
	 */
	public function addChild($name, $attrs = array(), $level = null)
	{
		// Deprecation warning.
		JLog::add('JSimpleXMLElement::addChild() is deprecated.', JLog::WARNING, 'deprecated');

		//If there is no array already set for the tag name being added,
		//create an empty array for it
		if (!isset($this->$name))
		{
			$this->$name = array();
		}

		// set the level if not already specified
		if ($level == null)
		{
			$level = ($this->_level + 1);
		}

		//Create the child object itself
		$classname = get_class($this);
		$child = new $classname($name, $attrs, $level);

		//Add the reference of it to the end of an array member named for the elements name
		$this->{$name}[] = &$child;

		//Add the reference to the children array member
		$this->_children[] = &$child;

		//return the new child
		return $child;
	}

	/**
	 * Remove the child node.
	 *
	 * @param   JSimpleXmlElement  &$child  The child element to remove.
	 *
	 * @return  void
	 *
	 * @since   11.1
	 * @deprecated  12.1
	 */
	public function removeChild(&$child)
	{
		// Deprecation warning.
		JLog::add('JSimpleXMLElement::removeChild() is deprecated.', JLog::WARNING, 'deprecated');

		$name = $child->name();
		for ($i = 0, $n = count($this->_children); $i < $n; $i++)
		{
			if ($this->_children[$i] == $child)
			{
				unset($this->_children[$i]);
			}
		}
		for ($i = 0, $n = count($this->{$name}); $i < $n; $i++)
		{
			if ($this->{$name}[$i] == $child)
			{
				unset($this->{$name}[$i]);
			}
		}
		$this->_children = array_values($this->_children);
		$this->{$name} = array_values($this->{$name});
		unset($child);
	}

	/**
	 * Get an element in the document by / separated path
	 *
	 * @param   string  $path  The / separated path to the element
	 *
	 * @return  object  JSimpleXMLElement
	 *
	 * @deprecated   12.1
	 * @since   11.1
	 */
	public function getElementByPath($path)
	{
		// Deprecation warning.
		JLog::add('JSimpleXMLElement::getElementByPath() is deprecated.', JLog::WARNING, 'deprecated');

		$tmp	= &$this;
		$parts	= explode('/', trim($path, '/'));

		foreach ($parts as $node)
		{
			$found = false;
			foreach ($tmp->_children as $child)
			{
				if (strtoupper($child->_name) == strtoupper($node))
				{
					$tmp = &$child;
					$found = true;
					break;
				}
			}
			if (!$found)
			{
				break;
			}
		}

		if ($found)
		{
			return $tmp;
		}

		return false;
	}

	/**
	 * Traverses the tree calling the $callback(JSimpleXMLElement
	 * $this, mixed $args=array()) function with each JSimpleXMLElement.
	 *
	 * @param   string  $callback  Function name
	 * @param   array   $args      The arguments (optional) for the function callback.
	 *
	 * @return  void
	 *
	 * @deprecated  12.1
	 * @since   11.1
	 */
	public function map($callback, $args = array())
	{
		// Deprecation warning.
		JLog::add('JSimpleXMLElement::map) is deprecated.', JLog::WARNING, 'deprecated');

		$callback($this, $args);
		// Map to all children
		if ($n = count($this->_children))
		{
			for ($i = 0; $i < $n; $i++)
			{
				$this->_children[$i]->map($callback, $args);
			}
		}
	}

	/**
	 * Return a well-formed XML string based on SimpleXML element
	 *
	 * @param   boolean  $whitespace  True if whitespace should be prepended to the string
	 *
	 * @return  string
	 *
	 * @deprecated   12.1
	 * @since   11.1
	 */
	public function toString($whitespace = true)
	{
		// Deprecation warning.
		JLog::add('JSimpleXMLElement::toString() is deprecated.', JLog::WARNING, 'deprecated');

		// Start a new line, indent by the number indicated in $this->level, add a <, and add the name of the tag
		if ($whitespace)
		{
			$out = "\n" . str_repeat("\t", $this->_level) . '<' . $this->_name;
		}
		else
		{
			$out = '<' . $this->_name;
		}

		// For each attribute, add attr="value"
		foreach ($this->_attributes as $attr => $value)
		{
			$out .= ' ' . $attr . '="' . htmlspecialchars($value, ENT_COMPAT, 'UTF-8') . '"';
		}

		// If there are no children and it contains no data, end it off with a />
		if (empty($this->_children) && empty($this->_data))
		{
			$out .= " />";
		}
		// Otherwise...
		else
		{
			// If there are children
			if (!empty($this->_children))
			{
				// Close off the start tag
				$out .= '>';

				// For each child, call the asXML function (this will ensure that all children are added recursively)
				foreach ($this->_children as $child)
				{
					$out .= $child->toString($whitespace);
				}

				// Add the newline and indentation to go along with the close tag
				if ($whitespace)
				{
					$out .= "\n" . str_repeat("\t", $this->_level);
				}
			}
			// If there is data, close off the start tag and add the data
			elseif (!empty($this->_data))
				$out .= '>' . htmlspecialchars($this->_data, ENT_COMPAT, 'UTF-8');

			// Add the end tag
			$out .= '</' . $this->_name . '>';
		}

		//Return the final output
		return $out;
	}
}
