root / drupal7 / sites / all / libraries / simplepie-1.3.1 / library / SimplePie.php @ 4b706e38
| 1 | 41cc1b08 | Assos Assos | <?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 | } |