Subversion Repositories Applications.papyrus

<?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 304308 2010-10-11 12:05:50Z clockwerx $

 * @link	   http://pear.php.net/package/XML_Feed_Parser/

 */

/**

 * This class handles RSS2 feeds.

 *

 * @author	James Stewart <james@jystewart.net>

 * @version	Release: @package_version@

 * @package XML_Feed_Parser

 */

class XmlFeedParserRss2 extends XmlFeedParserType {

	/**

	 * The URI of the RelaxNG schema used to (optionally) validate the feed

	 * @var string

	 */

	protected $relax = 'rss20.rng';

	/**

	 * 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 = 'XmlFeedParserRss2Element';

	/**

	 * 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->relaxNGValidate()) {

				throw new XmlFeedParserException('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->xpath->query("//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);

	}

}

?>