]>
Commit | Line | Data |
---|---|---|
1 | <?php | |
2 | /** | |
3 | * SimplePie | |
4 | * | |
5 | * A PHP-Based RSS and Atom Feed Framework. | |
6 | * Takes the hard work out of managing a complete RSS/Atom solution. | |
7 | * | |
8 | * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors | |
9 | * All rights reserved. | |
10 | * | |
11 | * Redistribution and use in source and binary forms, with or without modification, are | |
12 | * permitted provided that the following conditions are met: | |
13 | * | |
14 | * * Redistributions of source code must retain the above copyright notice, this list of | |
15 | * conditions and the following disclaimer. | |
16 | * | |
17 | * * Redistributions in binary form must reproduce the above copyright notice, this list | |
18 | * of conditions and the following disclaimer in the documentation and/or other materials | |
19 | * provided with the distribution. | |
20 | * | |
21 | * * Neither the name of the SimplePie Team nor the names of its contributors may be used | |
22 | * to endorse or promote products derived from this software without specific prior | |
23 | * written permission. | |
24 | * | |
25 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS | |
26 | * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY | |
27 | * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS | |
28 | * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR | |
29 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR | |
30 | * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
31 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR | |
32 | * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | |
33 | * POSSIBILITY OF SUCH DAMAGE. | |
34 | * | |
35 | * @package SimplePie | |
36 | * @version 1.3.1 | |
37 | * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue | |
38 | * @author Ryan Parman | |
39 | * @author Geoffrey Sneddon | |
40 | * @author Ryan McCue | |
41 | * @link http://simplepie.org/ SimplePie | |
42 | * @license http://www.opensource.org/licenses/bsd-license.php BSD License | |
43 | */ | |
44 | ||
45 | /** | |
46 | * SimplePie Name | |
47 | */ | |
48 | define('SIMPLEPIE_NAME', 'SimplePie'); | |
49 | ||
50 | /** | |
51 | * SimplePie Version | |
52 | */ | |
53 | define('SIMPLEPIE_VERSION', '1.3.1'); | |
54 | ||
55 | /** | |
56 | * SimplePie Build | |
57 | * @todo Hardcode for release (there's no need to have to call SimplePie_Misc::get_build() only every load of simplepie.inc) | |
58 | */ | |
59 | define('SIMPLEPIE_BUILD', gmdate('YmdHis', SimplePie_Misc::get_build())); | |
60 | ||
61 | /** | |
62 | * SimplePie Website URL | |
63 | */ | |
64 | define('SIMPLEPIE_URL', 'http://simplepie.org'); | |
65 | ||
66 | /** | |
67 | * SimplePie Useragent | |
68 | * @see SimplePie::set_useragent() | |
69 | */ | |
70 | define('SIMPLEPIE_USERAGENT', SIMPLEPIE_NAME . '/' . SIMPLEPIE_VERSION . ' (Feed Parser; ' . SIMPLEPIE_URL . '; Allow like Gecko) Build/' . SIMPLEPIE_BUILD); | |
71 | ||
72 | /** | |
73 | * SimplePie Linkback | |
74 | */ | |
75 | define('SIMPLEPIE_LINKBACK', '<a href="' . SIMPLEPIE_URL . '" title="' . SIMPLEPIE_NAME . ' ' . SIMPLEPIE_VERSION . '">' . SIMPLEPIE_NAME . '</a>'); | |
76 | ||
77 | /** | |
78 | * No Autodiscovery | |
79 | * @see SimplePie::set_autodiscovery_level() | |
80 | */ | |
81 | define('SIMPLEPIE_LOCATOR_NONE', 0); | |
82 | ||
83 | /** | |
84 | * Feed Link Element Autodiscovery | |
85 | * @see SimplePie::set_autodiscovery_level() | |
86 | */ | |
87 | define('SIMPLEPIE_LOCATOR_AUTODISCOVERY', 1); | |
88 | ||
89 | /** | |
90 | * Local Feed Extension Autodiscovery | |
91 | * @see SimplePie::set_autodiscovery_level() | |
92 | */ | |
93 | define('SIMPLEPIE_LOCATOR_LOCAL_EXTENSION', 2); | |
94 | ||
95 | /** | |
96 | * Local Feed Body Autodiscovery | |
97 | * @see SimplePie::set_autodiscovery_level() | |
98 | */ | |
99 | define('SIMPLEPIE_LOCATOR_LOCAL_BODY', 4); | |
100 | ||
101 | /** | |
102 | * Remote Feed Extension Autodiscovery | |
103 | * @see SimplePie::set_autodiscovery_level() | |
104 | */ | |
105 | define('SIMPLEPIE_LOCATOR_REMOTE_EXTENSION', 8); | |
106 | ||
107 | /** | |
108 | * Remote Feed Body Autodiscovery | |
109 | * @see SimplePie::set_autodiscovery_level() | |
110 | */ | |
111 | define('SIMPLEPIE_LOCATOR_REMOTE_BODY', 16); | |
112 | ||
113 | /** | |
114 | * All Feed Autodiscovery | |
115 | * @see SimplePie::set_autodiscovery_level() | |
116 | */ | |
117 | define('SIMPLEPIE_LOCATOR_ALL', 31); | |
118 | ||
119 | /** | |
120 | * No known feed type | |
121 | */ | |
122 | define('SIMPLEPIE_TYPE_NONE', 0); | |
123 | ||
124 | /** | |
125 | * RSS 0.90 | |
126 | */ | |
127 | define('SIMPLEPIE_TYPE_RSS_090', 1); | |
128 | ||
129 | /** | |
130 | * RSS 0.91 (Netscape) | |
131 | */ | |
132 | define('SIMPLEPIE_TYPE_RSS_091_NETSCAPE', 2); | |
133 | ||
134 | /** | |
135 | * RSS 0.91 (Userland) | |
136 | */ | |
137 | define('SIMPLEPIE_TYPE_RSS_091_USERLAND', 4); | |
138 | ||
139 | /** | |
140 | * RSS 0.91 (both Netscape and Userland) | |
141 | */ | |
142 | define('SIMPLEPIE_TYPE_RSS_091', 6); | |
143 | ||
144 | /** | |
145 | * RSS 0.92 | |
146 | */ | |
147 | define('SIMPLEPIE_TYPE_RSS_092', 8); | |
148 | ||
149 | /** | |
150 | * RSS 0.93 | |
151 | */ | |
152 | define('SIMPLEPIE_TYPE_RSS_093', 16); | |
153 | ||
154 | /** | |
155 | * RSS 0.94 | |
156 | */ | |
157 | define('SIMPLEPIE_TYPE_RSS_094', 32); | |
158 | ||
159 | /** | |
160 | * RSS 1.0 | |
161 | */ | |
162 | define('SIMPLEPIE_TYPE_RSS_10', 64); | |
163 | ||
164 | /** | |
165 | * RSS 2.0 | |
166 | */ | |
167 | define('SIMPLEPIE_TYPE_RSS_20', 128); | |
168 | ||
169 | /** | |
170 | * RDF-based RSS | |
171 | */ | |
172 | define('SIMPLEPIE_TYPE_RSS_RDF', 65); | |
173 | ||
174 | /** | |
175 | * Non-RDF-based RSS (truly intended as syndication format) | |
176 | */ | |
177 | define('SIMPLEPIE_TYPE_RSS_SYNDICATION', 190); | |
178 | ||
179 | /** | |
180 | * All RSS | |
181 | */ | |
182 | define('SIMPLEPIE_TYPE_RSS_ALL', 255); | |
183 | ||
184 | /** | |
185 | * Atom 0.3 | |
186 | */ | |
187 | define('SIMPLEPIE_TYPE_ATOM_03', 256); | |
188 | ||
189 | /** | |
190 | * Atom 1.0 | |
191 | */ | |
192 | define('SIMPLEPIE_TYPE_ATOM_10', 512); | |
193 | ||
194 | /** | |
195 | * All Atom | |
196 | */ | |
197 | define('SIMPLEPIE_TYPE_ATOM_ALL', 768); | |
198 | ||
199 | /** | |
200 | * All feed types | |
201 | */ | |
202 | define('SIMPLEPIE_TYPE_ALL', 1023); | |
203 | ||
204 | /** | |
205 | * No construct | |
206 | */ | |
207 | define('SIMPLEPIE_CONSTRUCT_NONE', 0); | |
208 | ||
209 | /** | |
210 | * Text construct | |
211 | */ | |
212 | define('SIMPLEPIE_CONSTRUCT_TEXT', 1); | |
213 | ||
214 | /** | |
215 | * HTML construct | |
216 | */ | |
217 | define('SIMPLEPIE_CONSTRUCT_HTML', 2); | |
218 | ||
219 | /** | |
220 | * XHTML construct | |
221 | */ | |
222 | define('SIMPLEPIE_CONSTRUCT_XHTML', 4); | |
223 | ||
224 | /** | |
225 | * base64-encoded construct | |
226 | */ | |
227 | define('SIMPLEPIE_CONSTRUCT_BASE64', 8); | |
228 | ||
229 | /** | |
230 | * IRI construct | |
231 | */ | |
232 | define('SIMPLEPIE_CONSTRUCT_IRI', 16); | |
233 | ||
234 | /** | |
235 | * A construct that might be HTML | |
236 | */ | |
237 | define('SIMPLEPIE_CONSTRUCT_MAYBE_HTML', 32); | |
238 | ||
239 | /** | |
240 | * All constructs | |
241 | */ | |
242 | define('SIMPLEPIE_CONSTRUCT_ALL', 63); | |
243 | ||
244 | /** | |
245 | * Don't change case | |
246 | */ | |
247 | define('SIMPLEPIE_SAME_CASE', 1); | |
248 | ||
249 | /** | |
250 | * Change to lowercase | |
251 | */ | |
252 | define('SIMPLEPIE_LOWERCASE', 2); | |
253 | ||
254 | /** | |
255 | * Change to uppercase | |
256 | */ | |
257 | define('SIMPLEPIE_UPPERCASE', 4); | |
258 | ||
259 | /** | |
260 | * PCRE for HTML attributes | |
261 | */ | |
262 | define('SIMPLEPIE_PCRE_HTML_ATTRIBUTE', '((?:[\x09\x0A\x0B\x0C\x0D\x20]+[^\x09\x0A\x0B\x0C\x0D\x20\x2F\x3E][^\x09\x0A\x0B\x0C\x0D\x20\x2F\x3D\x3E]*(?:[\x09\x0A\x0B\x0C\x0D\x20]*=[\x09\x0A\x0B\x0C\x0D\x20]*(?:"(?:[^"]*)"|\'(?:[^\']*)\'|(?:[^\x09\x0A\x0B\x0C\x0D\x20\x22\x27\x3E][^\x09\x0A\x0B\x0C\x0D\x20\x3E]*)?))?)*)[\x09\x0A\x0B\x0C\x0D\x20]*'); | |
263 | ||
264 | /** | |
265 | * PCRE for XML attributes | |
266 | */ | |
267 | define('SIMPLEPIE_PCRE_XML_ATTRIBUTE', '((?:\s+(?:(?:[^\s:]+:)?[^\s:]+)\s*=\s*(?:"(?:[^"]*)"|\'(?:[^\']*)\'))*)\s*'); | |
268 | ||
269 | /** | |
270 | * XML Namespace | |
271 | */ | |
272 | define('SIMPLEPIE_NAMESPACE_XML', 'http://www.w3.org/XML/1998/namespace'); | |
273 | ||
274 | /** | |
275 | * Atom 1.0 Namespace | |
276 | */ | |
277 | define('SIMPLEPIE_NAMESPACE_ATOM_10', 'http://www.w3.org/2005/Atom'); | |
278 | ||
279 | /** | |
280 | * Atom 0.3 Namespace | |
281 | */ | |
282 | define('SIMPLEPIE_NAMESPACE_ATOM_03', 'http://purl.org/atom/ns#'); | |
283 | ||
284 | /** | |
285 | * RDF Namespace | |
286 | */ | |
287 | define('SIMPLEPIE_NAMESPACE_RDF', 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'); | |
288 | ||
289 | /** | |
290 | * RSS 0.90 Namespace | |
291 | */ | |
292 | define('SIMPLEPIE_NAMESPACE_RSS_090', 'http://my.netscape.com/rdf/simple/0.9/'); | |
293 | ||
294 | /** | |
295 | * RSS 1.0 Namespace | |
296 | */ | |
297 | define('SIMPLEPIE_NAMESPACE_RSS_10', 'http://purl.org/rss/1.0/'); | |
298 | ||
299 | /** | |
300 | * RSS 1.0 Content Module Namespace | |
301 | */ | |
302 | define('SIMPLEPIE_NAMESPACE_RSS_10_MODULES_CONTENT', 'http://purl.org/rss/1.0/modules/content/'); | |
303 | ||
304 | /** | |
305 | * RSS 2.0 Namespace | |
306 | * (Stupid, I know, but I'm certain it will confuse people less with support.) | |
307 | */ | |
308 | define('SIMPLEPIE_NAMESPACE_RSS_20', ''); | |
309 | ||
310 | /** | |
311 | * DC 1.0 Namespace | |
312 | */ | |
313 | define('SIMPLEPIE_NAMESPACE_DC_10', 'http://purl.org/dc/elements/1.0/'); | |
314 | ||
315 | /** | |
316 | * DC 1.1 Namespace | |
317 | */ | |
318 | define('SIMPLEPIE_NAMESPACE_DC_11', 'http://purl.org/dc/elements/1.1/'); | |
319 | ||
320 | /** | |
321 | * W3C Basic Geo (WGS84 lat/long) Vocabulary Namespace | |
322 | */ | |
323 | define('SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO', 'http://www.w3.org/2003/01/geo/wgs84_pos#'); | |
324 | ||
325 | /** | |
326 | * GeoRSS Namespace | |
327 | */ | |
328 | define('SIMPLEPIE_NAMESPACE_GEORSS', 'http://www.georss.org/georss'); | |
329 | ||
330 | /** | |
331 | * Media RSS Namespace | |
332 | */ | |
333 | define('SIMPLEPIE_NAMESPACE_MEDIARSS', 'http://search.yahoo.com/mrss/'); | |
334 | ||
335 | /** | |
336 | * Wrong Media RSS Namespace. Caused by a long-standing typo in the spec. | |
337 | */ | |
338 | define('SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG', 'http://search.yahoo.com/mrss'); | |
339 | ||
340 | /** | |
341 | * Wrong Media RSS Namespace #2. New namespace introduced in Media RSS 1.5. | |
342 | */ | |
343 | define('SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG2', 'http://video.search.yahoo.com/mrss'); | |
344 | ||
345 | /** | |
346 | * Wrong Media RSS Namespace #3. A possible typo of the Media RSS 1.5 namespace. | |
347 | */ | |
348 | define('SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG3', 'http://video.search.yahoo.com/mrss/'); | |
349 | ||
350 | /** | |
351 | * Wrong Media RSS Namespace #4. New spec location after the RSS Advisory Board takes it over, but not a valid namespace. | |
352 | */ | |
353 | define('SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG4', 'http://www.rssboard.org/media-rss'); | |
354 | ||
355 | /** | |
356 | * Wrong Media RSS Namespace #5. A possible typo of the RSS Advisory Board URL. | |
357 | */ | |
358 | define('SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG5', 'http://www.rssboard.org/media-rss/'); | |
359 | ||
360 | /** | |
361 | * iTunes RSS Namespace | |
362 | */ | |
363 | define('SIMPLEPIE_NAMESPACE_ITUNES', 'http://www.itunes.com/dtds/podcast-1.0.dtd'); | |
364 | ||
365 | /** | |
366 | * XHTML Namespace | |
367 | */ | |
368 | define('SIMPLEPIE_NAMESPACE_XHTML', 'http://www.w3.org/1999/xhtml'); | |
369 | ||
370 | /** | |
371 | * IANA Link Relations Registry | |
372 | */ | |
373 | define('SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY', 'http://www.iana.org/assignments/relation/'); | |
374 | ||
375 | /** | |
376 | * No file source | |
377 | */ | |
378 | define('SIMPLEPIE_FILE_SOURCE_NONE', 0); | |
379 | ||
380 | /** | |
381 | * Remote file source | |
382 | */ | |
383 | define('SIMPLEPIE_FILE_SOURCE_REMOTE', 1); | |
384 | ||
385 | /** | |
386 | * Local file source | |
387 | */ | |
388 | define('SIMPLEPIE_FILE_SOURCE_LOCAL', 2); | |
389 | ||
390 | /** | |
391 | * fsockopen() file source | |
392 | */ | |
393 | define('SIMPLEPIE_FILE_SOURCE_FSOCKOPEN', 4); | |
394 | ||
395 | /** | |
396 | * cURL file source | |
397 | */ | |
398 | define('SIMPLEPIE_FILE_SOURCE_CURL', 8); | |
399 | ||
400 | /** | |
401 | * file_get_contents() file source | |
402 | */ | |
403 | define('SIMPLEPIE_FILE_SOURCE_FILE_GET_CONTENTS', 16); | |
404 | ||
405 | ||
406 | ||
407 | /** | |
408 | * SimplePie | |
409 | * | |
410 | * @package SimplePie | |
411 | * @subpackage API | |
412 | */ | |
413 | class SimplePie | |
414 | { | |
415 | /** | |
416 | * @var array Raw data | |
417 | * @access private | |
418 | */ | |
419 | public $data = array(); | |
420 | ||
421 | /** | |
422 | * @var mixed Error string | |
423 | * @access private | |
424 | */ | |
425 | public $error; | |
426 | ||
427 | /** | |
428 | * @var object Instance of SimplePie_Sanitize (or other class) | |
429 | * @see SimplePie::set_sanitize_class() | |
430 | * @access private | |
431 | */ | |
432 | public $sanitize; | |
433 | ||
434 | /** | |
435 | * @var string SimplePie Useragent | |
436 | * @see SimplePie::set_useragent() | |
437 | * @access private | |
438 | */ | |
439 | public $useragent = SIMPLEPIE_USERAGENT; | |
440 | ||
441 | /** | |
442 | * @var string Feed URL | |
443 | * @see SimplePie::set_feed_url() | |
444 | * @access private | |
445 | */ | |
446 | public $feed_url; | |
447 | ||
448 | /** | |
449 | * @var object Instance of SimplePie_File to use as a feed | |
450 | * @see SimplePie::set_file() | |
451 | * @access private | |
452 | */ | |
453 | public $file; | |
454 | ||
455 | /** | |
456 | * @var string Raw feed data | |
457 | * @see SimplePie::set_raw_data() | |
458 | * @access private | |
459 | */ | |
460 | public $raw_data; | |
461 | ||
462 | /** | |
463 | * @var int Timeout for fetching remote files | |
464 | * @see SimplePie::set_timeout() | |
465 | * @access private | |
466 | */ | |
467 | public $timeout = 10; | |
468 | ||
469 | /** | |
470 | * @var bool Forces fsockopen() to be used for remote files instead | |
471 | * of cURL, even if a new enough version is installed | |
472 | * @see SimplePie::force_fsockopen() | |
473 | * @access private | |
474 | */ | |
475 | public $force_fsockopen = false; | |
476 | ||
477 | /** | |
478 | * @var bool Force the given data/URL to be treated as a feed no matter what | |
479 | * it appears like | |
480 | * @see SimplePie::force_feed() | |
481 | * @access private | |
482 | */ | |
483 | public $force_feed = false; | |
484 | ||
485 | /** | |
486 | * @var bool Enable/Disable Caching | |
487 | * @see SimplePie::enable_cache() | |
488 | * @access private | |
489 | */ | |
490 | public $cache = true; | |
491 | ||
492 | /** | |
493 | * @var int Cache duration (in seconds) | |
494 | * @see SimplePie::set_cache_duration() | |
495 | * @access private | |
496 | */ | |
497 | public $cache_duration = 3600; | |
498 | ||
499 | /** | |
500 | * @var int Auto-discovery cache duration (in seconds) | |
501 | * @see SimplePie::set_autodiscovery_cache_duration() | |
502 | * @access private | |
503 | */ | |
504 | public $autodiscovery_cache_duration = 604800; // 7 Days. | |
505 | ||
506 | /** | |
507 | * @var string Cache location (relative to executing script) | |
508 | * @see SimplePie::set_cache_location() | |
509 | * @access private | |
510 | */ | |
511 | public $cache_location = './cache'; | |
512 | ||
513 | /** | |
514 | * @var string Function that creates the cache filename | |
515 | * @see SimplePie::set_cache_name_function() | |
516 | * @access private | |
517 | */ | |
518 | public $cache_name_function = 'md5'; | |
519 | ||
520 | /** | |
521 | * @var bool Reorder feed by date descending | |
522 | * @see SimplePie::enable_order_by_date() | |
523 | * @access private | |
524 | */ | |
525 | public $order_by_date = true; | |
526 | ||
527 | /** | |
528 | * @var mixed Force input encoding to be set to the follow value | |
529 | * (false, or anything type-cast to false, disables this feature) | |
530 | * @see SimplePie::set_input_encoding() | |
531 | * @access private | |
532 | */ | |
533 | public $input_encoding = false; | |
534 | ||
535 | /** | |
536 | * @var int Feed Autodiscovery Level | |
537 | * @see SimplePie::set_autodiscovery_level() | |
538 | * @access private | |
539 | */ | |
540 | public $autodiscovery = SIMPLEPIE_LOCATOR_ALL; | |
541 | ||
542 | /** | |
543 | * Class registry object | |
544 | * | |
545 | * @var SimplePie_Registry | |
546 | */ | |
547 | public $registry; | |
548 | ||
549 | /** | |
550 | * @var int Maximum number of feeds to check with autodiscovery | |
551 | * @see SimplePie::set_max_checked_feeds() | |
552 | * @access private | |
553 | */ | |
554 | public $max_checked_feeds = 10; | |
555 | ||
556 | /** | |
557 | * @var array All the feeds found during the autodiscovery process | |
558 | * @see SimplePie::get_all_discovered_feeds() | |
559 | * @access private | |
560 | */ | |
561 | public $all_discovered_feeds = array(); | |
562 | ||
563 | /** | |
564 | * @var string Web-accessible path to the handler_image.php file. | |
565 | * @see SimplePie::set_image_handler() | |
566 | * @access private | |
567 | */ | |
568 | public $image_handler = ''; | |
569 | ||
570 | /** | |
571 | * @var array Stores the URLs when multiple feeds are being initialized. | |
572 | * @see SimplePie::set_feed_url() | |
573 | * @access private | |
574 | */ | |
575 | public $multifeed_url = array(); | |
576 | ||
577 | /** | |
578 | * @var array Stores SimplePie objects when multiple feeds initialized. | |
579 | * @access private | |
580 | */ | |
581 | public $multifeed_objects = array(); | |
582 | ||
583 | /** | |
584 | * @var array Stores the get_object_vars() array for use with multifeeds. | |
585 | * @see SimplePie::set_feed_url() | |
586 | * @access private | |
587 | */ | |
588 | public $config_settings = null; | |
589 | ||
590 | /** | |
591 | * @var integer Stores the number of items to return per-feed with multifeeds. | |
592 | * @see SimplePie::set_item_limit() | |
593 | * @access private | |
594 | */ | |
595 | public $item_limit = 0; | |
596 | ||
597 | /** | |
598 | * @var array Stores the default attributes to be stripped by strip_attributes(). | |
599 | * @see SimplePie::strip_attributes() | |
600 | * @access private | |
601 | */ | |
602 | public $strip_attributes = array('bgsound', 'class', 'expr', 'id', 'style', 'onclick', 'onerror', 'onfinish', 'onmouseover', 'onmouseout', 'onfocus', 'onblur', 'lowsrc', 'dynsrc'); | |
603 | ||
604 | /** | |
605 | * @var array Stores the default tags to be stripped by strip_htmltags(). | |
606 | * @see SimplePie::strip_htmltags() | |
607 | * @access private | |
608 | */ | |
609 | public $strip_htmltags = array('base', 'blink', 'body', 'doctype', 'embed', 'font', 'form', 'frame', 'frameset', 'html', 'iframe', 'input', 'marquee', 'meta', 'noscript', 'object', 'param', 'script', 'style'); | |
610 | ||
611 | /** | |
612 | * The SimplePie class contains feed level data and options | |
613 | * | |
614 | * To use SimplePie, create the SimplePie object with no parameters. You can | |
615 | * then set configuration options using the provided methods. After setting | |
616 | * them, you must initialise the feed using $feed->init(). At that point the | |
617 | * object's methods and properties will be available to you. | |
618 | * | |
619 | * Previously, it was possible to pass in the feed URL along with cache | |
620 | * options directly into the constructor. This has been removed as of 1.3 as | |
621 | * it caused a lot of confusion. | |
622 | * | |
623 | * @since 1.0 Preview Release | |
624 | */ | |
625 | public function __construct() | |
626 | { | |
627 | if (version_compare(PHP_VERSION, '5.2', '<')) | |
628 | { | |
629 | trigger_error('PHP 4.x, 5.0 and 5.1 are no longer supported. Please upgrade to PHP 5.2 or newer.'); | |
630 | die(); | |
631 | } | |
632 | ||
633 | // Other objects, instances created here so we can set options on them | |
634 | $this->sanitize = new SimplePie_Sanitize(); | |
635 | $this->registry = new SimplePie_Registry(); | |
636 | ||
637 | if (func_num_args() > 0) | |
638 | { | |
639 | $level = defined('E_USER_DEPRECATED') ? E_USER_DEPRECATED : E_USER_WARNING; | |
640 | trigger_error('Passing parameters to the constructor is no longer supported. Please use set_feed_url(), set_cache_location(), and set_cache_location() directly.', $level); | |
641 | ||
642 | $args = func_get_args(); | |
643 | switch (count($args)) { | |
644 | case 3: | |
645 | $this->set_cache_duration($args[2]); | |
646 | case 2: | |
647 | $this->set_cache_location($args[1]); | |
648 | case 1: | |
649 | $this->set_feed_url($args[0]); | |
650 | $this->init(); | |
651 | } | |
652 | } | |
653 | } | |
654 | ||
655 | /** | |
656 | * Used for converting object to a string | |
657 | */ | |
658 | public function __toString() | |
659 | { | |
660 | return md5(serialize($this->data)); | |
661 | } | |
662 | ||
663 | /** | |
664 | * Remove items that link back to this before destroying this object | |
665 | */ | |
666 | public function __destruct() | |
667 | { | |
668 | if ((version_compare(PHP_VERSION, '5.3', '<') || !gc_enabled()) && !ini_get('zend.ze1_compatibility_mode')) | |
669 | { | |
670 | if (!empty($this->data['items'])) | |
671 | { | |
672 | foreach ($this->data['items'] as $item) | |
673 | { | |
674 | $item->__destruct(); | |
675 | } | |
676 | unset($item, $this->data['items']); | |
677 | } | |
678 | if (!empty($this->data['ordered_items'])) | |
679 | { | |
680 | foreach ($this->data['ordered_items'] as $item) | |
681 | { | |
682 | $item->__destruct(); | |
683 | } | |
684 | unset($item, $this->data['ordered_items']); | |
685 | } | |
686 | } | |
687 | } | |
688 | ||
689 | /** | |
690 | * Force the given data/URL to be treated as a feed | |
691 | * | |
692 | * This tells SimplePie to ignore the content-type provided by the server. | |
693 | * Be careful when using this option, as it will also disable autodiscovery. | |
694 | * | |
695 | * @since 1.1 | |
696 | * @param bool $enable Force the given data/URL to be treated as a feed | |
697 | */ | |
698 | public function force_feed($enable = false) | |
699 | { | |
700 | $this->force_feed = (bool) $enable; | |
701 | } | |
702 | ||
703 | /** | |
704 | * Set the URL of the feed you want to parse | |
705 | * | |
706 | * This allows you to enter the URL of the feed you want to parse, or the | |
707 | * website you want to try to use auto-discovery on. This takes priority | |
708 | * over any set raw data. | |
709 | * | |
710 | * You can set multiple feeds to mash together by passing an array instead | |
711 | * of a string for the $url. Remember that with each additional feed comes | |
712 | * additional processing and resources. | |
713 | * | |
714 | * @since 1.0 Preview Release | |
715 | * @see set_raw_data() | |
716 | * @param string|array $url This is the URL (or array of URLs) that you want to parse. | |
717 | */ | |
718 | public function set_feed_url($url) | |
719 | { | |
720 | $this->multifeed_url = array(); | |
721 | if (is_array($url)) | |
722 | { | |
723 | foreach ($url as $value) | |
724 | { | |
725 | $this->multifeed_url[] = $this->registry->call('Misc', 'fix_protocol', array($value, 1)); | |
726 | } | |
727 | } | |
728 | else | |
729 | { | |
730 | $this->feed_url = $this->registry->call('Misc', 'fix_protocol', array($url, 1)); | |
731 | } | |
732 | } | |
733 | ||
734 | /** | |
735 | * Set an instance of {@see SimplePie_File} to use as a feed | |
736 | * | |
737 | * @param SimplePie_File &$file | |
738 | * @return bool True on success, false on failure | |
739 | */ | |
740 | public function set_file(&$file) | |
741 | { | |
742 | if ($file instanceof SimplePie_File) | |
743 | { | |
744 | $this->feed_url = $file->url; | |
745 | $this->file =& $file; | |
746 | return true; | |
747 | } | |
748 | return false; | |
749 | } | |
750 | ||
751 | /** | |
752 | * Set the raw XML data to parse | |
753 | * | |
754 | * Allows you to use a string of RSS/Atom data instead of a remote feed. | |
755 | * | |
756 | * If you have a feed available as a string in PHP, you can tell SimplePie | |
757 | * to parse that data string instead of a remote feed. Any set feed URL | |
758 | * takes precedence. | |
759 | * | |
760 | * @since 1.0 Beta 3 | |
761 | * @param string $data RSS or Atom data as a string. | |
762 | * @see set_feed_url() | |
763 | */ | |
764 | public function set_raw_data($data) | |
765 | { | |
766 | $this->raw_data = $data; | |
767 | } | |
768 | ||
769 | /** | |
770 | * Set the the default timeout for fetching remote feeds | |
771 | * | |
772 | * This allows you to change the maximum time the feed's server to respond | |
773 | * and send the feed back. | |
774 | * | |
775 | * @since 1.0 Beta 3 | |
776 | * @param int $timeout The maximum number of seconds to spend waiting to retrieve a feed. | |
777 | */ | |
778 | public function set_timeout($timeout = 10) | |
779 | { | |
780 | $this->timeout = (int) $timeout; | |
781 | } | |
782 | ||
783 | /** | |
784 | * Force SimplePie to use fsockopen() instead of cURL | |
785 | * | |
786 | * @since 1.0 Beta 3 | |
787 | * @param bool $enable Force fsockopen() to be used | |
788 | */ | |
789 | public function force_fsockopen($enable = false) | |
790 | { | |
791 | $this->force_fsockopen = (bool) $enable; | |
792 | } | |
793 | ||
794 | /** | |
795 | * Enable/disable caching in SimplePie. | |
796 | * | |
797 | * This option allows you to disable caching all-together in SimplePie. | |
798 | * However, disabling the cache can lead to longer load times. | |
799 | * | |
800 | * @since 1.0 Preview Release | |
801 | * @param bool $enable Enable caching | |
802 | */ | |
803 | public function enable_cache($enable = true) | |
804 | { | |
805 | $this->cache = (bool) $enable; | |
806 | } | |
807 | ||
808 | /** | |
809 | * Set the length of time (in seconds) that the contents of a feed will be | |
810 | * cached | |
811 | * | |
812 | * @param int $seconds The feed content cache duration | |
813 | */ | |
814 | public function set_cache_duration($seconds = 3600) | |
815 | { | |
816 | $this->cache_duration = (int) $seconds; | |
817 | } | |
818 | ||
819 | /** | |
820 | * Set the length of time (in seconds) that the autodiscovered feed URL will | |
821 | * be cached | |
822 | * | |
823 | * @param int $seconds The autodiscovered feed URL cache duration. | |
824 | */ | |
825 | public function set_autodiscovery_cache_duration($seconds = 604800) | |
826 | { | |
827 | $this->autodiscovery_cache_duration = (int) $seconds; | |
828 | } | |
829 | ||
830 | /** | |
831 | * Set the file system location where the cached files should be stored | |
832 | * | |
833 | * @param string $location The file system location. | |
834 | */ | |
835 | public function set_cache_location($location = './cache') | |
836 | { | |
837 | $this->cache_location = (string) $location; | |
838 | } | |
839 | ||
840 | /** | |
841 | * Set whether feed items should be sorted into reverse chronological order | |
842 | * | |
843 | * @param bool $enable Sort as reverse chronological order. | |
844 | */ | |
845 | public function enable_order_by_date($enable = true) | |
846 | { | |
847 | $this->order_by_date = (bool) $enable; | |
848 | } | |
849 | ||
850 | /** | |
851 | * Set the character encoding used to parse the feed | |
852 | * | |
853 | * This overrides the encoding reported by the feed, however it will fall | |
854 | * back to the normal encoding detection if the override fails | |
855 | * | |
856 | * @param string $encoding Character encoding | |
857 | */ | |
858 | public function set_input_encoding($encoding = false) | |
859 | { | |
860 | if ($encoding) | |
861 | { | |
862 | $this->input_encoding = (string) $encoding; | |
863 | } | |
864 | else | |
865 | { | |
866 | $this->input_encoding = false; | |
867 | } | |
868 | } | |
869 | ||
870 | /** | |
871 | * Set how much feed autodiscovery to do | |
872 | * | |
873 | * @see SIMPLEPIE_LOCATOR_NONE | |
874 | * @see SIMPLEPIE_LOCATOR_AUTODISCOVERY | |
875 | * @see SIMPLEPIE_LOCATOR_LOCAL_EXTENSION | |
876 | * @see SIMPLEPIE_LOCATOR_LOCAL_BODY | |
877 | * @see SIMPLEPIE_LOCATOR_REMOTE_EXTENSION | |
878 | * @see SIMPLEPIE_LOCATOR_REMOTE_BODY | |
879 | * @see SIMPLEPIE_LOCATOR_ALL | |
880 | * @param int $level Feed Autodiscovery Level (level can be a combination of the above constants, see bitwise OR operator) | |
881 | */ | |
882 | public function set_autodiscovery_level($level = SIMPLEPIE_LOCATOR_ALL) | |
883 | { | |
884 | $this->autodiscovery = (int) $level; | |
885 | } | |
886 | ||
887 | /** | |
888 | * Get the class registry | |
889 | * | |
890 | * Use this to override SimplePie's default classes | |
891 | * @see SimplePie_Registry | |
892 | * @return SimplePie_Registry | |
893 | */ | |
894 | public function &get_registry() | |
895 | { | |
896 | return $this->registry; | |
897 | } | |
898 | ||
899 | /**#@+ | |
900 | * Useful when you are overloading or extending SimplePie's default classes. | |
901 | * | |
902 | * @deprecated Use {@see get_registry()} instead | |
903 | * @link http://php.net/manual/en/language.oop5.basic.php#language.oop5.basic.extends PHP5 extends documentation | |
904 | * @param string $class Name of custom class | |
905 | * @return boolean True on success, false otherwise | |
906 | */ | |
907 | /** | |
908 | * Set which class SimplePie uses for caching | |
909 | */ | |
910 | public function set_cache_class($class = 'SimplePie_Cache') | |
911 | { | |
912 | return $this->registry->register('Cache', $class, true); | |
913 | } | |
914 | ||
915 | /** | |
916 | * Set which class SimplePie uses for auto-discovery | |
917 | */ | |
918 | public function set_locator_class($class = 'SimplePie_Locator') | |
919 | { | |
920 | return $this->registry->register('Locator', $class, true); | |
921 | } | |
922 | ||
923 | /** | |
924 | * Set which class SimplePie uses for XML parsing | |
925 | */ | |
926 | public function set_parser_class($class = 'SimplePie_Parser') | |
927 | { | |
928 | return $this->registry->register('Parser', $class, true); | |
929 | } | |
930 | ||
931 | /** | |
932 | * Set which class SimplePie uses for remote file fetching | |
933 | */ | |
934 | public function set_file_class($class = 'SimplePie_File') | |
935 | { | |
936 | return $this->registry->register('File', $class, true); | |
937 | } | |
938 | ||
939 | /** | |
940 | * Set which class SimplePie uses for data sanitization | |
941 | */ | |
942 | public function set_sanitize_class($class = 'SimplePie_Sanitize') | |
943 | { | |
944 | return $this->registry->register('Sanitize', $class, true); | |
945 | } | |
946 | ||
947 | /** | |
948 | * Set which class SimplePie uses for handling feed items | |
949 | */ | |
950 | public function set_item_class($class = 'SimplePie_Item') | |
951 | { | |
952 | return $this->registry->register('Item', $class, true); | |
953 | } | |
954 | ||
955 | /** | |
956 | * Set which class SimplePie uses for handling author data | |
957 | */ | |
958 | public function set_author_class($class = 'SimplePie_Author') | |
959 | { | |
960 | return $this->registry->register('Author', $class, true); | |
961 | } | |
962 | ||
963 | /** | |
964 | * Set which class SimplePie uses for handling category data | |
965 | */ | |
966 | public function set_category_class($class = 'SimplePie_Category') | |
967 | { | |
968 | return $this->registry->register('Category', $class, true); | |
969 | } | |
970 | ||
971 | /** | |
972 | * Set which class SimplePie uses for feed enclosures | |
973 | */ | |
974 | public function set_enclosure_class($class = 'SimplePie_Enclosure') | |
975 | { | |
976 | return $this->registry->register('Enclosure', $class, true); | |
977 | } | |
978 | ||
979 | /** | |
980 | * Set which class SimplePie uses for `<media:text>` captions | |
981 | */ | |
982 | public function set_caption_class($class = 'SimplePie_Caption') | |
983 | { | |
984 | return $this->registry->register('Caption', $class, true); | |
985 | } | |
986 | ||
987 | /** | |
988 | * Set which class SimplePie uses for `<media:copyright>` | |
989 | */ | |
990 | public function set_copyright_class($class = 'SimplePie_Copyright') | |
991 | { | |
992 | return $this->registry->register('Copyright', $class, true); | |
993 | } | |
994 | ||
995 | /** | |
996 | * Set which class SimplePie uses for `<media:credit>` | |
997 | */ | |
998 | public function set_credit_class($class = 'SimplePie_Credit') | |
999 | { | |
1000 | return $this->registry->register('Credit', $class, true); | |
1001 | } | |
1002 | ||
1003 | /** | |
1004 | * Set which class SimplePie uses for `<media:rating>` | |
1005 | */ | |
1006 | public function set_rating_class($class = 'SimplePie_Rating') | |
1007 | { | |
1008 | return $this->registry->register('Rating', $class, true); | |
1009 | } | |
1010 | ||
1011 | /** | |
1012 | * Set which class SimplePie uses for `<media:restriction>` | |
1013 | */ | |
1014 | public function set_restriction_class($class = 'SimplePie_Restriction') | |
1015 | { | |
1016 | return $this->registry->register('Restriction', $class, true); | |
1017 | } | |
1018 | ||
1019 | /** | |
1020 | * Set which class SimplePie uses for content-type sniffing | |
1021 | */ | |
1022 | public function set_content_type_sniffer_class($class = 'SimplePie_Content_Type_Sniffer') | |
1023 | { | |
1024 | return $this->registry->register('Content_Type_Sniffer', $class, true); | |
1025 | } | |
1026 | ||
1027 | /** | |
1028 | * Set which class SimplePie uses item sources | |
1029 | */ | |
1030 | public function set_source_class($class = 'SimplePie_Source') | |
1031 | { | |
1032 | return $this->registry->register('Source', $class, true); | |
1033 | } | |
1034 | /**#@-*/ | |
1035 | ||
1036 | /** | |
1037 | * Set the user agent string | |
1038 | * | |
1039 | * @param string $ua New user agent string. | |
1040 | */ | |
1041 | public function set_useragent($ua = SIMPLEPIE_USERAGENT) | |
1042 | { | |
1043 | $this->useragent = (string) $ua; | |
1044 | } | |
1045 | ||
1046 | /** | |
1047 | * Set callback function to create cache filename with | |
1048 | * | |
1049 | * @param mixed $function Callback function | |
1050 | */ | |
1051 | public function set_cache_name_function($function = 'md5') | |
1052 | { | |
1053 | if (is_callable($function)) | |
1054 | { | |
1055 | $this->cache_name_function = $function; | |
1056 | } | |
1057 | } | |
1058 | ||
1059 | /** | |
1060 | * Set options to make SP as fast as possible | |
1061 | * | |
1062 | * Forgoes a substantial amount of data sanitization in favor of speed. This | |
1063 | * turns SimplePie into a dumb parser of feeds. | |
1064 | * | |
1065 | * @param bool $set Whether to set them or not | |
1066 | */ | |
1067 | public function set_stupidly_fast($set = false) | |
1068 | { | |
1069 | if ($set) | |
1070 | { | |
1071 | $this->enable_order_by_date(false); | |
1072 | $this->remove_div(false); | |
1073 | $this->strip_comments(false); | |
1074 | $this->strip_htmltags(false); | |
1075 | $this->strip_attributes(false); | |
1076 | $this->set_image_handler(false); | |
1077 | } | |
1078 | } | |
1079 | ||
1080 | /** | |
1081 | * Set maximum number of feeds to check with autodiscovery | |
1082 | * | |
1083 | * @param int $max Maximum number of feeds to check | |
1084 | */ | |
1085 | public function set_max_checked_feeds($max = 10) | |
1086 | { | |
1087 | $this->max_checked_feeds = (int) $max; | |
1088 | } | |
1089 | ||
1090 | public function remove_div($enable = true) | |
1091 | { | |
1092 | $this->sanitize->remove_div($enable); | |
1093 | } | |
1094 | ||
1095 | public function strip_htmltags($tags = '', $encode = null) | |
1096 | { | |
1097 | if ($tags === '') | |
1098 | { | |
1099 | $tags = $this->strip_htmltags; | |
1100 | } | |
1101 | $this->sanitize->strip_htmltags($tags); | |
1102 | if ($encode !== null) | |
1103 | { | |
1104 | $this->sanitize->encode_instead_of_strip($tags); | |
1105 | } | |
1106 | } | |
1107 | ||
1108 | public function encode_instead_of_strip($enable = true) | |
1109 | { | |
1110 | $this->sanitize->encode_instead_of_strip($enable); | |
1111 | } | |
1112 | ||
1113 | public function strip_attributes($attribs = '') | |
1114 | { | |
1115 | if ($attribs === '') | |
1116 | { | |
1117 | $attribs = $this->strip_attributes; | |
1118 | } | |
1119 | $this->sanitize->strip_attributes($attribs); | |
1120 | } | |
1121 | ||
1122 | /** | |
1123 | * Set the output encoding | |
1124 | * | |
1125 | * Allows you to override SimplePie's output to match that of your webpage. | |
1126 | * This is useful for times when your webpages are not being served as | |
1127 | * UTF-8. This setting will be obeyed by {@see handle_content_type()}, and | |
1128 | * is similar to {@see set_input_encoding()}. | |
1129 | * | |
1130 | * It should be noted, however, that not all character encodings can support | |
1131 | * all characters. If your page is being served as ISO-8859-1 and you try | |
1132 | * to display a Japanese feed, you'll likely see garbled characters. | |
1133 | * Because of this, it is highly recommended to ensure that your webpages | |
1134 | * are served as UTF-8. | |
1135 | * | |
1136 | * The number of supported character encodings depends on whether your web | |
1137 | * host supports {@link http://php.net/mbstring mbstring}, | |
1138 | * {@link http://php.net/iconv iconv}, or both. See | |
1139 | * {@link http://simplepie.org/wiki/faq/Supported_Character_Encodings} for | |
1140 | * more information. | |
1141 | * | |
1142 | * @param string $encoding | |
1143 | */ | |
1144 | public function set_output_encoding($encoding = 'UTF-8') | |
1145 | { | |
1146 | $this->sanitize->set_output_encoding($encoding); | |
1147 | } | |
1148 | ||
1149 | public function strip_comments($strip = false) | |
1150 | { | |
1151 | $this->sanitize->strip_comments($strip); | |
1152 | } | |
1153 | ||
1154 | /** | |
1155 | * Set element/attribute key/value pairs of HTML attributes | |
1156 | * containing URLs that need to be resolved relative to the feed | |
1157 | * | |
1158 | * Defaults to |a|@href, |area|@href, |blockquote|@cite, |del|@cite, | |
1159 | * |form|@action, |img|@longdesc, |img|@src, |input|@src, |ins|@cite, | |
1160 | * |q|@cite | |
1161 | * | |
1162 | * @since 1.0 | |
1163 | * @param array|null $element_attribute Element/attribute key/value pairs, null for default | |
1164 | */ | |
1165 | public function set_url_replacements($element_attribute = null) | |
1166 | { | |
1167 | $this->sanitize->set_url_replacements($element_attribute); | |
1168 | } | |
1169 | ||
1170 | /** | |
1171 | * Set the handler to enable the display of cached images. | |
1172 | * | |
1173 | * @param str $page Web-accessible path to the handler_image.php file. | |
1174 | * @param str $qs The query string that the value should be passed to. | |
1175 | */ | |
1176 | public function set_image_handler($page = false, $qs = 'i') | |
1177 | { | |
1178 | if ($page !== false) | |
1179 | { | |
1180 | $this->sanitize->set_image_handler($page . '?' . $qs . '='); | |
1181 | } | |
1182 | else | |
1183 | { | |
1184 | $this->image_handler = ''; | |
1185 | } | |
1186 | } | |
1187 | ||
1188 | /** | |
1189 | * Set the limit for items returned per-feed with multifeeds | |
1190 | * | |
1191 | * @param integer $limit The maximum number of items to return. | |
1192 | */ | |
1193 | public function set_item_limit($limit = 0) | |
1194 | { | |
1195 | $this->item_limit = (int) $limit; | |
1196 | } | |
1197 | ||
1198 | /** | |
1199 | * Initialize the feed object | |
1200 | * | |
1201 | * This is what makes everything happen. Period. This is where all of the | |
1202 | * configuration options get processed, feeds are fetched, cached, and | |
1203 | * parsed, and all of that other good stuff. | |
1204 | * | |
1205 | * @return boolean True if successful, false otherwise | |
1206 | */ | |
1207 | public function init() | |
1208 | { | |
1209 | // Check absolute bare minimum requirements. | |
1210 | if (!extension_loaded('xml') || !extension_loaded('pcre')) | |
1211 | { | |
1212 | return false; | |
1213 | } | |
1214 | // Then check the xml extension is sane (i.e., libxml 2.7.x issue on PHP < 5.2.9 and libxml 2.7.0 to 2.7.2 on any version) if we don't have xmlreader. | |
1215 | elseif (!extension_loaded('xmlreader')) | |
1216 | { | |
1217 | static $xml_is_sane = null; | |
1218 | if ($xml_is_sane === null) | |
1219 | { | |
1220 | $parser_check = xml_parser_create(); | |
1221 | xml_parse_into_struct($parser_check, '<foo>&</foo>', $values); | |
1222 | xml_parser_free($parser_check); | |
1223 | $xml_is_sane = isset($values[0]['value']); | |
1224 | } | |
1225 | if (!$xml_is_sane) | |
1226 | { | |
1227 | return false; | |
1228 | } | |
1229 | } | |
1230 | ||
1231 | if (method_exists($this->sanitize, 'set_registry')) | |
1232 | { | |
1233 | $this->sanitize->set_registry($this->registry); | |
1234 | } | |
1235 | ||
1236 | // Pass whatever was set with config options over to the sanitizer. | |
1237 | // Pass the classes in for legacy support; new classes should use the registry instead | |
1238 | $this->sanitize->pass_cache_data($this->cache, $this->cache_location, $this->cache_name_function, $this->registry->get_class('Cache')); | |
1239 | $this->sanitize->pass_file_data($this->registry->get_class('File'), $this->timeout, $this->useragent, $this->force_fsockopen); | |
1240 | ||
1241 | if (!empty($this->multifeed_url)) | |
1242 | { | |
1243 | $i = 0; | |
1244 | $success = 0; | |
1245 | $this->multifeed_objects = array(); | |
1246 | $this->error = array(); | |
1247 | foreach ($this->multifeed_url as $url) | |
1248 | { | |
1249 | $this->multifeed_objects[$i] = clone $this; | |
1250 | $this->multifeed_objects[$i]->set_feed_url($url); | |
1251 | $single_success = $this->multifeed_objects[$i]->init(); | |
1252 | $success |= $single_success; | |
1253 | if (!$single_success) | |
1254 | { | |
1255 | $this->error[$i] = $this->multifeed_objects[$i]->error(); | |
1256 | } | |
1257 | $i++; | |
1258 | } | |
1259 | return (bool) $success; | |
1260 | } | |
1261 | elseif ($this->feed_url === null && $this->raw_data === null) | |
1262 | { | |
1263 | return false; | |
1264 | } | |
1265 | ||
1266 | $this->error = null; | |
1267 | $this->data = array(); | |
1268 | $this->multifeed_objects = array(); | |
1269 | $cache = false; | |
1270 | ||
1271 | if ($this->feed_url !== null) | |
1272 | { | |
1273 | $parsed_feed_url = $this->registry->call('Misc', 'parse_url', array($this->feed_url)); | |
1274 | ||
1275 | // Decide whether to enable caching | |
1276 | if ($this->cache && $parsed_feed_url['scheme'] !== '') | |
1277 | { | |
1278 | $cache = $this->registry->call('Cache', 'get_handler', array($this->cache_location, call_user_func($this->cache_name_function, $this->feed_url), 'spc')); | |
1279 | } | |
1280 | ||
1281 | // Fetch the data via SimplePie_File into $this->raw_data | |
1282 | if (($fetched = $this->fetch_data($cache)) === true) | |
1283 | { | |
1284 | return true; | |
1285 | } | |
1286 | elseif ($fetched === false) { | |
1287 | return false; | |
1288 | } | |
1289 | ||
1290 | list($headers, $sniffed) = $fetched; | |
1291 | } | |
1292 | ||
1293 | // Set up array of possible encodings | |
1294 | $encodings = array(); | |
1295 | ||
1296 | // First check to see if input has been overridden. | |
1297 | if ($this->input_encoding !== false) | |
1298 | { | |
1299 | $encodings[] = $this->input_encoding; | |
1300 | } | |
1301 | ||
1302 | $application_types = array('application/xml', 'application/xml-dtd', 'application/xml-external-parsed-entity'); | |
1303 | $text_types = array('text/xml', 'text/xml-external-parsed-entity'); | |
1304 | ||
1305 | // RFC 3023 (only applies to sniffed content) | |
1306 | if (isset($sniffed)) | |
1307 | { | |
1308 | if (in_array($sniffed, $application_types) || substr($sniffed, 0, 12) === 'application/' && substr($sniffed, -4) === '+xml') | |
1309 | { | |
1310 | if (isset($headers['content-type']) && preg_match('/;\x20?charset=([^;]*)/i', $headers['content-type'], $charset)) | |
1311 | { | |
1312 | $encodings[] = strtoupper($charset[1]); | |
1313 | } | |
1314 | $encodings = array_merge($encodings, $this->registry->call('Misc', 'xml_encoding', array($this->raw_data, &$this->registry))); | |
1315 | $encodings[] = 'UTF-8'; | |
1316 | } | |
1317 | elseif (in_array($sniffed, $text_types) || substr($sniffed, 0, 5) === 'text/' && substr($sniffed, -4) === '+xml') | |
1318 | { | |
1319 | if (isset($headers['content-type']) && preg_match('/;\x20?charset=([^;]*)/i', $headers['content-type'], $charset)) | |
1320 | { | |
1321 | $encodings[] = $charset[1]; | |
1322 | } | |
1323 | $encodings[] = 'US-ASCII'; | |
1324 | } | |
1325 | // Text MIME-type default | |
1326 | elseif (substr($sniffed, 0, 5) === 'text/') | |
1327 | { | |
1328 | $encodings[] = 'US-ASCII'; | |
1329 | } | |
1330 | } | |
1331 | ||
1332 | // Fallback to XML 1.0 Appendix F.1/UTF-8/ISO-8859-1 | |
1333 | $encodings = array_merge($encodings, $this->registry->call('Misc', 'xml_encoding', array($this->raw_data, &$this->registry))); | |
1334 | $encodings[] = 'UTF-8'; | |
1335 | $encodings[] = 'ISO-8859-1'; | |
1336 | ||
1337 | // There's no point in trying an encoding twice | |
1338 | $encodings = array_unique($encodings); | |
1339 | ||
1340 | // Loop through each possible encoding, till we return something, or run out of possibilities | |
1341 | foreach ($encodings as $encoding) | |
1342 | { | |
1343 | // Change the encoding to UTF-8 (as we always use UTF-8 internally) | |
1344 | if ($utf8_data = $this->registry->call('Misc', 'change_encoding', array($this->raw_data, $encoding, 'UTF-8'))) | |
1345 | { | |
1346 | // Create new parser | |
1347 | $parser = $this->registry->create('Parser'); | |
1348 | ||
1349 | // If it's parsed fine | |
1350 | if ($parser->parse($utf8_data, 'UTF-8')) | |
1351 | { | |
1352 | $this->data = $parser->get_data(); | |
1353 | if (!($this->get_type() & ~SIMPLEPIE_TYPE_NONE)) | |
1354 | { | |
1355 | $this->error = "A feed could not be found at $this->feed_url. This does not appear to be a valid RSS or Atom feed."; | |
1356 | $this->registry->call('Misc', 'error', array($this->error, E_USER_NOTICE, __FILE__, __LINE__)); | |
1357 | return false; | |
1358 | } | |
1359 | ||
1360 | if (isset($headers)) | |
1361 | { | |
1362 | $this->data['headers'] = $headers; | |
1363 | } | |
1364 | $this->data['build'] = SIMPLEPIE_BUILD; | |
1365 | ||
1366 | // Cache the file if caching is enabled | |
1367 | if ($cache && !$cache->save($this)) | |
1368 | { | |
1369 | trigger_error("$this->cache_location is not writeable. Make sure you've set the correct relative or absolute path, and that the location is server-writable.", E_USER_WARNING); | |
1370 | } | |
1371 | return true; | |
1372 | } | |
1373 | } | |
1374 | } | |
1375 | ||
1376 | if (isset($parser)) | |
1377 | { | |
1378 | // We have an error, just set SimplePie_Misc::error to it and quit | |
1379 | $this->error = sprintf('This XML document is invalid, likely due to invalid characters. XML error: %s at line %d, column %d', $parser->get_error_string(), $parser->get_current_line(), $parser->get_current_column()); | |
1380 | } | |
1381 | else | |
1382 | { | |
1383 | $this->error = 'The data could not be converted to UTF-8. You MUST have either the iconv or mbstring extension installed. Upgrading to PHP 5.x (which includes iconv) is highly recommended.'; | |
1384 | } | |
1385 | ||
1386 | $this->registry->call('Misc', 'error', array($this->error, E_USER_NOTICE, __FILE__, __LINE__)); | |
1387 | ||
1388 | return false; | |
1389 | } | |
1390 | ||
1391 | /** | |
1392 | * Fetch the data via SimplePie_File | |
1393 | * | |
1394 | * If the data is already cached, attempt to fetch it from there instead | |
1395 | * @param SimplePie_Cache|false $cache Cache handler, or false to not load from the cache | |
1396 | * @return array|true Returns true if the data was loaded from the cache, or an array of HTTP headers and sniffed type | |
1397 | */ | |
1398 | protected function fetch_data(&$cache) | |
1399 | { | |
1400 | // If it's enabled, use the cache | |
1401 | if ($cache) | |
1402 | { | |
1403 | // Load the Cache | |
1404 | $this->data = $cache->load(); | |
1405 | if (!empty($this->data)) | |
1406 | { | |
1407 | // If the cache is for an outdated build of SimplePie | |
1408 | if (!isset($this->data['build']) || $this->data['build'] !== SIMPLEPIE_BUILD) | |
1409 | { | |
1410 | $cache->unlink(); | |
1411 | $this->data = array(); | |
1412 | } | |
1413 | // If we've hit a collision just rerun it with caching disabled | |
1414 | elseif (isset($this->data['url']) && $this->data['url'] !== $this->feed_url) | |
1415 | { | |
1416 | $cache = false; | |
1417 | $this->data = array(); | |
1418 | } | |
1419 | // If we've got a non feed_url stored (if the page isn't actually a feed, or is a redirect) use that URL. | |
1420 | elseif (isset($this->data['feed_url'])) | |
1421 | { | |
1422 | // If the autodiscovery cache is still valid use it. | |
1423 | if ($cache->mtime() + $this->autodiscovery_cache_duration > time()) | |
1424 | { | |
1425 | // Do not need to do feed autodiscovery yet. | |
1426 | if ($this->data['feed_url'] !== $this->data['url']) | |
1427 | { | |
1428 | $this->set_feed_url($this->data['feed_url']); | |
1429 | return $this->init(); | |
1430 | } | |
1431 | ||
1432 | $cache->unlink(); | |
1433 | $this->data = array(); | |
1434 | } | |
1435 | } | |
1436 | // Check if the cache has been updated | |
1437 | elseif ($cache->mtime() + $this->cache_duration < time()) | |
1438 | { | |
1439 | // If we have last-modified and/or etag set | |
1440 | if (isset($this->data['headers']['last-modified']) || isset($this->data['headers']['etag'])) | |
1441 | { | |
1442 | $headers = array( | |
1443 | 'Accept' => 'application/atom+xml, application/rss+xml, application/rdf+xml;q=0.9, application/xml;q=0.8, text/xml;q=0.8, text/html;q=0.7, unknown/unknown;q=0.1, application/unknown;q=0.1, */*;q=0.1', | |
1444 | ); | |
1445 | if (isset($this->data['headers']['last-modified'])) | |
1446 | { | |
1447 | $headers['if-modified-since'] = $this->data['headers']['last-modified']; | |
1448 | } | |
1449 | if (isset($this->data['headers']['etag'])) | |
1450 | { | |
1451 | $headers['if-none-match'] = $this->data['headers']['etag']; | |
1452 | } | |
1453 | ||
1454 | $file = $this->registry->create('File', array($this->feed_url, $this->timeout/10, 5, $headers, $this->useragent, $this->force_fsockopen)); | |
1455 | ||
1456 | if ($file->success) | |
1457 | { | |
1458 | if ($file->status_code === 304) | |
1459 | { | |
1460 | $cache->touch(); | |
1461 | return true; | |
1462 | } | |
1463 | } | |
1464 | else | |
1465 | { | |
1466 | unset($file); | |
1467 | } | |
1468 | } | |
1469 | } | |
1470 | // If the cache is still valid, just return true | |
1471 | else | |
1472 | { | |
1473 | $this->raw_data = false; | |
1474 | return true; | |
1475 | } | |
1476 | } | |
1477 | // If the cache is empty, delete it | |
1478 | else | |
1479 | { | |
1480 | $cache->unlink(); | |
1481 | $this->data = array(); | |
1482 | } | |
1483 | } | |
1484 | // If we don't already have the file (it'll only exist if we've opened it to check if the cache has been modified), open it. | |
1485 | if (!isset($file)) | |
1486 | { | |
1487 | if ($this->file instanceof SimplePie_File && $this->file->url === $this->feed_url) | |
1488 | { | |
1489 | $file =& $this->file; | |
1490 | } | |
1491 | else | |
1492 | { | |
1493 | $headers = array( | |
1494 | 'Accept' => 'application/atom+xml, application/rss+xml, application/rdf+xml;q=0.9, application/xml;q=0.8, text/xml;q=0.8, text/html;q=0.7, unknown/unknown;q=0.1, application/unknown;q=0.1, */*;q=0.1', | |
1495 | ); | |
1496 | $file = $this->registry->create('File', array($this->feed_url, $this->timeout, 5, $headers, $this->useragent, $this->force_fsockopen)); | |
1497 | } | |
1498 | } | |
1499 | // If the file connection has an error, set SimplePie::error to that and quit | |
1500 | if (!$file->success && !($file->method & SIMPLEPIE_FILE_SOURCE_REMOTE === 0 || ($file->status_code === 200 || $file->status_code > 206 && $file->status_code < 300))) | |
1501 | { | |
1502 | $this->error = $file->error; | |
1503 | return !empty($this->data); | |
1504 | } | |
1505 | ||
1506 | if (!$this->force_feed) | |
1507 | { | |
1508 | // Check if the supplied URL is a feed, if it isn't, look for it. | |
1509 | $locate = $this->registry->create('Locator', array(&$file, $this->timeout, $this->useragent, $this->max_checked_feeds)); | |
1510 | ||
1511 | if (!$locate->is_feed($file)) | |
1512 | { | |
1513 | // We need to unset this so that if SimplePie::set_file() has been called that object is untouched | |
1514 | unset($file); | |
1515 | try | |
1516 | { | |
1517 | if (!($file = $locate->find($this->autodiscovery, $this->all_discovered_feeds))) | |
1518 | { | |
1519 | $this->error = "A feed could not be found at $this->feed_url. A feed with an invalid mime type may fall victim to this error, or " . SIMPLEPIE_NAME . " was unable to auto-discover it.. Use force_feed() if you are certain this URL is a real feed."; | |
1520 | $this->registry->call('Misc', 'error', array($this->error, E_USER_NOTICE, __FILE__, __LINE__)); | |
1521 | return false; | |
1522 | } | |
1523 | } | |
1524 | catch (SimplePie_Exception $e) | |
1525 | { | |
1526 | // This is usually because DOMDocument doesn't exist | |
1527 | $this->error = $e->getMessage(); | |
1528 | $this->registry->call('Misc', 'error', array($this->error, E_USER_NOTICE, $e->getFile(), $e->getLine())); | |
1529 | return false; | |
1530 | } | |
1531 | if ($cache) | |
1532 | { | |
1533 | $this->data = array('url' => $this->feed_url, 'feed_url' => $file->url, 'build' => SIMPLEPIE_BUILD); | |
1534 | if (!$cache->save($this)) | |
1535 | { | |
1536 | trigger_error("$this->cache_location is not writeable. Make sure you've set the correct relative or absolute path, and that the location is server-writable.", E_USER_WARNING); | |
1537 | } | |
1538 | $cache = $this->registry->call('Cache', 'get_handler', array($this->cache_location, call_user_func($this->cache_name_function, $file->url), 'spc')); | |
1539 | } | |
1540 | $this->feed_url = $file->url; | |
1541 | } | |
1542 | $locate = null; | |
1543 | } | |
1544 | ||
1545 | $this->raw_data = $file->body; | |
1546 | ||
1547 | $headers = $file->headers; | |
1548 | $sniffer = $this->registry->create('Content_Type_Sniffer', array(&$file)); | |
1549 | $sniffed = $sniffer->get_type(); | |
1550 | ||
1551 | return array($headers, $sniffed); | |
1552 | } | |
1553 | ||
1554 | /** | |
1555 | * Get the error message for the occured error | |
1556 | * | |
1557 | * @return string|array Error message, or array of messages for multifeeds | |
1558 | */ | |
1559 | public function error() | |
1560 | { | |
1561 | return $this->error; | |
1562 | } | |
1563 | ||
1564 | /** | |
1565 | * Get the raw XML | |
1566 | * | |
1567 | * This is the same as the old `$feed->enable_xml_dump(true)`, but returns | |
1568 | * the data instead of printing it. | |
1569 | * | |
1570 | * @return string|boolean Raw XML data, false if the cache is used | |
1571 | */ | |
1572 | public function get_raw_data() | |
1573 | { | |
1574 | return $this->raw_data; | |
1575 | } | |
1576 | ||
1577 | /** | |
1578 | * Get the character encoding used for output | |
1579 | * | |
1580 | * @since Preview Release | |
1581 | * @return string | |
1582 | */ | |
1583 | public function get_encoding() | |
1584 | { | |
1585 | return $this->sanitize->output_encoding; | |
1586 | } | |
1587 | ||
1588 | /** | |
1589 | * Send the content-type header with correct encoding | |
1590 | * | |
1591 | * This method ensures that the SimplePie-enabled page is being served with | |
1592 | * the correct {@link http://www.iana.org/assignments/media-types/ mime-type} | |
1593 | * and character encoding HTTP headers (character encoding determined by the | |
1594 | * {@see set_output_encoding} config option). | |
1595 | * | |
1596 | * This won't work properly if any content or whitespace has already been | |
1597 | * sent to the browser, because it relies on PHP's | |
1598 | * {@link http://php.net/header header()} function, and these are the | |
1599 | * circumstances under which the function works. | |
1600 | * | |
1601 | * Because it's setting these settings for the entire page (as is the nature | |
1602 | * of HTTP headers), this should only be used once per page (again, at the | |
1603 | * top). | |
1604 | * | |
1605 | * @param string $mime MIME type to serve the page as | |
1606 | */ | |
1607 | public function handle_content_type($mime = 'text/html') | |
1608 | { | |
1609 | if (!headers_sent()) | |
1610 | { | |
1611 | $header = "Content-type: $mime;"; | |
1612 | if ($this->get_encoding()) | |
1613 | { | |
1614 | $header .= ' charset=' . $this->get_encoding(); | |
1615 | } | |
1616 | else | |
1617 | { | |
1618 | $header .= ' charset=UTF-8'; | |
1619 | } | |
1620 | header($header); | |
1621 | } | |
1622 | } | |
1623 | ||
1624 | /** | |
1625 | * Get the type of the feed | |
1626 | * | |
1627 | * This returns a SIMPLEPIE_TYPE_* constant, which can be tested against | |
1628 | * using {@link http://php.net/language.operators.bitwise bitwise operators} | |
1629 | * | |
1630 | * @since 0.8 (usage changed to using constants in 1.0) | |
1631 | * @see SIMPLEPIE_TYPE_NONE Unknown. | |
1632 | * @see SIMPLEPIE_TYPE_RSS_090 RSS 0.90. | |
1633 | * @see SIMPLEPIE_TYPE_RSS_091_NETSCAPE RSS 0.91 (Netscape). | |
1634 | * @see SIMPLEPIE_TYPE_RSS_091_USERLAND RSS 0.91 (Userland). | |
1635 | * @see SIMPLEPIE_TYPE_RSS_091 RSS 0.91. | |
1636 | * @see SIMPLEPIE_TYPE_RSS_092 RSS 0.92. | |
1637 | * @see SIMPLEPIE_TYPE_RSS_093 RSS 0.93. | |
1638 | * @see SIMPLEPIE_TYPE_RSS_094 RSS 0.94. | |
1639 | * @see SIMPLEPIE_TYPE_RSS_10 RSS 1.0. | |
1640 | * @see SIMPLEPIE_TYPE_RSS_20 RSS 2.0.x. | |
1641 | * @see SIMPLEPIE_TYPE_RSS_RDF RDF-based RSS. | |
1642 | * @see SIMPLEPIE_TYPE_RSS_SYNDICATION Non-RDF-based RSS (truly intended as syndication format). | |
1643 | * @see SIMPLEPIE_TYPE_RSS_ALL Any version of RSS. | |
1644 | * @see SIMPLEPIE_TYPE_ATOM_03 Atom 0.3. | |
1645 | * @see SIMPLEPIE_TYPE_ATOM_10 Atom 1.0. | |
1646 | * @see SIMPLEPIE_TYPE_ATOM_ALL Any version of Atom. | |
1647 | * @see SIMPLEPIE_TYPE_ALL Any known/supported feed type. | |
1648 | * @return int SIMPLEPIE_TYPE_* constant | |
1649 | */ | |
1650 | public function get_type() | |
1651 | { | |
1652 | if (!isset($this->data['type'])) | |
1653 | { | |
1654 | $this->data['type'] = SIMPLEPIE_TYPE_ALL; | |
1655 | if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['feed'])) | |
1656 | { | |
1657 | $this->data['type'] &= SIMPLEPIE_TYPE_ATOM_10; | |
1658 | } | |
1659 | elseif (isset($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['feed'])) | |
1660 | { | |
1661 | $this->data['type'] &= SIMPLEPIE_TYPE_ATOM_03; | |
1662 | } | |
1663 | elseif (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'])) | |
1664 | { | |
1665 | if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_10]['channel']) | |
1666 | || isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_10]['image']) | |
1667 | || isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_10]['item']) | |
1668 | || isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_10]['textinput'])) | |
1669 | { | |
1670 | $this->data['type'] &= SIMPLEPIE_TYPE_RSS_10; | |
1671 | } | |
1672 | if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_090]['channel']) | |
1673 | || isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_090]['image']) | |
1674 | || isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_090]['item']) | |
1675 | || isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_090]['textinput'])) | |
1676 | { | |
1677 | $this->data['type'] &= SIMPLEPIE_TYPE_RSS_090; | |
1678 | } | |
1679 | } | |
1680 | elseif (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'])) | |
1681 | { | |
1682 | $this->data['type'] &= SIMPLEPIE_TYPE_RSS_ALL; | |
1683 | if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['attribs']['']['version'])) | |
1684 | { | |
1685 | switch (trim($this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['attribs']['']['version'])) | |
1686 | { | |
1687 | case '0.91': | |
1688 | $this->data['type'] &= SIMPLEPIE_TYPE_RSS_091; | |
1689 | if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_20]['skiphours']['hour'][0]['data'])) | |
1690 | { | |
1691 | switch (trim($this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_20]['skiphours']['hour'][0]['data'])) | |
1692 | { | |
1693 | case '0': | |
1694 | $this->data['type'] &= SIMPLEPIE_TYPE_RSS_091_NETSCAPE; | |
1695 | break; | |
1696 | ||
1697 | case '24': | |
1698 | $this->data['type'] &= SIMPLEPIE_TYPE_RSS_091_USERLAND; | |
1699 | break; | |
1700 | } | |
1701 | } | |
1702 | break; | |
1703 | ||
1704 | case '0.92': | |
1705 | $this->data['type'] &= SIMPLEPIE_TYPE_RSS_092; | |
1706 | break; | |
1707 | ||
1708 | case '0.93': | |
1709 | $this->data['type'] &= SIMPLEPIE_TYPE_RSS_093; | |
1710 | break; | |
1711 | ||
1712 | case '0.94': | |
1713 | $this->data['type'] &= SIMPLEPIE_TYPE_RSS_094; | |
1714 | break; | |
1715 | ||
1716 | case '2.0': | |
1717 | $this->data['type'] &= SIMPLEPIE_TYPE_RSS_20; | |
1718 | break; | |
1719 | } | |
1720 | } | |
1721 | } | |
1722 | else | |
1723 | { | |
1724 | $this->data['type'] = SIMPLEPIE_TYPE_NONE; | |
1725 | } | |
1726 | } | |
1727 | return $this->data['type']; | |
1728 | } | |
1729 | ||
1730 | /** | |
1731 | * Get the URL for the feed | |
1732 | * | |
1733 | * May or may not be different from the URL passed to {@see set_feed_url()}, | |
1734 | * depending on whether auto-discovery was used. | |
1735 | * | |
1736 | * @since Preview Release (previously called `get_feed_url()` since SimplePie 0.8.) | |
1737 | * @todo If we have a perm redirect we should return the new URL | |
1738 | * @todo When we make the above change, let's support <itunes:new-feed-url> as well | |
1739 | * @todo Also, |atom:link|@rel=self | |
1740 | * @return string|null | |
1741 | */ | |
1742 | public function subscribe_url() | |
1743 | { | |
1744 | if ($this->feed_url !== null) | |
1745 | { | |
1746 | return $this->sanitize($this->feed_url, SIMPLEPIE_CONSTRUCT_IRI); | |
1747 | } | |
1748 | else | |
1749 | { | |
1750 | return null; | |
1751 | } | |
1752 | } | |
1753 | ||
1754 | /** | |
1755 | * Get data for an feed-level element | |
1756 | * | |
1757 | * This method allows you to get access to ANY element/attribute that is a | |
1758 | * sub-element of the opening feed tag. | |
1759 | * | |
1760 | * The return value is an indexed array of elements matching the given | |
1761 | * namespace and tag name. Each element has `attribs`, `data` and `child` | |
1762 | * subkeys. For `attribs` and `child`, these contain namespace subkeys. | |
1763 | * `attribs` then has one level of associative name => value data (where | |
1764 | * `value` is a string) after the namespace. `child` has tag-indexed keys | |
1765 | * after the namespace, each member of which is an indexed array matching | |
1766 | * this same format. | |
1767 | * | |
1768 | * For example: | |
1769 | * <pre> | |
1770 | * // This is probably a bad example because we already support | |
1771 | * // <media:content> natively, but it shows you how to parse through | |
1772 | * // the nodes. | |
1773 | * $group = $item->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'group'); | |
1774 | * $content = $group[0]['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['content']; | |
1775 | * $file = $content[0]['attribs']['']['url']; | |
1776 | * echo $file; | |
1777 | * </pre> | |
1778 | * | |
1779 | * @since 1.0 | |
1780 | * @see http://simplepie.org/wiki/faq/supported_xml_namespaces | |
1781 | * @param string $namespace The URL of the XML namespace of the elements you're trying to access | |
1782 | * @param string $tag Tag name | |
1783 | * @return array | |
1784 | */ | |
1785 | public function get_feed_tags($namespace, $tag) | |
1786 | { | |
1787 | $type = $this->get_type(); | |
1788 | if ($type & SIMPLEPIE_TYPE_ATOM_10) | |
1789 | { | |
1790 | if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['feed'][0]['child'][$namespace][$tag])) | |
1791 | { | |
1792 | return $this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['feed'][0]['child'][$namespace][$tag]; | |
1793 | } | |
1794 | } | |
1795 | if ($type & SIMPLEPIE_TYPE_ATOM_03) | |
1796 | { | |
1797 | if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['feed'][0]['child'][$namespace][$tag])) | |
1798 | { | |
1799 | return $this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['feed'][0]['child'][$namespace][$tag]; | |
1800 | } | |
1801 | } | |
1802 | if ($type & SIMPLEPIE_TYPE_RSS_RDF) | |
1803 | { | |
1804 | if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][$namespace][$tag])) | |
1805 | { | |
1806 | return $this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][$namespace][$tag]; | |
1807 | } | |
1808 | } | |
1809 | if ($type & SIMPLEPIE_TYPE_RSS_SYNDICATION) | |
1810 | { | |
1811 | if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['child'][$namespace][$tag])) | |
1812 | { | |
1813 | return $this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['child'][$namespace][$tag]; | |
1814 | } | |
1815 | } | |
1816 | return null; | |
1817 | } | |
1818 | ||
1819 | /** | |
1820 | * Get data for an channel-level element | |
1821 | * | |
1822 | * This method allows you to get access to ANY element/attribute in the | |
1823 | * channel/header section of the feed. | |
1824 | * | |
1825 | * See {@see SimplePie::get_feed_tags()} for a description of the return value | |
1826 | * | |
1827 | * @since 1.0 | |
1828 | * @see http://simplepie.org/wiki/faq/supported_xml_namespaces | |
1829 | * @param string $namespace The URL of the XML namespace of the elements you're trying to access | |
1830 | * @param string $tag Tag name | |
1831 | * @return array | |
1832 | */ | |
1833 | public function get_channel_tags($namespace, $tag) | |
1834 | { | |
1835 | $type = $this->get_type(); | |
1836 | if ($type & SIMPLEPIE_TYPE_ATOM_ALL) | |
1837 | { | |
1838 | if ($return = $this->get_feed_tags($namespace, $tag)) | |
1839 | { | |
1840 | return $return; | |
1841 | } | |
1842 | } | |
1843 | if ($type & SIMPLEPIE_TYPE_RSS_10) | |
1844 | { | |
1845 | if ($channel = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'channel')) | |
1846 | { | |
1847 | if (isset($channel[0]['child'][$namespace][$tag])) | |
1848 | { | |
1849 | return $channel[0]['child'][$namespace][$tag]; | |
1850 | } | |
1851 | } | |
1852 | } | |
1853 | if ($type & SIMPLEPIE_TYPE_RSS_090) | |
1854 | { | |
1855 | if ($channel = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'channel')) | |
1856 | { | |
1857 | if (isset($channel[0]['child'][$namespace][$tag])) | |
1858 | { | |
1859 | return $channel[0]['child'][$namespace][$tag]; | |
1860 | } | |
1861 | } | |
1862 | } | |
1863 | if ($type & SIMPLEPIE_TYPE_RSS_SYNDICATION) | |
1864 | { | |
1865 | if ($channel = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'channel')) | |
1866 | { | |
1867 | if (isset($channel[0]['child'][$namespace][$tag])) | |
1868 | { | |
1869 | return $channel[0]['child'][$namespace][$tag]; | |
1870 | } | |
1871 | } | |
1872 | } | |
1873 | return null; | |
1874 | } | |
1875 | ||
1876 | /** | |
1877 | * Get data for an channel-level element | |
1878 | * | |
1879 | * This method allows you to get access to ANY element/attribute in the | |
1880 | * image/logo section of the feed. | |
1881 | * | |
1882 | * See {@see SimplePie::get_feed_tags()} for a description of the return value | |
1883 | * | |
1884 | * @since 1.0 | |
1885 | * @see http://simplepie.org/wiki/faq/supported_xml_namespaces | |
1886 | * @param string $namespace The URL of the XML namespace of the elements you're trying to access | |
1887 | * @param string $tag Tag name | |
1888 | * @return array | |
1889 | */ | |
1890 | public function get_image_tags($namespace, $tag) | |
1891 | { | |
1892 | $type = $this->get_type(); | |
1893 | if ($type & SIMPLEPIE_TYPE_RSS_10) | |
1894 | { | |
1895 | if ($image = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'image')) | |
1896 | { | |
1897 | if (isset($image[0]['child'][$namespace][$tag])) | |
1898 | { | |
1899 | return $image[0]['child'][$namespace][$tag]; | |
1900 | } | |
1901 | } | |
1902 | } | |
1903 | if ($type & SIMPLEPIE_TYPE_RSS_090) | |
1904 | { | |
1905 | if ($image = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'image')) | |
1906 | { | |
1907 | if (isset($image[0]['child'][$namespace][$tag])) | |
1908 | { | |
1909 | return $image[0]['child'][$namespace][$tag]; | |
1910 | } | |
1911 | } | |
1912 | } | |
1913 | if ($type & SIMPLEPIE_TYPE_RSS_SYNDICATION) | |
1914 | { | |
1915 | if ($image = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'image')) | |
1916 | { | |
1917 | if (isset($image[0]['child'][$namespace][$tag])) | |
1918 | { | |
1919 | return $image[0]['child'][$namespace][$tag]; | |
1920 | } | |
1921 | } | |
1922 | } | |
1923 | return null; | |
1924 | } | |
1925 | ||
1926 | /** | |
1927 | * Get the base URL value from the feed | |
1928 | * | |
1929 | * Uses `<xml:base>` if available, otherwise uses the first link in the | |
1930 | * feed, or failing that, the URL of the feed itself. | |
1931 | * | |
1932 | * @see get_link | |
1933 | * @see subscribe_url | |
1934 | * | |
1935 | * @param array $element | |
1936 | * @return string | |
1937 | */ | |
1938 | public function get_base($element = array()) | |
1939 | { | |
1940 | if (!($this->get_type() & SIMPLEPIE_TYPE_RSS_SYNDICATION) && !empty($element['xml_base_explicit']) && isset($element['xml_base'])) | |
1941 | { | |
1942 | return $element['xml_base']; | |
1943 | } | |
1944 | elseif ($this->get_link() !== null) | |
1945 | { | |
1946 | return $this->get_link(); | |
1947 | } | |
1948 | else | |
1949 | { | |
1950 | return $this->subscribe_url(); | |
1951 | } | |
1952 | } | |
1953 | ||
1954 | /** | |
1955 | * Sanitize feed data | |
1956 | * | |
1957 | * @access private | |
1958 | * @see SimplePie_Sanitize::sanitize() | |
1959 | * @param string $data Data to sanitize | |
1960 | * @param int $type One of the SIMPLEPIE_CONSTRUCT_* constants | |
1961 | * @param string $base Base URL to resolve URLs against | |
1962 | * @return string Sanitized data | |
1963 | */ | |
1964 | public function sanitize($data, $type, $base = '') | |
1965 | { | |
1966 | return $this->sanitize->sanitize($data, $type, $base); | |
1967 | } | |
1968 | ||
1969 | /** | |
1970 | * Get the title of the feed | |
1971 | * | |
1972 | * Uses `<atom:title>`, `<title>` or `<dc:title>` | |
1973 | * | |
1974 | * @since 1.0 (previously called `get_feed_title` since 0.8) | |
1975 | * @return string|null | |
1976 | */ | |
1977 | public function get_title() | |
1978 | { | |
1979 | if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'title')) | |
1980 | { | |
1981 | return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); | |
1982 | } | |
1983 | elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'title')) | |
1984 | { | |
1985 | return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); | |
1986 | } | |
1987 | elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'title')) | |
1988 | { | |
1989 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0])); | |
1990 | } | |
1991 | elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'title')) | |
1992 | { | |
1993 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0])); | |
1994 | } | |
1995 | elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'title')) | |
1996 | { | |
1997 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0])); | |
1998 | } | |
1999 | elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_11, 'title')) | |
2000 | { | |
2001 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2002 | } | |
2003 | elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_10, 'title')) | |
2004 | { | |
2005 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2006 | } | |
2007 | else | |
2008 | { | |
2009 | return null; | |
2010 | } | |
2011 | } | |
2012 | ||
2013 | /** | |
2014 | * Get a category for the feed | |
2015 | * | |
2016 | * @since Unknown | |
2017 | * @param int $key The category that you want to return. Remember that arrays begin with 0, not 1 | |
2018 | * @return SimplePie_Category|null | |
2019 | */ | |
2020 | public function get_category($key = 0) | |
2021 | { | |
2022 | $categories = $this->get_categories(); | |
2023 | if (isset($categories[$key])) | |
2024 | { | |
2025 | return $categories[$key]; | |
2026 | } | |
2027 | else | |
2028 | { | |
2029 | return null; | |
2030 | } | |
2031 | } | |
2032 | ||
2033 | /** | |
2034 | * Get all categories for the feed | |
2035 | * | |
2036 | * Uses `<atom:category>`, `<category>` or `<dc:subject>` | |
2037 | * | |
2038 | * @since Unknown | |
2039 | * @return array|null List of {@see SimplePie_Category} objects | |
2040 | */ | |
2041 | public function get_categories() | |
2042 | { | |
2043 | $categories = array(); | |
2044 | ||
2045 | foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'category') as $category) | |
2046 | { | |
2047 | $term = null; | |
2048 | $scheme = null; | |
2049 | $label = null; | |
2050 | if (isset($category['attribs']['']['term'])) | |
2051 | { | |
2052 | $term = $this->sanitize($category['attribs']['']['term'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2053 | } | |
2054 | if (isset($category['attribs']['']['scheme'])) | |
2055 | { | |
2056 | $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2057 | } | |
2058 | if (isset($category['attribs']['']['label'])) | |
2059 | { | |
2060 | $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2061 | } | |
2062 | $categories[] = $this->registry->create('Category', array($term, $scheme, $label)); | |
2063 | } | |
2064 | foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'category') as $category) | |
2065 | { | |
2066 | // This is really the label, but keep this as the term also for BC. | |
2067 | // Label will also work on retrieving because that falls back to term. | |
2068 | $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2069 | if (isset($category['attribs']['']['domain'])) | |
2070 | { | |
2071 | $scheme = $this->sanitize($category['attribs']['']['domain'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2072 | } | |
2073 | else | |
2074 | { | |
2075 | $scheme = null; | |
2076 | } | |
2077 | $categories[] = $this->registry->create('Category', array($term, $scheme, null)); | |
2078 | } | |
2079 | foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_11, 'subject') as $category) | |
2080 | { | |
2081 | $categories[] = $this->registry->create('Category', array($this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null)); | |
2082 | } | |
2083 | foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_10, 'subject') as $category) | |
2084 | { | |
2085 | $categories[] = $this->registry->create('Category', array($this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null)); | |
2086 | } | |
2087 | ||
2088 | if (!empty($categories)) | |
2089 | { | |
2090 | return array_unique($categories); | |
2091 | } | |
2092 | else | |
2093 | { | |
2094 | return null; | |
2095 | } | |
2096 | } | |
2097 | ||
2098 | /** | |
2099 | * Get an author for the feed | |
2100 | * | |
2101 | * @since 1.1 | |
2102 | * @param int $key The author that you want to return. Remember that arrays begin with 0, not 1 | |
2103 | * @return SimplePie_Author|null | |
2104 | */ | |
2105 | public function get_author($key = 0) | |
2106 | { | |
2107 | $authors = $this->get_authors(); | |
2108 | if (isset($authors[$key])) | |
2109 | { | |
2110 | return $authors[$key]; | |
2111 | } | |
2112 | else | |
2113 | { | |
2114 | return null; | |
2115 | } | |
2116 | } | |
2117 | ||
2118 | /** | |
2119 | * Get all authors for the feed | |
2120 | * | |
2121 | * Uses `<atom:author>`, `<author>`, `<dc:creator>` or `<itunes:author>` | |
2122 | * | |
2123 | * @since 1.1 | |
2124 | * @return array|null List of {@see SimplePie_Author} objects | |
2125 | */ | |
2126 | public function get_authors() | |
2127 | { | |
2128 | $authors = array(); | |
2129 | foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'author') as $author) | |
2130 | { | |
2131 | $name = null; | |
2132 | $uri = null; | |
2133 | $email = null; | |
2134 | if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'])) | |
2135 | { | |
2136 | $name = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2137 | } | |
2138 | if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'])) | |
2139 | { | |
2140 | $uri = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0])); | |
2141 | } | |
2142 | if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'])) | |
2143 | { | |
2144 | $email = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2145 | } | |
2146 | if ($name !== null || $email !== null || $uri !== null) | |
2147 | { | |
2148 | $authors[] = $this->registry->create('Author', array($name, $uri, $email)); | |
2149 | } | |
2150 | } | |
2151 | if ($author = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'author')) | |
2152 | { | |
2153 | $name = null; | |
2154 | $url = null; | |
2155 | $email = null; | |
2156 | if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'])) | |
2157 | { | |
2158 | $name = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2159 | } | |
2160 | if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'])) | |
2161 | { | |
2162 | $url = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0])); | |
2163 | } | |
2164 | if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'])) | |
2165 | { | |
2166 | $email = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2167 | } | |
2168 | if ($name !== null || $email !== null || $url !== null) | |
2169 | { | |
2170 | $authors[] = $this->registry->create('Author', array($name, $url, $email)); | |
2171 | } | |
2172 | } | |
2173 | foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_11, 'creator') as $author) | |
2174 | { | |
2175 | $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null)); | |
2176 | } | |
2177 | foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_10, 'creator') as $author) | |
2178 | { | |
2179 | $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null)); | |
2180 | } | |
2181 | foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'author') as $author) | |
2182 | { | |
2183 | $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null)); | |
2184 | } | |
2185 | ||
2186 | if (!empty($authors)) | |
2187 | { | |
2188 | return array_unique($authors); | |
2189 | } | |
2190 | else | |
2191 | { | |
2192 | return null; | |
2193 | } | |
2194 | } | |
2195 | ||
2196 | /** | |
2197 | * Get a contributor for the feed | |
2198 | * | |
2199 | * @since 1.1 | |
2200 | * @param int $key The contrbutor that you want to return. Remember that arrays begin with 0, not 1 | |
2201 | * @return SimplePie_Author|null | |
2202 | */ | |
2203 | public function get_contributor($key = 0) | |
2204 | { | |
2205 | $contributors = $this->get_contributors(); | |
2206 | if (isset($contributors[$key])) | |
2207 | { | |
2208 | return $contributors[$key]; | |
2209 | } | |
2210 | else | |
2211 | { | |
2212 | return null; | |
2213 | } | |
2214 | } | |
2215 | ||
2216 | /** | |
2217 | * Get all contributors for the feed | |
2218 | * | |
2219 | * Uses `<atom:contributor>` | |
2220 | * | |
2221 | * @since 1.1 | |
2222 | * @return array|null List of {@see SimplePie_Author} objects | |
2223 | */ | |
2224 | public function get_contributors() | |
2225 | { | |
2226 | $contributors = array(); | |
2227 | foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'contributor') as $contributor) | |
2228 | { | |
2229 | $name = null; | |
2230 | $uri = null; | |
2231 | $email = null; | |
2232 | if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'])) | |
2233 | { | |
2234 | $name = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2235 | } | |
2236 | if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'])) | |
2237 | { | |
2238 | $uri = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0])); | |
2239 | } | |
2240 | if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'])) | |
2241 | { | |
2242 | $email = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2243 | } | |
2244 | if ($name !== null || $email !== null || $uri !== null) | |
2245 | { | |
2246 | $contributors[] = $this->registry->create('Author', array($name, $uri, $email)); | |
2247 | } | |
2248 | } | |
2249 | foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'contributor') as $contributor) | |
2250 | { | |
2251 | $name = null; | |
2252 | $url = null; | |
2253 | $email = null; | |
2254 | if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'])) | |
2255 | { | |
2256 | $name = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2257 | } | |
2258 | if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'])) | |
2259 | { | |
2260 | $url = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0])); | |
2261 | } | |
2262 | if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'])) | |
2263 | { | |
2264 | $email = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2265 | } | |
2266 | if ($name !== null || $email !== null || $url !== null) | |
2267 | { | |
2268 | $contributors[] = $this->registry->create('Author', array($name, $url, $email)); | |
2269 | } | |
2270 | } | |
2271 | ||
2272 | if (!empty($contributors)) | |
2273 | { | |
2274 | return array_unique($contributors); | |
2275 | } | |
2276 | else | |
2277 | { | |
2278 | return null; | |
2279 | } | |
2280 | } | |
2281 | ||
2282 | /** | |
2283 | * Get a single link for the feed | |
2284 | * | |
2285 | * @since 1.0 (previously called `get_feed_link` since Preview Release, `get_feed_permalink()` since 0.8) | |
2286 | * @param int $key The link that you want to return. Remember that arrays begin with 0, not 1 | |
2287 | * @param string $rel The relationship of the link to return | |
2288 | * @return string|null Link URL | |
2289 | */ | |
2290 | public function get_link($key = 0, $rel = 'alternate') | |
2291 | { | |
2292 | $links = $this->get_links($rel); | |
2293 | if (isset($links[$key])) | |
2294 | { | |
2295 | return $links[$key]; | |
2296 | } | |
2297 | else | |
2298 | { | |
2299 | return null; | |
2300 | } | |
2301 | } | |
2302 | ||
2303 | /** | |
2304 | * Get the permalink for the item | |
2305 | * | |
2306 | * Returns the first link available with a relationship of "alternate". | |
2307 | * Identical to {@see get_link()} with key 0 | |
2308 | * | |
2309 | * @see get_link | |
2310 | * @since 1.0 (previously called `get_feed_link` since Preview Release, `get_feed_permalink()` since 0.8) | |
2311 | * @internal Added for parity between the parent-level and the item/entry-level. | |
2312 | * @return string|null Link URL | |
2313 | */ | |
2314 | public function get_permalink() | |
2315 | { | |
2316 | return $this->get_link(0); | |
2317 | } | |
2318 | ||
2319 | /** | |
2320 | * Get all links for the feed | |
2321 | * | |
2322 | * Uses `<atom:link>` or `<link>` | |
2323 | * | |
2324 | * @since Beta 2 | |
2325 | * @param string $rel The relationship of links to return | |
2326 | * @return array|null Links found for the feed (strings) | |
2327 | */ | |
2328 | public function get_links($rel = 'alternate') | |
2329 | { | |
2330 | if (!isset($this->data['links'])) | |
2331 | { | |
2332 | $this->data['links'] = array(); | |
2333 | if ($links = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'link')) | |
2334 | { | |
2335 | foreach ($links as $link) | |
2336 | { | |
2337 | if (isset($link['attribs']['']['href'])) | |
2338 | { | |
2339 | $link_rel = (isset($link['attribs']['']['rel'])) ? $link['attribs']['']['rel'] : 'alternate'; | |
2340 | $this->data['links'][$link_rel][] = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link)); | |
2341 | } | |
2342 | } | |
2343 | } | |
2344 | if ($links = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'link')) | |
2345 | { | |
2346 | foreach ($links as $link) | |
2347 | { | |
2348 | if (isset($link['attribs']['']['href'])) | |
2349 | { | |
2350 | $link_rel = (isset($link['attribs']['']['rel'])) ? $link['attribs']['']['rel'] : 'alternate'; | |
2351 | $this->data['links'][$link_rel][] = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link)); | |
2352 | ||
2353 | } | |
2354 | } | |
2355 | } | |
2356 | if ($links = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'link')) | |
2357 | { | |
2358 | $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0])); | |
2359 | } | |
2360 | if ($links = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'link')) | |
2361 | { | |
2362 | $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0])); | |
2363 | } | |
2364 | if ($links = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'link')) | |
2365 | { | |
2366 | $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0])); | |
2367 | } | |
2368 | ||
2369 | $keys = array_keys($this->data['links']); | |
2370 | foreach ($keys as $key) | |
2371 | { | |
2372 | if ($this->registry->call('Misc', 'is_isegment_nz_nc', array($key))) | |
2373 | { | |
2374 | if (isset($this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key])) | |
2375 | { | |
2376 | $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key] = array_merge($this->data['links'][$key], $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key]); | |
2377 | $this->data['links'][$key] =& $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key]; | |
2378 | } | |
2379 | else | |
2380 | { | |
2381 | $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key] =& $this->data['links'][$key]; | |
2382 | } | |
2383 | } | |
2384 | elseif (substr($key, 0, 41) === SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY) | |
2385 | { | |
2386 | $this->data['links'][substr($key, 41)] =& $this->data['links'][$key]; | |
2387 | } | |
2388 | $this->data['links'][$key] = array_unique($this->data['links'][$key]); | |
2389 | } | |
2390 | } | |
2391 | ||
2392 | if (isset($this->data['links'][$rel])) | |
2393 | { | |
2394 | return $this->data['links'][$rel]; | |
2395 | } | |
2396 | else | |
2397 | { | |
2398 | return null; | |
2399 | } | |
2400 | } | |
2401 | ||
2402 | public function get_all_discovered_feeds() | |
2403 | { | |
2404 | return $this->all_discovered_feeds; | |
2405 | } | |
2406 | ||
2407 | /** | |
2408 | * Get the content for the item | |
2409 | * | |
2410 | * Uses `<atom:subtitle>`, `<atom:tagline>`, `<description>`, | |
2411 | * `<dc:description>`, `<itunes:summary>` or `<itunes:subtitle>` | |
2412 | * | |
2413 | * @since 1.0 (previously called `get_feed_description()` since 0.8) | |
2414 | * @return string|null | |
2415 | */ | |
2416 | public function get_description() | |
2417 | { | |
2418 | if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'subtitle')) | |
2419 | { | |
2420 | return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); | |
2421 | } | |
2422 | elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'tagline')) | |
2423 | { | |
2424 | return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); | |
2425 | } | |
2426 | elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'description')) | |
2427 | { | |
2428 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0])); | |
2429 | } | |
2430 | elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'description')) | |
2431 | { | |
2432 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0])); | |
2433 | } | |
2434 | elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'description')) | |
2435 | { | |
2436 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0])); | |
2437 | } | |
2438 | elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_11, 'description')) | |
2439 | { | |
2440 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2441 | } | |
2442 | elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_10, 'description')) | |
2443 | { | |
2444 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2445 | } | |
2446 | elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'summary')) | |
2447 | { | |
2448 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0])); | |
2449 | } | |
2450 | elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'subtitle')) | |
2451 | { | |
2452 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0])); | |
2453 | } | |
2454 | else | |
2455 | { | |
2456 | return null; | |
2457 | } | |
2458 | } | |
2459 | ||
2460 | /** | |
2461 | * Get the copyright info for the feed | |
2462 | * | |
2463 | * Uses `<atom:rights>`, `<atom:copyright>` or `<dc:rights>` | |
2464 | * | |
2465 | * @since 1.0 (previously called `get_feed_copyright()` since 0.8) | |
2466 | * @return string|null | |
2467 | */ | |
2468 | public function get_copyright() | |
2469 | { | |
2470 | if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'rights')) | |
2471 | { | |
2472 | return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); | |
2473 | } | |
2474 | elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'copyright')) | |
2475 | { | |
2476 | return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); | |
2477 | } | |
2478 | elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'copyright')) | |
2479 | { | |
2480 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2481 | } | |
2482 | elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_11, 'rights')) | |
2483 | { | |
2484 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2485 | } | |
2486 | elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_10, 'rights')) | |
2487 | { | |
2488 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2489 | } | |
2490 | else | |
2491 | { | |
2492 | return null; | |
2493 | } | |
2494 | } | |
2495 | ||
2496 | /** | |
2497 | * Get the language for the feed | |
2498 | * | |
2499 | * Uses `<language>`, `<dc:language>`, or @xml_lang | |
2500 | * | |
2501 | * @since 1.0 (previously called `get_feed_language()` since 0.8) | |
2502 | * @return string|null | |
2503 | */ | |
2504 | public function get_language() | |
2505 | { | |
2506 | if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'language')) | |
2507 | { | |
2508 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2509 | } | |
2510 | elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_11, 'language')) | |
2511 | { | |
2512 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2513 | } | |
2514 | elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_10, 'language')) | |
2515 | { | |
2516 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2517 | } | |
2518 | elseif (isset($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['feed'][0]['xml_lang'])) | |
2519 | { | |
2520 | return $this->sanitize($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['feed'][0]['xml_lang'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2521 | } | |
2522 | elseif (isset($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['feed'][0]['xml_lang'])) | |
2523 | { | |
2524 | return $this->sanitize($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['feed'][0]['xml_lang'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2525 | } | |
2526 | elseif (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['xml_lang'])) | |
2527 | { | |
2528 | return $this->sanitize($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['xml_lang'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2529 | } | |
2530 | elseif (isset($this->data['headers']['content-language'])) | |
2531 | { | |
2532 | return $this->sanitize($this->data['headers']['content-language'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2533 | } | |
2534 | else | |
2535 | { | |
2536 | return null; | |
2537 | } | |
2538 | } | |
2539 | ||
2540 | /** | |
2541 | * Get the latitude coordinates for the item | |
2542 | * | |
2543 | * Compatible with the W3C WGS84 Basic Geo and GeoRSS specifications | |
2544 | * | |
2545 | * Uses `<geo:lat>` or `<georss:point>` | |
2546 | * | |
2547 | * @since 1.0 | |
2548 | * @link http://www.w3.org/2003/01/geo/ W3C WGS84 Basic Geo | |
2549 | * @link http://www.georss.org/ GeoRSS | |
2550 | * @return string|null | |
2551 | */ | |
2552 | public function get_latitude() | |
2553 | { | |
2554 | ||
2555 | if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'lat')) | |
2556 | { | |
2557 | return (float) $return[0]['data']; | |
2558 | } | |
2559 | elseif (($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_GEORSS, 'point')) && preg_match('/^((?:-)?[0-9]+(?:\.[0-9]+)) ((?:-)?[0-9]+(?:\.[0-9]+))$/', trim($return[0]['data']), $match)) | |
2560 | { | |
2561 | return (float) $match[1]; | |
2562 | } | |
2563 | else | |
2564 | { | |
2565 | return null; | |
2566 | } | |
2567 | } | |
2568 | ||
2569 | /** | |
2570 | * Get the longitude coordinates for the feed | |
2571 | * | |
2572 | * Compatible with the W3C WGS84 Basic Geo and GeoRSS specifications | |
2573 | * | |
2574 | * Uses `<geo:long>`, `<geo:lon>` or `<georss:point>` | |
2575 | * | |
2576 | * @since 1.0 | |
2577 | * @link http://www.w3.org/2003/01/geo/ W3C WGS84 Basic Geo | |
2578 | * @link http://www.georss.org/ GeoRSS | |
2579 | * @return string|null | |
2580 | */ | |
2581 | public function get_longitude() | |
2582 | { | |
2583 | if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'long')) | |
2584 | { | |
2585 | return (float) $return[0]['data']; | |
2586 | } | |
2587 | elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'lon')) | |
2588 | { | |
2589 | return (float) $return[0]['data']; | |
2590 | } | |
2591 | elseif (($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_GEORSS, 'point')) && preg_match('/^((?:-)?[0-9]+(?:\.[0-9]+)) ((?:-)?[0-9]+(?:\.[0-9]+))$/', trim($return[0]['data']), $match)) | |
2592 | { | |
2593 | return (float) $match[2]; | |
2594 | } | |
2595 | else | |
2596 | { | |
2597 | return null; | |
2598 | } | |
2599 | } | |
2600 | ||
2601 | /** | |
2602 | * Get the feed logo's title | |
2603 | * | |
2604 | * RSS 0.9.0, 1.0 and 2.0 feeds are allowed to have a "feed logo" title. | |
2605 | * | |
2606 | * Uses `<image><title>` or `<image><dc:title>` | |
2607 | * | |
2608 | * @return string|null | |
2609 | */ | |
2610 | public function get_image_title() | |
2611 | { | |
2612 | if ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'title')) | |
2613 | { | |
2614 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2615 | } | |
2616 | elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'title')) | |
2617 | { | |
2618 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2619 | } | |
2620 | elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'title')) | |
2621 | { | |
2622 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2623 | } | |
2624 | elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_DC_11, 'title')) | |
2625 | { | |
2626 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2627 | } | |
2628 | elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_DC_10, 'title')) | |
2629 | { | |
2630 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); | |
2631 | } | |
2632 | else | |
2633 | { | |
2634 | return null; | |
2635 | } | |
2636 | } | |
2637 | ||
2638 | /** | |
2639 | * Get the feed logo's URL | |
2640 | * | |
2641 | * RSS 0.9.0, 2.0, Atom 1.0, and feeds with iTunes RSS tags are allowed to | |
2642 | * have a "feed logo" URL. This points directly to the image itself. | |
2643 | * | |
2644 | * Uses `<itunes:image>`, `<atom:logo>`, `<atom:icon>`, | |
2645 | * `<image><title>` or `<image><dc:title>` | |
2646 | * | |
2647 | * @return string|null | |
2648 | */ | |
2649 | public function get_image_url() | |
2650 | { | |
2651 | if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'image')) | |
2652 | { | |
2653 | return $this->sanitize($return[0]['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI); | |
2654 | } | |
2655 | elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'logo')) | |
2656 | { | |
2657 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0])); | |
2658 | } | |
2659 | elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'icon')) | |
2660 | { | |
2661 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0])); | |
2662 | } | |
2663 | elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'url')) | |
2664 | { | |
2665 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0])); | |
2666 | } | |
2667 | elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'url')) | |
2668 | { | |
2669 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0])); | |
2670 | } | |
2671 | elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'url')) | |
2672 | { | |
2673 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0])); | |
2674 | } | |
2675 | else | |
2676 | { | |
2677 | return null; | |
2678 | } | |
2679 | } | |
2680 | ||
2681 | ||
2682 | /** | |
2683 | * Get the feed logo's link | |
2684 | * | |
2685 | * RSS 0.9.0, 1.0 and 2.0 feeds are allowed to have a "feed logo" link. This | |
2686 | * points to a human-readable page that the image should link to. | |
2687 | * | |
2688 | * Uses `<itunes:image>`, `<atom:logo>`, `<atom:icon>`, | |
2689 | * `<image><title>` or `<image><dc:title>` | |
2690 | * | |
2691 | * @return string|null | |
2692 | */ | |
2693 | public function get_image_link() | |
2694 | { | |
2695 | if ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'link')) | |
2696 | { | |
2697 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0])); | |
2698 | } | |
2699 | elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'link')) | |
2700 | { | |
2701 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0])); | |
2702 | } | |
2703 | elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'link')) | |
2704 | { | |
2705 | return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0])); | |
2706 | } | |
2707 | else | |
2708 | { | |
2709 | return null; | |
2710 | } | |
2711 | } | |
2712 | ||
2713 | /** | |
2714 | * Get the feed logo's link | |
2715 | * | |
2716 | * RSS 2.0 feeds are allowed to have a "feed logo" width. | |
2717 | * | |
2718 | * Uses `<image><width>` or defaults to 88.0 if no width is specified and | |
2719 | * the feed is an RSS 2.0 feed. | |
2720 | * | |
2721 | * @return int|float|null | |
2722 | */ | |
2723 | public function get_image_width() | |
2724 | { | |
2725 | if ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'width')) | |
2726 | { | |
2727 | return round($return[0]['data']); | |
2728 | } | |
2729 | elseif ($this->get_type() & SIMPLEPIE_TYPE_RSS_SYNDICATION && $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'url')) | |
2730 | { | |
2731 | return 88.0; | |
2732 | } | |
2733 | else | |
2734 | { | |
2735 | return null; | |
2736 | } | |
2737 | } | |
2738 | ||
2739 | /** | |
2740 | * Get the feed logo's height | |
2741 | * | |
2742 | * RSS 2.0 feeds are allowed to have a "feed logo" height. | |
2743 | * | |
2744 | * Uses `<image><height>` or defaults to 31.0 if no height is specified and | |
2745 | * the feed is an RSS 2.0 feed. | |
2746 | * | |
2747 | * @return int|float|null | |
2748 | */ | |
2749 | public function get_image_height() | |
2750 | { | |
2751 | if ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'height')) | |
2752 | { | |
2753 | return round($return[0]['data']); | |
2754 | } | |
2755 | elseif ($this->get_type() & SIMPLEPIE_TYPE_RSS_SYNDICATION && $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'url')) | |
2756 | { | |
2757 | return 31.0; | |
2758 | } | |
2759 | else | |
2760 | { | |
2761 | return null; | |
2762 | } | |
2763 | } | |
2764 | ||
2765 | /** | |
2766 | * Get the number of items in the feed | |
2767 | * | |
2768 | * This is well-suited for {@link http://php.net/for for()} loops with | |
2769 | * {@see get_item()} | |
2770 | * | |
2771 | * @param int $max Maximum value to return. 0 for no limit | |
2772 | * @return int Number of items in the feed | |
2773 | */ | |
2774 | public function get_item_quantity($max = 0) | |
2775 | { | |
2776 | $max = (int) $max; | |
2777 | $qty = count($this->get_items()); | |
2778 | if ($max === 0) | |
2779 | { | |
2780 | return $qty; | |
2781 | } | |
2782 | else | |
2783 | { | |
2784 | return ($qty > $max) ? $max : $qty; | |
2785 | } | |
2786 | } | |
2787 | ||
2788 | /** | |
2789 | * Get a single item from the feed | |
2790 | * | |
2791 | * This is better suited for {@link http://php.net/for for()} loops, whereas | |
2792 | * {@see get_items()} is better suited for | |
2793 | * {@link http://php.net/foreach foreach()} loops. | |
2794 | * | |
2795 | * @see get_item_quantity() | |
2796 | * @since Beta 2 | |
2797 | * @param int $key The item that you want to return. Remember that arrays begin with 0, not 1 | |
2798 | * @return SimplePie_Item|null | |
2799 | */ | |
2800 | public function get_item($key = 0) | |
2801 | { | |
2802 | $items = $this->get_items(); | |
2803 | if (isset($items[$key])) | |
2804 | { | |
2805 | return $items[$key]; | |
2806 | } | |
2807 | else | |
2808 | { | |
2809 | return null; | |
2810 | } | |
2811 | } | |
2812 | ||
2813 | /** | |
2814 | * Get all items from the feed | |
2815 | * | |
2816 | * This is better suited for {@link http://php.net/for for()} loops, whereas | |
2817 | * {@see get_items()} is better suited for | |
2818 | * {@link http://php.net/foreach foreach()} loops. | |
2819 | * | |
2820 | * @see get_item_quantity | |
2821 | * @since Beta 2 | |
2822 | * @param int $start Index to start at | |
2823 | * @param int $end Number of items to return. 0 for all items after `$start` | |
2824 | * @return array|null List of {@see SimplePie_Item} objects | |
2825 | */ | |
2826 | public function get_items($start = 0, $end = 0) | |
2827 | { | |
2828 | if (!isset($this->data['items'])) | |
2829 | { | |
2830 | if (!empty($this->multifeed_objects)) | |
2831 | { | |
2832 | $this->data['items'] = SimplePie::merge_items($this->multifeed_objects, $start, $end, $this->item_limit); | |
2833 | } | |
2834 | else | |
2835 | { | |
2836 | $this->data['items'] = array(); | |
2837 | if ($items = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'entry')) | |
2838 | { | |
2839 | $keys = array_keys($items); | |
2840 | foreach ($keys as $key) | |
2841 | { | |
2842 | $this->data['items'][] = $this->registry->create('Item', array($this, $items[$key])); | |
2843 | } | |
2844 | } | |
2845 | if ($items = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'entry')) | |
2846 | { | |
2847 | $keys = array_keys($items); | |
2848 | foreach ($keys as $key) | |
2849 | { | |
2850 | $this->data['items'][] = $this->registry->create('Item', array($this, $items[$key])); | |
2851 | } | |
2852 | } | |
2853 | if ($items = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'item')) | |
2854 | { | |
2855 | $keys = array_keys($items); | |
2856 | foreach ($keys as $key) | |
2857 | { | |
2858 | $this->data['items'][] = $this->registry->create('Item', array($this, $items[$key])); | |
2859 | } | |
2860 | } | |
2861 | if ($items = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'item')) | |
2862 | { | |
2863 | $keys = array_keys($items); | |
2864 | foreach ($keys as $key) | |
2865 | { | |
2866 | $this->data['items'][] = $this->registry->create('Item', array($this, $items[$key])); | |
2867 | } | |
2868 | } | |
2869 | if ($items = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'item')) | |
2870 | { | |
2871 | $keys = array_keys($items); | |
2872 | foreach ($keys as $key) | |
2873 | { | |
2874 | $this->data['items'][] = $this->registry->create('Item', array($this, $items[$key])); | |
2875 | } | |
2876 | } | |
2877 | } | |
2878 | } | |
2879 | ||
2880 | if (!empty($this->data['items'])) | |
2881 | { | |
2882 | // If we want to order it by date, check if all items have a date, and then sort it | |
2883 | if ($this->order_by_date && empty($this->multifeed_objects)) | |
2884 | { | |
2885 | if (!isset($this->data['ordered_items'])) | |
2886 | { | |
2887 | $do_sort = true; | |
2888 | foreach ($this->data['items'] as $item) | |
2889 | { | |
2890 | if (!$item->get_date('U')) | |
2891 | { | |
2892 | $do_sort = false; | |
2893 | break; | |
2894 | } | |
2895 | } | |
2896 | $item = null; | |
2897 | $this->data['ordered_items'] = $this->data['items']; | |
2898 | if ($do_sort) | |
2899 | { | |
2900 | usort($this->data['ordered_items'], array(get_class($this), 'sort_items')); | |
2901 | } | |
2902 | } | |
2903 | $items = $this->data['ordered_items']; | |
2904 | } | |
2905 | else | |
2906 | { | |
2907 | $items = $this->data['items']; | |
2908 | } | |
2909 | ||
2910 | // Slice the data as desired | |
2911 | if ($end === 0) | |
2912 | { | |
2913 | return array_slice($items, $start); | |
2914 | } | |
2915 | else | |
2916 | { | |
2917 | return array_slice($items, $start, $end); | |
2918 | } | |
2919 | } | |
2920 | else | |
2921 | { | |
2922 | return array(); | |
2923 | } | |
2924 | } | |
2925 | ||
2926 | /** | |
2927 | * Set the favicon handler | |
2928 | * | |
2929 | * @deprecated Use your own favicon handling instead | |
2930 | */ | |
2931 | public function set_favicon_handler($page = false, $qs = 'i') | |
2932 | { | |
2933 | $level = defined('E_USER_DEPRECATED') ? E_USER_DEPRECATED : E_USER_WARNING; | |
2934 | trigger_error('Favicon handling has been removed, please use your own handling', $level); | |
2935 | return false; | |
2936 | } | |
2937 | ||
2938 | /** | |
2939 | * Get the favicon for the current feed | |
2940 | * | |
2941 | * @deprecated Use your own favicon handling instead | |
2942 | */ | |
2943 | public function get_favicon() | |
2944 | { | |
2945 | $level = defined('E_USER_DEPRECATED') ? E_USER_DEPRECATED : E_USER_WARNING; | |
2946 | trigger_error('Favicon handling has been removed, please use your own handling', $level); | |
2947 | ||
2948 | if (($url = $this->get_link()) !== null) | |
2949 | { | |
2950 | return 'http://g.etfv.co/' . urlencode($url); | |
2951 | } | |
2952 | ||
2953 | return false; | |
2954 | } | |
2955 | ||
2956 | /** | |
2957 | * Magic method handler | |
2958 | * | |
2959 | * @param string $method Method name | |
2960 | * @param array $args Arguments to the method | |
2961 | * @return mixed | |
2962 | */ | |
2963 | public function __call($method, $args) | |
2964 | { | |
2965 | if (strpos($method, 'subscribe_') === 0) | |
2966 | { | |
2967 | $level = defined('E_USER_DEPRECATED') ? E_USER_DEPRECATED : E_USER_WARNING; | |
2968 | trigger_error('subscribe_*() has been deprecated, implement the callback yourself', $level); | |
2969 | return ''; | |
2970 | } | |
2971 | if ($method === 'enable_xml_dump') | |
2972 | { | |
2973 | $level = defined('E_USER_DEPRECATED') ? E_USER_DEPRECATED : E_USER_WARNING; | |
2974 | trigger_error('enable_xml_dump() has been deprecated, use get_raw_data() instead', $level); | |
2975 | return false; | |
2976 | } | |
2977 | ||
2978 | $class = get_class($this); | |
2979 | $trace = debug_backtrace(); | |
2980 | $file = $trace[0]['file']; | |
2981 | $line = $trace[0]['line']; | |
2982 | trigger_error("Call to undefined method $class::$method() in $file on line $line", E_USER_ERROR); | |
2983 | } | |
2984 | ||
2985 | /** | |
2986 | * Sorting callback for items | |
2987 | * | |
2988 | * @access private | |
2989 | * @param SimplePie $a | |
2990 | * @param SimplePie $b | |
2991 | * @return boolean | |
2992 | */ | |
2993 | public static function sort_items($a, $b) | |
2994 | { | |
2995 | return $a->get_date('U') <= $b->get_date('U'); | |
2996 | } | |
2997 | ||
2998 | /** | |
2999 | * Merge items from several feeds into one | |
3000 | * | |
3001 | * If you're merging multiple feeds together, they need to all have dates | |
3002 | * for the items or else SimplePie will refuse to sort them. | |
3003 | * | |
3004 | * @link http://simplepie.org/wiki/tutorial/sort_multiple_feeds_by_time_and_date#if_feeds_require_separate_per-feed_settings | |
3005 | * @param array $urls List of SimplePie feed objects to merge | |
3006 | * @param int $start Starting item | |
3007 | * @param int $end Number of items to return | |
3008 | * @param int $limit Maximum number of items per feed | |
3009 | * @return array | |
3010 | */ | |
3011 | public static function merge_items($urls, $start = 0, $end = 0, $limit = 0) | |
3012 | { | |
3013 | if (is_array($urls) && sizeof($urls) > 0) | |
3014 | { | |
3015 | $items = array(); | |
3016 | foreach ($urls as $arg) | |
3017 | { | |
3018 | if ($arg instanceof SimplePie) | |
3019 | { | |
3020 | $items = array_merge($items, $arg->get_items(0, $limit)); | |
3021 | } | |
3022 | else | |
3023 | { | |
3024 | trigger_error('Arguments must be SimplePie objects', E_USER_WARNING); | |
3025 | } | |
3026 | } | |
3027 | ||
3028 | $do_sort = true; | |
3029 | foreach ($items as $item) | |
3030 | { | |
3031 | if (!$item->get_date('U')) | |
3032 | { | |
3033 | $do_sort = false; | |
3034 | break; | |
3035 | } | |
3036 | } | |
3037 | $item = null; | |
3038 | if ($do_sort) | |
3039 | { | |
3040 | usort($items, array(get_class($urls[0]), 'sort_items')); | |
3041 | } | |
3042 | ||
3043 | if ($end === 0) | |
3044 | { | |
3045 | return array_slice($items, $start); | |
3046 | } | |
3047 | else | |
3048 | { | |
3049 | return array_slice($items, $start, $end); | |
3050 | } | |
3051 | } | |
3052 | else | |
3053 | { | |
3054 | trigger_error('Cannot merge zero SimplePie objects', E_USER_WARNING); | |
3055 | return array(); | |
3056 | } | |
3057 | } | |
3058 | } |