Subversion Repositories Applications.papyrus

<?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.2 2007-07-25 15:05:34 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);

    }

}

?>