mirror of
https://port.numenaute.org/aleajactaest/khanat-code-old.git
synced 2024-12-03 16:54:47 +00:00
1457 lines
34 KiB
PHP
1457 lines
34 KiB
PHP
<?php
|
|
/**
|
|
* XML handling for Cake.
|
|
*
|
|
* The methods in these classes enable the datasources that use XML to work.
|
|
*
|
|
* PHP versions 4 and 5
|
|
*
|
|
* CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
|
|
* Copyright 2005-2010, Cake Software Foundation, Inc. (http://cakefoundation.org)
|
|
*
|
|
* Licensed under The MIT License
|
|
* Redistributions of files must retain the above copyright notice.
|
|
*
|
|
* @copyright Copyright 2005-2010, Cake Software Foundation, Inc. (http://cakefoundation.org)
|
|
* @link http://cakephp.org CakePHP(tm) Project
|
|
* @package cake
|
|
* @subpackage cake.cake.libs
|
|
* @since CakePHP v .0.10.3.1400
|
|
* @license MIT License (http://www.opensource.org/licenses/mit-license.php)
|
|
*/
|
|
App::import('Core', 'Set');
|
|
|
|
/**
|
|
* XML node.
|
|
*
|
|
* Single XML node in an XML tree.
|
|
*
|
|
* @package cake
|
|
* @subpackage cake.cake.libs
|
|
* @since CakePHP v .0.10.3.1400
|
|
*/
|
|
class XmlNode extends Object {
|
|
|
|
/**
|
|
* Name of node
|
|
*
|
|
* @var string
|
|
* @access public
|
|
*/
|
|
var $name = null;
|
|
|
|
/**
|
|
* Node namespace
|
|
*
|
|
* @var string
|
|
* @access public
|
|
*/
|
|
var $namespace = null;
|
|
|
|
/**
|
|
* Namespaces defined for this node and all child nodes
|
|
*
|
|
* @var array
|
|
* @access public
|
|
*/
|
|
var $namespaces = array();
|
|
|
|
/**
|
|
* Value of node
|
|
*
|
|
* @var string
|
|
* @access public
|
|
*/
|
|
var $value;
|
|
|
|
/**
|
|
* Attributes on this node
|
|
*
|
|
* @var array
|
|
* @access public
|
|
*/
|
|
var $attributes = array();
|
|
|
|
/**
|
|
* This node's children
|
|
*
|
|
* @var array
|
|
* @access public
|
|
*/
|
|
var $children = array();
|
|
|
|
/**
|
|
* Reference to parent node.
|
|
*
|
|
* @var XmlNode
|
|
* @access private
|
|
*/
|
|
var $__parent = null;
|
|
|
|
/**
|
|
* Constructor.
|
|
*
|
|
* @param string $name Node name
|
|
* @param array $attributes Node attributes
|
|
* @param mixed $value Node contents (text)
|
|
* @param array $children Node children
|
|
*/
|
|
function __construct($name = null, $value = null, $namespace = null) {
|
|
if (strpos($name, ':') !== false) {
|
|
list($prefix, $name) = explode(':', $name);
|
|
if (!$namespace) {
|
|
$namespace = $prefix;
|
|
}
|
|
}
|
|
$this->name = $name;
|
|
if ($namespace) {
|
|
$this->namespace = $namespace;
|
|
}
|
|
|
|
if (is_array($value) || is_object($value)) {
|
|
$this->normalize($value);
|
|
} elseif (!empty($value) || $value === 0 || $value === '0') {
|
|
$this->createTextNode($value);
|
|
}
|
|
}
|
|
/**
|
|
* Adds a namespace to the current node
|
|
*
|
|
* @param string $prefix The namespace prefix
|
|
* @param string $url The namespace DTD URL
|
|
* @return void
|
|
*/
|
|
function addNamespace($prefix, $url) {
|
|
if ($ns = Xml::addGlobalNs($prefix, $url)) {
|
|
$this->namespaces = array_merge($this->namespaces, $ns);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Adds a namespace to the current node
|
|
*
|
|
* @param string $prefix The namespace prefix
|
|
* @param string $url The namespace DTD URL
|
|
* @return void
|
|
*/
|
|
function removeNamespace($prefix) {
|
|
if (Xml::removeGlobalNs($prefix)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Creates an XmlNode object that can be appended to this document or a node in it
|
|
*
|
|
* @param string $name Node name
|
|
* @param string $value Node value
|
|
* @param string $namespace Node namespace
|
|
* @return object XmlNode
|
|
*/
|
|
function &createNode($name = null, $value = null, $namespace = false) {
|
|
$node =& new XmlNode($name, $value, $namespace);
|
|
$node->setParent($this);
|
|
return $node;
|
|
}
|
|
|
|
/**
|
|
* Creates an XmlElement object that can be appended to this document or a node in it
|
|
*
|
|
* @param string $name Element name
|
|
* @param string $value Element value
|
|
* @param array $attributes Element attributes
|
|
* @param string $namespace Node namespace
|
|
* @return object XmlElement
|
|
*/
|
|
function &createElement($name = null, $value = null, $attributes = array(), $namespace = false) {
|
|
$element =& new XmlElement($name, $value, $attributes, $namespace);
|
|
$element->setParent($this);
|
|
return $element;
|
|
}
|
|
|
|
/**
|
|
* Creates an XmlTextNode object that can be appended to this document or a node in it
|
|
*
|
|
* @param string $value Node value
|
|
* @return object XmlTextNode
|
|
*/
|
|
function &createTextNode($value = null) {
|
|
$node = new XmlTextNode($value);
|
|
$node->setParent($this);
|
|
return $node;
|
|
}
|
|
|
|
/**
|
|
* Gets the XML element properties from an object.
|
|
*
|
|
* @param object $object Object to get properties from
|
|
* @return array Properties from object
|
|
* @access public
|
|
*/
|
|
function normalize($object, $keyName = null, $options = array()) {
|
|
if (is_a($object, 'XmlNode')) {
|
|
return $object;
|
|
}
|
|
$name = null;
|
|
$options += array('format' => 'attributes');
|
|
|
|
if ($keyName !== null && !is_numeric($keyName)) {
|
|
$name = $keyName;
|
|
} elseif (!empty($object->_name_)) {
|
|
$name = $object->_name_;
|
|
} elseif (isset($object->name)) {
|
|
$name = $object->name;
|
|
} elseif ($options['format'] == 'attributes') {
|
|
$name = get_class($object);
|
|
}
|
|
|
|
$tagOpts = $this->__tagOptions($name);
|
|
|
|
if ($tagOpts === false) {
|
|
return;
|
|
}
|
|
|
|
if (isset($tagOpts['name'])) {
|
|
$name = $tagOpts['name'];
|
|
} elseif ($name != strtolower($name) && $options['slug'] !== false) {
|
|
$name = Inflector::slug(Inflector::underscore($name));
|
|
}
|
|
|
|
if (!empty($name)) {
|
|
$node =& $this->createElement($name);
|
|
} else {
|
|
$node =& $this;
|
|
}
|
|
|
|
$namespace = array();
|
|
$attributes = array();
|
|
$children = array();
|
|
$chldObjs = array();
|
|
|
|
if (is_object($object)) {
|
|
$chldObjs = get_object_vars($object);
|
|
} elseif (is_array($object)) {
|
|
$chldObjs = $object;
|
|
} elseif (!empty($object) || $object === 0 || $object === '0') {
|
|
$node->createTextNode($object);
|
|
}
|
|
$attr = array();
|
|
|
|
if (isset($tagOpts['attributes'])) {
|
|
$attr = $tagOpts['attributes'];
|
|
}
|
|
if (isset($tagOpts['value']) && isset($chldObjs[$tagOpts['value']])) {
|
|
$node->createTextNode($chldObjs[$tagOpts['value']]);
|
|
unset($chldObjs[$tagOpts['value']]);
|
|
}
|
|
|
|
$n = $name;
|
|
if (isset($chldObjs['_name_'])) {
|
|
$n = null;
|
|
unset($chldObjs['_name_']);
|
|
}
|
|
$c = 0;
|
|
|
|
foreach ($chldObjs as $key => $val) {
|
|
if (in_array($key, $attr) && !is_object($val) && !is_array($val)) {
|
|
$attributes[$key] = $val;
|
|
} else {
|
|
if (!isset($tagOpts['children']) || $tagOpts['children'] === array() || (is_array($tagOpts['children']) && in_array($key, $tagOpts['children']))) {
|
|
if (!is_numeric($key)) {
|
|
$n = $key;
|
|
}
|
|
if (is_array($val)) {
|
|
foreach ($val as $n2 => $obj2) {
|
|
if (is_numeric($n2)) {
|
|
$n2 = $n;
|
|
}
|
|
$node->normalize($obj2, $n2, $options);
|
|
}
|
|
} else {
|
|
if (is_object($val)) {
|
|
|
|
$node->normalize($val, $n, $options);
|
|
} elseif ($options['format'] == 'tags' && $this->__tagOptions($key) !== false) {
|
|
$tmp =& $node->createElement($key);
|
|
if (!empty($val) || $val === 0 || $val === '0') {
|
|
$tmp->createTextNode($val);
|
|
}
|
|
} elseif ($options['format'] == 'attributes') {
|
|
$node->addAttribute($key, $val);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
$c++;
|
|
}
|
|
if (!empty($name)) {
|
|
return $node;
|
|
}
|
|
return $children;
|
|
}
|
|
|
|
/**
|
|
* Gets the tag-specific options for the given node name
|
|
*
|
|
* @param string $name XML tag name
|
|
* @param string $option The specific option to query. Omit for all options
|
|
* @return mixed A specific option value if $option is specified, otherwise an array of all options
|
|
* @access private
|
|
*/
|
|
function __tagOptions($name, $option = null) {
|
|
if (isset($this->__tags[$name])) {
|
|
$tagOpts = $this->__tags[$name];
|
|
} elseif (isset($this->__tags[strtolower($name)])) {
|
|
$tagOpts = $this->__tags[strtolower($name)];
|
|
} else {
|
|
return null;
|
|
}
|
|
if ($tagOpts === false) {
|
|
return false;
|
|
}
|
|
if (empty($option)) {
|
|
return $tagOpts;
|
|
}
|
|
if (isset($tagOpts[$option])) {
|
|
return $tagOpts[$option];
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Returns the fully-qualified XML node name, with namespace
|
|
*
|
|
* @access public
|
|
*/
|
|
function name() {
|
|
if (!empty($this->namespace)) {
|
|
$_this =& XmlManager::getInstance();
|
|
if (!isset($_this->options['verifyNs']) || !$_this->options['verifyNs'] || in_array($this->namespace, array_keys($_this->namespaces))) {
|
|
return $this->namespace . ':' . $this->name;
|
|
}
|
|
}
|
|
return $this->name;
|
|
}
|
|
|
|
/**
|
|
* Sets the parent node of this XmlNode.
|
|
*
|
|
* @access public
|
|
*/
|
|
function setParent(&$parent) {
|
|
if (strtolower(get_class($this)) == 'xml') {
|
|
return;
|
|
}
|
|
if (isset($this->__parent) && is_object($this->__parent)) {
|
|
if ($this->__parent->compare($parent)) {
|
|
return;
|
|
}
|
|
foreach ($this->__parent->children as $i => $child) {
|
|
if ($this->compare($child)) {
|
|
array_splice($this->__parent->children, $i, 1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if ($parent == null) {
|
|
unset($this->__parent);
|
|
} else {
|
|
$parent->children[] =& $this;
|
|
$this->__parent =& $parent;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns a copy of self.
|
|
*
|
|
* @return object Cloned instance
|
|
* @access public
|
|
*/
|
|
function cloneNode() {
|
|
return clone($this);
|
|
}
|
|
|
|
/**
|
|
* Compares $node to this XmlNode object
|
|
*
|
|
* @param object An XmlNode or subclass instance
|
|
* @return boolean True if the nodes match, false otherwise
|
|
* @access public
|
|
*/
|
|
function compare($node) {
|
|
$keys = array(get_object_vars($this), get_object_vars($node));
|
|
return ($keys[0] === $keys[1]);
|
|
}
|
|
|
|
/**
|
|
* Append given node as a child.
|
|
*
|
|
* @param object $child XmlNode with appended child
|
|
* @param array $options XML generator options for objects and arrays
|
|
* @return object A reference to the appended child node
|
|
* @access public
|
|
*/
|
|
function &append(&$child, $options = array()) {
|
|
if (empty($child)) {
|
|
$return = false;
|
|
return $return;
|
|
}
|
|
|
|
if (is_object($child)) {
|
|
if ($this->compare($child)) {
|
|
trigger_error(__('Cannot append a node to itself.', true));
|
|
$return = false;
|
|
return $return;
|
|
}
|
|
} else if (is_array($child)) {
|
|
$child = Set::map($child);
|
|
if (is_array($child)) {
|
|
if (!is_a(current($child), 'XmlNode')) {
|
|
foreach ($child as $i => $childNode) {
|
|
$child[$i] = $this->normalize($childNode, null, $options);
|
|
}
|
|
} else {
|
|
foreach ($child as $childNode) {
|
|
$this->append($childNode, $options);
|
|
}
|
|
}
|
|
return $child;
|
|
}
|
|
} else {
|
|
$attributes = array();
|
|
if (func_num_args() >= 2) {
|
|
$attributes = func_get_arg(1);
|
|
}
|
|
$child =& $this->createNode($child, null, $attributes);
|
|
}
|
|
|
|
$child = $this->normalize($child, null, $options);
|
|
|
|
if (empty($child->namespace) && !empty($this->namespace)) {
|
|
$child->namespace = $this->namespace;
|
|
}
|
|
|
|
if (is_a($child, 'XmlNode')) {
|
|
$child->setParent($this);
|
|
}
|
|
|
|
return $child;
|
|
}
|
|
|
|
/**
|
|
* Returns first child node, or null if empty.
|
|
*
|
|
* @return object First XmlNode
|
|
* @access public
|
|
*/
|
|
function &first() {
|
|
if (isset($this->children[0])) {
|
|
return $this->children[0];
|
|
} else {
|
|
$return = null;
|
|
return $return;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns last child node, or null if empty.
|
|
*
|
|
* @return object Last XmlNode
|
|
* @access public
|
|
*/
|
|
function &last() {
|
|
if (count($this->children) > 0) {
|
|
return $this->children[count($this->children) - 1];
|
|
} else {
|
|
$return = null;
|
|
return $return;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns child node with given ID.
|
|
*
|
|
* @param string $id Name of child node
|
|
* @return object Child XmlNode
|
|
* @access public
|
|
*/
|
|
function &child($id) {
|
|
$null = null;
|
|
|
|
if (is_int($id)) {
|
|
if (isset($this->children[$id])) {
|
|
return $this->children[$id];
|
|
} else {
|
|
return null;
|
|
}
|
|
} elseif (is_string($id)) {
|
|
for ($i = 0; $i < count($this->children); $i++) {
|
|
if ($this->children[$i]->name == $id) {
|
|
return $this->children[$i];
|
|
}
|
|
}
|
|
}
|
|
return $null;
|
|
}
|
|
|
|
/**
|
|
* Gets a list of childnodes with the given tag name.
|
|
*
|
|
* @param string $name Tag name of child nodes
|
|
* @return array An array of XmlNodes with the given tag name
|
|
* @access public
|
|
*/
|
|
function children($name) {
|
|
$nodes = array();
|
|
$count = count($this->children);
|
|
for ($i = 0; $i < $count; $i++) {
|
|
if ($this->children[$i]->name == $name) {
|
|
$nodes[] =& $this->children[$i];
|
|
}
|
|
}
|
|
return $nodes;
|
|
}
|
|
|
|
/**
|
|
* Gets a reference to the next child node in the list of this node's parent.
|
|
*
|
|
* @return object A reference to the XmlNode object
|
|
* @access public
|
|
*/
|
|
function &nextSibling() {
|
|
$null = null;
|
|
$count = count($this->__parent->children);
|
|
for ($i = 0; $i < $count; $i++) {
|
|
if ($this->__parent->children[$i] == $this) {
|
|
if ($i >= $count - 1 || !isset($this->__parent->children[$i + 1])) {
|
|
return $null;
|
|
}
|
|
return $this->__parent->children[$i + 1];
|
|
}
|
|
}
|
|
return $null;
|
|
}
|
|
|
|
/**
|
|
* Gets a reference to the previous child node in the list of this node's parent.
|
|
*
|
|
* @return object A reference to the XmlNode object
|
|
* @access public
|
|
*/
|
|
function &previousSibling() {
|
|
$null = null;
|
|
$count = count($this->__parent->children);
|
|
for ($i = 0; $i < $count; $i++) {
|
|
if ($this->__parent->children[$i] == $this) {
|
|
if ($i == 0 || !isset($this->__parent->children[$i - 1])) {
|
|
return $null;
|
|
}
|
|
return $this->__parent->children[$i - 1];
|
|
}
|
|
}
|
|
return $null;
|
|
}
|
|
|
|
/**
|
|
* Returns parent node.
|
|
*
|
|
* @return object Parent XmlNode
|
|
* @access public
|
|
*/
|
|
function &parent() {
|
|
return $this->__parent;
|
|
}
|
|
|
|
/**
|
|
* Returns the XML document to which this node belongs
|
|
*
|
|
* @return object Parent XML object
|
|
* @access public
|
|
*/
|
|
function &document() {
|
|
$document =& $this;
|
|
while (true) {
|
|
if (get_class($document) == 'Xml' || $document == null) {
|
|
break;
|
|
}
|
|
$document =& $document->parent();
|
|
}
|
|
return $document;
|
|
}
|
|
|
|
/**
|
|
* Returns true if this structure has child nodes.
|
|
*
|
|
* @return bool
|
|
* @access public
|
|
*/
|
|
function hasChildren() {
|
|
if (is_array($this->children) && !empty($this->children)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns this XML structure as a string.
|
|
*
|
|
* @return string String representation of the XML structure.
|
|
* @access public
|
|
*/
|
|
function toString($options = array(), $depth = 0) {
|
|
if (is_int($options)) {
|
|
$depth = $options;
|
|
$options = array();
|
|
}
|
|
$defaults = array('cdata' => true, 'whitespace' => false, 'convertEntities' => false, 'showEmpty' => true, 'leaveOpen' => false);
|
|
$options = array_merge($defaults, Xml::options(), $options);
|
|
$tag = !(strpos($this->name, '#') === 0);
|
|
$d = '';
|
|
|
|
if ($tag) {
|
|
if ($options['whitespace']) {
|
|
$d .= str_repeat("\t", $depth);
|
|
}
|
|
|
|
$d .= '<' . $this->name();
|
|
if (!empty($this->namespaces) > 0) {
|
|
foreach ($this->namespaces as $key => $val) {
|
|
$val = str_replace('"', '\"', $val);
|
|
$d .= ' xmlns:' . $key . '="' . $val . '"';
|
|
}
|
|
}
|
|
|
|
$parent =& $this->parent();
|
|
if ($parent->name === '#document' && !empty($parent->namespaces)) {
|
|
foreach ($parent->namespaces as $key => $val) {
|
|
$val = str_replace('"', '\"', $val);
|
|
$d .= ' xmlns:' . $key . '="' . $val . '"';
|
|
}
|
|
}
|
|
|
|
if (is_array($this->attributes) && !empty($this->attributes)) {
|
|
foreach ($this->attributes as $key => $val) {
|
|
if (is_bool($val) && $val === false) {
|
|
$val = 0;
|
|
}
|
|
$d .= ' ' . $key . '="' . htmlspecialchars($val, ENT_QUOTES, Configure::read('App.encoding')) . '"';
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!$this->hasChildren() && empty($this->value) && $this->value !== 0 && $tag) {
|
|
if (!$options['leaveOpen']) {
|
|
$d .= ' />';
|
|
}
|
|
if ($options['whitespace']) {
|
|
$d .= "\n";
|
|
}
|
|
} elseif ($tag || $this->hasChildren()) {
|
|
if ($tag) {
|
|
$d .= '>';
|
|
}
|
|
if ($this->hasChildren()) {
|
|
if ($options['whitespace']) {
|
|
$d .= "\n";
|
|
}
|
|
$count = count($this->children);
|
|
$cDepth = $depth + 1;
|
|
for ($i = 0; $i < $count; $i++) {
|
|
$d .= $this->children[$i]->toString($options, $cDepth);
|
|
}
|
|
if ($tag) {
|
|
if ($options['whitespace'] && $tag) {
|
|
$d .= str_repeat("\t", $depth);
|
|
}
|
|
if (!$options['leaveOpen']) {
|
|
$d .= '</' . $this->name() . '>';
|
|
}
|
|
if ($options['whitespace']) {
|
|
$d .= "\n";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return $d;
|
|
}
|
|
|
|
/**
|
|
* Return array representation of current object.
|
|
*
|
|
* @param boolean $camelize true will camelize child nodes, false will not alter node names
|
|
* @return array Array representation
|
|
* @access public
|
|
*/
|
|
function toArray($camelize = true) {
|
|
$out = $this->attributes;
|
|
|
|
foreach ($this->children as $child) {
|
|
$key = $camelize ? Inflector::camelize($child->name) : $child->name;
|
|
|
|
$leaf = false;
|
|
if (is_a($child, 'XmlTextNode')) {
|
|
$out['value'] = $child->value;
|
|
continue;
|
|
} elseif (isset($child->children[0]) && is_a($child->children[0], 'XmlTextNode')) {
|
|
$value = $child->children[0]->value;
|
|
if ($child->attributes) {
|
|
$value = array_merge(array('value' => $value), $child->attributes);
|
|
}
|
|
if (count($child->children) == 1) {
|
|
$leaf = true;
|
|
}
|
|
} elseif (count($child->children) === 0 && $child->value == '') {
|
|
$value = $child->attributes;
|
|
if (empty($value)) {
|
|
$leaf = true;
|
|
}
|
|
} else {
|
|
$value = $child->toArray($camelize);
|
|
}
|
|
|
|
if (isset($out[$key])) {
|
|
if(!isset($out[$key][0]) || !is_array($out[$key]) || !is_int(key($out[$key]))) {
|
|
$out[$key] = array($out[$key]);
|
|
}
|
|
$out[$key][] = $value;
|
|
} elseif (isset($out[$child->name])) {
|
|
$t = $out[$child->name];
|
|
unset($out[$child->name]);
|
|
$out[$key] = array($t);
|
|
$out[$key][] = $value;
|
|
} elseif ($leaf) {
|
|
$out[$child->name] = $value;
|
|
} else {
|
|
$out[$key] = $value;
|
|
}
|
|
}
|
|
return $out;
|
|
}
|
|
|
|
/**
|
|
* Returns data from toString when this object is converted to a string.
|
|
*
|
|
* @return string String representation of this structure.
|
|
* @access private
|
|
*/
|
|
function __toString() {
|
|
return $this->toString();
|
|
}
|
|
|
|
/**
|
|
* Debug method. Deletes the parent. Also deletes this node's children,
|
|
* if given the $recursive parameter.
|
|
*
|
|
* @param boolean $recursive Recursively delete elements.
|
|
* @access protected
|
|
*/
|
|
function _killParent($recursive = true) {
|
|
unset($this->__parent, $this->_log);
|
|
if ($recursive && $this->hasChildren()) {
|
|
for ($i = 0; $i < count($this->children); $i++) {
|
|
$this->children[$i]->_killParent(true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Main XML class.
|
|
*
|
|
* Parses and stores XML data, representing the root of an XML document
|
|
*
|
|
* @package cake
|
|
* @subpackage cake.cake.libs
|
|
* @since CakePHP v .0.10.3.1400
|
|
*/
|
|
class Xml extends XmlNode {
|
|
|
|
/**
|
|
* Resource handle to XML parser.
|
|
*
|
|
* @var resource
|
|
* @access private
|
|
*/
|
|
var $__parser;
|
|
|
|
/**
|
|
* File handle to XML indata file.
|
|
*
|
|
* @var resource
|
|
* @access private
|
|
*/
|
|
var $__file;
|
|
|
|
/**
|
|
* Raw XML string data (for loading purposes)
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
var $__rawData = null;
|
|
|
|
/**
|
|
* XML document header
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
var $__header = null;
|
|
|
|
/**
|
|
* Default array keys/object properties to use as tag names when converting objects or array
|
|
* structures to XML. Set by passing $options['tags'] to this object's constructor.
|
|
*
|
|
* @var array
|
|
* @access private
|
|
*/
|
|
var $__tags = array();
|
|
|
|
/**
|
|
* XML document version
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
var $version = '1.0';
|
|
|
|
/**
|
|
* XML document encoding
|
|
*
|
|
* @var string
|
|
* @access private
|
|
*/
|
|
var $encoding = 'UTF-8';
|
|
|
|
/**
|
|
* Constructor. Sets up the XML parser with options, gives it this object as
|
|
* its XML object, and sets some variables.
|
|
*
|
|
* ### Options
|
|
* - 'root': The name of the root element, defaults to '#document'
|
|
* - 'version': The XML version, defaults to '1.0'
|
|
* - 'encoding': Document encoding, defaults to 'UTF-8'
|
|
* - 'namespaces': An array of namespaces (as strings) used in this document
|
|
* - 'format': Specifies the format this document converts to when parsed or
|
|
* rendered out as text, either 'attributes' or 'tags', defaults to 'attributes'
|
|
* - 'tags': An array specifying any tag-specific formatting options, indexed
|
|
* by tag name. See XmlNode::normalize().
|
|
* - 'slug': A boolean to indicate whether or not you want the string version of the XML document
|
|
* to have its tags run through Inflector::slug(). Defaults to true
|
|
*
|
|
* @param mixed $input The content with which this XML document should be initialized. Can be a
|
|
* string, array or object. If a string is specified, it may be a literal XML
|
|
* document, or a URL or file path to read from.
|
|
* @param array $options Options to set up with, for valid options see above:
|
|
* @see XmlNode::normalize()
|
|
*/
|
|
function __construct($input = null, $options = array()) {
|
|
$defaults = array(
|
|
'root' => '#document', 'tags' => array(), 'namespaces' => array(),
|
|
'version' => '1.0', 'encoding' => 'UTF-8', 'format' => 'attributes',
|
|
'slug' => true
|
|
);
|
|
$options = array_merge($defaults, Xml::options(), $options);
|
|
|
|
foreach (array('version', 'encoding', 'namespaces') as $key) {
|
|
$this->{$key} = $options[$key];
|
|
}
|
|
$this->__tags = $options['tags'];
|
|
parent::__construct('#document');
|
|
|
|
if ($options['root'] !== '#document') {
|
|
$Root =& $this->createNode($options['root']);
|
|
} else {
|
|
$Root =& $this;
|
|
}
|
|
|
|
if (!empty($input)) {
|
|
if (is_string($input)) {
|
|
$Root->load($input);
|
|
} elseif (is_array($input) || is_object($input)) {
|
|
$Root->append($input, $options);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Initialize XML object from a given XML string. Returns false on error.
|
|
*
|
|
* @param string $input XML string, a path to a file, or an HTTP resource to load
|
|
* @return boolean Success
|
|
* @access public
|
|
*/
|
|
function load($input) {
|
|
if (!is_string($input)) {
|
|
return false;
|
|
}
|
|
$this->__rawData = null;
|
|
$this->__header = null;
|
|
|
|
if (strstr($input, "<")) {
|
|
$this->__rawData = $input;
|
|
} elseif (strpos($input, 'http://') === 0 || strpos($input, 'https://') === 0) {
|
|
App::import('Core', 'HttpSocket');
|
|
$socket = new HttpSocket();
|
|
$this->__rawData = $socket->get($input);
|
|
} elseif (file_exists($input)) {
|
|
$this->__rawData = file_get_contents($input);
|
|
} else {
|
|
trigger_error(__('XML cannot be read', true));
|
|
return false;
|
|
}
|
|
return $this->parse();
|
|
}
|
|
|
|
/**
|
|
* Parses and creates XML nodes from the __rawData property.
|
|
*
|
|
* @return boolean Success
|
|
* @access public
|
|
* @see Xml::load()
|
|
* @todo figure out how to link attributes and namespaces
|
|
*/
|
|
function parse() {
|
|
$this->__initParser();
|
|
$this->__rawData = trim($this->__rawData);
|
|
$this->__header = trim(str_replace(
|
|
array('<' . '?', '?' . '>'),
|
|
array('', ''),
|
|
substr($this->__rawData, 0, strpos($this->__rawData, '?' . '>'))
|
|
));
|
|
|
|
xml_parse_into_struct($this->__parser, $this->__rawData, $vals);
|
|
$xml =& $this;
|
|
$count = count($vals);
|
|
|
|
for ($i = 0; $i < $count; $i++) {
|
|
$data = $vals[$i];
|
|
$data += array('tag' => null, 'value' => null, 'attributes' => array());
|
|
switch ($data['type']) {
|
|
case "open" :
|
|
$xml =& $xml->createElement($data['tag'], $data['value'], $data['attributes']);
|
|
break;
|
|
case "close" :
|
|
$xml =& $xml->parent();
|
|
break;
|
|
case "complete" :
|
|
$xml->createElement($data['tag'], $data['value'], $data['attributes']);
|
|
break;
|
|
case 'cdata':
|
|
$xml->createTextNode($data['value']);
|
|
break;
|
|
}
|
|
}
|
|
xml_parser_free($this->__parser);
|
|
$this->__parser = null;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Initializes the XML parser resource
|
|
*
|
|
* @return void
|
|
* @access private
|
|
*/
|
|
function __initParser() {
|
|
if (empty($this->__parser)) {
|
|
$this->__parser = xml_parser_create();
|
|
xml_set_object($this->__parser, $this);
|
|
xml_parser_set_option($this->__parser, XML_OPTION_CASE_FOLDING, 0);
|
|
xml_parser_set_option($this->__parser, XML_OPTION_SKIP_WHITE, 1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns a string representation of the XML object
|
|
*
|
|
* @param mixed $options If boolean: whether to include the XML header with the document
|
|
* (defaults to true); if an array, overrides the default XML generation options
|
|
* @return string XML data
|
|
* @access public
|
|
* @deprecated
|
|
* @see Xml::toString()
|
|
*/
|
|
function compose($options = array()) {
|
|
return $this->toString($options);
|
|
}
|
|
|
|
/**
|
|
* If debug mode is on, this method echoes an error message.
|
|
*
|
|
* @param string $msg Error message
|
|
* @param integer $code Error code
|
|
* @param integer $line Line in file
|
|
* @access public
|
|
*/
|
|
function error($msg, $code = 0, $line = 0) {
|
|
if (Configure::read('debug')) {
|
|
echo $msg . " " . $code . " " . $line;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns a string with a textual description of the error code, or FALSE if no description was found.
|
|
*
|
|
* @param integer $code Error code
|
|
* @return string Error message
|
|
* @access public
|
|
*/
|
|
function getError($code) {
|
|
$r = @xml_error_string($code);
|
|
return $r;
|
|
}
|
|
|
|
// Overridden functions from superclass
|
|
|
|
/**
|
|
* Get next element. NOT implemented.
|
|
*
|
|
* @return object
|
|
* @access public
|
|
*/
|
|
function &next() {
|
|
$return = null;
|
|
return $return;
|
|
}
|
|
|
|
/**
|
|
* Get previous element. NOT implemented.
|
|
*
|
|
* @return object
|
|
* @access public
|
|
*/
|
|
function &previous() {
|
|
$return = null;
|
|
return $return;
|
|
}
|
|
|
|
/**
|
|
* Get parent element. NOT implemented.
|
|
*
|
|
* @return object
|
|
* @access public
|
|
*/
|
|
function &parent() {
|
|
$return = null;
|
|
return $return;
|
|
}
|
|
|
|
/**
|
|
* Adds a namespace to the current document
|
|
*
|
|
* @param string $prefix The namespace prefix
|
|
* @param string $url The namespace DTD URL
|
|
* @return void
|
|
*/
|
|
function addNamespace($prefix, $url) {
|
|
if ($count = count($this->children)) {
|
|
for ($i = 0; $i < $count; $i++) {
|
|
$this->children[$i]->addNamespace($prefix, $url);
|
|
}
|
|
return true;
|
|
}
|
|
return parent::addNamespace($prefix, $url);
|
|
}
|
|
|
|
/**
|
|
* Removes a namespace to the current document
|
|
*
|
|
* @param string $prefix The namespace prefix
|
|
* @return void
|
|
*/
|
|
function removeNamespace($prefix) {
|
|
if ($count = count($this->children)) {
|
|
for ($i = 0; $i < $count; $i++) {
|
|
$this->children[$i]->removeNamespace($prefix);
|
|
}
|
|
return true;
|
|
}
|
|
return parent::removeNamespace($prefix);
|
|
}
|
|
|
|
/**
|
|
* Return string representation of current object.
|
|
*
|
|
* @return string String representation
|
|
* @access public
|
|
*/
|
|
function toString($options = array()) {
|
|
if (is_bool($options)) {
|
|
$options = array('header' => $options);
|
|
}
|
|
|
|
$defaults = array('header' => false, 'encoding' => $this->encoding);
|
|
$options = array_merge($defaults, Xml::options(), $options);
|
|
$data = parent::toString($options, 0);
|
|
|
|
if ($options['header']) {
|
|
if (!empty($this->__header)) {
|
|
return $this->header($this->__header) . "\n" . $data;
|
|
}
|
|
return $this->header() . "\n" . $data;
|
|
}
|
|
|
|
return $data;
|
|
}
|
|
|
|
/**
|
|
* Return a header used on the first line of the xml file
|
|
*
|
|
* @param mixed $attrib attributes of the header element
|
|
* @return string formated header
|
|
*/
|
|
function header($attrib = array()) {
|
|
$header = 'xml';
|
|
if (is_string($attrib)) {
|
|
$header = $attrib;
|
|
} else {
|
|
|
|
$attrib = array_merge(array('version' => $this->version, 'encoding' => $this->encoding), $attrib);
|
|
foreach ($attrib as $key=>$val) {
|
|
$header .= ' ' . $key . '="' . $val . '"';
|
|
}
|
|
}
|
|
return '<' . '?' . $header . ' ?' . '>';
|
|
}
|
|
|
|
/**
|
|
* Destructor, used to free resources.
|
|
*
|
|
* @access private
|
|
*/
|
|
function __destruct() {
|
|
$this->_killParent(true);
|
|
}
|
|
|
|
/**
|
|
* Adds a namespace to any XML documents generated or parsed
|
|
*
|
|
* @param string $name The namespace name
|
|
* @param string $url The namespace URI; can be empty if in the default namespace map
|
|
* @return boolean False if no URL is specified, and the namespace does not exist
|
|
* default namespace map, otherwise true
|
|
* @access public
|
|
* @static
|
|
*/
|
|
function addGlobalNs($name, $url = null) {
|
|
$_this =& XmlManager::getInstance();
|
|
if ($ns = Xml::resolveNamespace($name, $url)) {
|
|
$_this->namespaces = array_merge($_this->namespaces, $ns);
|
|
return $ns;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Resolves current namespace
|
|
*
|
|
* @param string $name
|
|
* @param string $url
|
|
* @return array
|
|
*/
|
|
function resolveNamespace($name, $url) {
|
|
$_this =& XmlManager::getInstance();
|
|
if ($url == null && isset($_this->defaultNamespaceMap[$name])) {
|
|
$url = $_this->defaultNamespaceMap[$name];
|
|
} elseif ($url == null) {
|
|
return false;
|
|
}
|
|
|
|
if (!strpos($url, '://') && isset($_this->defaultNamespaceMap[$name])) {
|
|
$_url = $_this->defaultNamespaceMap[$name];
|
|
$name = $url;
|
|
$url = $_url;
|
|
}
|
|
return array($name => $url);
|
|
}
|
|
|
|
/**
|
|
* Alias to Xml::addNs
|
|
*
|
|
* @access public
|
|
* @static
|
|
*/
|
|
function addGlobalNamespace($name, $url = null) {
|
|
return Xml::addGlobalNs($name, $url);
|
|
}
|
|
|
|
/**
|
|
* Removes a namespace added in addNs()
|
|
*
|
|
* @param string $name The namespace name or URI
|
|
* @access public
|
|
* @static
|
|
*/
|
|
function removeGlobalNs($name) {
|
|
$_this =& XmlManager::getInstance();
|
|
if (isset($_this->namespaces[$name])) {
|
|
unset($_this->namespaces[$name]);
|
|
unset($this->namespaces[$name]);
|
|
return true;
|
|
} elseif (in_array($name, $_this->namespaces)) {
|
|
$keys = array_keys($_this->namespaces);
|
|
$count = count($keys);
|
|
for ($i = 0; $i < $count; $i++) {
|
|
if ($_this->namespaces[$keys[$i]] == $name) {
|
|
unset($_this->namespaces[$keys[$i]]);
|
|
unset($this->namespaces[$keys[$i]]);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Alias to Xml::removeNs
|
|
*
|
|
* @access public
|
|
* @static
|
|
*/
|
|
function removeGlobalNamespace($name) {
|
|
return Xml::removeGlobalNs($name);
|
|
}
|
|
|
|
/**
|
|
* Sets/gets global XML options
|
|
*
|
|
* @param array $options
|
|
* @return array
|
|
* @access public
|
|
* @static
|
|
*/
|
|
function options($options = array()) {
|
|
$_this =& XmlManager::getInstance();
|
|
$_this->options = array_merge($_this->options, $options);
|
|
return $_this->options;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The XML Element
|
|
*
|
|
*/
|
|
class XmlElement extends XmlNode {
|
|
|
|
/**
|
|
* Construct an Xml element
|
|
*
|
|
* @param string $name name of the node
|
|
* @param string $value value of the node
|
|
* @param array $attributes
|
|
* @param string $namespace
|
|
* @return string A copy of $data in XML format
|
|
*/
|
|
function __construct($name = null, $value = null, $attributes = array(), $namespace = false) {
|
|
parent::__construct($name, $value, $namespace);
|
|
$this->addAttribute($attributes);
|
|
}
|
|
|
|
/**
|
|
* Get all the attributes for this element
|
|
*
|
|
* @return array
|
|
*/
|
|
function attributes() {
|
|
return $this->attributes;
|
|
}
|
|
|
|
/**
|
|
* Add attributes to this element
|
|
*
|
|
* @param string $name name of the node
|
|
* @param string $value value of the node
|
|
* @return boolean
|
|
*/
|
|
function addAttribute($name, $val = null) {
|
|
if (is_object($name)) {
|
|
$name = get_object_vars($name);
|
|
}
|
|
if (is_array($name)) {
|
|
foreach ($name as $key => $val) {
|
|
$this->addAttribute($key, $val);
|
|
}
|
|
return true;
|
|
}
|
|
if (is_numeric($name)) {
|
|
$name = $val;
|
|
$val = null;
|
|
}
|
|
if (!empty($name)) {
|
|
if (strpos($name, 'xmlns') === 0) {
|
|
if ($name == 'xmlns') {
|
|
$this->namespace = $val;
|
|
} else {
|
|
list($pre, $prefix) = explode(':', $name);
|
|
$this->addNamespace($prefix, $val);
|
|
return true;
|
|
}
|
|
}
|
|
$this->attributes[$name] = $val;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Remove attributes to this element
|
|
*
|
|
* @param string $name name of the node
|
|
* @return boolean
|
|
*/
|
|
function removeAttribute($attr) {
|
|
if (array_key_exists($attr, $this->attributes)) {
|
|
unset($this->attributes[$attr]);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* XML text or CDATA node
|
|
*
|
|
* Stores XML text data according to the encoding of the parent document
|
|
*
|
|
* @package cake
|
|
* @subpackage cake.cake.libs
|
|
* @since CakePHP v .1.2.6000
|
|
*/
|
|
class XmlTextNode extends XmlNode {
|
|
|
|
/**
|
|
* Harcoded XML node name, represents this object as a text node
|
|
*
|
|
* @var string
|
|
*/
|
|
var $name = '#text';
|
|
|
|
/**
|
|
* The text/data value which this node contains
|
|
*
|
|
* @var string
|
|
*/
|
|
var $value = null;
|
|
|
|
/**
|
|
* Construct text node with the given parent object and data
|
|
*
|
|
* @param object $parent Parent XmlNode/XmlElement object
|
|
* @param mixed $value Node value
|
|
*/
|
|
function __construct($value = null) {
|
|
$this->value = $value;
|
|
}
|
|
|
|
/**
|
|
* Looks for child nodes in this element
|
|
*
|
|
* @return boolean False - not supported
|
|
*/
|
|
function hasChildren() {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Append an XML node: XmlTextNode does not support this operation
|
|
*
|
|
* @return boolean False - not supported
|
|
* @todo make convertEntities work without mb support, convert entities to number entities
|
|
*/
|
|
function append() {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Return string representation of current text node object.
|
|
*
|
|
* @return string String representation
|
|
* @access public
|
|
*/
|
|
function toString($options = array(), $depth = 0) {
|
|
if (is_int($options)) {
|
|
$depth = $options;
|
|
$options = array();
|
|
}
|
|
|
|
$defaults = array('cdata' => true, 'whitespace' => false, 'convertEntities' => false);
|
|
$options = array_merge($defaults, Xml::options(), $options);
|
|
$val = $this->value;
|
|
|
|
if ($options['convertEntities'] && function_exists('mb_convert_encoding')) {
|
|
$val = mb_convert_encoding($val,'UTF-8', 'HTML-ENTITIES');
|
|
}
|
|
|
|
if ($options['cdata'] === true && !is_numeric($val)) {
|
|
$val = '<![CDATA[' . $val . ']]>';
|
|
}
|
|
|
|
if ($options['whitespace']) {
|
|
return str_repeat("\t", $depth) . $val . "\n";
|
|
}
|
|
return $val;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Manages application-wide namespaces and XML parsing/generation settings.
|
|
* Private class, used exclusively within scope of XML class.
|
|
*
|
|
* @access private
|
|
*/
|
|
class XmlManager {
|
|
|
|
/**
|
|
* Global XML namespaces. Used in all XML documents processed by this application
|
|
*
|
|
* @var array
|
|
* @access public
|
|
*/
|
|
var $namespaces = array();
|
|
|
|
/**
|
|
* Global XML document parsing/generation settings.
|
|
*
|
|
* @var array
|
|
* @access public
|
|
*/
|
|
var $options = array();
|
|
|
|
/**
|
|
* Map of common namespace URIs
|
|
*
|
|
* @access private
|
|
* @var array
|
|
*/
|
|
var $defaultNamespaceMap = array(
|
|
'dc' => 'http://purl.org/dc/elements/1.1/', // Dublin Core
|
|
'dct' => 'http://purl.org/dc/terms/', // Dublin Core Terms
|
|
'g' => 'http://base.google.com/ns/1.0', // Google Base
|
|
'rc' => 'http://purl.org/rss/1.0/modules/content/', // RSS 1.0 Content Module
|
|
'wf' => 'http://wellformedweb.org/CommentAPI/', // Well-Formed Web Comment API
|
|
'fb' => 'http://rssnamespace.org/feedburner/ext/1.0', // FeedBurner extensions
|
|
'lj' => 'http://www.livejournal.org/rss/lj/1.0/', // Live Journal
|
|
'itunes' => 'http://www.itunes.com/dtds/podcast-1.0.dtd', // iTunes
|
|
'xhtml' => 'http://www.w3.org/1999/xhtml', // XHTML,
|
|
'atom' => 'http://www.w3.org/2005/Atom' // Atom
|
|
);
|
|
|
|
/**
|
|
* Returns a reference to the global XML object that manages app-wide XML settings
|
|
*
|
|
* @return object
|
|
* @access public
|
|
*/
|
|
function &getInstance() {
|
|
static $instance = array();
|
|
|
|
if (!$instance) {
|
|
$instance[0] =& new XmlManager();
|
|
}
|
|
return $instance[0];
|
|
}
|
|
}
|