3669 |
killian |
1 |
<?php
|
|
|
2 |
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
|
|
|
3 |
|
|
|
4 |
/**
|
|
|
5 |
* Key gateway class for XML_Feed_Parser package
|
|
|
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
|
|
|
20 |
* @version CVS: $Id: Parser.php 304308 2010-10-11 12:05:50Z clockwerx $
|
|
|
21 |
* @link http://pear.php.net/package/XML_Feed_Parser/
|
|
|
22 |
*/
|
|
|
23 |
|
|
|
24 |
/**
|
|
|
25 |
* This is the core of the XML_Feed_Parser package. It identifies feed types
|
|
|
26 |
* and abstracts access to them. It is an iterator, allowing for easy access
|
|
|
27 |
* to the entire feed.
|
|
|
28 |
*
|
|
|
29 |
* @author James Stewart <james@jystewart.net>
|
|
|
30 |
* @version Release: @package_version@
|
|
|
31 |
* @package XML_Feed_Parser
|
|
|
32 |
*/
|
|
|
33 |
class XmlFeedParser implements Iterator {
|
|
|
34 |
/**
|
|
|
35 |
* This is where we hold the feed object
|
|
|
36 |
* @var Object
|
|
|
37 |
*/
|
|
|
38 |
private $feed;
|
|
|
39 |
|
|
|
40 |
/**
|
|
|
41 |
* To allow for extensions, we make a public reference to the feed model
|
|
|
42 |
* @var DOMDocument
|
|
|
43 |
*/
|
|
|
44 |
public $model;
|
|
|
45 |
|
|
|
46 |
/**
|
|
|
47 |
* A map between entry ID and offset
|
|
|
48 |
* @var array
|
|
|
49 |
*/
|
|
|
50 |
protected $idMappings = array();
|
|
|
51 |
|
|
|
52 |
/**
|
|
|
53 |
* A storage space for Namespace URIs.
|
|
|
54 |
* @var array
|
|
|
55 |
*/
|
|
|
56 |
private $feedNamespaces = array(
|
|
|
57 |
'rss2' => array(
|
|
|
58 |
'http://backend.userland.com/rss',
|
|
|
59 |
'http://backend.userland.com/rss2',
|
|
|
60 |
'http://blogs.law.harvard.edu/tech/rss'));
|
|
|
61 |
/**
|
|
|
62 |
* Detects feed types and instantiate appropriate objects.
|
|
|
63 |
*
|
|
|
64 |
* Our constructor takes care of detecting feed types and instantiating
|
|
|
65 |
* appropriate classes. For now we're going to treat Atom 0.3 as Atom 1.0
|
|
|
66 |
* but raise a warning. I do not intend to introduce full support for
|
|
|
67 |
* Atom 0.3 as it has been deprecated, but others are welcome to.
|
|
|
68 |
*
|
|
|
69 |
* @param string $feed XML serialization of the feed
|
|
|
70 |
* @param bool $strict Whether or not to validate the feed
|
|
|
71 |
* @param bool $suppressWarnings Trigger errors for deprecated feed types?
|
|
|
72 |
* @param bool $tidy Whether or not to try and use the tidy library on input
|
|
|
73 |
*/
|
|
|
74 |
function __construct($feed, $strict = false, $suppressWarnings = true, $tidy = true) {
|
|
|
75 |
$this->model = new DOMDocument;
|
|
|
76 |
if (! $this->model->loadXML($feed)) {
|
|
|
77 |
if (extension_loaded('tidy') && $tidy) {
|
|
|
78 |
$tidy = new tidy;
|
|
|
79 |
$tidy->parseString($feed, array('input-xml' => true, 'output-xml' => true));
|
|
|
80 |
$tidy->cleanRepair();
|
|
|
81 |
if (! $this->model->loadXML((string) $tidy)) {
|
|
|
82 |
throw new XmlFeedParserException("Entrée invalide : le flux n'est pas du XML valide");
|
|
|
83 |
}
|
|
|
84 |
} else {
|
|
|
85 |
throw new XmlFeedParserException("Entrée invalide : le flux n'est pas du XML valide");
|
|
|
86 |
}
|
|
|
87 |
}
|
|
|
88 |
|
|
|
89 |
/* detect feed type */
|
|
|
90 |
$doc_element = $this->model->documentElement;
|
|
|
91 |
$error = false;
|
|
|
92 |
|
|
|
93 |
switch (true) {
|
|
|
94 |
case ($doc_element->namespaceURI == 'http://www.w3.org/2005/Atom'):
|
|
|
95 |
$class = 'XmlFeedParserAtom';
|
|
|
96 |
break;
|
|
|
97 |
case ($doc_element->namespaceURI == 'http://purl.org/atom/ns#'):
|
|
|
98 |
$class = 'XmlFeedParserAtom';
|
|
|
99 |
$error = "Atom 0.3 est déprécié, le parseur en version 1.0 sera utilisé mais toutes les options ne seront pas disponibles.";
|
|
|
100 |
break;
|
|
|
101 |
case ($doc_element->namespaceURI == 'http://purl.org/rss/1.0/'
|
|
|
102 |
|| ($doc_element->hasChildNodes() && $doc_element->childNodes->length > 1
|
|
|
103 |
&& $doc_element->childNodes->item(1)->namespaceURI == 'http://purl.org/rss/1.0/')):
|
|
|
104 |
$class = 'XmlFeedParserRss1';
|
|
|
105 |
break;
|
|
|
106 |
case ($doc_element->namespaceURI == 'http://purl.org/rss/1.1/'
|
|
|
107 |
|| ($doc_element->hasChildNodes()
|
|
|
108 |
&& $doc_element->childNodes->length > 1
|
|
|
109 |
&& $doc_element->childNodes->item(1)->namespaceURI == 'http://purl.org/rss/1.1/')):
|
|
|
110 |
$class = 'XmlFeedParserRss11';
|
|
|
111 |
break;
|
|
|
112 |
case (($doc_element->hasChildNodes()
|
|
|
113 |
&& $doc_element->childNodes->length > 1
|
|
|
114 |
&& $doc_element->childNodes->item(1)->namespaceURI == 'http://my.netscape.com/rdf/simple/0.9/')
|
|
|
115 |
|| $doc_element->namespaceURI == 'http://my.netscape.com/rdf/simple/0.9/'):
|
|
|
116 |
$class = 'XmlFeedParserRss09';
|
|
|
117 |
break;
|
|
|
118 |
case ($doc_element->tagName == 'rss'
|
|
|
119 |
and $doc_element->hasAttribute('version')
|
|
|
120 |
&& $doc_element->getAttribute('version') == 0.91):
|
|
|
121 |
$error = 'RSS 0.91 has been superceded by RSS2.0. Using RSS2.0 parser.';
|
|
|
122 |
$class = 'XmlFeedParserRss2';
|
|
|
123 |
break;
|
|
|
124 |
case ($doc_element->tagName == 'rss'
|
|
|
125 |
and $doc_element->hasAttribute('version')
|
|
|
126 |
&& $doc_element->getAttribute('version') == 0.92):
|
|
|
127 |
$error = 'RSS 0.92 has been superceded by RSS2.0. Using RSS2.0 parser.';
|
|
|
128 |
$class = 'XmlFeedParserRss2';
|
|
|
129 |
break;
|
|
|
130 |
case (in_array($doc_element->namespaceURI, $this->feedNamespaces['rss2'])
|
|
|
131 |
|| $doc_element->tagName == 'rss'):
|
|
|
132 |
if (! $doc_element->hasAttribute('version') || $doc_element->getAttribute('version') != 2) {
|
|
|
133 |
$error = 'RSS version not specified. Parsing as RSS2.0';
|
|
|
134 |
}
|
|
|
135 |
$class = 'XmlFeedParserRss2';
|
|
|
136 |
break;
|
|
|
137 |
default:
|
|
|
138 |
throw new XmlFeedParserException('Type de flux de syndicaton inconnu');
|
|
|
139 |
break;
|
|
|
140 |
}
|
|
|
141 |
|
|
|
142 |
if (! $suppressWarnings && ! empty($error)) {
|
|
|
143 |
trigger_error($error, E_USER_WARNING);
|
|
|
144 |
}
|
|
|
145 |
|
|
|
146 |
/* Instantiate feed object */
|
|
|
147 |
$this->feed = new $class($this->model, $strict);
|
|
|
148 |
}
|
|
|
149 |
|
|
|
150 |
/**
|
|
|
151 |
* Proxy to allow feed element names to be used as method names
|
|
|
152 |
*
|
|
|
153 |
* For top-level feed elements we will provide access using methods or
|
|
|
154 |
* attributes. This function simply passes on a request to the appropriate
|
|
|
155 |
* feed type object.
|
|
|
156 |
*
|
|
|
157 |
* @param string $call - the method being called
|
|
|
158 |
* @param array $attributes
|
|
|
159 |
*/
|
|
|
160 |
function __call($call, $attributes) {
|
|
|
161 |
$attributes = array_pad($attributes, 5, false);
|
|
|
162 |
list($a, $b, $c, $d, $e) = $attributes;
|
|
|
163 |
return $this->feed->$call($a, $b, $c, $d, $e);
|
|
|
164 |
}
|
|
|
165 |
|
|
|
166 |
/**
|
|
|
167 |
* Proxy to allow feed element names to be used as attribute names
|
|
|
168 |
*
|
|
|
169 |
* To allow variable-like access to feed-level data we use this
|
|
|
170 |
* method. It simply passes along to __call() which in turn passes
|
|
|
171 |
* along to the relevant object.
|
|
|
172 |
*
|
|
|
173 |
* @param string $val - the name of the variable required
|
|
|
174 |
*/
|
|
|
175 |
function __get($val) {
|
|
|
176 |
return $this->feed->$val;
|
|
|
177 |
}
|
|
|
178 |
|
|
|
179 |
/**
|
|
|
180 |
* Provides iteration functionality.
|
|
|
181 |
*
|
|
|
182 |
* Of course we must be able to iterate... This function simply increases
|
|
|
183 |
* our internal counter.
|
|
|
184 |
*/
|
|
|
185 |
function next() {
|
|
|
186 |
if (isset($this->current_item) &&
|
|
|
187 |
$this->current_item <= $this->feed->numberEntries - 1) {
|
|
|
188 |
++$this->current_item;
|
|
|
189 |
} else if (! isset($this->current_item)) {
|
|
|
190 |
$this->current_item = 0;
|
|
|
191 |
} else {
|
|
|
192 |
return false;
|
|
|
193 |
}
|
|
|
194 |
}
|
|
|
195 |
|
|
|
196 |
/**
|
|
|
197 |
* Return XML_Feed_Type object for current element
|
|
|
198 |
*
|
|
|
199 |
* @return XML_Feed_Parser_Type Object
|
|
|
200 |
*/
|
|
|
201 |
function current() {
|
|
|
202 |
return $this->getEntryByOffset($this->current_item);
|
|
|
203 |
}
|
|
|
204 |
|
|
|
205 |
/**
|
|
|
206 |
* For iteration -- returns the key for the current stage in the array.
|
|
|
207 |
*
|
|
|
208 |
* @return int
|
|
|
209 |
*/
|
|
|
210 |
function key() {
|
|
|
211 |
return $this->current_item;
|
|
|
212 |
}
|
|
|
213 |
|
|
|
214 |
/**
|
|
|
215 |
* For iteration -- tells whether we have reached the
|
|
|
216 |
* end.
|
|
|
217 |
*
|
|
|
218 |
* @return bool
|
|
|
219 |
*/
|
|
|
220 |
function valid() {
|
|
|
221 |
return $this->current_item < $this->feed->numberEntries;
|
|
|
222 |
}
|
|
|
223 |
|
|
|
224 |
/**
|
|
|
225 |
* For iteration -- resets the internal counter to the beginning.
|
|
|
226 |
*/
|
|
|
227 |
function rewind() {
|
|
|
228 |
$this->current_item = 0;
|
|
|
229 |
}
|
|
|
230 |
|
|
|
231 |
/**
|
|
|
232 |
* Provides access to entries by ID if one is specified in the source feed.
|
|
|
233 |
*
|
|
|
234 |
* As well as allowing the items to be iterated over we want to allow
|
|
|
235 |
* users to be able to access a specific entry. This is one of two ways of
|
|
|
236 |
* doing that, the other being by offset. This method can be quite slow
|
|
|
237 |
* if dealing with a large feed that hasn't yet been processed as it
|
|
|
238 |
* instantiates objects for every entry until it finds the one needed.
|
|
|
239 |
*
|
|
|
240 |
* @param string $id Valid ID for the given feed format
|
|
|
241 |
* @return XML_Feed_Parser_Type|false
|
|
|
242 |
*/
|
|
|
243 |
function getEntryById($id) {
|
|
|
244 |
if (isset($this->idMappings[$id])) {
|
|
|
245 |
return $this->getEntryByOffset($this->idMappings[$id]);
|
|
|
246 |
}
|
|
|
247 |
|
|
|
248 |
/*
|
|
|
249 |
* Since we have not yet encountered that ID, let's go through all the
|
|
|
250 |
* remaining entries in order till we find it.
|
|
|
251 |
* This is a fairly slow implementation, but it should work.
|
|
|
252 |
*/
|
|
|
253 |
return $this->feed->getEntryById($id);
|
|
|
254 |
}
|
|
|
255 |
|
|
|
256 |
/**
|
|
|
257 |
* Retrieve entry by numeric offset, starting from zero.
|
|
|
258 |
*
|
|
|
259 |
* As well as allowing the items to be iterated over we want to allow
|
|
|
260 |
* users to be able to access a specific entry. This is one of two ways of
|
|
|
261 |
* doing that, the other being by ID.
|
|
|
262 |
*
|
|
|
263 |
* @param int $offset The position of the entry within the feed, starting from 0
|
|
|
264 |
* @return XML_Feed_Parser_Type|false
|
|
|
265 |
*/
|
|
|
266 |
function getEntryByOffset($offset) {
|
|
|
267 |
if ($offset < $this->feed->numberEntries) {
|
|
|
268 |
if (isset($this->feed->entries[$offset])) {
|
|
|
269 |
return $this->feed->entries[$offset];
|
|
|
270 |
} else {
|
|
|
271 |
try {
|
|
|
272 |
$this->feed->getEntryByOffset($offset);
|
|
|
273 |
} catch (Exception $e) {
|
|
|
274 |
return false;
|
|
|
275 |
}
|
|
|
276 |
$id = $this->feed->entries[$offset]->getID();
|
|
|
277 |
$this->idMappings[$id] = $offset;
|
|
|
278 |
return $this->feed->entries[$offset];
|
|
|
279 |
}
|
|
|
280 |
} else {
|
|
|
281 |
return false;
|
|
|
282 |
}
|
|
|
283 |
}
|
|
|
284 |
|
|
|
285 |
/**
|
|
|
286 |
* Retrieve version details from feed type class.
|
|
|
287 |
*
|
|
|
288 |
* @return void
|
|
|
289 |
* @author James Stewart
|
|
|
290 |
*/
|
|
|
291 |
function version() {
|
|
|
292 |
return $this->feed->version;
|
|
|
293 |
}
|
|
|
294 |
|
|
|
295 |
/**
|
|
|
296 |
* Returns a string representation of the feed.
|
|
|
297 |
*
|
|
|
298 |
* @return String
|
|
|
299 |
**/
|
|
|
300 |
function __toString() {
|
|
|
301 |
return $this->feed->__toString();
|
|
|
302 |
}
|
|
|
303 |
}
|
|
|
304 |
?>
|