Subversion Repositories eFlore/Applications.cel

Rev

Rev 580 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
580 jpm 1
<?php
2
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
3
 
4
/**
5
 * Class representing feed-level data for an RSS2 feed
6
 *
7
 * PHP versions 5
8
 *
9
 * LICENSE: This source file is subject to version 3.0 of the PHP license
10
 * that is available through the world-wide-web at the following URI:
11
 * http://www.php.net/license/3_0.txt.  If you did not receive a copy of
12
 * the PHP License and are unable to obtain it through the web, please
13
 * send a note to license@php.net so we can mail you a copy immediately.
14
 *
15
 * @category   XML
16
 * @package	XML_Feed_Parser
17
 * @author	 James Stewart <james@jystewart.net>
18
 * @copyright  2005 James Stewart <james@jystewart.net>
19
 * @license	http://www.gnu.org/copyleft/lesser.html  GNU LGPL 2.1
20
 * @version	CVS: $Id: RSS2.php 304308 2010-10-11 12:05:50Z clockwerx $
21
 * @link	   http://pear.php.net/package/XML_Feed_Parser/
22
 */
23
 
24
/**
25
 * This class handles RSS2 feeds.
26
 *
27
 * @author	James Stewart <james@jystewart.net>
28
 * @version	Release: @package_version@
29
 * @package XML_Feed_Parser
30
 */
31
class XmlFeedParserRss2 extends XmlFeedParserType {
32
	/**
33
	 * The URI of the RelaxNG schema used to (optionally) validate the feed
34
	 * @var string
35
	 */
36
	protected $relax = 'rss20.rng';
37
 
38
	/**
39
	 * We're likely to use XPath, so let's keep it global
40
	 * @var DOMXPath
41
	 */
42
	protected $xpath;
43
 
44
	/**
45
	 * The feed type we are parsing
46
	 * @var string
47
	 */
48
	public $version = 'RSS 2.0';
49
 
50
	/**
51
	 * The class used to represent individual items
52
	 * @var string
53
	 */
54
	protected $itemClass = 'XmlFeedParserRss2Element';
55
 
56
	/**
57
	 * The element containing entries
58
	 * @var string
59
	 */
60
	protected $itemElement = 'item';
61
 
62
	/**
63
	 * Here we map those elements we're not going to handle individually
64
	 * to the constructs they are. The optional second parameter in the array
65
	 * tells the parser whether to 'fall back' (not apt. at the feed level) or
66
	 * fail if the element is missing. If the parameter is not set, the function
67
	 * will simply return false and leave it to the client to decide what to do.
68
	 * @var array
69
	 */
70
	protected $map = array(
71
		'ttl' => array('Text'),
72
		'pubDate' => array('Date'),
73
		'lastBuildDate' => array('Date'),
74
		'title' => array('Text'),
75
		'link' => array('Link'),
76
		'description' => array('Text'),
77
		'language' => array('Text'),
78
		'copyright' => array('Text'),
79
		'managingEditor' => array('Text'),
80
		'webMaster' => array('Text'),
81
		'category' => array('Text'),
82
		'generator' => array('Text'),
83
		'docs' => array('Text'),
84
		'ttl' => array('Text'),
85
		'image' => array('Image'),
86
		'skipDays' => array('skipDays'),
87
		'skipHours' => array('skipHours'));
88
 
89
	/**
90
	 * Here we map some elements to their atom equivalents. This is going to be
91
	 * quite tricky to pull off effectively (and some users' methods may vary)
92
	 * but is worth trying. The key is the atom version, the value is RSS2.
93
	 * @var array
94
	 */
95
	protected $compatMap = array(
96
		'title' => array('title'),
97
		'rights' => array('copyright'),
98
		'updated' => array('lastBuildDate'),
99
		'subtitle' => array('description'),
100
		'date' => array('pubDate'),
101
		'author' => array('managingEditor'));
102
 
103
	protected $namespaces = array(
104
		'dc' => 'http://purl.org/rss/1.0/modules/dc/',
105
		'content' => 'http://purl.org/rss/1.0/modules/content/');
106
 
107
	/**
108
	 * Our constructor does nothing more than its parent.
109
	 *
110
	 * @param	DOMDocument	$xml	A DOM object representing the feed
111
	 * @param	bool (optional) $string	Whether or not to validate this feed
112
	 */
113
	function __construct(DOMDocument $model, $strict = false) {
114
		$this->model = $model;
115
 
116
		if ($strict) {
117
			if (! $this->relaxNGValidate()) {
118
				throw new XmlFeedParserException('Failed required validation');
119
			}
120
		}
121
 
122
		$this->xpath = new DOMXPath($this->model);
123
		foreach ($this->namespaces as $key => $value) {
124
			$this->xpath->registerNamespace($key, $value);
125
		}
126
		$this->numberEntries = $this->count('item');
127
	}
128
 
129
	/**
130
	 * Retrieves an entry by ID, if the ID is specified with the guid element
131
	 *
132
	 * This is not really something that will work with RSS2 as it does not have
133
	 * clear restrictions on the global uniqueness of IDs. But we can emulate
134
	 * it by allowing access based on the 'guid' element. If DOMXPath::evaluate
135
	 * is available, we also use that to store a reference to the entry in the array
136
	 * used by getEntryByOffset so that method does not have to seek out the entry
137
	 * if it's requested that way.
138
	 *
139
	 * @param	string	$id	any valid ID.
140
	 * @return	XML_Feed_Parser_RSS2Element
141
	 */
142
	function getEntryById($id) {
143
		if (isset($this->idMappings[$id])) {
144
			return $this->entries[$this->idMappings[$id]];
145
		}
146
 
147
		$entries = $this->xpath->query("//item[guid='$id']");
148
		if ($entries->length > 0) {
149
			$entry = new $this->itemElement($entries->item(0), $this);
150
			if (in_array('evaluate', get_class_methods($this->xpath))) {
151
				$offset = $this->xpath->evaluate("count(preceding-sibling::item)", $entries->item(0));
152
				$this->entries[$offset] = $entry;
153
			}
154
			$this->idMappings[$id] = $entry;
155
			return $entry;
156
		}
157
	}
158
 
159
	/**
160
	 * Get a category from the element
161
	 *
162
	 * The category element is a simple text construct which can occur any number
163
	 * of times. We allow access by offset or access to an array of results.
164
	 *
165
	 * @param	string	$call	for compatibility with our overloading
166
	 * @param   array $arguments - arg 0 is the offset, arg 1 is whether to return as array
167
	 * @return  string|array|false
168
	 */
169
	function getCategory($call, $arguments = array()) {
170
		$categories = $this->model->getElementsByTagName('category');
171
		$offset = empty($arguments[0]) ? 0 : $arguments[0];
172
		$array = empty($arguments[1]) ? false : true;
173
		if ($categories->length <= $offset) {
174
			return false;
175
		}
176
		if ($array) {
177
			$list = array();
178
			foreach ($categories as $category) {
179
				array_push($list, $category->nodeValue);
180
			}
181
			return $list;
182
		}
183
		return $categories->item($offset)->nodeValue;
184
	}
185
 
186
	/**
187
	 * Get details of the image associated with the feed.
188
	 *
189
	 * @return  array|false an array simply containing the child elements
190
	 */
191
	protected function getImage() {
192
		$images = $this->xpath->query("//image");
193
		if ($images->length > 0) {
194
			$image = $images->item(0);
195
			$desc = $image->getElementsByTagName('description');
196
			$description = $desc->length ? $desc->item(0)->nodeValue : false;
197
			$heigh = $image->getElementsByTagName('height');
198
			$height = $heigh->length ? $heigh->item(0)->nodeValue : false;
199
			$widt = $image->getElementsByTagName('width');
200
			$width = $widt->length ? $widt->item(0)->nodeValue : false;
201
			return array(
202
				'title' => $image->getElementsByTagName('title')->item(0)->nodeValue,
203
				'link' => $image->getElementsByTagName('link')->item(0)->nodeValue,
204
				'url' => $image->getElementsByTagName('url')->item(0)->nodeValue,
205
				'description' => $description,
206
				'height' => $height,
207
				'width' => $width);
208
		}
209
		return false;
210
	}
211
 
212
	/**
213
	 * The textinput element is little used, but in the interests of
214
	 * completeness...
215
	 *
216
	 * @return  array|false
217
	 */
218
	function getTextInput() {
219
		$inputs = $this->model->getElementsByTagName('input');
220
		if ($inputs->length > 0) {
221
			$input = $inputs->item(0);
222
			return array(
223
				'title' => $input->getElementsByTagName('title')->item(0)->value,
224
				'description' =>
225
					$input->getElementsByTagName('description')->item(0)->value,
226
				'name' => $input->getElementsByTagName('name')->item(0)->value,
227
				'link' => $input->getElementsByTagName('link')->item(0)->value);
228
		}
229
		return false;
230
	}
231
 
232
	/**
233
	 * Utility function for getSkipDays and getSkipHours
234
	 *
235
	 * This is a general function used by both getSkipDays and getSkipHours. It simply
236
	 * returns an array of the values of the children of the appropriate tag.
237
	 *
238
	 * @param   string	  $tagName	The tag name (getSkipDays or getSkipHours)
239
	 * @return  array|false
240
	 */
241
	protected function getSkips($tagName) {
242
		$hours = $this->model->getElementsByTagName($tagName);
243
		if ($hours->length == 0) {
244
			return false;
245
		}
246
		$skipHours = array();
247
		foreach($hours->item(0)->childNodes as $hour) {
248
			if ($hour instanceof DOMElement) {
249
				array_push($skipHours, $hour->nodeValue);
250
			}
251
		}
252
		return $skipHours;
253
	}
254
 
255
	/**
256
	 * Retrieve skipHours data
257
	 *
258
	 * The skiphours element provides a list of hours on which this feed should
259
	 * not be checked. We return an array of those hours (integers, 24 hour clock)
260
	 *
261
	 * @return  array
262
	 */
263
	function getSkipHours() {
264
		return $this->getSkips('skipHours');
265
	}
266
 
267
	/**
268
	 * Retrieve skipDays data
269
	 *
270
	 * The skipdays element provides a list of days on which this feed should
271
	 * not be checked. We return an array of those days.
272
	 *
273
	 * @return  array
274
	 */
275
	function getSkipDays() {
276
		return $this->getSkips('skipDays');
277
	}
278
 
279
	/**
280
	 * Return content of the little-used 'cloud' element
281
	 *
282
	 * The cloud element is rarely used. It is designed to provide some details
283
	 * of a location to update the feed.
284
	 *
285
	 * @return  array   an array of the attributes of the element
286
	 */
287
	function getCloud() {
288
		$cloud = $this->model->getElementsByTagName('cloud');
289
		if ($cloud->length == 0) {
290
			return false;
291
		}
292
		$cloudData = array();
293
		foreach ($cloud->item(0)->attributes as $attribute) {
294
			$cloudData[$attribute->name] = $attribute->value;
295
		}
296
		return $cloudData;
297
	}
298
 
299
	/**
300
	 * Get link URL
301
	 *
302
	 * In RSS2 a link is a text element but in order to ensure that we resolve
303
	 * URLs properly we have a special function for them. We maintain the
304
	 * parameter used by the atom getLink method, though we only use the offset
305
	 * parameter.
306
	 *
307
	 * @param   int	 $offset The position of the link within the feed. Starts from 0
308
	 * @param   string  $attribute  The attribute of the link element required
309
	 * @param   array   $params An array of other parameters. Not used.
310
	 * @return  string
311
	 */
312
	function getLink($offset, $attribute = 'href', $params = array()) {
313
		$links = $this->model->getElementsByTagName('link');
314
 
315
		if ($links->length <= $offset) {
316
			return false;
317
		}
318
		$link = $links->item($offset);
319
		return $this->addBase($link->nodeValue, $link);
320
	}
321
}
322
 
323
?>