/branches/v2.0-narmer/api/pear/XML/Feed/Parser/RSS11Element.php |
---|
New file |
0,0 → 1,151 |
<?php |
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */ |
/** |
* RSS1 Element class for XML_Feed_Parser |
* |
* PHP versions 5 |
* |
* LICENSE: This source file is subject to version 3.0 of the PHP license |
* that is available through the world-wide-web at the following URI: |
* http://www.php.net/license/3_0.txt. If you did not receive a copy of |
* the PHP License and are unable to obtain it through the web, please |
* send a note to license@php.net so we can mail you a copy immediately. |
* |
* @category XML |
* @package XML_Feed_Parser |
* @author James Stewart <james@jystewart.net> |
* @copyright 2005 James Stewart <james@jystewart.net> |
* @license http://www.gnu.org/copyleft/lesser.html GNU LGPL 2.1 |
* @version CVS: $Id: RSS11Element.php,v 1.1.2.1 2007-07-25 09:45:07 jp_milcent Exp $ |
* @link http://pear.php.net/package/XML_Feed_Parser/ |
*/ |
/* |
* This class provides support for RSS 1.1 entries. It will usually be called by |
* XML_Feed_Parser_RSS11 with which it shares many methods. |
* |
* @author James Stewart <james@jystewart.net> |
* @version Release: 1.0.2 |
* @package XML_Feed_Parser |
*/ |
class XML_Feed_Parser_RSS11Element extends XML_Feed_Parser_RSS11 |
{ |
/** |
* This will be a reference to the parent object for when we want |
* to use a 'fallback' rule |
* @var XML_Feed_Parser_RSS1 |
*/ |
protected $parent; |
/** |
* Our specific element map |
* @var array |
*/ |
protected $map = array( |
'id' => array('Id'), |
'title' => array('Text'), |
'link' => array('Link'), |
'description' => array('Text'), # or dc:description |
'category' => array('Category'), |
'rights' => array('Text'), # dc:rights |
'creator' => array('Text'), # dc:creator |
'publisher' => array('Text'), # dc:publisher |
'contributor' => array('Text'), # dc:contributor |
'date' => array('Date'), # dc:date |
'content' => array('Content') |
); |
/** |
* Here we map some elements to their atom equivalents. This is going to be |
* quite tricky to pull off effectively (and some users' methods may vary) |
* but is worth trying. The key is the atom version, the value is RSS1. |
* @var array |
*/ |
protected $compatMap = array( |
'content' => array('content'), |
'updated' => array('lastBuildDate'), |
'published' => array('pubdate'), |
'subtitle' => array('description'), |
'updated' => array('date'), |
'author' => array('creator'), |
'contributor' => array('contributor') |
); |
/** |
* Store useful information for later. |
* |
* @param DOMElement $element - this item as a DOM element |
* @param XML_Feed_Parser_RSS1 $parent - the feed of which this is a member |
*/ |
function __construct(DOMElement $element, $parent, $xmlBase = '') |
{ |
$this->model = $element; |
$this->parent = $parent; |
} |
/** |
* If an rdf:about attribute is specified, return that as an ID |
* |
* There is no established way of showing an ID for an RSS1 entry. We will |
* simulate it using the rdf:about attribute of the entry element. This cannot |
* be relied upon for unique IDs but may prove useful. |
* |
* @return string|false |
*/ |
function getId() |
{ |
if ($this->model->attributes->getNamedItem('about')) { |
return $this->model->attributes->getNamedItem('about')->nodeValue; |
} |
return false; |
} |
/** |
* Return the entry's content |
* |
* The official way to include full content in an RSS1 entry is to use |
* the content module's element 'encoded'. Often, however, the 'description' |
* element is used instead. We will offer that as a fallback. |
* |
* @return string|false |
*/ |
function getContent() |
{ |
$options = array('encoded', 'description'); |
foreach ($options as $element) { |
$test = $this->model->getElementsByTagName($element); |
if ($test->length == 0) { |
continue; |
} |
if ($test->item(0)->hasChildNodes()) { |
$value = ''; |
foreach ($test->item(0)->childNodes as $child) { |
if ($child instanceof DOMText) { |
$value .= $child->nodeValue; |
} else { |
$simple = simplexml_import_dom($child); |
$value .= $simple->asXML(); |
} |
} |
return $value; |
} else if ($test->length > 0) { |
return $test->item(0)->nodeValue; |
} |
} |
return false; |
} |
/** |
* How RSS1.1 should support for enclosures is not clear. For now we will return |
* false. |
* |
* @return false |
*/ |
function getEnclosure() |
{ |
return false; |
} |
} |
?> |
/branches/v2.0-narmer/api/pear/XML/Feed/Parser/RSS2Element.php |
---|
New file |
0,0 → 1,171 |
<?php |
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */ |
/** |
* Class representing entries in an RSS2 feed. |
* |
* PHP versions 5 |
* |
* LICENSE: This source file is subject to version 3.0 of the PHP license |
* that is available through the world-wide-web at the following URI: |
* http://www.php.net/license/3_0.txt. If you did not receive a copy of |
* the PHP License and are unable to obtain it through the web, please |
* send a note to license@php.net so we can mail you a copy immediately. |
* |
* @category XML |
* @package XML_Feed_Parser |
* @author James Stewart <james@jystewart.net> |
* @copyright 2005 James Stewart <james@jystewart.net> |
* @license http://www.gnu.org/copyleft/lesser.html GNU LGPL 2.1 |
* @version CVS: $Id: RSS2Element.php,v 1.1.2.1 2007-07-25 09:45:07 jp_milcent Exp $ |
* @link http://pear.php.net/package/XML_Feed_Parser/ |
*/ |
/** |
* This class provides support for RSS 2.0 entries. It will usually be |
* called by XML_Feed_Parser_RSS2 with which it shares many methods. |
* |
* @author James Stewart <james@jystewart.net> |
* @version Release: 1.0.2 |
* @package XML_Feed_Parser |
*/ |
class XML_Feed_Parser_RSS2Element extends XML_Feed_Parser_RSS2 |
{ |
/** |
* This will be a reference to the parent object for when we want |
* to use a 'fallback' rule |
* @var XML_Feed_Parser_RSS2 |
*/ |
protected $parent; |
/** |
* Our specific element map |
* @var array |
*/ |
protected $map = array( |
'title' => array('Text'), |
'guid' => array('Guid'), |
'description' => array('Text'), |
'author' => array('Text'), |
'comments' => array('Text'), |
'enclosure' => array('Enclosure'), |
'pubDate' => array('Date'), |
'source' => array('Source'), |
'link' => array('Text'), |
'content' => array('Content')); |
/** |
* Here we map some elements to their atom equivalents. This is going to be |
* quite tricky to pull off effectively (and some users' methods may vary) |
* but is worth trying. The key is the atom version, the value is RSS2. |
* @var array |
*/ |
protected $compatMap = array( |
'id' => array('guid'), |
'updated' => array('lastBuildDate'), |
'published' => array('pubdate'), |
'guidislink' => array('guid', 'ispermalink'), |
'summary' => array('description')); |
/** |
* Store useful information for later. |
* |
* @param DOMElement $element - this item as a DOM element |
* @param XML_Feed_Parser_RSS2 $parent - the feed of which this is a member |
*/ |
function __construct(DOMElement $element, $parent, $xmlBase = '') |
{ |
$this->model = $element; |
$this->parent = $parent; |
} |
/** |
* Get the value of the guid element, if specified |
* |
* guid is the closest RSS2 has to atom's ID. It is usually but not always a |
* URI. The one attribute that RSS2 can posess is 'ispermalink' which specifies |
* whether the guid is itself dereferencable. Use of guid is not obligatory, |
* but is advisable. To get the guid you would call $item->id() (for atom |
* compatibility) or $item->guid(). To check if this guid is a permalink call |
* $item->guid("ispermalink"). |
* |
* @param string $method - the method name being called |
* @param array $params - parameters required |
* @return string the guid or value of ispermalink |
*/ |
protected function getGuid($method, $params) |
{ |
$attribute = (isset($params[0]) and $params[0] == 'ispermalink') ? |
true : false; |
$tag = $this->model->getElementsByTagName('guid'); |
if ($tag->length > 0) { |
if ($attribute) { |
if ($tag->hasAttribute("ispermalink")) { |
return $tag->getAttribute("ispermalink"); |
} |
} |
return $tag->item(0)->nodeValue; |
} |
return false; |
} |
/** |
* Access details of file enclosures |
* |
* The RSS2 spec is ambiguous as to whether an enclosure element must be |
* unique in a given entry. For now we will assume it needn't, and allow |
* for an offset. |
* |
* @param string $method - the method being called |
* @param array $parameters - we expect the first of these to be our offset |
* @return array|false |
*/ |
protected function getEnclosure($method, $parameters) |
{ |
$encs = $this->model->getElementsByTagName('enclosure'); |
$offset = isset($parameters[0]) ? $parameters[0] : 0; |
if ($encs->length > $offset) { |
try { |
if (! $encs->item($offset)->hasAttribute('url')) { |
return false; |
} |
$attrs = $encs->item($offset)->attributes; |
return array( |
'url' => $attrs->getNamedItem('url')->value, |
'length' => $attrs->getNamedItem('length')->value, |
'type' => $attrs->getNamedItem('type')->value); |
} catch (Exception $e) { |
return false; |
} |
} |
return false; |
} |
/** |
* Get the entry source if specified |
* |
* source is an optional sub-element of item. Like atom:source it tells |
* us about where the entry came from (eg. if it's been copied from another |
* feed). It is not a rich source of metadata in the same way as atom:source |
* and while it would be good to maintain compatibility by returning an |
* XML_Feed_Parser_RSS2 element, it makes a lot more sense to return an array. |
* |
* @return array|false |
*/ |
protected function getSource() |
{ |
$get = $this->model->getElementsByTagName('source'); |
if ($get->length) { |
$source = $get->item(0); |
$array = array( |
'content' => $source->nodeValue); |
foreach ($source->attributes as $attribute) { |
$array[$attribute->name] = $attribute->value; |
} |
return $array; |
} |
return false; |
} |
} |
?> |
/branches/v2.0-narmer/api/pear/XML/Feed/Parser/RSS1.php |
---|
New file |
0,0 → 1,277 |
<?php |
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */ |
/** |
* RSS1 class for XML_Feed_Parser |
* |
* PHP versions 5 |
* |
* LICENSE: This source file is subject to version 3.0 of the PHP license |
* that is available through the world-wide-web at the following URI: |
* http://www.php.net/license/3_0.txt. If you did not receive a copy of |
* the PHP License and are unable to obtain it through the web, please |
* send a note to license@php.net so we can mail you a copy immediately. |
* |
* @category XML |
* @package XML_Feed_Parser |
* @author James Stewart <james@jystewart.net> |
* @copyright 2005 James Stewart <james@jystewart.net> |
* @license http://www.gnu.org/copyleft/lesser.html GNU LGPL 2.1 |
* @version CVS: $Id: RSS1.php,v 1.1.2.1 2007-07-25 09:45:07 jp_milcent Exp $ |
* @link http://pear.php.net/package/XML_Feed_Parser/ |
*/ |
/** |
* This class handles RSS1.0 feeds. |
* |
* @author James Stewart <james@jystewart.net> |
* @version Release: 1.0.2 |
* @package XML_Feed_Parser |
* @todo Find a Relax NG URI we can use |
*/ |
class XML_Feed_Parser_RSS1 extends XML_Feed_Parser_Type |
{ |
/** |
* The URI of the RelaxNG schema used to (optionally) validate the feed |
* @var string |
*/ |
private $relax = 'rss10.rnc'; |
/** |
* We're likely to use XPath, so let's keep it global |
* @var DOMXPath |
*/ |
protected $xpath; |
/** |
* The feed type we are parsing |
* @var string |
*/ |
public $version = 'RSS 1.0'; |
/** |
* The class used to represent individual items |
* @var string |
*/ |
protected $itemClass = 'XML_Feed_Parser_RSS1Element'; |
/** |
* The element containing entries |
* @var string |
*/ |
protected $itemElement = 'item'; |
/** |
* Here we map those elements we're not going to handle individually |
* to the constructs they are. The optional second parameter in the array |
* tells the parser whether to 'fall back' (not apt. at the feed level) or |
* fail if the element is missing. If the parameter is not set, the function |
* will simply return false and leave it to the client to decide what to do. |
* @var array |
*/ |
protected $map = array( |
'title' => array('Text'), |
'link' => array('Text'), |
'description' => array('Text'), |
'image' => array('Image'), |
'textinput' => array('TextInput'), |
'updatePeriod' => array('Text'), |
'updateFrequency' => array('Text'), |
'updateBase' => array('Date'), |
'rights' => array('Text'), # dc:rights |
'description' => array('Text'), # dc:description |
'creator' => array('Text'), # dc:creator |
'publisher' => array('Text'), # dc:publisher |
'contributor' => array('Text'), # dc:contributor |
'date' => array('Date') # dc:contributor |
); |
/** |
* Here we map some elements to their atom equivalents. This is going to be |
* quite tricky to pull off effectively (and some users' methods may vary) |
* but is worth trying. The key is the atom version, the value is RSS2. |
* @var array |
*/ |
protected $compatMap = array( |
'title' => array('title'), |
'link' => array('link'), |
'subtitle' => array('description'), |
'author' => array('creator'), |
'updated' => array('date')); |
/** |
* We will be working with multiple namespaces and it is useful to |
* keep them together |
* @var array |
*/ |
protected $namespaces = array( |
'rdf' => 'http://www.w3.org/1999/02/22-rdf-syntax-ns#', |
'rss' => 'http://purl.org/rss/1.0/', |
'dc' => 'http://purl.org/rss/1.0/modules/dc/', |
'content' => 'http://purl.org/rss/1.0/modules/content/', |
'sy' => 'http://web.resource.org/rss/1.0/modules/syndication/'); |
/** |
* Our constructor does nothing more than its parent. |
* |
* @param DOMDocument $xml A DOM object representing the feed |
* @param bool (optional) $string Whether or not to validate this feed |
*/ |
function __construct(DOMDocument $model, $strict = false) |
{ |
$this->model = $model; |
if ($strict) { |
$validate = $this->model->relaxNGValidate(self::getSchemaDir . |
DIRECTORY_SEPARATOR . $this->relax); |
if (! $validate) { |
throw new XML_Feed_Parser_Exception('Failed required validation'); |
} |
} |
$this->xpath = new DOMXPath($model); |
foreach ($this->namespaces as $key => $value) { |
$this->xpath->registerNamespace($key, $value); |
} |
$this->numberEntries = $this->count('item'); |
} |
/** |
* Allows retrieval of an entry by ID where the rdf:about attribute is used |
* |
* This is not really something that will work with RSS1 as it does not have |
* clear restrictions on the global uniqueness of IDs. We will employ the |
* _very_ hit and miss method of selecting entries based on the rdf:about |
* attribute. If DOMXPath::evaluate is available, we also use that to store |
* a reference to the entry in the array used by getEntryByOffset so that |
* method does not have to seek out the entry if it's requested that way. |
* |
* @param string $id any valid ID. |
* @return XML_Feed_Parser_RSS1Element |
*/ |
function getEntryById($id) |
{ |
if (isset($this->idMappings[$id])) { |
return $this->entries[$this->idMappings[$id]]; |
} |
$entries = $this->xpath->query("//rss:item[@rdf:about='$id']"); |
if ($entries->length > 0) { |
$classname = $this->itemClass; |
$entry = new $classname($entries->item(0), $this); |
if (in_array('evaluate', get_class_methods($this->xpath))) { |
$offset = $this->xpath->evaluate("count(preceding-sibling::rss:item)", $entries->item(0)); |
$this->entries[$offset] = $entry; |
} |
$this->idMappings[$id] = $entry; |
return $entry; |
} |
return false; |
} |
/** |
* Get details of the image associated with the feed. |
* |
* @return array|false an array simply containing the child elements |
*/ |
protected function getImage() |
{ |
$images = $this->model->getElementsByTagName('image'); |
if ($images->length > 0) { |
$image = $images->item(0); |
$details = array(); |
if ($image->hasChildNodes()) { |
$details = array( |
'title' => $image->getElementsByTagName('title')->item(0)->value, |
'link' => $image->getElementsByTagName('link')->item(0)->value, |
'url' => $image->getElementsByTagName('url')->item(0)->value); |
} else { |
$details = array('title' => false, |
'link' => false, |
'url' => $image->attributes->getNamedItem('resource')->nodeValue); |
} |
$details = array_merge($details, array('description' => false, 'height' => false, 'width' => false)); |
if (! empty($details)) { |
return $details; |
} |
} |
return false; |
} |
/** |
* The textinput element is little used, but in the interests of |
* completeness we will support it. |
* |
* @return array|false |
*/ |
protected function getTextInput() |
{ |
$inputs = $this->model->getElementsByTagName('textinput'); |
if ($inputs->length > 0) { |
$input = $inputs->item(0); |
$results = array(); |
$results['title'] = isset( |
$input->getElementsByTagName('title')->item(0)->value) ? |
$input->getElementsByTagName('title')->item(0)->value : null; |
$results['description'] = isset( |
$input->getElementsByTagName('description')->item(0)->value) ? |
$input->getElementsByTagName('description')->item(0)->value : null; |
$results['name'] = isset( |
$input->getElementsByTagName('name')->item(0)->value) ? |
$input->getElementsByTagName('name')->item(0)->value : null; |
$results['link'] = isset( |
$input->getElementsByTagName('link')->item(0)->value) ? |
$input->getElementsByTagName('link')->item(0)->value : null; |
if (empty($results['link']) and |
$input->attributes->getNamedItem('resource')) { |
$results['link'] = |
$input->attributes->getNamedItem('resource')->nodeValue; |
} |
if (! empty($results)) { |
return $results; |
} |
} |
return false; |
} |
/** |
* Employs various techniques to identify the author |
* |
* Dublin Core provides the dc:creator, dc:contributor, and dc:publisher |
* elements for defining authorship in RSS1. We will try each of those in |
* turn in order to simulate the atom author element and will return it |
* as text. |
* |
* @return array|false |
*/ |
function getAuthor() |
{ |
$options = array('creator', 'contributor', 'publisher'); |
foreach ($options as $element) { |
$test = $this->model->getElementsByTagName($element); |
if ($test->length > 0) { |
return $test->item(0)->value; |
} |
} |
return false; |
} |
/** |
* Retrieve a link |
* |
* In RSS1 a link is a text element but in order to ensure that we resolve |
* URLs properly we have a special function for them. |
* |
* @return string |
*/ |
function getLink($offset = 0, $attribute = 'href', $params = false) |
{ |
$links = $this->model->getElementsByTagName('link'); |
if ($links->length <= $offset) { |
return false; |
} |
$link = $links->item($offset); |
return $this->addBase($link->nodeValue, $link); |
} |
} |
?> |
/branches/v2.0-narmer/api/pear/XML/Feed/Parser/RSS11.php |
---|
New file |
0,0 → 1,276 |
<?php |
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */ |
/** |
* RSS1.1 class for XML_Feed_Parser |
* |
* PHP versions 5 |
* |
* LICENSE: This source file is subject to version 3.0 of the PHP license |
* that is available through the world-wide-web at the following URI: |
* http://www.php.net/license/3_0.txt. If you did not receive a copy of |
* the PHP License and are unable to obtain it through the web, please |
* send a note to license@php.net so we can mail you a copy immediately. |
* |
* @category XML |
* @package XML_Feed_Parser |
* @author James Stewart <james@jystewart.net> |
* @copyright 2005 James Stewart <james@jystewart.net> |
* @license http://www.gnu.org/copyleft/lesser.html GNU LGPL 2.1 |
* @version CVS: $Id: RSS11.php,v 1.1.2.1 2007-07-25 09:45:07 jp_milcent Exp $ |
* @link http://pear.php.net/package/XML_Feed_Parser/ |
*/ |
/** |
* This class handles RSS1.1 feeds. RSS1.1 is documented at: |
* http://inamidst.com/rss1.1/ |
* |
* @author James Stewart <james@jystewart.net> |
* @version Release: 1.0.2 |
* @package XML_Feed_Parser |
* @todo Support for RDF:List |
* @todo Ensure xml:lang is accessible to users |
*/ |
class XML_Feed_Parser_RSS11 extends XML_Feed_Parser_Type |
{ |
/** |
* The URI of the RelaxNG schema used to (optionally) validate the feed |
* @var string |
*/ |
private $relax = 'rss11.rnc'; |
/** |
* We're likely to use XPath, so let's keep it global |
* @var DOMXPath |
*/ |
protected $xpath; |
/** |
* The feed type we are parsing |
* @var string |
*/ |
public $version = 'RSS 1.0'; |
/** |
* The class used to represent individual items |
* @var string |
*/ |
protected $itemClass = 'XML_Feed_Parser_RSS1Element'; |
/** |
* The element containing entries |
* @var string |
*/ |
protected $itemElement = 'item'; |
/** |
* Here we map those elements we're not going to handle individually |
* to the constructs they are. The optional second parameter in the array |
* tells the parser whether to 'fall back' (not apt. at the feed level) or |
* fail if the element is missing. If the parameter is not set, the function |
* will simply return false and leave it to the client to decide what to do. |
* @var array |
*/ |
protected $map = array( |
'title' => array('Text'), |
'link' => array('Text'), |
'description' => array('Text'), |
'image' => array('Image'), |
'updatePeriod' => array('Text'), |
'updateFrequency' => array('Text'), |
'updateBase' => array('Date'), |
'rights' => array('Text'), # dc:rights |
'description' => array('Text'), # dc:description |
'creator' => array('Text'), # dc:creator |
'publisher' => array('Text'), # dc:publisher |
'contributor' => array('Text'), # dc:contributor |
'date' => array('Date') # dc:contributor |
); |
/** |
* Here we map some elements to their atom equivalents. This is going to be |
* quite tricky to pull off effectively (and some users' methods may vary) |
* but is worth trying. The key is the atom version, the value is RSS2. |
* @var array |
*/ |
protected $compatMap = array( |
'title' => array('title'), |
'link' => array('link'), |
'subtitle' => array('description'), |
'author' => array('creator'), |
'updated' => array('date')); |
/** |
* We will be working with multiple namespaces and it is useful to |
* keep them together. We will retain support for some common RSS1.0 modules |
* @var array |
*/ |
protected $namespaces = array( |
'rdf' => 'http://www.w3.org/1999/02/22-rdf-syntax-ns#', |
'rss' => 'http://purl.org/net/rss1.1#', |
'dc' => 'http://purl.org/rss/1.0/modules/dc/', |
'content' => 'http://purl.org/rss/1.0/modules/content/', |
'sy' => 'http://web.resource.org/rss/1.0/modules/syndication/'); |
/** |
* Our constructor does nothing more than its parent. |
* |
* @param DOMDocument $xml A DOM object representing the feed |
* @param bool (optional) $string Whether or not to validate this feed |
*/ |
function __construct(DOMDocument $model, $strict = false) |
{ |
$this->model = $model; |
if ($strict) { |
$validate = $this->model->relaxNGValidate(self::getSchemaDir . |
DIRECTORY_SEPARATOR . $this->relax); |
if (! $validate) { |
throw new XML_Feed_Parser_Exception('Failed required validation'); |
} |
} |
$this->xpath = new DOMXPath($model); |
foreach ($this->namespaces as $key => $value) { |
$this->xpath->registerNamespace($key, $value); |
} |
$this->numberEntries = $this->count('item'); |
} |
/** |
* Attempts to identify an element by ID given by the rdf:about attribute |
* |
* This is not really something that will work with RSS1.1 as it does not have |
* clear restrictions on the global uniqueness of IDs. We will employ the |
* _very_ hit and miss method of selecting entries based on the rdf:about |
* attribute. Please note that this is even more hit and miss with RSS1.1 than |
* with RSS1.0 since RSS1.1 does not require the rdf:about attribute for items. |
* |
* @param string $id any valid ID. |
* @return XML_Feed_Parser_RSS1Element |
*/ |
function getEntryById($id) |
{ |
if (isset($this->idMappings[$id])) { |
return $this->entries[$this->idMappings[$id]]; |
} |
$entries = $this->xpath->query("//rss:item[@rdf:about='$id']"); |
if ($entries->length > 0) { |
$classname = $this->itemClass; |
$entry = new $classname($entries->item(0), $this); |
return $entry; |
} |
return false; |
} |
/** |
* Get details of the image associated with the feed. |
* |
* @return array|false an array simply containing the child elements |
*/ |
protected function getImage() |
{ |
$images = $this->model->getElementsByTagName('image'); |
if ($images->length > 0) { |
$image = $images->item(0); |
$details = array(); |
if ($image->hasChildNodes()) { |
$details = array( |
'title' => $image->getElementsByTagName('title')->item(0)->value, |
'url' => $image->getElementsByTagName('url')->item(0)->value); |
if ($image->getElementsByTagName('link')->length > 0) { |
$details['link'] = |
$image->getElementsByTagName('link')->item(0)->value; |
} |
} else { |
$details = array('title' => false, |
'link' => false, |
'url' => $image->attributes->getNamedItem('resource')->nodeValue); |
} |
$details = array_merge($details, |
array('description' => false, 'height' => false, 'width' => false)); |
if (! empty($details)) { |
return $details; |
} |
} |
return false; |
} |
/** |
* The textinput element is little used, but in the interests of |
* completeness we will support it. |
* |
* @return array|false |
*/ |
protected function getTextInput() |
{ |
$inputs = $this->model->getElementsByTagName('textinput'); |
if ($inputs->length > 0) { |
$input = $inputs->item(0); |
$results = array(); |
$results['title'] = isset( |
$input->getElementsByTagName('title')->item(0)->value) ? |
$input->getElementsByTagName('title')->item(0)->value : null; |
$results['description'] = isset( |
$input->getElementsByTagName('description')->item(0)->value) ? |
$input->getElementsByTagName('description')->item(0)->value : null; |
$results['name'] = isset( |
$input->getElementsByTagName('name')->item(0)->value) ? |
$input->getElementsByTagName('name')->item(0)->value : null; |
$results['link'] = isset( |
$input->getElementsByTagName('link')->item(0)->value) ? |
$input->getElementsByTagName('link')->item(0)->value : null; |
if (empty($results['link']) and |
$input->attributes->getNamedItem('resource')) { |
$results['link'] = $input->attributes->getNamedItem('resource')->nodeValue; |
} |
if (! empty($results)) { |
return $results; |
} |
} |
return false; |
} |
/** |
* Attempts to discern authorship |
* |
* Dublin Core provides the dc:creator, dc:contributor, and dc:publisher |
* elements for defining authorship in RSS1. We will try each of those in |
* turn in order to simulate the atom author element and will return it |
* as text. |
* |
* @return array|false |
*/ |
function getAuthor() |
{ |
$options = array('creator', 'contributor', 'publisher'); |
foreach ($options as $element) { |
$test = $this->model->getElementsByTagName($element); |
if ($test->length > 0) { |
return $test->item(0)->value; |
} |
} |
return false; |
} |
/** |
* Retrieve a link |
* |
* In RSS1 a link is a text element but in order to ensure that we resolve |
* URLs properly we have a special function for them. |
* |
* @return string |
*/ |
function getLink($offset = 0, $attribute = 'href', $params = false) |
{ |
$links = $this->model->getElementsByTagName('link'); |
if ($links->length <= $offset) { |
return false; |
} |
$link = $links->item($offset); |
return $this->addBase($link->nodeValue, $link); |
} |
} |
?> |
/branches/v2.0-narmer/api/pear/XML/Feed/Parser/RSS2.php |
---|
New file |
0,0 → 1,334 |
<?php |
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */ |
/** |
* Class representing feed-level data for an RSS2 feed |
* |
* PHP versions 5 |
* |
* LICENSE: This source file is subject to version 3.0 of the PHP license |
* that is available through the world-wide-web at the following URI: |
* http://www.php.net/license/3_0.txt. If you did not receive a copy of |
* the PHP License and are unable to obtain it through the web, please |
* send a note to license@php.net so we can mail you a copy immediately. |
* |
* @category XML |
* @package XML_Feed_Parser |
* @author James Stewart <james@jystewart.net> |
* @copyright 2005 James Stewart <james@jystewart.net> |
* @license http://www.gnu.org/copyleft/lesser.html GNU LGPL 2.1 |
* @version CVS: $Id: RSS2.php,v 1.1.2.1 2007-07-25 09:45:07 jp_milcent Exp $ |
* @link http://pear.php.net/package/XML_Feed_Parser/ |
*/ |
/** |
* This class handles RSS2 feeds. |
* |
* @author James Stewart <james@jystewart.net> |
* @version Release: 1.0.2 |
* @package XML_Feed_Parser |
*/ |
class XML_Feed_Parser_RSS2 extends XML_Feed_Parser_Type |
{ |
/** |
* The URI of the RelaxNG schema used to (optionally) validate the feed |
* @var string |
*/ |
private $relax = 'rss20.rnc'; |
/** |
* We're likely to use XPath, so let's keep it global |
* @var DOMXPath |
*/ |
protected $xpath; |
/** |
* The feed type we are parsing |
* @var string |
*/ |
public $version = 'RSS 2.0'; |
/** |
* The class used to represent individual items |
* @var string |
*/ |
protected $itemClass = 'XML_Feed_Parser_RSS2Element'; |
/** |
* The element containing entries |
* @var string |
*/ |
protected $itemElement = 'item'; |
/** |
* Here we map those elements we're not going to handle individually |
* to the constructs they are. The optional second parameter in the array |
* tells the parser whether to 'fall back' (not apt. at the feed level) or |
* fail if the element is missing. If the parameter is not set, the function |
* will simply return false and leave it to the client to decide what to do. |
* @var array |
*/ |
protected $map = array( |
'ttl' => array('Text'), |
'pubDate' => array('Date'), |
'lastBuildDate' => array('Date'), |
'title' => array('Text'), |
'link' => array('Link'), |
'description' => array('Text'), |
'language' => array('Text'), |
'copyright' => array('Text'), |
'managingEditor' => array('Text'), |
'webMaster' => array('Text'), |
'category' => array('Text'), |
'generator' => array('Text'), |
'docs' => array('Text'), |
'ttl' => array('Text'), |
'image' => array('Image'), |
'skipDays' => array('skipDays'), |
'skipHours' => array('skipHours')); |
/** |
* Here we map some elements to their atom equivalents. This is going to be |
* quite tricky to pull off effectively (and some users' methods may vary) |
* but is worth trying. The key is the atom version, the value is RSS2. |
* @var array |
*/ |
protected $compatMap = array( |
'title' => array('title'), |
'rights' => array('copyright'), |
'updated' => array('lastBuildDate'), |
'subtitle' => array('description'), |
'date' => array('pubDate'), |
'author' => array('managingEditor')); |
protected $namespaces = array( |
'dc' => 'http://purl.org/rss/1.0/modules/dc/', |
'content' => 'http://purl.org/rss/1.0/modules/content/'); |
/** |
* Our constructor does nothing more than its parent. |
* |
* @param DOMDocument $xml A DOM object representing the feed |
* @param bool (optional) $string Whether or not to validate this feed |
*/ |
function __construct(DOMDocument $model, $strict = false) |
{ |
$this->model = $model; |
if ($strict) { |
if (! $this->model->relaxNGValidate($this->relax)) { |
throw new XML_Feed_Parser_Exception('Failed required validation'); |
} |
} |
$this->xpath = new DOMXPath($this->model); |
foreach ($this->namespaces as $key => $value) { |
$this->xpath->registerNamespace($key, $value); |
} |
$this->numberEntries = $this->count('item'); |
} |
/** |
* Retrieves an entry by ID, if the ID is specified with the guid element |
* |
* This is not really something that will work with RSS2 as it does not have |
* clear restrictions on the global uniqueness of IDs. But we can emulate |
* it by allowing access based on the 'guid' element. If DOMXPath::evaluate |
* is available, we also use that to store a reference to the entry in the array |
* used by getEntryByOffset so that method does not have to seek out the entry |
* if it's requested that way. |
* |
* @param string $id any valid ID. |
* @return XML_Feed_Parser_RSS2Element |
*/ |
function getEntryById($id) |
{ |
if (isset($this->idMappings[$id])) { |
return $this->entries[$this->idMappings[$id]]; |
} |
$entries = $this->xpath->query("//item[guid='$id']"); |
if ($entries->length > 0) { |
$entry = new $this->itemElement($entries->item(0), $this); |
if (in_array('evaluate', get_class_methods($this->xpath))) { |
$offset = $this->xpath->evaluate("count(preceding-sibling::item)", $entries->item(0)); |
$this->entries[$offset] = $entry; |
} |
$this->idMappings[$id] = $entry; |
return $entry; |
} |
} |
/** |
* Get a category from the element |
* |
* The category element is a simple text construct which can occur any number |
* of times. We allow access by offset or access to an array of results. |
* |
* @param string $call for compatibility with our overloading |
* @param array $arguments - arg 0 is the offset, arg 1 is whether to return as array |
* @return string|array|false |
*/ |
function getCategory($call, $arguments = array()) |
{ |
$categories = $this->model->getElementsByTagName('category'); |
$offset = empty($arguments[0]) ? 0 : $arguments[0]; |
$array = empty($arguments[1]) ? false : true; |
if ($categories->length <= $offset) { |
return false; |
} |
if ($array) { |
$list = array(); |
foreach ($categories as $category) { |
array_push($list, $category->nodeValue); |
} |
return $list; |
} |
return $categories->item($offset)->nodeValue; |
} |
/** |
* Get details of the image associated with the feed. |
* |
* @return array|false an array simply containing the child elements |
*/ |
protected function getImage() |
{ |
$images = $this->model->getElementsByTagName('image'); |
if ($images->length > 0) { |
$image = $images->item(0); |
$desc = $image->getElementsByTagName('description'); |
$description = $desc->length ? $desc->item(0)->nodeValue : false; |
$heigh = $image->getElementsByTagName('height'); |
$height = $heigh->length ? $heigh->item(0)->nodeValue : false; |
$widt = $image->getElementsByTagName('width'); |
$width = $widt->length ? $widt->item(0)->nodeValue : false; |
return array( |
'title' => $image->getElementsByTagName('title')->item(0)->nodeValue, |
'link' => $image->getElementsByTagName('link')->item(0)->nodeValue, |
'url' => $image->getElementsByTagName('url')->item(0)->nodeValue, |
'description' => $description, |
'height' => $height, |
'width' => $width); |
} |
return false; |
} |
/** |
* The textinput element is little used, but in the interests of |
* completeness... |
* |
* @return array|false |
*/ |
function getTextInput() |
{ |
$inputs = $this->model->getElementsByTagName('input'); |
if ($inputs->length > 0) { |
$input = $inputs->item(0); |
return array( |
'title' => $input->getElementsByTagName('title')->item(0)->value, |
'description' => |
$input->getElementsByTagName('description')->item(0)->value, |
'name' => $input->getElementsByTagName('name')->item(0)->value, |
'link' => $input->getElementsByTagName('link')->item(0)->value); |
} |
return false; |
} |
/** |
* Utility function for getSkipDays and getSkipHours |
* |
* This is a general function used by both getSkipDays and getSkipHours. It simply |
* returns an array of the values of the children of the appropriate tag. |
* |
* @param string $tagName The tag name (getSkipDays or getSkipHours) |
* @return array|false |
*/ |
protected function getSkips($tagName) |
{ |
$hours = $this->model->getElementsByTagName($tagName); |
if ($hours->length == 0) { |
return false; |
} |
$skipHours = array(); |
foreach($hours->item(0)->childNodes as $hour) { |
if ($hour instanceof DOMElement) { |
array_push($skipHours, $hour->nodeValue); |
} |
} |
return $skipHours; |
} |
/** |
* Retrieve skipHours data |
* |
* The skiphours element provides a list of hours on which this feed should |
* not be checked. We return an array of those hours (integers, 24 hour clock) |
* |
* @return array |
*/ |
function getSkipHours() |
{ |
return $this->getSkips('skipHours'); |
} |
/** |
* Retrieve skipDays data |
* |
* The skipdays element provides a list of days on which this feed should |
* not be checked. We return an array of those days. |
* |
* @return array |
*/ |
function getSkipDays() |
{ |
return $this->getSkips('skipDays'); |
} |
/** |
* Return content of the little-used 'cloud' element |
* |
* The cloud element is rarely used. It is designed to provide some details |
* of a location to update the feed. |
* |
* @return array an array of the attributes of the element |
*/ |
function getCloud() |
{ |
$cloud = $this->model->getElementsByTagName('cloud'); |
if ($cloud->length == 0) { |
return false; |
} |
$cloudData = array(); |
foreach ($cloud->item(0)->attributes as $attribute) { |
$cloudData[$attribute->name] = $attribute->value; |
} |
return $cloudData; |
} |
/** |
* Get link URL |
* |
* In RSS2 a link is a text element but in order to ensure that we resolve |
* URLs properly we have a special function for them. We maintain the |
* parameter used by the atom getLink method, though we only use the offset |
* parameter. |
* |
* @param int $offset The position of the link within the feed. Starts from 0 |
* @param string $attribute The attribute of the link element required |
* @param array $params An array of other parameters. Not used. |
* @return string |
*/ |
function getLink($offset, $attribute = 'href', $params = array()) |
{ |
$links = $this->model->getElementsByTagName('link'); |
if ($links->length <= $offset) { |
return false; |
} |
$link = $links->item($offset); |
return $this->addBase($link->nodeValue, $link); |
} |
} |
?> |
/branches/v2.0-narmer/api/pear/XML/Feed/Parser/AtomElement.php |
---|
New file |
0,0 → 1,261 |
<?php |
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */ |
/** |
* AtomElement class for XML_Feed_Parser package |
* |
* PHP versions 5 |
* |
* LICENSE: This source file is subject to version 3.0 of the PHP license |
* that is available through the world-wide-web at the following URI: |
* http://www.php.net/license/3_0.txt. If you did not receive a copy of |
* the PHP License and are unable to obtain it through the web, please |
* send a note to license@php.net so we can mail you a copy immediately. |
* |
* @category XML |
* @package XML_Feed_Parser |
* @author James Stewart <james@jystewart.net> |
* @copyright 2005 James Stewart <james@jystewart.net> |
* @license http://www.gnu.org/copyleft/lesser.html GNU LGPL 2.1 |
* @version CVS: $Id: AtomElement.php,v 1.1.2.1 2007-07-25 09:45:07 jp_milcent Exp $ |
* @link http://pear.php.net/package/XML_Feed_Parser/ |
*/ |
/** |
* This class provides support for atom entries. It will usually be called by |
* XML_Feed_Parser_Atom with which it shares many methods. |
* |
* @author James Stewart <james@jystewart.net> |
* @version Release: 1.0.2 |
* @package XML_Feed_Parser |
*/ |
class XML_Feed_Parser_AtomElement extends XML_Feed_Parser_Atom |
{ |
/** |
* This will be a reference to the parent object for when we want |
* to use a 'fallback' rule |
* @var XML_Feed_Parser_Atom |
*/ |
protected $parent; |
/** |
* When performing XPath queries we will use this prefix |
* @var string |
*/ |
private $xpathPrefix = ''; |
/** |
* xml:base values inherited by the element |
* @var string |
*/ |
protected $xmlBase; |
/** |
* Here we provide a few mappings for those very special circumstances in |
* which it makes sense to map back to the RSS2 spec or to manage other |
* compatibilities (eg. with the Univeral Feed Parser). Key is the other version's |
* name for the command, value is an array consisting of the equivalent in our atom |
* api and any attributes needed to make the mapping. |
* @var array |
*/ |
protected $compatMap = array( |
'guid' => array('id'), |
'links' => array('link'), |
'tags' => array('category'), |
'contributors' => array('contributor')); |
/** |
* Our specific element map |
* @var array |
*/ |
protected $map = array( |
'author' => array('Person', 'fallback'), |
'contributor' => array('Person'), |
'id' => array('Text', 'fail'), |
'published' => array('Date'), |
'updated' => array('Date', 'fail'), |
'title' => array('Text', 'fail'), |
'rights' => array('Text', 'fallback'), |
'summary' => array('Text'), |
'content' => array('Content'), |
'link' => array('Link'), |
'enclosure' => array('Enclosure'), |
'category' => array('Category')); |
/** |
* Store useful information for later. |
* |
* @param DOMElement $element - this item as a DOM element |
* @param XML_Feed_Parser_Atom $parent - the feed of which this is a member |
*/ |
function __construct(DOMElement $element, $parent, $xmlBase = '') |
{ |
$this->model = $element; |
$this->parent = $parent; |
$this->xmlBase = $xmlBase; |
$this->xpathPrefix = "//atom:entry[atom:id='" . $this->id . "']/"; |
$this->xpath = $this->parent->xpath; |
} |
/** |
* Provides access to specific aspects of the author data for an atom entry |
* |
* Author data at the entry level is more complex than at the feed level. |
* If atom:author is not present for the entry we need to look for it in |
* an atom:source child of the atom:entry. If it's not there either, then |
* we look to the parent for data. |
* |
* @param array |
* @return string |
*/ |
function getAuthor($arguments) |
{ |
/* Find out which part of the author data we're looking for */ |
if (isset($arguments['param'])) { |
$parameter = $arguments['param']; |
} else { |
$parameter = 'name'; |
} |
$test = $this->model->getElementsByTagName('author'); |
if ($test->length > 0) { |
$item = $test->item(0); |
return $item->getElementsByTagName($parameter)->item(0)->nodeValue; |
} |
$source = $this->model->getElementsByTagName('source'); |
if ($source->length > 0) { |
$test = $this->model->getElementsByTagName('author'); |
if ($test->length > 0) { |
$item = $test->item(0); |
return $item->getElementsByTagName($parameter)->item(0)->nodeValue; |
} |
} |
return $this->parent->getAuthor($arguments); |
} |
/** |
* Returns the content of the content element or info on a specific attribute |
* |
* This element may or may not be present. It cannot be present more than |
* once. It may have a 'src' attribute, in which case there's no content |
* If not present, then the entry must have link with rel="alternate". |
* If there is content we return it, if not and there's a 'src' attribute |
* we return the value of that instead. The method can take an 'attribute' |
* argument, in which case we return the value of that attribute if present. |
* eg. $item->content("type") will return the type of the content. It is |
* recommended that all users check the type before getting the content to |
* ensure that their script is capable of handling the type of returned data. |
* (data carried in the content element can be either 'text', 'html', 'xhtml', |
* or any standard MIME type). |
* |
* @return string|false |
*/ |
protected function getContent($method, $arguments = array()) |
{ |
$attribute = empty($arguments[0]) ? false : $arguments[0]; |
$tags = $this->model->getElementsByTagName('content'); |
if ($tags->length == 0) { |
return false; |
} |
$content = $tags->item(0); |
if (! $content->hasAttribute('type')) { |
$content->setAttribute('type', 'text'); |
} |
if (! empty($attribute)) { |
return $content->getAttribute($attribute); |
} |
$type = $content->getAttribute('type'); |
if (! empty($attribute)) { |
if ($content->hasAttribute($attribute)) |
{ |
return $content->getAttribute($attribute); |
} |
return false; |
} |
if ($content->hasAttribute('src')) { |
return $content->getAttribute('src'); |
} |
return $this->parseTextConstruct($content); |
} |
/** |
* For compatibility, this method provides a mapping to access enclosures. |
* |
* The Atom spec doesn't provide for an enclosure element, but it is |
* generally supported using the link element with rel='enclosure'. |
* |
* @param string $method - for compatibility with our __call usage |
* @param array $arguments - for compatibility with our __call usage |
* @return array|false |
*/ |
function getEnclosure($method, $arguments = array()) |
{ |
$offset = isset($arguments[0]) ? $arguments[0] : 0; |
$query = "//atom:entry[atom:id='" . $this->getText('id', false) . |
"']/atom:link[@rel='enclosure']"; |
$encs = $this->parent->xpath->query($query); |
if ($encs->length > $offset) { |
try { |
if (! $encs->item($offset)->hasAttribute('href')) { |
return false; |
} |
$attrs = $encs->item($offset)->attributes; |
$length = $encs->item($offset)->hasAttribute('length') ? |
$encs->item($offset)->getAttribute('length') : false; |
return array( |
'url' => $attrs->getNamedItem('href')->value, |
'type' => $attrs->getNamedItem('type')->value, |
'length' => $length); |
} catch (Exception $e) { |
return false; |
} |
} |
return false; |
} |
/** |
* Get details of this entry's source, if available/relevant |
* |
* Where an atom:entry is taken from another feed then the aggregator |
* is supposed to include an atom:source element which replicates at least |
* the atom:id, atom:title, and atom:updated metadata from the original |
* feed. Atom:source therefore has a very similar structure to atom:feed |
* and if we find it we will return it as an XML_Feed_Parser_Atom object. |
* |
* @return XML_Feed_Parser_Atom|false |
*/ |
function getSource() |
{ |
$test = $this->model->getElementsByTagName('source'); |
if ($test->length == 0) { |
return false; |
} |
$source = new XML_Feed_Parser_Atom($test->item(0)); |
} |
/** |
* Get the entry as an XML string |
* |
* Return an XML serialization of the feed, should it be required. Most |
* users however, will already have a serialization that they used when |
* instantiating the object. |
* |
* @return string XML serialization of element |
*/ |
function __toString() |
{ |
$simple = simplexml_import_dom($this->model); |
return $simple->asXML(); |
} |
} |
?> |
/branches/v2.0-narmer/api/pear/XML/Feed/Parser/RSS09Element.php |
---|
New file |
0,0 → 1,62 |
<?php |
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */ |
/** |
* RSS0.9 Element class for XML_Feed_Parser |
* |
* PHP versions 5 |
* |
* LICENSE: This source file is subject to version 3.0 of the PHP license |
* that is available through the world-wide-web at the following URI: |
* http://www.php.net/license/3_0.txt. If you did not receive a copy of |
* the PHP License and are unable to obtain it through the web, please |
* send a note to license@php.net so we can mail you a copy immediately. |
* |
* @category XML |
* @package XML_Feed_Parser |
* @author James Stewart <james@jystewart.net> |
* @copyright 2005 James Stewart <james@jystewart.net> |
* @license http://www.gnu.org/copyleft/lesser.html GNU LGPL 2.1 |
* @version CVS: $Id: RSS09Element.php,v 1.1.2.1 2007-07-25 09:45:07 jp_milcent Exp $ |
* @link http://pear.php.net/package/XML_Feed_Parser/ |
*/ |
/* |
* This class provides support for RSS 0.9 entries. It will usually be called by |
* XML_Feed_Parser_RSS09 with which it shares many methods. |
* |
* @author James Stewart <james@jystewart.net> |
* @version Release: 1.0.2 |
* @package XML_Feed_Parser |
*/ |
class XML_Feed_Parser_RSS09Element extends XML_Feed_Parser_RSS09 |
{ |
/** |
* This will be a reference to the parent object for when we want |
* to use a 'fallback' rule |
* @var XML_Feed_Parser_RSS09 |
*/ |
protected $parent; |
/** |
* Our specific element map |
* @var array |
*/ |
protected $map = array( |
'title' => array('Text'), |
'link' => array('Link')); |
/** |
* Store useful information for later. |
* |
* @param DOMElement $element - this item as a DOM element |
* @param XML_Feed_Parser_RSS1 $parent - the feed of which this is a member |
*/ |
function __construct(DOMElement $element, $parent, $xmlBase = '') |
{ |
$this->model = $element; |
$this->parent = $parent; |
} |
} |
?> |
/branches/v2.0-narmer/api/pear/XML/Feed/Parser/Exception.php |
---|
New file |
0,0 → 1,42 |
<?php |
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */ |
/** |
* Keeps the exception class for XML_Feed_Parser. |
* |
* PHP versions 5 |
* |
* LICENSE: This source file is subject to version 3.0 of the PHP license |
* that is available through the world-wide-web at the following URI: |
* http://www.php.net/license/3_0.txt. If you did not receive a copy of |
* the PHP License and are unable to obtain it through the web, please |
* send a note to license@php.net so we can mail you a copy immediately. |
* |
* @category XML |
* @package XML_Feed_Parser |
* @author James Stewart <james@jystewart.net> |
* @copyright 2005 James Stewart <james@jystewart.net> |
* @license http://www.gnu.org/copyleft/lesser.html GNU LGPL |
* @version CVS: $Id: Exception.php,v 1.1.2.1 2007-07-25 09:45:07 jp_milcent Exp $ |
* @link http://pear.php.net/package/XML_Feed_Parser/ |
*/ |
/** |
* We are extending PEAR_Exception |
*/ |
require_once 'PEAR/Exception.php'; |
/** |
* XML_Feed_Parser_Exception is a simple extension of PEAR_Exception, existing |
* to help with identification of the source of exceptions. |
* |
* @author James Stewart <james@jystewart.net> |
* @version Release: 1.0.2 |
* @package XML_Feed_Parser |
*/ |
class XML_Feed_Parser_Exception extends PEAR_Exception |
{ |
} |
?> |
/branches/v2.0-narmer/api/pear/XML/Feed/Parser/Atom.php |
---|
New file |
0,0 → 1,365 |
<?php |
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */ |
/** |
* Atom feed class for XML_Feed_Parser |
* |
* PHP versions 5 |
* |
* LICENSE: This source file is subject to version 3.0 of the PHP license |
* that is available through the world-wide-web at the following URI: |
* http://www.php.net/license/3_0.txt. If you did not receive a copy of |
* the PHP License and are unable to obtain it through the web, please |
* send a note to license@php.net so we can mail you a copy immediately. |
* |
* @category XML |
* @package XML_Feed_Parser |
* @author James Stewart <james@jystewart.net> |
* @copyright 2005 James Stewart <james@jystewart.net> |
* @license http://www.gnu.org/copyleft/lesser.html GNU LGPL 2.1 |
* @version CVS: $Id: Atom.php,v 1.1.2.1 2007-07-25 09:45:07 jp_milcent Exp $ |
* @link http://pear.php.net/package/XML_Feed_Parser/ |
*/ |
/** |
* This is the class that determines how we manage Atom 1.0 feeds |
* |
* How we deal with constructs: |
* date - return as unix datetime for use with the 'date' function unless specified otherwise |
* text - return as is. optional parameter will give access to attributes |
* person - defaults to name, but parameter based access |
* |
* @author James Stewart <james@jystewart.net> |
* @version Release: 1.0.2 |
* @package XML_Feed_Parser |
*/ |
class XML_Feed_Parser_Atom extends XML_Feed_Parser_Type |
{ |
/** |
* The URI of the RelaxNG schema used to (optionally) validate the feed |
* @var string |
*/ |
private $relax = 'atom.rnc'; |
/** |
* We're likely to use XPath, so let's keep it global |
* @var DOMXPath |
*/ |
public $xpath; |
/** |
* When performing XPath queries we will use this prefix |
* @var string |
*/ |
private $xpathPrefix = '//'; |
/** |
* The feed type we are parsing |
* @var string |
*/ |
public $version = 'Atom 1.0'; |
/** |
* The class used to represent individual items |
* @var string |
*/ |
protected $itemClass = 'XML_Feed_Parser_AtomElement'; |
/** |
* The element containing entries |
* @var string |
*/ |
protected $itemElement = 'entry'; |
/** |
* Here we map those elements we're not going to handle individually |
* to the constructs they are. The optional second parameter in the array |
* tells the parser whether to 'fall back' (not apt. at the feed level) or |
* fail if the element is missing. If the parameter is not set, the function |
* will simply return false and leave it to the client to decide what to do. |
* @var array |
*/ |
protected $map = array( |
'author' => array('Person'), |
'contributor' => array('Person'), |
'icon' => array('Text'), |
'logo' => array('Text'), |
'id' => array('Text', 'fail'), |
'rights' => array('Text'), |
'subtitle' => array('Text'), |
'title' => array('Text', 'fail'), |
'updated' => array('Date', 'fail'), |
'link' => array('Link'), |
'generator' => array('Text'), |
'category' => array('Category')); |
/** |
* Here we provide a few mappings for those very special circumstances in |
* which it makes sense to map back to the RSS2 spec. Key is RSS2 version |
* value is an array consisting of the equivalent in atom and any attributes |
* needed to make the mapping. |
* @var array |
*/ |
protected $compatMap = array( |
'guid' => array('id'), |
'links' => array('link'), |
'tags' => array('category'), |
'contributors' => array('contributor')); |
/** |
* Our constructor does nothing more than its parent. |
* |
* @param DOMDocument $xml A DOM object representing the feed |
* @param bool (optional) $string Whether or not to validate this feed |
*/ |
function __construct(DOMDocument $model, $strict = false) |
{ |
$this->model = $model; |
if ($strict) { |
if (! $this->model->relaxNGValidateSource($this->relax)) { |
throw new XML_Feed_Parser_Exception('Failed required validation'); |
} |
} |
$this->xpath = new DOMXPath($this->model); |
$this->xpath->registerNamespace('atom', 'http://www.w3.org/2005/Atom'); |
$this->numberEntries = $this->count('entry'); |
} |
/** |
* Implement retrieval of an entry based on its ID for atom feeds. |
* |
* This function uses XPath to get the entry based on its ID. If DOMXPath::evaluate |
* is available, we also use that to store a reference to the entry in the array |
* used by getEntryByOffset so that method does not have to seek out the entry |
* if it's requested that way. |
* |
* @param string $id any valid Atom ID. |
* @return XML_Feed_Parser_AtomElement |
*/ |
function getEntryById($id) |
{ |
if (isset($this->idMappings[$id])) { |
return $this->entries[$this->idMappings[$id]]; |
} |
$entries = $this->xpath->query("//atom:entry[atom:id='$id']"); |
if ($entries->length > 0) { |
$xmlBase = $entries->item(0)->baseURI; |
$entry = new $this->itemElement($entries->item(0), $this, $xmlBase); |
if (in_array('evaluate', get_class_methods($this->xpath))) { |
$offset = $this->xpath->evaluate("count(preceding-sibling::atom:entry)", $entries->item(0)); |
$this->entries[$offset] = $entry; |
} |
$this->idMappings[$id] = $entry; |
return $entry; |
} |
} |
/** |
* Retrieves data from a person construct. |
* |
* Get a person construct. We default to the 'name' element but allow |
* access to any of the elements. |
* |
* @param string $method The name of the person construct we want |
* @param array $arguments An array which we hope gives a 'param' |
* @return string|false |
*/ |
protected function getPerson($method, $arguments) |
{ |
$offset = empty($arguments[0]) ? 0 : $arguments[0]; |
$parameter = empty($arguments[1]['param']) ? 'name' : $arguments[1]['param']; |
$section = $this->model->getElementsByTagName($method); |
if ($parameter == 'url') { |
$parameter = 'uri'; |
} |
if ($section->length <= $offset) { |
return false; |
} |
$param = $section->item($offset)->getElementsByTagName($parameter); |
if ($param->length == 0) { |
return false; |
} |
return $param->item(0)->nodeValue; |
} |
/** |
* Retrieves an element's content where that content is a text construct. |
* |
* Get a text construct. When calling this method, the two arguments |
* allowed are 'offset' and 'attribute', so $parser->subtitle() would |
* return the content of the element, while $parser->subtitle(false, 'type') |
* would return the value of the type attribute. |
* |
* @todo Clarify overlap with getContent() |
* @param string $method The name of the text construct we want |
* @param array $arguments An array which we hope gives a 'param' |
* @return string |
*/ |
protected function getText($method, $arguments) |
{ |
$offset = empty($arguments[0]) ? 0: $arguments[0]; |
$attribute = empty($arguments[1]) ? false : $arguments[1]; |
$tags = $this->model->getElementsByTagName($method); |
if ($tags->length <= $offset) { |
return false; |
} |
$content = $tags->item($offset); |
if (! $content->hasAttribute('type')) { |
$content->setAttribute('type', 'text'); |
} |
$type = $content->getAttribute('type'); |
if (! empty($attribute) and |
! ($method == 'generator' and $attribute == 'name')) { |
if ($content->hasAttribute($attribute)) { |
return $content->getAttribute($attribute); |
} else if ($attribute == 'href' and $content->hasAttribute('uri')) { |
return $content->getAttribute('uri'); |
} |
return false; |
} |
return $this->parseTextConstruct($content); |
} |
/** |
* Extract content appropriately from atom text constructs |
* |
* Because of different rules applied to the content element and other text |
* constructs, they are deployed as separate functions, but they share quite |
* a bit of processing. This method performs the core common process, which is |
* to apply the rules for different mime types in order to extract the content. |
* |
* @param DOMNode $content the text construct node to be parsed |
* @return String |
* @author James Stewart |
**/ |
protected function parseTextConstruct(DOMNode $content) |
{ |
if ($content->hasAttribute('type')) { |
$type = $content->getAttribute('type'); |
} else { |
$type = 'text'; |
} |
if (strpos($type, 'text/') === 0) { |
$type = 'text'; |
} |
switch ($type) { |
case 'text': |
return $content->nodeValue; |
break; |
case 'html': |
return str_replace('<', '<', $content->nodeValue); |
break; |
case 'xhtml': |
$container = $content->getElementsByTagName('div'); |
if ($container->length == 0) { |
return false; |
} |
$contents = $container->item(0); |
if ($contents->hasChildNodes()) { |
/* Iterate through, applying xml:base and store the result */ |
$result = ''; |
foreach ($contents->childNodes as $node) { |
$result .= $this->traverseNode($node); |
} |
return utf8_decode($result); |
} |
break; |
case preg_match('@^[a-zA-Z]+/[a-zA-Z+]*xml@i', $type) > 0: |
return $content; |
break; |
case 'application/octet-stream': |
default: |
return base64_decode(trim($content->nodeValue)); |
break; |
} |
return false; |
} |
/** |
* Get a category from the entry. |
* |
* A feed or entry can have any number of categories. A category can have the |
* attributes term, scheme and label. |
* |
* @param string $method The name of the text construct we want |
* @param array $arguments An array which we hope gives a 'param' |
* @return string |
*/ |
function getCategory($method, $arguments) |
{ |
$offset = empty($arguments[0]) ? 0: $arguments[0]; |
$attribute = empty($arguments[1]) ? 'term' : $arguments[1]; |
$categories = $this->model->getElementsByTagName('category'); |
if ($categories->length <= $offset) { |
$category = $categories->item($offset); |
if ($category->hasAttribute($attribute)) { |
return $category->getAttribute($attribute); |
} |
} |
return false; |
} |
/** |
* This element must be present at least once with rel="feed". This element may be |
* present any number of further times so long as there is no clash. If no 'rel' is |
* present and we're asked for one, we follow the example of the Universal Feed |
* Parser and presume 'alternate'. |
* |
* @param int $offset the position of the link within the container |
* @param string $attribute the attribute name required |
* @param array an array of attributes to search by |
* @return string the value of the attribute |
*/ |
function getLink($offset = 0, $attribute = 'href', $params = false) |
{ |
if (is_array($params) and !empty($params)) { |
$terms = array(); |
$alt_predicate = ''; |
$other_predicate = ''; |
foreach ($params as $key => $value) { |
if ($key == 'rel' && $value == 'alternate') { |
$alt_predicate = '[not(@rel) or @rel="alternate"]'; |
} else { |
$terms[] = "@$key='$value'"; |
} |
} |
if (!empty($terms)) { |
$other_predicate = '[' . join(' and ', $terms) . ']'; |
} |
$query = $this->xpathPrefix . 'atom:link' . $alt_predicate . $other_predicate; |
$links = $this->xpath->query($query); |
} else { |
$links = $this->model->getElementsByTagName('link'); |
} |
if ($links->length > $offset) { |
if ($links->item($offset)->hasAttribute($attribute)) { |
$value = $links->item($offset)->getAttribute($attribute); |
if ($attribute == 'href') { |
$value = $this->addBase($value, $links->item($offset)); |
} |
return $value; |
} else if ($attribute == 'rel') { |
return 'alternate'; |
} |
} |
return false; |
} |
} |
?> |
/branches/v2.0-narmer/api/pear/XML/Feed/Parser/RSS09.php |
---|
New file |
0,0 → 1,214 |
<?php |
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */ |
/** |
* RSS0.9 class for XML_Feed_Parser |
* |
* PHP versions 5 |
* |
* LICENSE: This source file is subject to version 3.0 of the PHP license |
* that is available through the world-wide-web at the following URI: |
* http://www.php.net/license/3_0.txt. If you did not receive a copy of |
* the PHP License and are unable to obtain it through the web, please |
* send a note to license@php.net so we can mail you a copy immediately. |
* |
* @category XML |
* @package XML_Feed_Parser |
* @author James Stewart <james@jystewart.net> |
* @copyright 2005 James Stewart <james@jystewart.net> |
* @license http://www.gnu.org/copyleft/lesser.html GNU LGPL 2.1 |
* @version CVS: $Id: RSS09.php,v 1.1.2.1 2007-07-25 09:45:07 jp_milcent Exp $ |
* @link http://pear.php.net/package/XML_Feed_Parser/ |
*/ |
/** |
* This class handles RSS0.9 feeds. |
* |
* @author James Stewart <james@jystewart.net> |
* @version Release: 1.0.2 |
* @package XML_Feed_Parser |
* @todo Find a Relax NG URI we can use |
*/ |
class XML_Feed_Parser_RSS09 extends XML_Feed_Parser_Type |
{ |
/** |
* The URI of the RelaxNG schema used to (optionally) validate the feed |
* @var string |
*/ |
private $relax = ''; |
/** |
* We're likely to use XPath, so let's keep it global |
* @var DOMXPath |
*/ |
protected $xpath; |
/** |
* The feed type we are parsing |
* @var string |
*/ |
public $version = 'RSS 0.9'; |
/** |
* The class used to represent individual items |
* @var string |
*/ |
protected $itemClass = 'XML_Feed_Parser_RSS09Element'; |
/** |
* The element containing entries |
* @var string |
*/ |
protected $itemElement = 'item'; |
/** |
* Here we map those elements we're not going to handle individually |
* to the constructs they are. The optional second parameter in the array |
* tells the parser whether to 'fall back' (not apt. at the feed level) or |
* fail if the element is missing. If the parameter is not set, the function |
* will simply return false and leave it to the client to decide what to do. |
* @var array |
*/ |
protected $map = array( |
'title' => array('Text'), |
'link' => array('Text'), |
'description' => array('Text'), |
'image' => array('Image'), |
'textinput' => array('TextInput')); |
/** |
* Here we map some elements to their atom equivalents. This is going to be |
* quite tricky to pull off effectively (and some users' methods may vary) |
* but is worth trying. The key is the atom version, the value is RSS2. |
* @var array |
*/ |
protected $compatMap = array( |
'title' => array('title'), |
'link' => array('link'), |
'subtitle' => array('description')); |
/** |
* We will be working with multiple namespaces and it is useful to |
* keep them together |
* @var array |
*/ |
protected $namespaces = array( |
'rdf' => 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'); |
/** |
* Our constructor does nothing more than its parent. |
* |
* @todo RelaxNG validation |
* @param DOMDocument $xml A DOM object representing the feed |
* @param bool (optional) $string Whether or not to validate this feed |
*/ |
function __construct(DOMDocument $model, $strict = false) |
{ |
$this->model = $model; |
$this->xpath = new DOMXPath($model); |
foreach ($this->namespaces as $key => $value) { |
$this->xpath->registerNamespace($key, $value); |
} |
$this->numberEntries = $this->count('item'); |
} |
/** |
* Included for compatibility -- will not work with RSS 0.9 |
* |
* This is not something that will work with RSS0.9 as it does not have |
* clear restrictions on the global uniqueness of IDs. |
* |
* @param string $id any valid ID. |
* @return false |
*/ |
function getEntryById($id) |
{ |
return false; |
} |
/** |
* Get details of the image associated with the feed. |
* |
* @return array|false an array simply containing the child elements |
*/ |
protected function getImage() |
{ |
$images = $this->model->getElementsByTagName('image'); |
if ($images->length > 0) { |
$image = $images->item(0); |
$details = array(); |
if ($image->hasChildNodes()) { |
$details = array( |
'title' => $image->getElementsByTagName('title')->item(0)->value, |
'link' => $image->getElementsByTagName('link')->item(0)->value, |
'url' => $image->getElementsByTagName('url')->item(0)->value); |
} else { |
$details = array('title' => false, |
'link' => false, |
'url' => $image->attributes->getNamedItem('resource')->nodeValue); |
} |
$details = array_merge($details, |
array('description' => false, 'height' => false, 'width' => false)); |
if (! empty($details)) { |
return $details; |
} |
} |
return false; |
} |
/** |
* The textinput element is little used, but in the interests of |
* completeness we will support it. |
* |
* @return array|false |
*/ |
protected function getTextInput() |
{ |
$inputs = $this->model->getElementsByTagName('textinput'); |
if ($inputs->length > 0) { |
$input = $inputs->item(0); |
$results = array(); |
$results['title'] = isset( |
$input->getElementsByTagName('title')->item(0)->value) ? |
$input->getElementsByTagName('title')->item(0)->value : null; |
$results['description'] = isset( |
$input->getElementsByTagName('description')->item(0)->value) ? |
$input->getElementsByTagName('description')->item(0)->value : null; |
$results['name'] = isset( |
$input->getElementsByTagName('name')->item(0)->value) ? |
$input->getElementsByTagName('name')->item(0)->value : null; |
$results['link'] = isset( |
$input->getElementsByTagName('link')->item(0)->value) ? |
$input->getElementsByTagName('link')->item(0)->value : null; |
if (empty($results['link']) && |
$input->attributes->getNamedItem('resource')) { |
$results['link'] = $input->attributes->getNamedItem('resource')->nodeValue; |
} |
if (! empty($results)) { |
return $results; |
} |
} |
return false; |
} |
/** |
* Get details of a link from the feed. |
* |
* In RSS1 a link is a text element but in order to ensure that we resolve |
* URLs properly we have a special function for them. |
* |
* @return string |
*/ |
function getLink($offset = 0, $attribute = 'href', $params = false) |
{ |
$links = $this->model->getElementsByTagName('link'); |
if ($links->length <= $offset) { |
return false; |
} |
$link = $links->item($offset); |
return $this->addBase($link->nodeValue, $link); |
} |
} |
?> |
/branches/v2.0-narmer/api/pear/XML/Feed/Parser/Type.php |
---|
New file |
0,0 → 1,441 |
<?php |
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */ |
/** |
* Abstract class providing common methods for XML_Feed_Parser feeds. |
* |
* PHP versions 5 |
* |
* LICENSE: This source file is subject to version 3.0 of the PHP license |
* that is available through the world-wide-web at the following URI: |
* http://www.php.net/license/3_0.txt. If you did not receive a copy of |
* the PHP License and are unable to obtain it through the web, please |
* send a note to license@php.net so we can mail you a copy immediately. |
* |
* @category XML |
* @package XML_Feed_Parser |
* @author James Stewart <james@jystewart.net> |
* @copyright 2005 James Stewart <james@jystewart.net> |
* @license http://www.gnu.org/copyleft/lesser.html GNU LGPL 2.1 |
* @version CVS: $Id: Type.php,v 1.1.2.1 2007-07-25 09:45:07 jp_milcent Exp $ |
* @link http://pear.php.net/package/XML_Feed_Parser/ |
*/ |
/** |
* This abstract class provides some general methods that are likely to be |
* implemented exactly the same way for all feed types. |
* |
* @package XML_Feed_Parser |
* @author James Stewart <james@jystewart.net> |
* @version Release: 1.0.2 |
*/ |
abstract class XML_Feed_Parser_Type |
{ |
/** |
* Where we store our DOM object for this feed |
* @var DOMDocument |
*/ |
public $model; |
/** |
* For iteration we'll want a count of the number of entries |
* @var int |
*/ |
public $numberEntries; |
/** |
* Where we store our entry objects once instantiated |
* @var array |
*/ |
public $entries = array(); |
/** |
* Proxy to allow use of element names as method names |
* |
* We are not going to provide methods for every entry type so this |
* function will allow for a lot of mapping. We rely pretty heavily |
* on this to handle our mappings between other feed types and atom. |
* |
* @param string $call - the method attempted |
* @param array $arguments - arguments to that method |
* @return mixed |
*/ |
function __call($call, $arguments = array()) |
{ |
if (! is_array($arguments)) { |
$arguments = array(); |
} |
if (isset($this->compatMap[$call])) { |
$tempMap = $this->compatMap; |
$tempcall = array_pop($tempMap[$call]); |
if (! empty($tempMap)) { |
$arguments = array_merge($arguments, $tempMap[$call]); |
} |
$call = $tempcall; |
} |
/* To be helpful, we allow a case-insensitive search for this method */ |
if (! isset($this->map[$call])) { |
foreach (array_keys($this->map) as $key) { |
if (strtoupper($key) == strtoupper($call)) { |
$call = $key; |
break; |
} |
} |
} |
if (empty($this->map[$call])) { |
return false; |
} |
$method = 'get' . $this->map[$call][0]; |
if ($method == 'getLink') { |
$offset = empty($arguments[0]) ? 0 : $arguments[0]; |
$attribute = empty($arguments[1]) ? 'href' : $arguments[1]; |
$params = isset($arguments[2]) ? $arguments[2] : array(); |
return $this->getLink($offset, $attribute, $params); |
} |
if (method_exists($this, $method)) { |
return $this->$method($call, $arguments); |
} |
return false; |
} |
/** |
* Proxy to allow use of element names as attribute names |
* |
* For many elements variable-style access will be desirable. This function |
* provides for that. |
* |
* @param string $value - the variable required |
* @return mixed |
*/ |
function __get($value) |
{ |
return $this->__call($value, array()); |
} |
/** |
* Utility function to help us resolve xml:base values |
* |
* We have other methods which will traverse the DOM and work out the different |
* xml:base declarations we need to be aware of. We then need to combine them. |
* If a declaration starts with a protocol then we restart the string. If it |
* starts with a / then we add on to the domain name. Otherwise we simply tag |
* it on to the end. |
* |
* @param string $base - the base to add the link to |
* @param string $link |
*/ |
function combineBases($base, $link) |
{ |
if (preg_match('/^[A-Za-z]+:\/\//', $link)) { |
return $link; |
} else if (preg_match('/^\//', $link)) { |
/* Extract domain and suffix link to that */ |
preg_match('/^([A-Za-z]+:\/\/.*)?\/*/', $base, $results); |
$firstLayer = $results[0]; |
return $firstLayer . "/" . $link; |
} else if (preg_match('/^\.\.\//', $base)) { |
/* Step up link to find place to be */ |
preg_match('/^((\.\.\/)+)(.*)$/', $link, $bases); |
$suffix = $bases[3]; |
$count = preg_match_all('/\.\.\//', $bases[1], $steps); |
$url = explode("/", $base); |
for ($i = 0; $i <= $count; $i++) { |
array_pop($url); |
} |
return implode("/", $url) . "/" . $suffix; |
} else if (preg_match('/^(?!\/$)/', $base)) { |
$base = preg_replace('/(.*\/).*$/', '$1', $base) ; |
return $base . $link; |
} else { |
/* Just stick it on the end */ |
return $base . $link; |
} |
} |
/** |
* Determine whether we need to apply our xml:base rules |
* |
* Gets us the xml:base data and then processes that with regard |
* to our current link. |
* |
* @param string |
* @param DOMElement |
* @return string |
*/ |
function addBase($link, $element) |
{ |
if (preg_match('/^[A-Za-z]+:\/\//', $link)) { |
return $link; |
} |
return $this->combineBases($element->baseURI, $link); |
} |
/** |
* Get an entry by its position in the feed, starting from zero |
* |
* As well as allowing the items to be iterated over we want to allow |
* users to be able to access a specific entry. This is one of two ways of |
* doing that, the other being by ID. |
* |
* @param int $offset |
* @return XML_Feed_Parser_RSS1Element |
*/ |
function getEntryByOffset($offset) |
{ |
if (! isset($this->entries[$offset])) { |
$entries = $this->model->getElementsByTagName($this->itemElement); |
if ($entries->length > $offset) { |
$xmlBase = $entries->item($offset)->baseURI; |
$this->entries[$offset] = new $this->itemClass( |
$entries->item($offset), $this, $xmlBase); |
if ($id = $this->entries[$offset]->id) { |
$this->idMappings[$id] = $this->entries[$offset]; |
} |
} else { |
throw new XML_Feed_Parser_Exception('No entries found'); |
} |
} |
return $this->entries[$offset]; |
} |
/** |
* Return a date in seconds since epoch. |
* |
* Get a date construct. We use PHP's strtotime to return it as a unix datetime, which |
* is the number of seconds since 1970-01-01 00:00:00. |
* |
* @link http://php.net/strtotime |
* @param string $method The name of the date construct we want |
* @param array $arguments Included for compatibility with our __call usage |
* @return int|false datetime |
*/ |
protected function getDate($method, $arguments) |
{ |
$time = $this->model->getElementsByTagName($method); |
if ($time->length == 0) { |
return false; |
} |
return strtotime($time->item(0)->nodeValue); |
} |
/** |
* Get a text construct. |
* |
* @param string $method The name of the text construct we want |
* @param array $arguments Included for compatibility with our __call usage |
* @return string |
*/ |
protected function getText($method, $arguments = array()) |
{ |
$tags = $this->model->getElementsByTagName($method); |
if ($tags->length > 0) { |
$value = $tags->item(0)->nodeValue; |
return $value; |
} |
return false; |
} |
/** |
* Apply various rules to retrieve category data. |
* |
* There is no single way of declaring a category in RSS1/1.1 as there is in RSS2 |
* and Atom. Instead the usual approach is to use the dublin core namespace to |
* declare categories. For example delicious use both: |
* <dc:subject>PEAR</dc:subject> and: <taxo:topics><rdf:Bag> |
* <rdf:li resource="http://del.icio.us/tag/PEAR" /></rdf:Bag></taxo:topics> |
* to declare a categorisation of 'PEAR'. |
* |
* We need to be sensitive to this where possible. |
* |
* @param string $call for compatibility with our overloading |
* @param array $arguments - arg 0 is the offset, arg 1 is whether to return as array |
* @return string|array|false |
*/ |
protected function getCategory($call, $arguments) |
{ |
$categories = $this->model->getElementsByTagName('subject'); |
$offset = empty($arguments[0]) ? 0 : $arguments[0]; |
$array = empty($arguments[1]) ? false : true; |
if ($categories->length <= $offset) { |
return false; |
} |
if ($array) { |
$list = array(); |
foreach ($categories as $category) { |
array_push($list, $category->nodeValue); |
} |
return $list; |
} |
return $categories->item($offset)->nodeValue; |
} |
/** |
* Count occurrences of an element |
* |
* This function will tell us how many times the element $type |
* appears at this level of the feed. |
* |
* @param string $type the element we want to get a count of |
* @return int |
*/ |
protected function count($type) |
{ |
if ($tags = $this->model->getElementsByTagName($type)) { |
return $tags->length; |
} |
return 0; |
} |
/** |
* Part of our xml:base processing code |
* |
* We need a couple of methods to access XHTML content stored in feeds. |
* This is because we dereference all xml:base references before returning |
* the element. This method handles the attributes. |
* |
* @param DOMElement $node The DOM node we are iterating over |
* @return string |
*/ |
function processXHTMLAttributes($node) { |
$return = ''; |
foreach ($node->attributes as $attribute) { |
if ($attribute->name == 'src' or $attribute->name == 'href') { |
$attribute->value = $this->addBase($attribute->value, $attribute); |
} |
if ($attribute->name == 'base') { |
continue; |
} |
$return .= $attribute->name . '="' . $attribute->value .'" '; |
} |
if (! empty($return)) { |
return ' ' . trim($return); |
} |
return ''; |
} |
/** |
* Part of our xml:base processing code |
* |
* We need a couple of methods to access XHTML content stored in feeds. |
* This is because we dereference all xml:base references before returning |
* the element. This method recurs through the tree descending from the node |
* and builds our string |
* |
* @param DOMElement $node The DOM node we are processing |
* @return string |
*/ |
function traverseNode($node) |
{ |
$content = ''; |
/* Add the opening of this node to the content */ |
if ($node instanceof DOMElement) { |
$content .= '<' . $node->tagName . |
$this->processXHTMLAttributes($node) . '>'; |
} |
/* Process children */ |
if ($node->hasChildNodes()) { |
foreach ($node->childNodes as $child) { |
$content .= $this->traverseNode($child); |
} |
} |
if ($node instanceof DOMText) { |
$content .= htmlentities($node->nodeValue); |
} |
/* Add the closing of this node to the content */ |
if ($node instanceof DOMElement) { |
$content .= '</' . $node->tagName . '>'; |
} |
return $content; |
} |
/** |
* Get content from RSS feeds (atom has its own implementation) |
* |
* The official way to include full content in an RSS1 entry is to use |
* the content module's element 'encoded', and RSS2 feeds often duplicate that. |
* Often, however, the 'description' element is used instead. We will offer that |
* as a fallback. Atom uses its own approach and overrides this method. |
* |
* @return string|false |
*/ |
protected function getContent() |
{ |
$options = array('encoded', 'description'); |
foreach ($options as $element) { |
$test = $this->model->getElementsByTagName($element); |
if ($test->length == 0) { |
continue; |
} |
if ($test->item(0)->hasChildNodes()) { |
$value = ''; |
foreach ($test->item(0)->childNodes as $child) { |
if ($child instanceof DOMText) { |
$value .= $child->nodeValue; |
} else { |
$simple = simplexml_import_dom($child); |
$value .= $simple->asXML(); |
} |
} |
return $value; |
} else if ($test->length > 0) { |
return $test->item(0)->nodeValue; |
} |
} |
return false; |
} |
/** |
* Checks if this element has a particular child element. |
* |
* @param String |
* @param Integer |
* @return bool |
**/ |
function hasKey($name, $offset = 0) |
{ |
$search = $this->model->getElementsByTagName($name); |
return $search->length > $offset; |
} |
/** |
* Return an XML serialization of the feed, should it be required. Most |
* users however, will already have a serialization that they used when |
* instantiating the object. |
* |
* @return string XML serialization of element |
*/ |
function __toString() |
{ |
$simple = simplexml_import_dom($this->model); |
return $simple->asXML(); |
} |
/** |
* Get directory holding RNG schemas. Method is based on that |
* found in Contact_AddressBook. |
* |
* @return string PEAR data directory. |
* @access public |
* @static |
*/ |
static function getSchemaDir() |
{ |
require_once 'PEAR/Config.php'; |
$config = new PEAR_Config; |
return $config->get('data_dir') . '/XML_Feed_Parser/schemas'; |
} |
} |
?> |
/branches/v2.0-narmer/api/pear/XML/Feed/Parser/RSS1Element.php |
---|
New file |
0,0 → 1,116 |
<?php |
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */ |
/** |
* RSS1 Element class for XML_Feed_Parser |
* |
* PHP versions 5 |
* |
* LICENSE: This source file is subject to version 3.0 of the PHP license |
* that is available through the world-wide-web at the following URI: |
* http://www.php.net/license/3_0.txt. If you did not receive a copy of |
* the PHP License and are unable to obtain it through the web, please |
* send a note to license@php.net so we can mail you a copy immediately. |
* |
* @category XML |
* @package XML_Feed_Parser |
* @author James Stewart <james@jystewart.net> |
* @copyright 2005 James Stewart <james@jystewart.net> |
* @license http://www.gnu.org/copyleft/lesser.html GNU LGPL 2.1 |
* @version CVS: $Id: RSS1Element.php,v 1.1.2.1 2007-07-25 09:45:07 jp_milcent Exp $ |
* @link http://pear.php.net/package/XML_Feed_Parser/ |
*/ |
/* |
* This class provides support for RSS 1.0 entries. It will usually be called by |
* XML_Feed_Parser_RSS1 with which it shares many methods. |
* |
* @author James Stewart <james@jystewart.net> |
* @version Release: 1.0.2 |
* @package XML_Feed_Parser |
*/ |
class XML_Feed_Parser_RSS1Element extends XML_Feed_Parser_RSS1 |
{ |
/** |
* This will be a reference to the parent object for when we want |
* to use a 'fallback' rule |
* @var XML_Feed_Parser_RSS1 |
*/ |
protected $parent; |
/** |
* Our specific element map |
* @var array |
*/ |
protected $map = array( |
'id' => array('Id'), |
'title' => array('Text'), |
'link' => array('Link'), |
'description' => array('Text'), # or dc:description |
'category' => array('Category'), |
'rights' => array('Text'), # dc:rights |
'creator' => array('Text'), # dc:creator |
'publisher' => array('Text'), # dc:publisher |
'contributor' => array('Text'), # dc:contributor |
'date' => array('Date'), # dc:date |
'content' => array('Content') |
); |
/** |
* Here we map some elements to their atom equivalents. This is going to be |
* quite tricky to pull off effectively (and some users' methods may vary) |
* but is worth trying. The key is the atom version, the value is RSS1. |
* @var array |
*/ |
protected $compatMap = array( |
'content' => array('content'), |
'updated' => array('lastBuildDate'), |
'published' => array('pubdate'), |
'subtitle' => array('description'), |
'updated' => array('date'), |
'author' => array('creator'), |
'contributor' => array('contributor') |
); |
/** |
* Store useful information for later. |
* |
* @param DOMElement $element - this item as a DOM element |
* @param XML_Feed_Parser_RSS1 $parent - the feed of which this is a member |
*/ |
function __construct(DOMElement $element, $parent, $xmlBase = '') |
{ |
$this->model = $element; |
$this->parent = $parent; |
} |
/** |
* If an rdf:about attribute is specified, return it as an ID |
* |
* There is no established way of showing an ID for an RSS1 entry. We will |
* simulate it using the rdf:about attribute of the entry element. This cannot |
* be relied upon for unique IDs but may prove useful. |
* |
* @return string|false |
*/ |
function getId() |
{ |
if ($this->model->attributes->getNamedItem('about')) { |
return $this->model->attributes->getNamedItem('about')->nodeValue; |
} |
return false; |
} |
/** |
* How RSS1 should support for enclosures is not clear. For now we will return |
* false. |
* |
* @return false |
*/ |
function getEnclosure() |
{ |
return false; |
} |
} |
?> |
/branches/v2.0-narmer/api/pear/XML/Feed/Parser.php |
---|
New file |
0,0 → 1,351 |
<?php |
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */ |
/** |
* Key gateway class for XML_Feed_Parser package |
* |
* PHP versions 5 |
* |
* LICENSE: This source file is subject to version 3.0 of the PHP license |
* that is available through the world-wide-web at the following URI: |
* http://www.php.net/license/3_0.txt. If you did not receive a copy of |
* the PHP License and are unable to obtain it through the web, please |
* send a note to license@php.net so we can mail you a copy immediately. |
* |
* @category XML |
* @package XML_Feed_Parser |
* @author James Stewart <james@jystewart.net> |
* @copyright 2005 James Stewart <james@jystewart.net> |
* @license http://www.gnu.org/copyleft/lesser.html GNU LGPL |
* @version CVS: $Id: Parser.php,v 1.1.2.1 2007-07-25 09:45:08 jp_milcent Exp $ |
* @link http://pear.php.net/package/XML_Feed_Parser/ |
*/ |
/** |
* XML_Feed_Parser_Type is an abstract class required by all of our |
* feed types. It makes sense to load it here to keep the other files |
* clean. |
*/ |
require_once 'XML/Feed/Parser/Type.php'; |
/** |
* We will throw exceptions when errors occur. |
*/ |
require_once 'XML/Feed/Parser/Exception.php'; |
/** |
* This is the core of the XML_Feed_Parser package. It identifies feed types |
* and abstracts access to them. It is an iterator, allowing for easy access |
* to the entire feed. |
* |
* @author James Stewart <james@jystewart.net> |
* @version Release: 1.0.2 |
* @package XML_Feed_Parser |
*/ |
class XML_Feed_Parser implements Iterator |
{ |
/** |
* This is where we hold the feed object |
* @var Object |
*/ |
private $feed; |
/** |
* To allow for extensions, we make a public reference to the feed model |
* @var DOMDocument |
*/ |
public $model; |
/** |
* A map between entry ID and offset |
* @var array |
*/ |
protected $idMappings = array(); |
/** |
* A storage space for Namespace URIs. |
* @var array |
*/ |
private $feedNamespaces = array( |
'rss2' => array( |
'http://backend.userland.com/rss', |
'http://backend.userland.com/rss2', |
'http://blogs.law.harvard.edu/tech/rss')); |
/** |
* Detects feed types and instantiate appropriate objects. |
* |
* Our constructor takes care of detecting feed types and instantiating |
* appropriate classes. For now we're going to treat Atom 0.3 as Atom 1.0 |
* but raise a warning. I do not intend to introduce full support for |
* Atom 0.3 as it has been deprecated, but others are welcome to. |
* |
* @param string $feed XML serialization of the feed |
* @param bool $strict Whether or not to validate the feed |
* @param bool $suppressWarnings Trigger errors for deprecated feed types? |
* @param bool $tidy Whether or not to try and use the tidy library on input |
*/ |
function __construct($feed, $strict = false, $suppressWarnings = false, $tidy = false) |
{ |
$this->model = new DOMDocument; |
if (! $this->model->loadXML($feed)) { |
if (extension_loaded('tidy') && $tidy) { |
$tidy = new tidy; |
$tidy->parseString($feed, |
array('input-xml' => true, 'output-xml' => true)); |
$tidy->cleanRepair(); |
if (! $this->model->loadXML((string) $tidy)) { |
throw new XML_Feed_Parser_Exception('Invalid input: this is not ' . |
'valid XML'); |
} |
} else { |
throw new XML_Feed_Parser_Exception('Invalid input: this is not valid XML'); |
} |
} |
/* detect feed type */ |
$doc_element = $this->model->documentElement; |
$error = false; |
switch (true) { |
case ($doc_element->namespaceURI == 'http://www.w3.org/2005/Atom'): |
require_once 'XML/Feed/Parser/Atom.php'; |
require_once 'XML/Feed/Parser/AtomElement.php'; |
$class = 'XML_Feed_Parser_Atom'; |
break; |
case ($doc_element->namespaceURI == 'http://purl.org/atom/ns#'): |
require_once 'XML/Feed/Parser/Atom.php'; |
require_once 'XML/Feed/Parser/AtomElement.php'; |
$class = 'XML_Feed_Parser_Atom'; |
$error = 'Atom 0.3 deprecated, using 1.0 parser which won\'t provide ' . |
'all options'; |
break; |
case ($doc_element->namespaceURI == 'http://purl.org/rss/1.0/' || |
($doc_element->hasChildNodes() && $doc_element->childNodes->length > 1 |
&& $doc_element->childNodes->item(1)->namespaceURI == |
'http://purl.org/rss/1.0/')): |
require_once 'XML/Feed/Parser/RSS1.php'; |
require_once 'XML/Feed/Parser/RSS1Element.php'; |
$class = 'XML_Feed_Parser_RSS1'; |
break; |
case ($doc_element->namespaceURI == 'http://purl.org/rss/1.1/' || |
($doc_element->hasChildNodes() && $doc_element->childNodes->length > 1 |
&& $doc_element->childNodes->item(1)->namespaceURI == |
'http://purl.org/rss/1.1/')): |
require_once 'XML/Feed/Parser/RSS11.php'; |
require_once 'XML/Feed/Parser/RSS11Element.php'; |
$class = 'XML_Feed_Parser_RSS11'; |
break; |
case (($doc_element->hasChildNodes() && $doc_element->childNodes->length > 1 |
&& $doc_element->childNodes->item(1)->namespaceURI == |
'http://my.netscape.com/rdf/simple/0.9/') || |
$doc_element->namespaceURI == 'http://my.netscape.com/rdf/simple/0.9/'): |
require_once 'XML/Feed/Parser/RSS09.php'; |
require_once 'XML/Feed/Parser/RSS09Element.php'; |
$class = 'XML_Feed_Parser_RSS09'; |
break; |
case ($doc_element->tagName == 'rss' and |
$doc_element->hasAttribute('version') && |
$doc_element->getAttribute('version') == 0.91): |
$error = 'RSS 0.91 has been superceded by RSS2.0. Using RSS2.0 parser.'; |
require_once 'XML/Feed/Parser/RSS2.php'; |
require_once 'XML/Feed/Parser/RSS2Element.php'; |
$class = 'XML_Feed_Parser_RSS2'; |
break; |
case ($doc_element->tagName == 'rss' and |
$doc_element->hasAttribute('version') && |
$doc_element->getAttribute('version') == 0.92): |
$error = 'RSS 0.92 has been superceded by RSS2.0. Using RSS2.0 parser.'; |
require_once 'XML/Feed/Parser/RSS2.php'; |
require_once 'XML/Feed/Parser/RSS2Element.php'; |
$class = 'XML_Feed_Parser_RSS2'; |
break; |
case (in_array($doc_element->namespaceURI, $this->feedNamespaces['rss2']) |
|| $doc_element->tagName == 'rss'): |
if (! $doc_element->hasAttribute('version') || |
$doc_element->getAttribute('version') != 2) { |
$error = 'RSS version not specified. Parsing as RSS2.0'; |
} |
require_once 'XML/Feed/Parser/RSS2.php'; |
require_once 'XML/Feed/Parser/RSS2Element.php'; |
$class = 'XML_Feed_Parser_RSS2'; |
break; |
default: |
throw new XML_Feed_Parser_Exception('Feed type unknown'); |
break; |
} |
if (! $suppressWarnings && ! empty($error)) { |
trigger_error($error, E_USER_WARNING); |
} |
/* Instantiate feed object */ |
$this->feed = new $class($this->model, $strict); |
} |
/** |
* Proxy to allow feed element names to be used as method names |
* |
* For top-level feed elements we will provide access using methods or |
* attributes. This function simply passes on a request to the appropriate |
* feed type object. |
* |
* @param string $call - the method being called |
* @param array $attributes |
*/ |
function __call($call, $attributes) |
{ |
$attributes = array_pad($attributes, 5, false); |
list($a, $b, $c, $d, $e) = $attributes; |
return $this->feed->$call($a, $b, $c, $d, $e); |
} |
/** |
* Proxy to allow feed element names to be used as attribute names |
* |
* To allow variable-like access to feed-level data we use this |
* method. It simply passes along to __call() which in turn passes |
* along to the relevant object. |
* |
* @param string $val - the name of the variable required |
*/ |
function __get($val) |
{ |
return $this->feed->$val; |
} |
/** |
* Provides iteration functionality. |
* |
* Of course we must be able to iterate... This function simply increases |
* our internal counter. |
*/ |
function next() |
{ |
if (isset($this->current_item) && |
$this->current_item <= $this->feed->numberEntries - 1) { |
++$this->current_item; |
} else if (! isset($this->current_item)) { |
$this->current_item = 0; |
} else { |
return false; |
} |
} |
/** |
* Return XML_Feed_Type object for current element |
* |
* @return XML_Feed_Parser_Type Object |
*/ |
function current() |
{ |
return $this->getEntryByOffset($this->current_item); |
} |
/** |
* For iteration -- returns the key for the current stage in the array. |
* |
* @return int |
*/ |
function key() |
{ |
return $this->current_item; |
} |
/** |
* For iteration -- tells whether we have reached the |
* end. |
* |
* @return bool |
*/ |
function valid() |
{ |
return $this->current_item < $this->feed->numberEntries; |
} |
/** |
* For iteration -- resets the internal counter to the beginning. |
*/ |
function rewind() |
{ |
$this->current_item = 0; |
} |
/** |
* Provides access to entries by ID if one is specified in the source feed. |
* |
* As well as allowing the items to be iterated over we want to allow |
* users to be able to access a specific entry. This is one of two ways of |
* doing that, the other being by offset. This method can be quite slow |
* if dealing with a large feed that hasn't yet been processed as it |
* instantiates objects for every entry until it finds the one needed. |
* |
* @param string $id Valid ID for the given feed format |
* @return XML_Feed_Parser_Type|false |
*/ |
function getEntryById($id) |
{ |
if (isset($this->idMappings[$id])) { |
return $this->getEntryByOffset($this->idMappings[$id]); |
} |
/* |
* Since we have not yet encountered that ID, let's go through all the |
* remaining entries in order till we find it. |
* This is a fairly slow implementation, but it should work. |
*/ |
return $this->feed->getEntryById($id); |
} |
/** |
* Retrieve entry by numeric offset, starting from zero. |
* |
* As well as allowing the items to be iterated over we want to allow |
* users to be able to access a specific entry. This is one of two ways of |
* doing that, the other being by ID. |
* |
* @param int $offset The position of the entry within the feed, starting from 0 |
* @return XML_Feed_Parser_Type|false |
*/ |
function getEntryByOffset($offset) |
{ |
if ($offset < $this->feed->numberEntries) { |
if (isset($this->feed->entries[$offset])) { |
return $this->feed->entries[$offset]; |
} else { |
try { |
$this->feed->getEntryByOffset($offset); |
} catch (Exception $e) { |
return false; |
} |
$id = $this->feed->entries[$offset]->getID(); |
$this->idMappings[$id] = $offset; |
return $this->feed->entries[$offset]; |
} |
} else { |
return false; |
} |
} |
/** |
* Retrieve version details from feed type class. |
* |
* @return void |
* @author James Stewart |
*/ |
function version() |
{ |
return $this->feed->version; |
} |
/** |
* Returns a string representation of the feed. |
* |
* @return String |
**/ |
function __toString() |
{ |
return $this->feed->__toString(); |
} |
} |
?> |
/branches/v2.0-narmer/api/pear/XML/Util.php |
---|
New file |
0,0 → 1,752 |
<?PHP |
/* vim: set expandtab tabstop=4 shiftwidth=4: */ |
// +----------------------------------------------------------------------+ |
// | PHP Version 4 | |
// +----------------------------------------------------------------------+ |
// | Copyright (c) 1997-2002 The PHP Group | |
// +----------------------------------------------------------------------+ |
// | This source file is subject to version 2.0 of the PHP license, | |
// | that is bundled with this package in the file LICENSE, and is | |
// | available at through the world-wide-web at | |
// | http://www.php.net/license/2_02.txt. | |
// | If you did not receive a copy of the PHP license and are unable to | |
// | obtain it through the world-wide-web, please send a note to | |
// | license@php.net so we can mail you a copy immediately. | |
// +----------------------------------------------------------------------+ |
// | Authors: Stephan Schmidt <schst@php-tools.net> | |
// +----------------------------------------------------------------------+ |
// |
// $Id: Util.php,v 1.1 2007-03-28 08:51:22 neiluj Exp $ |
/** |
* error code for invalid chars in XML name |
*/ |
define("XML_UTIL_ERROR_INVALID_CHARS", 51); |
/** |
* error code for invalid chars in XML name |
*/ |
define("XML_UTIL_ERROR_INVALID_START", 52); |
/** |
* error code for non-scalar tag content |
*/ |
define("XML_UTIL_ERROR_NON_SCALAR_CONTENT", 60); |
/** |
* error code for missing tag name |
*/ |
define("XML_UTIL_ERROR_NO_TAG_NAME", 61); |
/** |
* replace XML entities |
*/ |
define("XML_UTIL_REPLACE_ENTITIES", 1); |
/** |
* embedd content in a CData Section |
*/ |
define("XML_UTIL_CDATA_SECTION", 5); |
/** |
* do not replace entitites |
*/ |
define("XML_UTIL_ENTITIES_NONE", 0); |
/** |
* replace all XML entitites |
* This setting will replace <, >, ", ' and & |
*/ |
define("XML_UTIL_ENTITIES_XML", 1); |
/** |
* replace only required XML entitites |
* This setting will replace <, " and & |
*/ |
define("XML_UTIL_ENTITIES_XML_REQUIRED", 2); |
/** |
* replace HTML entitites |
* @link http://www.php.net/htmlentities |
*/ |
define("XML_UTIL_ENTITIES_HTML", 3); |
/** |
* Collapse all empty tags. |
*/ |
define("XML_UTIL_COLLAPSE_ALL", 1); |
/** |
* Collapse only empty XHTML tags that have no end tag. |
*/ |
define("XML_UTIL_COLLAPSE_XHTML_ONLY", 2); |
/** |
* utility class for working with XML documents |
* |
* @category XML |
* @package XML_Util |
* @version 1.1.0 |
* @author Stephan Schmidt <schst@php.net> |
*/ |
class XML_Util { |
/** |
* return API version |
* |
* @access public |
* @static |
* @return string $version API version |
*/ |
function apiVersion() |
{ |
return '1.1'; |
} |
/** |
* replace XML entities |
* |
* With the optional second parameter, you may select, which |
* entities should be replaced. |
* |
* <code> |
* require_once 'XML/Util.php'; |
* |
* // replace XML entites: |
* $string = XML_Util::replaceEntities("This string contains < & >."); |
* </code> |
* |
* @access public |
* @static |
* @param string string where XML special chars should be replaced |
* @param integer setting for entities in attribute values (one of XML_UTIL_ENTITIES_XML, XML_UTIL_ENTITIES_XML_REQUIRED, XML_UTIL_ENTITIES_HTML) |
* @return string string with replaced chars |
* @see reverseEntities() |
*/ |
function replaceEntities($string, $replaceEntities = XML_UTIL_ENTITIES_XML) |
{ |
switch ($replaceEntities) { |
case XML_UTIL_ENTITIES_XML: |
return strtr($string,array( |
'&' => '&', |
'>' => '>', |
'<' => '<', |
'"' => '"', |
'\'' => ''' )); |
break; |
case XML_UTIL_ENTITIES_XML_REQUIRED: |
return strtr($string,array( |
'&' => '&', |
'<' => '<', |
'"' => '"' )); |
break; |
case XML_UTIL_ENTITIES_HTML: |
return htmlentities($string); |
break; |
} |
return $string; |
} |
/** |
* reverse XML entities |
* |
* With the optional second parameter, you may select, which |
* entities should be reversed. |
* |
* <code> |
* require_once 'XML/Util.php'; |
* |
* // reverse XML entites: |
* $string = XML_Util::reverseEntities("This string contains < & >."); |
* </code> |
* |
* @access public |
* @static |
* @param string string where XML special chars should be replaced |
* @param integer setting for entities in attribute values (one of XML_UTIL_ENTITIES_XML, XML_UTIL_ENTITIES_XML_REQUIRED, XML_UTIL_ENTITIES_HTML) |
* @return string string with replaced chars |
* @see replaceEntities() |
*/ |
function reverseEntities($string, $replaceEntities = XML_UTIL_ENTITIES_XML) |
{ |
switch ($replaceEntities) { |
case XML_UTIL_ENTITIES_XML: |
return strtr($string,array( |
'&' => '&', |
'>' => '>', |
'<' => '<', |
'"' => '"', |
''' => '\'' )); |
break; |
case XML_UTIL_ENTITIES_XML_REQUIRED: |
return strtr($string,array( |
'&' => '&', |
'<' => '<', |
'"' => '"' )); |
break; |
case XML_UTIL_ENTITIES_HTML: |
$arr = array_flip(get_html_translation_table(HTML_ENTITIES)); |
return strtr($string, $arr); |
break; |
} |
return $string; |
} |
/** |
* build an xml declaration |
* |
* <code> |
* require_once 'XML/Util.php'; |
* |
* // get an XML declaration: |
* $xmlDecl = XML_Util::getXMLDeclaration("1.0", "UTF-8", true); |
* </code> |
* |
* @access public |
* @static |
* @param string $version xml version |
* @param string $encoding character encoding |
* @param boolean $standAlone document is standalone (or not) |
* @return string $decl xml declaration |
* @uses XML_Util::attributesToString() to serialize the attributes of the XML declaration |
*/ |
function getXMLDeclaration($version = "1.0", $encoding = null, $standalone = null) |
{ |
$attributes = array( |
"version" => $version, |
); |
// add encoding |
if ($encoding !== null) { |
$attributes["encoding"] = $encoding; |
} |
// add standalone, if specified |
if ($standalone !== null) { |
$attributes["standalone"] = $standalone ? "yes" : "no"; |
} |
return sprintf("<?xml%s?>", XML_Util::attributesToString($attributes, false)); |
} |
/** |
* build a document type declaration |
* |
* <code> |
* require_once 'XML/Util.php'; |
* |
* // get a doctype declaration: |
* $xmlDecl = XML_Util::getDocTypeDeclaration("rootTag","myDocType.dtd"); |
* </code> |
* |
* @access public |
* @static |
* @param string $root name of the root tag |
* @param string $uri uri of the doctype definition (or array with uri and public id) |
* @param string $internalDtd internal dtd entries |
* @return string $decl doctype declaration |
* @since 0.2 |
*/ |
function getDocTypeDeclaration($root, $uri = null, $internalDtd = null) |
{ |
if (is_array($uri)) { |
$ref = sprintf( ' PUBLIC "%s" "%s"', $uri["id"], $uri["uri"] ); |
} elseif (!empty($uri)) { |
$ref = sprintf( ' SYSTEM "%s"', $uri ); |
} else { |
$ref = ""; |
} |
if (empty($internalDtd)) { |
return sprintf("<!DOCTYPE %s%s>", $root, $ref); |
} else { |
return sprintf("<!DOCTYPE %s%s [\n%s\n]>", $root, $ref, $internalDtd); |
} |
} |
/** |
* create string representation of an attribute list |
* |
* <code> |
* require_once 'XML/Util.php'; |
* |
* // build an attribute string |
* $att = array( |
* "foo" => "bar", |
* "argh" => "tomato" |
* ); |
* |
* $attList = XML_Util::attributesToString($att); |
* </code> |
* |
* @access public |
* @static |
* @param array $attributes attribute array |
* @param boolean|array $sort sort attribute list alphabetically, may also be an assoc array containing the keys 'sort', 'multiline', 'indent', 'linebreak' and 'entities' |
* @param boolean $multiline use linebreaks, if more than one attribute is given |
* @param string $indent string used for indentation of multiline attributes |
* @param string $linebreak string used for linebreaks of multiline attributes |
* @param integer $entities setting for entities in attribute values (one of XML_UTIL_ENTITIES_NONE, XML_UTIL_ENTITIES_XML, XML_UTIL_ENTITIES_XML_REQUIRED, XML_UTIL_ENTITIES_HTML) |
* @return string string representation of the attributes |
* @uses XML_Util::replaceEntities() to replace XML entities in attribute values |
* @todo allow sort also to be an options array |
*/ |
function attributesToString($attributes, $sort = true, $multiline = false, $indent = ' ', $linebreak = "\n", $entities = XML_UTIL_ENTITIES_XML) |
{ |
/** |
* second parameter may be an array |
*/ |
if (is_array($sort)) { |
if (isset($sort['multiline'])) { |
$multiline = $sort['multiline']; |
} |
if (isset($sort['indent'])) { |
$indent = $sort['indent']; |
} |
if (isset($sort['linebreak'])) { |
$multiline = $sort['linebreak']; |
} |
if (isset($sort['entities'])) { |
$entities = $sort['entities']; |
} |
if (isset($sort['sort'])) { |
$sort = $sort['sort']; |
} else { |
$sort = true; |
} |
} |
$string = ''; |
if (is_array($attributes) && !empty($attributes)) { |
if ($sort) { |
ksort($attributes); |
} |
if( !$multiline || count($attributes) == 1) { |
foreach ($attributes as $key => $value) { |
if ($entities != XML_UTIL_ENTITIES_NONE) { |
if ($entities === XML_UTIL_CDATA_SECTION) { |
$entities = XML_UTIL_ENTITIES_XML; |
} |
$value = XML_Util::replaceEntities($value, $entities); |
} |
$string .= ' '.$key.'="'.$value.'"'; |
} |
} else { |
$first = true; |
foreach ($attributes as $key => $value) { |
if ($entities != XML_UTIL_ENTITIES_NONE) { |
$value = XML_Util::replaceEntities($value, $entities); |
} |
if ($first) { |
$string .= " ".$key.'="'.$value.'"'; |
$first = false; |
} else { |
$string .= $linebreak.$indent.$key.'="'.$value.'"'; |
} |
} |
} |
} |
return $string; |
} |
/** |
* Collapses empty tags. |
* |
* @access public |
* @static |
* @param string $xml XML |
* @param integer $mode Whether to collapse all empty tags (XML_UTIL_COLLAPSE_ALL) or only XHTML (XML_UTIL_COLLAPSE_XHTML_ONLY) ones. |
* @return string $xml XML |
*/ |
function collapseEmptyTags($xml, $mode = XML_UTIL_COLLAPSE_ALL) { |
if ($mode == XML_UTIL_COLLAPSE_XHTML_ONLY) { |
return preg_replace( |
'/<(area|base|br|col|hr|img|input|link|meta|param)([^>]*)><\/\\1>/s', |
'<\\1\\2 />', |
$xml |
); |
} else { |
return preg_replace( |
'/<(\w+)([^>]*)><\/\\1>/s', |
'<\\1\\2 />', |
$xml |
); |
} |
} |
/** |
* create a tag |
* |
* This method will call XML_Util::createTagFromArray(), which |
* is more flexible. |
* |
* <code> |
* require_once 'XML/Util.php'; |
* |
* // create an XML tag: |
* $tag = XML_Util::createTag("myNs:myTag", array("foo" => "bar"), "This is inside the tag", "http://www.w3c.org/myNs#"); |
* </code> |
* |
* @access public |
* @static |
* @param string $qname qualified tagname (including namespace) |
* @param array $attributes array containg attributes |
* @param mixed $content |
* @param string $namespaceUri URI of the namespace |
* @param integer $replaceEntities whether to replace XML special chars in content, embedd it in a CData section or none of both |
* @param boolean $multiline whether to create a multiline tag where each attribute gets written to a single line |
* @param string $indent string used to indent attributes (_auto indents attributes so they start at the same column) |
* @param string $linebreak string used for linebreaks |
* @param boolean $sortAttributes Whether to sort the attributes or not |
* @return string $string XML tag |
* @see XML_Util::createTagFromArray() |
* @uses XML_Util::createTagFromArray() to create the tag |
*/ |
function createTag($qname, $attributes = array(), $content = null, $namespaceUri = null, $replaceEntities = XML_UTIL_REPLACE_ENTITIES, $multiline = false, $indent = "_auto", $linebreak = "\n", $sortAttributes = true) |
{ |
$tag = array( |
"qname" => $qname, |
"attributes" => $attributes |
); |
// add tag content |
if ($content !== null) { |
$tag["content"] = $content; |
} |
// add namespace Uri |
if ($namespaceUri !== null) { |
$tag["namespaceUri"] = $namespaceUri; |
} |
return XML_Util::createTagFromArray($tag, $replaceEntities, $multiline, $indent, $linebreak, $sortAttributes); |
} |
/** |
* create a tag from an array |
* this method awaits an array in the following format |
* <pre> |
* array( |
* "qname" => $qname // qualified name of the tag |
* "namespace" => $namespace // namespace prefix (optional, if qname is specified or no namespace) |
* "localpart" => $localpart, // local part of the tagname (optional, if qname is specified) |
* "attributes" => array(), // array containing all attributes (optional) |
* "content" => $content, // tag content (optional) |
* "namespaceUri" => $namespaceUri // namespaceUri for the given namespace (optional) |
* ) |
* </pre> |
* |
* <code> |
* require_once 'XML/Util.php'; |
* |
* $tag = array( |
* "qname" => "foo:bar", |
* "namespaceUri" => "http://foo.com", |
* "attributes" => array( "key" => "value", "argh" => "fruit&vegetable" ), |
* "content" => "I'm inside the tag", |
* ); |
* // creating a tag with qualified name and namespaceUri |
* $string = XML_Util::createTagFromArray($tag); |
* </code> |
* |
* @access public |
* @static |
* @param array $tag tag definition |
* @param integer $replaceEntities whether to replace XML special chars in content, embedd it in a CData section or none of both |
* @param boolean $multiline whether to create a multiline tag where each attribute gets written to a single line |
* @param string $indent string used to indent attributes (_auto indents attributes so they start at the same column) |
* @param string $linebreak string used for linebreaks |
* @param boolean $sortAttributes Whether to sort the attributes or not |
* @return string $string XML tag |
* @see XML_Util::createTag() |
* @uses XML_Util::attributesToString() to serialize the attributes of the tag |
* @uses XML_Util::splitQualifiedName() to get local part and namespace of a qualified name |
*/ |
function createTagFromArray($tag, $replaceEntities = XML_UTIL_REPLACE_ENTITIES, $multiline = false, $indent = "_auto", $linebreak = "\n", $sortAttributes = true) |
{ |
if (isset($tag['content']) && !is_scalar($tag['content'])) { |
return XML_Util::raiseError( 'Supplied non-scalar value as tag content', XML_UTIL_ERROR_NON_SCALAR_CONTENT ); |
} |
if (!isset($tag['qname']) && !isset($tag['localPart'])) { |
return XML_Util::raiseError( 'You must either supply a qualified name (qname) or local tag name (localPart).', XML_UTIL_ERROR_NO_TAG_NAME ); |
} |
// if no attributes hav been set, use empty attributes |
if (!isset($tag["attributes"]) || !is_array($tag["attributes"])) { |
$tag["attributes"] = array(); |
} |
if (isset($tag['namespaces'])) { |
foreach ($tag['namespaces'] as $ns => $uri) { |
$tag['attributes']['xmlns:'.$ns] = $uri; |
} |
} |
// qualified name is not given |
if (!isset($tag["qname"])) { |
// check for namespace |
if (isset($tag["namespace"]) && !empty($tag["namespace"])) { |
$tag["qname"] = $tag["namespace"].":".$tag["localPart"]; |
} else { |
$tag["qname"] = $tag["localPart"]; |
} |
// namespace URI is set, but no namespace |
} elseif (isset($tag["namespaceUri"]) && !isset($tag["namespace"])) { |
$parts = XML_Util::splitQualifiedName($tag["qname"]); |
$tag["localPart"] = $parts["localPart"]; |
if (isset($parts["namespace"])) { |
$tag["namespace"] = $parts["namespace"]; |
} |
} |
if (isset($tag["namespaceUri"]) && !empty($tag["namespaceUri"])) { |
// is a namespace given |
if (isset($tag["namespace"]) && !empty($tag["namespace"])) { |
$tag["attributes"]["xmlns:".$tag["namespace"]] = $tag["namespaceUri"]; |
} else { |
// define this Uri as the default namespace |
$tag["attributes"]["xmlns"] = $tag["namespaceUri"]; |
} |
} |
// check for multiline attributes |
if ($multiline === true) { |
if ($indent === "_auto") { |
$indent = str_repeat(" ", (strlen($tag["qname"])+2)); |
} |
} |
// create attribute list |
$attList = XML_Util::attributesToString($tag['attributes'], $sortAttributes, $multiline, $indent, $linebreak, $replaceEntities ); |
if (!isset($tag['content']) || (string)$tag['content'] == '') { |
$tag = sprintf('<%s%s />', $tag['qname'], $attList); |
} else { |
switch ($replaceEntities) { |
case XML_UTIL_ENTITIES_NONE: |
break; |
case XML_UTIL_CDATA_SECTION: |
$tag['content'] = XML_Util::createCDataSection($tag['content']); |
break; |
default: |
$tag['content'] = XML_Util::replaceEntities($tag['content'], $replaceEntities); |
break; |
} |
$tag = sprintf('<%s%s>%s</%s>', $tag['qname'], $attList, $tag['content'], $tag['qname'] ); |
} |
return $tag; |
} |
/** |
* create a start element |
* |
* <code> |
* require_once 'XML/Util.php'; |
* |
* // create an XML start element: |
* $tag = XML_Util::createStartElement("myNs:myTag", array("foo" => "bar") ,"http://www.w3c.org/myNs#"); |
* </code> |
* |
* @access public |
* @static |
* @param string $qname qualified tagname (including namespace) |
* @param array $attributes array containg attributes |
* @param string $namespaceUri URI of the namespace |
* @param boolean $multiline whether to create a multiline tag where each attribute gets written to a single line |
* @param string $indent string used to indent attributes (_auto indents attributes so they start at the same column) |
* @param string $linebreak string used for linebreaks |
* @param boolean $sortAttributes Whether to sort the attributes or not |
* @return string $string XML start element |
* @see XML_Util::createEndElement(), XML_Util::createTag() |
*/ |
function createStartElement($qname, $attributes = array(), $namespaceUri = null, $multiline = false, $indent = '_auto', $linebreak = "\n", $sortAttributes = true) |
{ |
// if no attributes hav been set, use empty attributes |
if (!isset($attributes) || !is_array($attributes)) { |
$attributes = array(); |
} |
if ($namespaceUri != null) { |
$parts = XML_Util::splitQualifiedName($qname); |
} |
// check for multiline attributes |
if ($multiline === true) { |
if ($indent === "_auto") { |
$indent = str_repeat(" ", (strlen($qname)+2)); |
} |
} |
if ($namespaceUri != null) { |
// is a namespace given |
if (isset($parts["namespace"]) && !empty($parts["namespace"])) { |
$attributes["xmlns:".$parts["namespace"]] = $namespaceUri; |
} else { |
// define this Uri as the default namespace |
$attributes["xmlns"] = $namespaceUri; |
} |
} |
// create attribute list |
$attList = XML_Util::attributesToString($attributes, $sortAttributes, $multiline, $indent, $linebreak); |
$element = sprintf("<%s%s>", $qname, $attList); |
return $element; |
} |
/** |
* create an end element |
* |
* <code> |
* require_once 'XML/Util.php'; |
* |
* // create an XML start element: |
* $tag = XML_Util::createEndElement("myNs:myTag"); |
* </code> |
* |
* @access public |
* @static |
* @param string $qname qualified tagname (including namespace) |
* @return string $string XML end element |
* @see XML_Util::createStartElement(), XML_Util::createTag() |
*/ |
function createEndElement($qname) |
{ |
$element = sprintf("</%s>", $qname); |
return $element; |
} |
/** |
* create an XML comment |
* |
* <code> |
* require_once 'XML/Util.php'; |
* |
* // create an XML start element: |
* $tag = XML_Util::createComment("I am a comment"); |
* </code> |
* |
* @access public |
* @static |
* @param string $content content of the comment |
* @return string $comment XML comment |
*/ |
function createComment($content) |
{ |
$comment = sprintf("<!-- %s -->", $content); |
return $comment; |
} |
/** |
* create a CData section |
* |
* <code> |
* require_once 'XML/Util.php'; |
* |
* // create a CData section |
* $tag = XML_Util::createCDataSection("I am content."); |
* </code> |
* |
* @access public |
* @static |
* @param string $data data of the CData section |
* @return string $string CData section with content |
*/ |
function createCDataSection($data) |
{ |
return sprintf("<![CDATA[%s]]>", $data); |
} |
/** |
* split qualified name and return namespace and local part |
* |
* <code> |
* require_once 'XML/Util.php'; |
* |
* // split qualified tag |
* $parts = XML_Util::splitQualifiedName("xslt:stylesheet"); |
* </code> |
* the returned array will contain two elements: |
* <pre> |
* array( |
* "namespace" => "xslt", |
* "localPart" => "stylesheet" |
* ); |
* </pre> |
* |
* @access public |
* @static |
* @param string $qname qualified tag name |
* @param string $defaultNs default namespace (optional) |
* @return array $parts array containing namespace and local part |
*/ |
function splitQualifiedName($qname, $defaultNs = null) |
{ |
if (strstr($qname, ':')) { |
$tmp = explode(":", $qname); |
return array( |
"namespace" => $tmp[0], |
"localPart" => $tmp[1] |
); |
} |
return array( |
"namespace" => $defaultNs, |
"localPart" => $qname |
); |
} |
/** |
* check, whether string is valid XML name |
* |
* <p>XML names are used for tagname, attribute names and various |
* other, lesser known entities.</p> |
* <p>An XML name may only consist of alphanumeric characters, |
* dashes, undescores and periods, and has to start with a letter |
* or an underscore. |
* </p> |
* |
* <code> |
* require_once 'XML/Util.php'; |
* |
* // verify tag name |
* $result = XML_Util::isValidName("invalidTag?"); |
* if (XML_Util::isError($result)) { |
* print "Invalid XML name: " . $result->getMessage(); |
* } |
* </code> |
* |
* @access public |
* @static |
* @param string $string string that should be checked |
* @return mixed $valid true, if string is a valid XML name, PEAR error otherwise |
* @todo support for other charsets |
*/ |
function isValidName($string) |
{ |
// check for invalid chars |
if (!preg_match('/^[[:alpha:]_]$/', $string{0})) { |
return XML_Util::raiseError('XML names may only start with letter or underscore', XML_UTIL_ERROR_INVALID_START); |
} |
// check for invalid chars |
if (!preg_match('/^([[:alpha:]_]([[:alnum:]\-\.]*)?:)?[[:alpha:]_]([[:alnum:]\_\-\.]+)?$/', $string)) { |
return XML_Util::raiseError('XML names may only contain alphanumeric chars, period, hyphen, colon and underscores', XML_UTIL_ERROR_INVALID_CHARS); |
} |
// XML name is valid |
return true; |
} |
/** |
* replacement for XML_Util::raiseError |
* |
* Avoids the necessity to always require |
* PEAR.php |
* |
* @access public |
* @param string error message |
* @param integer error code |
* @return object PEAR_Error |
*/ |
function raiseError($msg, $code) |
{ |
require_once 'PEAR.php'; |
return PEAR::raiseError($msg, $code); |
} |
} |
?> |
/branches/v2.0-narmer/api/pear/XML/Tree.php |
---|
New file |
0,0 → 1,370 |
<?php |
// |
// +----------------------------------------------------------------------+ |
// | PHP Version 4 | |
// +----------------------------------------------------------------------+ |
// | Copyright (c) 1997-2002 The PHP Group | |
// +----------------------------------------------------------------------+ |
// | This source file is subject to version 2.02 of the PHP license, | |
// | that is bundled with this package in the file LICENSE, and is | |
// | available at through the world-wide-web at | |
// | http://www.php.net/license/2_02.txt. | |
// | If you did not receive a copy of the PHP license and are unable to | |
// | obtain it through the world-wide-web, please send a note to | |
// | license@php.net so we can mail you a copy immediately. | |
// +----------------------------------------------------------------------+ |
// | Authors: Bernd Römer <berndr@bonn.edu> | |
// | Sebastian Bergmann <sb@sebastian-bergmann.de> | |
// | Tomas V.V.Cox <cox@idecnet.com> (tree mapping from xml file)| |
// +----------------------------------------------------------------------+ |
// |
// $Id: Tree.php,v 1.1 2005-04-18 16:13:31 jpm Exp $ |
// |
require_once 'XML/Parser.php'; |
require_once 'XML/Tree/Node.php'; |
/** |
* PEAR::XML_Tree |
* |
* Purpose |
* |
* Allows for the building of XML data structures |
* using a tree representation, without the need |
* for an extension like DOMXML. |
* |
* Example |
* |
* $tree = new XML_Tree; |
* $root =& $tree->addRoot('root'); |
* $foo =& $root->addChild('foo'); |
* |
* header('Content-Type: text/xml'); |
* $tree->dump(); |
* |
* @author Bernd Römer <berndr@bonn.edu> |
* @package XML |
* @version $Version$ - 1.0 |
*/ |
class XML_Tree extends XML_Parser |
{ |
/** |
* File Handle |
* |
* @var ressource |
*/ |
var $file = NULL; |
/** |
* Filename |
* |
* @var string |
*/ |
var $filename = ''; |
/** |
* Namespace |
* |
* @var array |
*/ |
var $namespace = array(); |
/** |
* Root |
* |
* @var object XML_Tree_Node |
*/ |
var $root = NULL; |
/** |
* XML Version |
* |
* @var string |
*/ |
var $version = '1.0'; |
/** |
* Constructor |
* |
* @param string Filename |
* @param string XML Version |
*/ |
function XML_Tree($filename = '', $version = '1.0') { |
$this->filename = $filename; |
$this->version = $version; |
} |
/** |
* Add root node. |
* |
* @param string $name name of root element |
* @return object XML_Tree_Node reference to root node |
* |
* @access public |
*/ |
function &addRoot($name, $content = '', $attributes = array()) { |
$this->root = new XML_Tree_Node($name, $content, $attributes); |
return $this->root; |
} |
/** |
* @deprecated |
*/ |
function &add_root($name, $content = '', $attributes = array()) { |
return $this->addRoot($name, $content, $attributes); |
} |
/** |
* inserts a child/tree (child) into tree ($path,$pos) and |
* maintains namespace integrity |
* |
* @param array $path path to parent of child to remove |
* @param integer $pos position of child to be inserted in its parents children-list |
* @param mixed $child child-node (by XML_Tree,XML_Node or Name) |
* @param string $content content (text) for new node |
* @param array $attributes attribute-hash for new node |
* |
* @return object XML_Tree_Node inserted child (node) |
* @access public |
*/ |
function &insertChild($path,$pos,$child, $content = '', $attributes = array()) { |
// update namespace to maintain namespace integrity |
$count=count($path); |
foreach($this->namespace as $key => $val) { |
if ((array_slice($val,0,$count)==$path) && ($val[$count]>=$pos)) |
$this->namespace[$key][$count]++; |
} |
$parent=&$this->get_node_by_path($path); |
return($parent->insert_child($pos,$child,$content,$attributes)); |
} |
/** |
* @deprecated |
*/ |
function &insert_child($path,$pos,$child, $content = '', $attributes = array()) { |
return $this->insertChild($path, $child, $content, $attributes); |
} |
/* |
* removes a child ($path,$pos) from tree ($path,$pos) and |
* maintains namespace integrity |
* |
* @param array $path path to parent of child to remove |
* @param integer $pos position of child in parents children-list |
* |
* @return object XML_Tree_Node parent whichs child was removed |
* @access public |
*/ |
function &removeChild($path,$pos) { |
// update namespace to maintain namespace integrity |
$count=count($path); |
foreach($this->namespace as $key => $val) { |
if (array_slice($val,0,$count)==$path) { |
if ($val[$count]==$pos) { unset($this->namespace[$key]); break; } |
if ($val[$count]>$pos) |
$this->namespace[$key][$count]--; |
} |
} |
$parent=&$this->get_node_by_path($path); |
return($parent->remove_child($pos)); |
} |
/** |
* @deprecated |
*/ |
function &remove_child($path, $pos) { |
return $this->removeChild($path, $pos); |
} |
/* |
* Maps a xml file to a objects tree |
* |
* @return mixed The objects tree (XML_tree or an Pear error) |
* @access public |
*/ |
function &getTreeFromFile () |
{ |
$this->folding = false; |
$this->XML_Parser(null, 'event'); |
$err = $this->setInputFile($this->filename); |
if (PEAR::isError($err)) { |
return $err; |
} |
$this->cdata = null; |
$err = $this->parse(); |
if (PEAR::isError($err)) { |
return $err; |
} |
return $this->root; |
} |
function getTreeFromString($str) |
{ |
$this->folding = false; |
$this->XML_Parser(null, 'event'); |
$this->cdata = null; |
$err = $this->parseString($str); |
if (PEAR::isError($err)) { |
return $err; |
} |
return $this->root; |
} |
/** |
* Handler for the xml-data |
* |
* @param mixed $xp ignored |
* @param string $elem name of the element |
* @param array $attribs attributes for the generated node |
* |
* @access private |
*/ |
function startHandler($xp, $elem, &$attribs) |
{ |
// root elem |
if (!isset($this->i)) { |
$this->obj1 =& $this->add_root($elem, null, $attribs); |
$this->i = 2; |
} else { |
// mixed contents |
if (!empty($this->cdata)) { |
$parent_id = 'obj' . ($this->i - 1); |
$parent =& $this->$parent_id; |
$parent->children[] = &new XML_Tree_Node(null, $this->cdata); |
} |
$obj_id = 'obj' . $this->i++; |
$this->$obj_id = &new XML_Tree_Node($elem, null, $attribs); |
} |
$this->cdata = null; |
return null; |
} |
/** |
* Handler for the xml-data |
* |
* @param mixed $xp ignored |
* @param string $elem name of the element |
* |
* @access private |
*/ |
function endHandler($xp, $elem) |
{ |
$this->i--; |
if ($this->i > 1) { |
$obj_id = 'obj' . $this->i; |
// recover the node created in StartHandler |
$node =& $this->$obj_id; |
// mixed contents |
if (count($node->children) > 0) { |
if (trim($this->cdata)) { |
$node->children[] = &new XML_Tree_Node(null, $this->cdata); |
} |
} else { |
$node->set_content($this->cdata); |
} |
$parent_id = 'obj' . ($this->i - 1); |
$parent =& $this->$parent_id; |
// attach the node to its parent node children array |
$parent->children[] = $node; |
} |
$this->cdata = null; |
return null; |
} |
/* |
* The xml character data handler |
* |
* @param mixed $xp ignored |
* @param string $data PCDATA between tags |
* |
* @access private |
*/ |
function cdataHandler($xp, $data) |
{ |
if (trim($data)) { |
$this->cdata .= $data; |
} |
} |
/** |
* Get a copy of this tree. |
* |
* @return object XML_Tree |
* @access public |
*/ |
function clone() { |
$clone=new XML_Tree($this->filename,$this->version); |
$clone->root=$this->root->clone(); |
// clone all other vars |
$temp=get_object_vars($this); |
foreach($temp as $varname => $value) |
if (!in_array($varname,array('filename','version','root'))) |
$clone->$varname=$value; |
return($clone); |
} |
/** |
* Print text representation of XML tree. |
* |
* @access public |
*/ |
function dump() { |
echo $this->get(); |
} |
/** |
* Get text representation of XML tree. |
* |
* @return string XML |
* @access public |
*/ |
function &get() { |
$out = '<?xml version="' . $this->version . "\"?>\n"; |
$out .= $this->root->get(); |
return $out; |
} |
/** |
* Get current namespace. |
* |
* @param string $name namespace |
* @return string |
* |
* @access public |
*/ |
function &getName($name) { |
return $this->root->get_element($this->namespace[$name]); |
} |
/** |
* @deprecated |
*/ |
function &get_name($name) { |
return $this->getName($name); |
} |
/** |
* Register a namespace. |
* |
* @param string $name namespace |
* @param string $path path |
* |
* @access public |
*/ |
function registerName($name, $path) { |
$this->namespace[$name] = $path; |
} |
/** |
* @deprecated |
*/ |
function register_name($name, $path) { |
return $this->registerName($name, $path); |
} |
} |
?> |
/branches/v2.0-narmer/api/pear/XML/Parser/Simple.php |
---|
New file |
0,0 → 1,297 |
<?php |
// |
// +----------------------------------------------------------------------+ |
// | PHP Version 4 | |
// +----------------------------------------------------------------------+ |
// | Copyright (c) 1997-2004 The PHP Group | |
// +----------------------------------------------------------------------+ |
// | This source file is subject to version 3.0 of the PHP license, | |
// | that is bundled with this package in the file LICENSE, and is | |
// | available at through the world-wide-web at | |
// | http://www.php.net/license/3_0.txt. | |
// | If you did not receive a copy of the PHP license and are unable to | |
// | obtain it through the world-wide-web, please send a note to | |
// | license@php.net so we can mail you a copy immediately. | |
// +----------------------------------------------------------------------+ |
// | Author: Stephan Schmidt <schst@php-tools.net> | |
// +----------------------------------------------------------------------+ |
// |
// $Id: Simple.php,v 1.1 2005-04-18 16:13:31 jpm Exp $ |
/** |
* Simple XML parser class. |
* |
* This class is a simplified version of XML_Parser. |
* In most XML applications the real action is executed, |
* when a closing tag is found. |
* |
* XML_Parser_Simple allows you to just implement one callback |
* for each tag that will receive the tag with its attributes |
* and CData |
* |
* @category XML |
* @package XML_Parser |
* @author Stephan Schmidt <schst@php-tools.net> |
*/ |
/** |
* built on XML_Parser |
*/ |
require_once 'XML/Parser.php'; |
/** |
* Simple XML parser class. |
* |
* This class is a simplified version of XML_Parser. |
* In most XML applications the real action is executed, |
* when a closing tag is found. |
* |
* XML_Parser_Simple allows you to just implement one callback |
* for each tag that will receive the tag with its attributes |
* and CData. |
* |
* <code> |
* require_once '../Parser/Simple.php'; |
* |
* class myParser extends XML_Parser_Simple |
* { |
* function myParser() |
* { |
* $this->XML_Parser_Simple(); |
* } |
* |
* function handleElement($name, $attribs, $data) |
* { |
* printf('handle %s<br>', $name); |
* } |
* } |
* |
* $p = &new myParser(); |
* |
* $result = $p->setInputFile('myDoc.xml'); |
* $result = $p->parse(); |
* </code> |
* |
* @category XML |
* @package XML_Parser |
* @author Stephan Schmidt <schst@php-tools.net> |
*/ |
class XML_Parser_Simple extends XML_Parser |
{ |
/** |
* element stack |
* |
* @access private |
* @var array |
*/ |
var $_elStack = array(); |
/** |
* all character data |
* |
* @access private |
* @var array |
*/ |
var $_data = array(); |
/** |
* element depth |
* |
* @access private |
* @var integer |
*/ |
var $_depth = 0; |
/** |
* Mapping from expat handler function to class method. |
* |
* @var array |
*/ |
var $handler = array( |
'default_handler' => 'defaultHandler', |
'processing_instruction_handler' => 'piHandler', |
'unparsed_entity_decl_handler' => 'unparsedHandler', |
'notation_decl_handler' => 'notationHandler', |
'external_entity_ref_handler' => 'entityrefHandler' |
); |
/** |
* Creates an XML parser. |
* |
* This is needed for PHP4 compatibility, it will |
* call the constructor, when a new instance is created. |
* |
* @param string $srcenc source charset encoding, use NULL (default) to use |
* whatever the document specifies |
* @param string $mode how this parser object should work, "event" for |
* handleElement(), "func" to have it call functions |
* named after elements (handleElement_$name()) |
* @param string $tgenc a valid target encoding |
*/ |
function XML_Parser_Simple($srcenc = null, $mode = 'event', $tgtenc = null) |
{ |
$this->XML_Parser($srcenc, $mode, $tgtenc); |
} |
/** |
* inits the handlers |
* |
* @access private |
*/ |
function _initHandlers() |
{ |
if (!is_object($this->_handlerObj)) { |
$this->_handlerObj = &$this; |
} |
if ($this->mode != 'func' && $this->mode != 'event') { |
return $this->raiseError('Unsupported mode given', XML_PARSER_ERROR_UNSUPPORTED_MODE); |
} |
xml_set_object($this->parser, $this->_handlerObj); |
xml_set_element_handler($this->parser, array(&$this, 'startHandler'), array(&$this, 'endHandler')); |
xml_set_character_data_handler($this->parser, array(&$this, 'cdataHandler')); |
/** |
* set additional handlers for character data, entities, etc. |
*/ |
foreach ($this->handler as $xml_func => $method) { |
if (method_exists($this->_handlerObj, $method)) { |
$xml_func = 'xml_set_' . $xml_func; |
$xml_func($this->parser, $method); |
} |
} |
} |
/** |
* Reset the parser. |
* |
* This allows you to use one parser instance |
* to parse multiple XML documents. |
* |
* @access public |
* @return boolean|object true on success, PEAR_Error otherwise |
*/ |
function reset() |
{ |
$this->_elStack = array(); |
$this->_data = array(); |
$this->_depth = 0; |
$result = $this->_create(); |
if ($this->isError( $result )) { |
return $result; |
} |
return true; |
} |
/** |
* start handler |
* |
* Pushes attributes and tagname onto a stack |
* |
* @access private |
* @final |
* @param resource xml parser resource |
* @param string element name |
* @param array attributes |
*/ |
function startHandler($xp, $elem, &$attribs) |
{ |
array_push($this->_elStack, array( |
'name' => $elem, |
'attribs' => $attribs |
) |
); |
$this->_depth++; |
$this->_data[$this->_depth] = ''; |
} |
/** |
* end handler |
* |
* Pulls attributes and tagname from a stack |
* |
* @access private |
* @final |
* @param resource xml parser resource |
* @param string element name |
*/ |
function endHandler($xp, $elem) |
{ |
$el = array_pop($this->_elStack); |
$data = $this->_data[$this->_depth]; |
$this->_depth--; |
switch ($this->mode) { |
case 'event': |
$this->_handlerObj->handleElement($el['name'], $el['attribs'], $data); |
break; |
case 'func': |
$func = 'handleElement_' . $elem; |
if (strchr($func, '.')) { |
$func = str_replace('.', '_', $func); |
} |
if (method_exists($this->_handlerObj, $func)) { |
call_user_func(array(&$this->_handlerObj, $func), $el['name'], $el['attribs'], $data); |
} |
break; |
} |
} |
/** |
* handle character data |
* |
* @access private |
* @final |
* @param resource xml parser resource |
* @param string data |
*/ |
function cdataHandler($xp, $data) |
{ |
$this->_data[$this->_depth] .= $data; |
} |
/** |
* handle a tag |
* |
* Implement this in your parser |
* |
* @access public |
* @abstract |
* @param string element name |
* @param array attributes |
* @param string character data |
*/ |
function handleElement($name, $attribs, $data) |
{ |
} |
/** |
* get the current tag depth |
* |
* The root tag is in depth 0. |
* |
* @access public |
* @return integer |
*/ |
function getCurrentDepth() |
{ |
return $this->_depth; |
} |
/** |
* add some string to the current ddata. |
* |
* This is commonly needed, when a document is parsed recursively. |
* |
* @access public |
* @param string data to add |
* @return void |
*/ |
function addToData( $data ) |
{ |
$this->_data[$this->_depth] .= $data; |
} |
} |
?> |
/branches/v2.0-narmer/api/pear/XML/RSS.php |
---|
New file |
0,0 → 1,359 |
<?php |
// vim: set expandtab tabstop=4 shiftwidth=4 fdm=marker: |
// +----------------------------------------------------------------------+ |
// | PHP Version 4 | |
// +----------------------------------------------------------------------+ |
// | Copyright (c) 1997-2003 The PHP Group | |
// +----------------------------------------------------------------------+ |
// | This source file is subject to version 2.02 of the PHP license, | |
// | that is bundled with this package in the file LICENSE, and is | |
// | available at through the world-wide-web at | |
// | http://www.php.net/license/2_02.txt. | |
// | If you did not receive a copy of the PHP license and are unable to | |
// | obtain it through the world-wide-web, please send a note to | |
// | license@php.net so we can mail you a copy immediately. | |
// +----------------------------------------------------------------------+ |
// | Authors: Martin Jansen <mj@php.net> | |
// | | |
// +----------------------------------------------------------------------+ |
// |
// $Id: RSS.php,v 1.1 2005-04-18 16:13:31 jpm Exp $ |
// |
require_once 'XML/Parser.php'; |
/** |
* RSS parser class. |
* |
* This class is a parser for Resource Description Framework (RDF) Site |
* Summary (RSS) documents. For more information on RSS see the |
* website of the RSS working group (http://www.purl.org/rss/). |
* |
* @author Martin Jansen <mj@php.net> |
* @version $Revision: 1.1 $ |
* @access public |
*/ |
class XML_RSS extends XML_Parser |
{ |
// {{{ properties |
/** |
* @var string |
*/ |
var $insideTag = ''; |
/** |
* @var string |
*/ |
var $activeTag = ''; |
/** |
* @var array |
*/ |
var $channel = array(); |
/** |
* @var array |
*/ |
var $items = array(); |
/** |
* @var array |
*/ |
var $item = array(); |
/** |
* @var array |
*/ |
var $image = array(); |
/** |
* @var array |
*/ |
var $textinput = array(); |
/** |
* @var array |
*/ |
var $textinputs = array(); |
/** |
* @var array |
*/ |
var $parentTags = array('CHANNEL', 'ITEM', 'IMAGE', 'TEXTINPUT'); |
/** |
* @var array |
*/ |
var $channelTags = array('TITLE', 'LINK', 'DESCRIPTION', 'IMAGE', |
'ITEMS', 'TEXTINPUT'); |
/** |
* @var array |
*/ |
var $itemTags = array('TITLE', 'LINK', 'DESCRIPTION', 'PUBDATE'); |
/** |
* @var array |
*/ |
var $imageTags = array('TITLE', 'URL', 'LINK'); |
var $textinputTags = array('TITLE', 'DESCRIPTION', 'NAME', 'LINK'); |
/** |
* List of allowed module tags |
* |
* Currently Dublin Core Metadata and the blogChannel RSS module |
* are supported. |
* |
* @var array |
*/ |
var $moduleTags = array('DC:TITLE', 'DC:CREATOR', 'DC:SUBJECT', 'DC:DESCRIPTION', |
'DC:PUBLISHER', 'DC:CONTRIBUTOR', 'DC:DATE', 'DC:TYPE', |
'DC:FORMAT', 'DC:IDENTIFIER', 'DC:SOURCE', 'DC:LANGUAGE', |
'DC:RELATION', 'DC:COVERAGE', 'DC:RIGHTS', |
'BLOGCHANNEL:BLOGROLL', 'BLOGCHANNEL:MYSUBSCRIPTIONS', |
'BLOGCHANNEL:MYSUBSCRIPTIONS', 'BLOGCHANNEL:CHANGES'); |
// }}} |
// {{{ Constructor |
/** |
* Constructor |
* |
* @access public |
* @param mixed File pointer or name of the RDF file. |
* @return void |
*/ |
function XML_RSS($handle = '') |
{ |
$this->XML_Parser(); |
if (@is_resource($handle)) { |
$this->setInput($handle); |
} elseif ($handle != '') { |
$this->setInputFile($handle); |
} else { |
$this->raiseError('No filename passed.'); |
} |
} |
// }}} |
// {{{ startHandler() |
/** |
* Start element handler for XML parser |
* |
* @access private |
* @param object XML parser object |
* @param string XML element |
* @param array Attributes of XML tag |
* @return void |
*/ |
function startHandler($parser, $element, $attribs) |
{ |
switch ($element) { |
case 'CHANNEL': |
case 'ITEM': |
case 'IMAGE': |
case 'TEXTINPUT': |
$this->insideTag = $element; |
break; |
default: |
$this->activeTag = $element; |
} |
} |
// }}} |
// {{{ endHandler() |
/** |
* End element handler for XML parser |
* |
* If the end of <item>, <channel>, <image> or <textinput> |
* is reached, this function updates the structure array |
* $this->struct[] and adds the field "type" to this array, |
* that defines the type of the current field. |
* |
* @access private |
* @param object XML parser object |
* @param string |
* @return void |
*/ |
function endHandler($parser, $element) |
{ |
if ($element == $this->insideTag) { |
$this->insideTag = ''; |
$this->struct[] = array_merge(array('type' => strtolower($element)), |
$this->last); |
} |
if ($element == 'ITEM') { |
$this->items[] = $this->item; |
$this->item = ''; |
} |
if ($element == 'IMAGE') { |
$this->images[] = $this->image; |
$this->image = ''; |
} |
if ($element == 'TEXTINPUT') { |
$this->textinputs = $this->textinput; |
$this->textinput = ''; |
} |
$this->activeTag = ''; |
} |
// }}} |
// {{{ cdataHandler() |
/** |
* Handler for character data |
* |
* @access private |
* @param object XML parser object |
* @param string CDATA |
* @return void |
*/ |
function cdataHandler($parser, $cdata) |
{ |
if (in_array($this->insideTag, $this->parentTags)) { |
$tagName = strtolower($this->insideTag); |
$var = $this->{$tagName . 'Tags'}; |
if (in_array($this->activeTag, $var) || |
in_array($this->activeTag, $this->moduleTags)) { |
$this->_add($tagName, strtolower($this->activeTag), |
$cdata); |
} |
} |
} |
// }}} |
// {{{ defaultHandler() |
/** |
* Default handler for XML parser |
* |
* @access private |
* @param object XML parser object |
* @param string CDATA |
* @return void |
*/ |
function defaultHandler($parser, $cdata) |
{ |
return; |
} |
// }}} |
// {{{ _add() |
/** |
* Add element to internal result sets |
* |
* @access private |
* @param string Name of the result set |
* @param string Fieldname |
* @param string Value |
* @return void |
* @see cdataHandler |
*/ |
function _add($type, $field, $value) |
{ |
if (empty($this->{$type}) || empty($this->{$type}[$field])) { |
$this->{$type}[$field] = $value; |
} else { |
$this->{$type}[$field] .= $value; |
} |
$this->last = $this->{$type}; |
} |
// }}} |
// {{{ getStructure() |
/** |
* Get complete structure of RSS file |
* |
* @access public |
* @return array |
*/ |
function getStructure() |
{ |
return (array)$this->struct; |
} |
// }}} |
// {{{ getchannelInfo() |
/** |
* Get general information about current channel |
* |
* This function returns an array containing the information |
* that has been extracted from the <channel>-tag while parsing |
* the RSS file. |
* |
* @access public |
* @return array |
*/ |
function getChannelInfo() |
{ |
return (array)$this->channel; |
} |
// }}} |
// {{{ getItems() |
/** |
* Get items from RSS file |
* |
* This function returns an array containing the set of items |
* that are provided by the RSS file. |
* |
* @access public |
* @return array |
*/ |
function getItems() |
{ |
return (array)$this->items; |
} |
// }}} |
// {{{ getImages() |
/** |
* Get images from RSS file |
* |
* This function returns an array containing the set of images |
* that are provided by the RSS file. |
* |
* @access public |
* @return array |
*/ |
function getImages() |
{ |
return (array)$this->images; |
} |
// }}} |
// {{{ getTextinputs() |
/** |
* Get text input fields from RSS file |
* |
* @access public |
* @return array |
*/ |
function getTextinputs() |
{ |
return (array)$this->textinputs; |
} |
// }}} |
} |
?> |
/branches/v2.0-narmer/api/pear/XML/Tree/Node.php |
---|
New file |
0,0 → 1,354 |
<?php |
// |
// +----------------------------------------------------------------------+ |
// | PHP Version 4 | |
// +----------------------------------------------------------------------+ |
// | Copyright (c) 1997-2002 The PHP Group | |
// +----------------------------------------------------------------------+ |
// | This source file is subject to version 2.02 of the PHP license, | |
// | that is bundled with this package in the file LICENSE, and is | |
// | available at through the world-wide-web at | |
// | http://www.php.net/license/2_02.txt. | |
// | If you did not receive a copy of the PHP license and are unable to | |
// | obtain it through the world-wide-web, please send a note to | |
// | license@php.net so we can mail you a copy immediately. | |
// +----------------------------------------------------------------------+ |
// | Authors: Bernd Römer <berndr@bonn.edu> | |
// | Sebastian Bergmann <sb@sebastian-bergmann.de> | |
// | Christian Kühn <ck@chkuehn.de> (escape xml entities) | |
// +----------------------------------------------------------------------+ |
// |
// $Id: Node.php,v 1.1 2005-04-18 16:13:31 jpm Exp $ |
// |
/** |
* PEAR::XML_Tree_Node |
* |
* @author Bernd Römer <berndr@bonn.edu> |
* @package XML_Tree |
* @version 1.0 16-Aug-2001 |
*/ |
class XML_Tree_Node { |
/** |
* Attributes of this node |
* |
* @var array |
*/ |
var $attributes; |
/** |
* Children of this node |
* |
* @var array |
*/ |
var $children; |
/** |
* Content |
* |
* @var string |
*/ |
var $content; |
/** |
* Name |
* |
* @var string |
*/ |
var $name; |
/** |
* Constructor |
* |
* @param string name |
* @param string content |
* @param array attributes |
*/ |
function XML_Tree_Node($name, $content = '', $attributes = array()) { |
$this->attributes = $attributes; |
$this->children = array(); |
$this->set_content($content); |
$this->name = $name; |
} |
/** |
* Adds a child node to this node. |
* |
* @param mixed child |
* @param string content |
* @param array attributes |
* @return object reference to new child node |
*/ |
function &addChild($child, $content = '', $attributes = array()) { |
$index = sizeof($this->children); |
if (is_object($child)) { |
if (strtolower(get_class($child)) == 'xml_tree_node') { |
$this->children[$index] = $child; |
} |
if (strtolower(get_class($child)) == 'xml_tree' && isset($child->root)) { |
$this->children[$index] = $child->root->get_element(); |
} |
} else { |
$this->children[$index] = new XML_Tree_Node($child, $content, $attributes); |
} |
return $this->children[$index]; |
} |
/** |
* @deprecated |
*/ |
function &add_child($child, $content = '', $attributes = array()) { |
return $this->addChild($child, $content, $attributes); |
} |
/** |
* clone node and all its children (recursive) |
* |
* @return object reference to the clone-node |
*/ |
function &clone() { |
$clone=new XML_Tree_Node($this->name,$this->content,$this->attributes); |
$max_child=count($this->children); |
for($i=0;$i<$max_child;$i++) { |
$clone->children[]=$this->children[$i]->clone(); |
} |
/* for future use.... |
// clone all other vars |
$temp=get_object_vars($this); |
foreach($temp as $varname => $value) |
if (!in_array($varname,array('name','content','attributes','children'))) |
$clone->$varname=$value; |
*/ |
return($clone); |
} |
/** |
* inserts child ($child) to a specified child-position ($pos) |
* |
* @return inserted node |
*/ |
function &insertChild($path,$pos,&$child, $content = '', $attributes = array()) { |
// direct insert of objects useing array_splice() faild :( |
array_splice($this->children,$pos,0,'dummy'); |
if (is_object($child)) { // child offered is not instanziated |
// insert a single node |
if (strtolower(get_class($child)) == 'xml_tree_node') { |
$this->children[$pos]=&$child; |
} |
// insert a tree i.e insert root-element |
if (strtolower(get_class($child)) == 'xml_tree' && isset($child->root)) { |
$this->children[$pos]=$child->root->get_element(); |
} |
} else { // child offered is not instanziated |
$this->children[$pos]=new XML_Tree_Node($child, $content, $attributes); |
} |
return($this); |
} |
/** |
* @deprecated |
*/ |
function &insert_child($path,$pos,&$child, $content = '', $attributes = array()) { |
return $this->insertChild($path,$pos,$child, $content, $attributes); |
} |
/** |
* removes child ($pos) |
* |
* @param integer pos position of child in children-list |
* |
* @return removed node |
*/ |
function &removeChild($pos) { |
// array_splice() instead of a simple unset() to maintain index-integrity |
return(array_splice($this->children,$pos,1)); |
} |
/** |
* @deprecated |
*/ |
function &remove_child($pos) { |
return $this->removeChild($pos); |
} |
/** |
* Returns text representation of this node. |
* |
* @return string xml |
*/ |
function &get() |
{ |
static $deep = -1; |
static $do_ident = true; |
$deep++; |
if ($this->name !== null) { |
$ident = str_repeat(' ', $deep); |
if ($do_ident) { |
$out = $ident . '<' . $this->name; |
} else { |
$out = '<' . $this->name; |
} |
foreach ($this->attributes as $name => $value) { |
$out .= ' ' . $name . '="' . $value . '"'; |
} |
$out .= '>' . $this->content; |
if (sizeof($this->children) > 0) { |
$out .= "\n"; |
foreach ($this->children as $child) { |
$out .= $child->get(); |
} |
} else { |
$ident = ''; |
} |
if ($do_ident) { |
$out .= $ident . '</' . $this->name . ">\n"; |
} else { |
$out .= '</' . $this->name . '>'; |
} |
$do_ident = true; |
} else { |
$out = $this->content; |
$do_ident = false; |
} |
$deep--; |
return $out; |
} |
/** |
* Gets an attribute by its name. |
* |
* @param string name |
* @return string attribute |
*/ |
function getAttribute($name) { |
return $this->attributes[strtolower($name)]; |
} |
/** |
* @deprecated |
*/ |
function get_attribute($name) { |
return $this->getAttribute($name); |
} |
/** |
* Gets an element by its 'path'. |
* |
* @param string path |
* @return object element |
*/ |
function &getElement($path) { |
if (sizeof($path) == 0) { |
return $this; |
} |
$next = array_shift($path); |
return $this->children[$next]->get_element($path); |
} |
/** |
* @deprecated |
*/ |
function &get_element($path) { |
return $this->getElement($path); |
} |
/** |
* Sets an attribute. |
* |
* @param string name |
* @param string value |
*/ |
function setAttribute($name, $value = '') { |
$this->attributes[strtolower($name)] = $value; |
} |
/** |
* @deprecated |
*/ |
function set_attribute($name, $value = '') { |
return $this->setAttribute($name, $value); |
} |
/** |
* Unsets an attribute. |
* |
* @param string name |
*/ |
function unsetAttribute($name) { |
unset($this->attributes[strtolower($name)]); |
} |
/** |
* @deprecated |
*/ |
function unset_attribute($name) { |
return $this->unsetAttribute($name); |
} |
/** |
* |
* |
*/ |
function setContent(&$content) |
{ |
$this->content = $this->_xml_entities($content); |
} |
function set_content(&$content) |
{ |
return $this->setContent($content); |
} |
/** |
* Escape XML entities. |
* |
* @param string xml |
* @return string xml |
* @access private |
*/ |
function _xml_entities($xml) { |
$xml = str_replace(array('ü', 'Ü', 'ö', |
'Ö', 'ä', 'Ä', |
'ß' |
), |
array('ü', 'Ü', 'ö', |
'Ö', 'ä', 'Ä', |
'ß' |
), |
$xml |
); |
$xml = preg_replace(array("/\&([a-z\d\#]+)\;/i", |
"/\&/", |
"/\#\|\|([a-z\d\#]+)\|\|\#/i", |
"/([^a-zA-Z\d\s\<\>\&\;\.\:\=\"\-\/\%\?\!\'\(\)\[\]\{\}\$\#\+\,\@_])/e" |
), |
array("#||\\1||#", |
"&", |
"&\\1;", |
"'&#'.ord('\\1').';'" |
), |
$xml |
); |
return $xml; |
} |
/** |
* Print text representation of XML tree. |
*/ |
function dump() { |
echo $this->get(); |
} |
} |
?> |