1: <?php
   2: /*
   3:  * You may not change or alter any portion of this comment or credits
   4:  * of supporting developers from this source code or any supporting source code
   5:  * which is considered copyrighted (c) material of the original comment or credit authors.
   6:  *
   7:  * This program is distributed in the hope that it will be useful,
   8:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  10:  */
  11: 
  12: /**
  13:  * @copyright    XOOPS Project http://xoops.org/
  14:  * @license      GNU GPL 2 or later (http://www.gnu.org/licenses/gpl-2.0.html)
  15:  * @package
  16:  * @since
  17:  * @author       XOOPS Development Team, Kazumi Ono (AKA onokazu)
  18:  */
  19: 
  20: defined('XOOPS_ROOT_PATH') || exit('XOOPS root path not defined');
  21: require_once(XOOPS_ROOT_PATH . '/class/xml/saxparser.php');
  22: require_once(XOOPS_ROOT_PATH . '/class/xml/xmltaghandler.php');
  23: 
  24: /**
  25:  * Class XoopsXmlRss2Parser
  26:  */
  27: class XoopsXmlRss2Parser extends SaxParser
  28: {
  29:     public $_tempArr     = array();
  30:     public $_channelData = array();
  31:     public $_imageData   = array();
  32:     public $_items       = array();
  33: 
  34:     /**
  35:      * @param $input
  36:      */
  37:     public function __construct($input)
  38:     {
  39:         parent::__construct($input);
  40:         $this->useUtfEncoding();
  41:         $this->addTagHandler(new RssChannelHandler());
  42:         $this->addTagHandler(new RssTitleHandler());
  43:         $this->addTagHandler(new RssLinkHandler());
  44:         $this->addTagHandler(new RssGeneratorHandler());
  45:         $this->addTagHandler(new RssDescriptionHandler());
  46:         $this->addTagHandler(new RssCopyrightHandler());
  47:         $this->addTagHandler(new RssNameHandler());
  48:         $this->addTagHandler(new RssManagingEditorHandler());
  49:         $this->addTagHandler(new RssLanguageHandler());
  50:         $this->addTagHandler(new RssLastBuildDateHandler());
  51:         $this->addTagHandler(new RssWebMasterHandler());
  52:         $this->addTagHandler(new RssImageHandler());
  53:         $this->addTagHandler(new RssUrlHandler());
  54:         $this->addTagHandler(new RssWidthHandler());
  55:         $this->addTagHandler(new RssHeightHandler());
  56:         $this->addTagHandler(new RssItemHandler());
  57:         $this->addTagHandler(new RssCategoryHandler());
  58:         $this->addTagHandler(new RssPubDateHandler());
  59:         $this->addTagHandler(new RssCommentsHandler());
  60:         $this->addTagHandler(new RssSourceHandler());
  61:         $this->addTagHandler(new RssAuthorHandler());
  62:         $this->addTagHandler(new RssGuidHandler());
  63:         $this->addTagHandler(new RssTextInputHandler());
  64:     }
  65: 
  66:     /**
  67:      * @param $name
  68:      * @param $value
  69:      */
  70:     public function setChannelData($name, &$value)
  71:     {
  72:         if (!isset($this->_channelData[$name])) {
  73:             $this->_channelData[$name] =& $value;
  74:         } else {
  75:             $this->_channelData[$name] .= $value;
  76:         }
  77:     }
  78: 
  79:     /**
  80:      * @param null $name
  81:      *
  82:      * @return array|bool
  83:      */
  84:     public function &getChannelData($name = null)
  85:     {
  86:         if (isset($name)) {
  87:             if (isset($this->_channelData[$name])) {
  88:                 return $this->_channelData[$name];
  89:             }
  90: 
  91:             return false;
  92:         }
  93: 
  94:         return $this->_channelData;
  95:     }
  96: 
  97:     /**
  98:      * @param $name
  99:      * @param $value
 100:      */
 101:     public function setImageData($name, &$value)
 102:     {
 103:         $this->_imageData[$name] =& $value;
 104:     }
 105: 
 106:     /**
 107:      * @param null $name
 108:      *
 109:      * @return array|bool
 110:      */
 111:     public function &getImageData($name = null)
 112:     {
 113:         if (isset($name)) {
 114:             if (isset($this->_imageData[$name])) {
 115:                 return $this->_imageData[$name];
 116:             }
 117:             $return = false;
 118: 
 119:             return $return;
 120:         }
 121: 
 122:         return $this->_imageData;
 123:     }
 124: 
 125:     /**
 126:      * @param $itemarr
 127:      */
 128:     public function setItems(&$itemarr)
 129:     {
 130:         $this->_items[] =& $itemarr;
 131:     }
 132: 
 133:     /**
 134:      * @return array
 135:      */
 136:     public function &getItems()
 137:     {
 138:         return $this->_items;
 139:     }
 140: 
 141:     /**
 142:      * @param        $name
 143:      * @param        $value
 144:      * @param string $delim
 145:      */
 146:     public function setTempArr($name, &$value, $delim = '')
 147:     {
 148:         if (!isset($this->_tempArr[$name])) {
 149:             $this->_tempArr[$name] =& $value;
 150:         } else {
 151:             $this->_tempArr[$name] .= $delim . $value;
 152:         }
 153:     }
 154: 
 155:     /**
 156:      * @return array
 157:      */
 158:     public function getTempArr()
 159:     {
 160:         return $this->_tempArr;
 161:     }
 162: 
 163:     public function resetTempArr()
 164:     {
 165:         unset($this->_tempArr);
 166:         $this->_tempArr = array();
 167:     }
 168: }
 169: 
 170: /**
 171:  * Class RssChannelHandler
 172:  */
 173: class RssChannelHandler extends XmlTagHandler
 174: {
 175:     /**
 176:      * RssChannelHandler constructor.
 177:      */
 178:     public function __construct()
 179:     {
 180:     }
 181: 
 182:     /**
 183:      * @return string
 184:      */
 185:     public function getName()
 186:     {
 187:         return 'channel';
 188:     }
 189: }
 190: 
 191: /**
 192:  * Class RssTitleHandler
 193:  */
 194: class RssTitleHandler extends XmlTagHandler
 195: {
 196:     /**
 197:      * RssTitleHandler constructor.
 198:      */
 199:     public function __construct()
 200:     {
 201:     }
 202: 
 203:     /**
 204:      * @return string
 205:      */
 206:     public function getName()
 207:     {
 208:         return 'title';
 209:     }
 210: 
 211:     /**
 212:      * @param $parser
 213:      * @param $data
 214:      */
 215:     public function handleCharacterData($parser, &$data)
 216:     {
 217:         switch ($parser->getParentTag()) {
 218:             case 'channel':
 219:                 $parser->setChannelData('title', $data);
 220:                 break;
 221:             case 'image':
 222:                 $parser->setImageData('title', $data);
 223:                 break;
 224:             case 'item':
 225:             case 'textInput':
 226:                 $parser->setTempArr('title', $data);
 227:                 break;
 228:             default:
 229:                 break;
 230:         }
 231:     }
 232: }
 233: 
 234: /**
 235:  * Class RssLinkHandler
 236:  */
 237: class RssLinkHandler extends XmlTagHandler
 238: {
 239:     /**
 240:      * RssLinkHandler constructor.
 241:      */
 242:     public function __construct()
 243:     {
 244:     }
 245: 
 246:     /**
 247:      * @return string
 248:      */
 249:     public function getName()
 250:     {
 251:         return 'link';
 252:     }
 253: 
 254:     /**
 255:      * @param $parser
 256:      * @param $data
 257:      */
 258:     public function handleCharacterData($parser, &$data)
 259:     {
 260:         switch ($parser->getParentTag()) {
 261:             case 'channel':
 262:                 $parser->setChannelData('link', $data);
 263:                 break;
 264:             case 'image':
 265:                 $parser->setImageData('link', $data);
 266:                 break;
 267:             case 'item':
 268:             case 'textInput':
 269:                 $parser->setTempArr('link', $data);
 270:                 break;
 271:             default:
 272:                 break;
 273:         }
 274:     }
 275: }
 276: 
 277: /**
 278:  * Class RssDescriptionHandler
 279:  */
 280: class RssDescriptionHandler extends XmlTagHandler
 281: {
 282:     /**
 283:      * RssDescriptionHandler constructor.
 284:      */
 285:     public function __construct()
 286:     {
 287:     }
 288: 
 289:     /**
 290:      * @return string
 291:      */
 292:     public function getName()
 293:     {
 294:         return 'description';
 295:     }
 296: 
 297:     /**
 298:      * @param $parser
 299:      * @param $data
 300:      */
 301:     public function handleCharacterData($parser, &$data)
 302:     {
 303:         switch ($parser->getParentTag()) {
 304:             case 'channel':
 305:                 $parser->setChannelData('description', $data);
 306:                 break;
 307:             case 'image':
 308:                 $parser->setImageData('description', $data);
 309:                 break;
 310:             case 'item':
 311:             case 'textInput':
 312:                 $parser->setTempArr('description', $data);
 313:                 break;
 314:             default:
 315:                 break;
 316:         }
 317:     }
 318: }
 319: 
 320: /**
 321:  * Class RssGeneratorHandler
 322:  */
 323: class RssGeneratorHandler extends XmlTagHandler
 324: {
 325:     /**
 326:      * RssGeneratorHandler constructor.
 327:      */
 328:     public function __construct()
 329:     {
 330:     }
 331: 
 332:     /**
 333:      * @return string
 334:      */
 335:     public function getName()
 336:     {
 337:         return 'generator';
 338:     }
 339: 
 340:     /**
 341:      * @param $parser
 342:      * @param $data
 343:      */
 344:     public function handleCharacterData($parser, &$data)
 345:     {
 346:         switch ($parser->getParentTag()) {
 347:             case 'channel':
 348:                 $parser->setChannelData('generator', $data);
 349:                 break;
 350:             default:
 351:                 break;
 352:         }
 353:     }
 354: }
 355: 
 356: /**
 357:  * Class RssCopyrightHandler
 358:  */
 359: class RssCopyrightHandler extends XmlTagHandler
 360: {
 361:     /**
 362:      * RssCopyrightHandler constructor.
 363:      */
 364:     public function __construct()
 365:     {
 366:     }
 367: 
 368:     /**
 369:      * @return string
 370:      */
 371:     public function getName()
 372:     {
 373:         return 'copyright';
 374:     }
 375: 
 376:     /**
 377:      * @param $parser
 378:      * @param $data
 379:      */
 380:     public function handleCharacterData($parser, &$data)
 381:     {
 382:         switch ($parser->getParentTag()) {
 383:             case 'channel':
 384:                 $parser->setChannelData('copyright', $data);
 385:                 break;
 386:             default:
 387:                 break;
 388:         }
 389:     }
 390: }
 391: 
 392: /**
 393:  * Class RssNameHandler
 394:  */
 395: class RssNameHandler extends XmlTagHandler
 396: {
 397:     /**
 398:      * RssNameHandler constructor.
 399:      */
 400:     public function __construct()
 401:     {
 402:     }
 403: 
 404:     /**
 405:      * @return string
 406:      */
 407:     public function getName()
 408:     {
 409:         return 'name';
 410:     }
 411: 
 412:     /**
 413:      * @param $parser
 414:      * @param $data
 415:      */
 416:     public function handleCharacterData($parser, &$data)
 417:     {
 418:         switch ($parser->getParentTag()) {
 419:             case 'textInput':
 420:                 $parser->setTempArr('name', $data);
 421:                 break;
 422:             default:
 423:                 break;
 424:         }
 425:     }
 426: }
 427: 
 428: /**
 429:  * Class RssManagingEditorHandler
 430:  */
 431: class RssManagingEditorHandler extends XmlTagHandler
 432: {
 433:     /**
 434:      * RssManagingEditorHandler constructor.
 435:      */
 436:     public function __construct()
 437:     {
 438:     }
 439: 
 440:     /**
 441:      * @return string
 442:      */
 443:     public function getName()
 444:     {
 445:         return 'managingEditor';
 446:     }
 447: 
 448:     /**
 449:      * @param $parser
 450:      * @param $data
 451:      */
 452:     public function handleCharacterData($parser, &$data)
 453:     {
 454:         switch ($parser->getParentTag()) {
 455:             case 'channel':
 456:                 $parser->setChannelData('editor', $data);
 457:                 break;
 458:             default:
 459:                 break;
 460:         }
 461:     }
 462: }
 463: 
 464: /**
 465:  * Class RssLanguageHandler
 466:  */
 467: class RssLanguageHandler extends XmlTagHandler
 468: {
 469:     /**
 470:      * RssLanguageHandler constructor.
 471:      */
 472:     public function __construct()
 473:     {
 474:     }
 475: 
 476:     /**
 477:      * @return string
 478:      */
 479:     public function getName()
 480:     {
 481:         return 'language';
 482:     }
 483: 
 484:     /**
 485:      * @param $parser
 486:      * @param $data
 487:      */
 488:     public function handleCharacterData($parser, &$data)
 489:     {
 490:         switch ($parser->getParentTag()) {
 491:             case 'channel':
 492:                 $parser->setChannelData('language', $data);
 493:                 break;
 494:             default:
 495:                 break;
 496:         }
 497:     }
 498: }
 499: 
 500: /**
 501:  * Class RssWebMasterHandler
 502:  */
 503: class RssWebMasterHandler extends XmlTagHandler
 504: {
 505:     /**
 506:      * RssWebMasterHandler constructor.
 507:      */
 508:     public function __construct()
 509:     {
 510:     }
 511: 
 512:     /**
 513:      * @return string
 514:      */
 515:     public function getName()
 516:     {
 517:         return 'webMaster';
 518:     }
 519: 
 520:     /**
 521:      * @param $parser
 522:      * @param $data
 523:      */
 524:     public function handleCharacterData($parser, &$data)
 525:     {
 526:         switch ($parser->getParentTag()) {
 527:             case 'channel':
 528:                 $parser->setChannelData('webmaster', $data);
 529:                 break;
 530:             default:
 531:                 break;
 532:         }
 533:     }
 534: }
 535: 
 536: /**
 537:  * Class RssDocsHandler
 538:  */
 539: class RssDocsHandler extends XmlTagHandler
 540: {
 541:     /**
 542:      * RssDocsHandler constructor.
 543:      */
 544:     public function __construct()
 545:     {
 546:     }
 547: 
 548:     /**
 549:      * @return string
 550:      */
 551:     public function getName()
 552:     {
 553:         return 'docs';
 554:     }
 555: 
 556:     /**
 557:      * @param $parser
 558:      * @param $data
 559:      */
 560:     public function handleCharacterData($parser, &$data)
 561:     {
 562:         switch ($parser->getParentTag()) {
 563:             case 'channel':
 564:                 $parser->setChannelData('docs', $data);
 565:                 break;
 566:             default:
 567:                 break;
 568:         }
 569:     }
 570: }
 571: 
 572: /**
 573:  * Class RssTtlHandler
 574:  */
 575: class RssTtlHandler extends XmlTagHandler
 576: {
 577:     /**
 578:      * RssTtlHandler constructor.
 579:      */
 580:     public function __construct()
 581:     {
 582:     }
 583: 
 584:     /**
 585:      * @return string
 586:      */
 587:     public function getName()
 588:     {
 589:         return 'ttl';
 590:     }
 591: 
 592:     /**
 593:      * @param $parser
 594:      * @param $data
 595:      */
 596:     public function handleCharacterData($parser, &$data)
 597:     {
 598:         switch ($parser->getParentTag()) {
 599:             case 'channel':
 600:                 $parser->setChannelData('ttl', $data);
 601:                 break;
 602:             default:
 603:                 break;
 604:         }
 605:     }
 606: }
 607: 
 608: /**
 609:  * Class RssTextInputHandler
 610:  */
 611: class RssTextInputHandler extends XmlTagHandler
 612: {
 613:     public function RssWebMasterHandler()
 614:     {
 615:     }
 616: 
 617:     /**
 618:      * @return string
 619:      */
 620:     public function getName()
 621:     {
 622:         return 'textInput';
 623:     }
 624: 
 625:     /**
 626:      * @param $parser
 627:      * @param $attributes
 628:      */
 629:     public function handleBeginElement($parser, &$attributes)
 630:     {
 631:         $parser->resetTempArr();
 632:     }
 633: 
 634:     /**
 635:      * @param $parser
 636:      */
 637:     public function handleEndElement($parser)
 638:     {
 639:         $parser->setChannelData('textinput', $parser->getTempArr());
 640:     }
 641: }
 642: 
 643: /**
 644:  * Class RssLastBuildDateHandler
 645:  */
 646: class RssLastBuildDateHandler extends XmlTagHandler
 647: {
 648:     /**
 649:      * RssLastBuildDateHandler constructor.
 650:      */
 651:     public function __construct()
 652:     {
 653:     }
 654: 
 655:     /**
 656:      * @return string
 657:      */
 658:     public function getName()
 659:     {
 660:         return 'lastBuildDate';
 661:     }
 662: 
 663:     /**
 664:      * @param $parser
 665:      * @param $data
 666:      */
 667:     public function handleCharacterData($parser, &$data)
 668:     {
 669:         switch ($parser->getParentTag()) {
 670:             case 'channel':
 671:                 $parser->setChannelData('lastbuilddate', $data);
 672:                 break;
 673:             default:
 674:                 break;
 675:         }
 676:     }
 677: }
 678: 
 679: /**
 680:  * Class RssImageHandler
 681:  */
 682: class RssImageHandler extends XmlTagHandler
 683: {
 684:     /**
 685:      * RssImageHandler constructor.
 686:      */
 687:     public function __construct()
 688:     {
 689:     }
 690: 
 691:     /**
 692:      * @return string
 693:      */
 694:     public function getName()
 695:     {
 696:         return 'image';
 697:     }
 698: }
 699: 
 700: /**
 701:  * Class RssUrlHandler
 702:  */
 703: class RssUrlHandler extends XmlTagHandler
 704: {
 705:     /**
 706:      * RssUrlHandler constructor.
 707:      */
 708:     public function __construct()
 709:     {
 710:     }
 711: 
 712:     /**
 713:      * @return string
 714:      */
 715:     public function getName()
 716:     {
 717:         return 'url';
 718:     }
 719: 
 720:     /**
 721:      * @param $parser
 722:      * @param $data
 723:      */
 724:     public function handleCharacterData($parser, &$data)
 725:     {
 726:         if ($parser->getParentTag() === 'image') {
 727:             $parser->setImageData('url', $data);
 728:         }
 729:     }
 730: }
 731: 
 732: /**
 733:  * Class RssWidthHandler
 734:  */
 735: class RssWidthHandler extends XmlTagHandler
 736: {
 737:     /**
 738:      * RssWidthHandler constructor.
 739:      */
 740:     public function __construct()
 741:     {
 742:     }
 743: 
 744:     /**
 745:      * @return string
 746:      */
 747:     public function getName()
 748:     {
 749:         return 'width';
 750:     }
 751: 
 752:     /**
 753:      * @param $parser
 754:      * @param $data
 755:      */
 756:     public function handleCharacterData($parser, &$data)
 757:     {
 758:         if ($parser->getParentTag() === 'image') {
 759:             $parser->setImageData('width', $data);
 760:         }
 761:     }
 762: }
 763: 
 764: /**
 765:  * Class RssHeightHandler
 766:  */
 767: class RssHeightHandler extends XmlTagHandler
 768: {
 769:     /**
 770:      * RssHeightHandler constructor.
 771:      */
 772:     public function __construct()
 773:     {
 774:     }
 775: 
 776:     /**
 777:      * @return string
 778:      */
 779:     public function getName()
 780:     {
 781:         return 'height';
 782:     }
 783: 
 784:     /**
 785:      * @param $parser
 786:      * @param $data
 787:      */
 788:     public function handleCharacterData($parser, &$data)
 789:     {
 790:         if ($parser->getParentTag() === 'image') {
 791:             $parser->setImageData('height', $data);
 792:         }
 793:     }
 794: }
 795: 
 796: /**
 797:  * Class RssItemHandler
 798:  */
 799: class RssItemHandler extends XmlTagHandler
 800: {
 801:     /**
 802:      * RssItemHandler constructor.
 803:      */
 804:     public function __construct()
 805:     {
 806:     }
 807: 
 808:     /**
 809:      * @return string
 810:      */
 811:     public function getName()
 812:     {
 813:         return 'item';
 814:     }
 815: 
 816:     /**
 817:      * @param $parser
 818:      * @param $attributes
 819:      */
 820:     public function handleBeginElement($parser, &$attributes)
 821:     {
 822:         $parser->resetTempArr();
 823:     }
 824: 
 825:     /**
 826:      * @param $parser
 827:      */
 828:     public function handleEndElement($parser)
 829:     {
 830:         $items = $parser->getTempArr();
 831:         $parser->setItems($items);
 832:     }
 833: }
 834: 
 835: /**
 836:  * Class RssCategoryHandler
 837:  */
 838: class RssCategoryHandler extends XmlTagHandler
 839: {
 840:     /**
 841:      * RssCategoryHandler constructor.
 842:      */
 843:     public function __construct()
 844:     {
 845:     }
 846: 
 847:     /**
 848:      * @return string
 849:      */
 850:     public function getName()
 851:     {
 852:         return 'category';
 853:     }
 854: 
 855:     /**
 856:      * @param $parser
 857:      * @param $data
 858:      */
 859:     public function handleCharacterData($parser, &$data)
 860:     {
 861:         switch ($parser->getParentTag()) {
 862:             case 'channel':
 863:                 $parser->setChannelData('category', $data);
 864:                 break;
 865:             case 'item':
 866:                 $parser->setTempArr('category', $data, ', ');
 867:                 break;
 868:             default:
 869:                 break;
 870:         }
 871:     }
 872: }
 873: 
 874: /**
 875:  * Class RssCommentsHandler
 876:  */
 877: class RssCommentsHandler extends XmlTagHandler
 878: {
 879:     /**
 880:      * RssCommentsHandler constructor.
 881:      */
 882:     public function __construct()
 883:     {
 884:     }
 885: 
 886:     /**
 887:      * @return string
 888:      */
 889:     public function getName()
 890:     {
 891:         return 'comments';
 892:     }
 893: 
 894:     /**
 895:      * @param $parser
 896:      * @param $data
 897:      */
 898:     public function handleCharacterData($parser, &$data)
 899:     {
 900:         if ($parser->getParentTag() === 'item') {
 901:             $parser->setTempArr('comments', $data);
 902:         }
 903:     }
 904: }
 905: 
 906: /**
 907:  * Class RssPubDateHandler
 908:  */
 909: class RssPubDateHandler extends XmlTagHandler
 910: {
 911:     /**
 912:      * RssPubDateHandler constructor.
 913:      */
 914:     public function __construct()
 915:     {
 916:     }
 917: 
 918:     /**
 919:      * @return string
 920:      */
 921:     public function getName()
 922:     {
 923:         return 'pubDate';
 924:     }
 925: 
 926:     /**
 927:      * @param $parser
 928:      * @param $data
 929:      */
 930:     public function handleCharacterData($parser, &$data)
 931:     {
 932:         switch ($parser->getParentTag()) {
 933:             case 'channel':
 934:                 $parser->setChannelData('pubdate', $data);
 935:                 break;
 936:             case 'item':
 937:                 $parser->setTempArr('pubdate', $data);
 938:                 break;
 939:             default:
 940:                 break;
 941:         }
 942:     }
 943: }
 944: 
 945: /**
 946:  * Class RssGuidHandler
 947:  */
 948: class RssGuidHandler extends XmlTagHandler
 949: {
 950:     /**
 951:      * RssGuidHandler constructor.
 952:      */
 953:     public function __construct()
 954:     {
 955:     }
 956: 
 957:     /**
 958:      * @return string
 959:      */
 960:     public function getName()
 961:     {
 962:         return 'guid';
 963:     }
 964: 
 965:     /**
 966:      * @param $parser
 967:      * @param $data
 968:      */
 969:     public function handleCharacterData($parser, &$data)
 970:     {
 971:         if ($parser->getParentTag() === 'item') {
 972:             $parser->setTempArr('guid', $data);
 973:         }
 974:     }
 975: }
 976: 
 977: /**
 978:  * Class RssAuthorHandler
 979:  */
 980: class RssAuthorHandler extends XmlTagHandler
 981: {
 982:     public function RssGuidHandler()
 983:     {
 984:     }
 985: 
 986:     /**
 987:      * @return string
 988:      */
 989:     public function getName()
 990:     {
 991:         return 'author';
 992:     }
 993: 
 994:     /**
 995:      * @param $parser
 996:      * @param $data
 997:      */
 998:     public function handleCharacterData($parser, &$data)
 999:     {
1000:         if ($parser->getParentTag() === 'item') {
1001:             $parser->setTempArr('author', $data);
1002:         }
1003:     }
1004: }
1005: 
1006: /**
1007:  * Class RssSourceHandler
1008:  */
1009: class RssSourceHandler extends XmlTagHandler
1010: {
1011:     /**
1012:      * RssSourceHandler constructor.
1013:      */
1014:     public function __construct()
1015:     {
1016:     }
1017: 
1018:     /**
1019:      * @return string
1020:      */
1021:     public function getName()
1022:     {
1023:         return 'source';
1024:     }
1025: 
1026:     /**
1027:      * @param $parser
1028:      * @param $attributes
1029:      */
1030:     public function handleBeginElement($parser, &$attributes)
1031:     {
1032:         if ($parser->getParentTag() === 'item') {
1033:             $parser->setTempArr('source_url', $attributes['url']);
1034:         }
1035:     }
1036: 
1037:     /**
1038:      * @param $parser
1039:      * @param $data
1040:      */
1041:     public function handleCharacterData($parser, &$data)
1042:     {
1043:         if ($parser->getParentTag() === 'item') {
1044:             $parser->setTempArr('source', $data);
1045:         }
1046:     }
1047: }
1048: