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         class
 16:  * @subpackage      xml
 17:  * @since           1.0.0
 18:  * @author          Kazumi Ono (AKA onokazu)
 19:  * @version         $Id $
 20:  */
 21: 
 22: class XoopsXmlRss2Parser extends SaxParser
 23: {
 24:     /**
 25:      * @var array
 26:      */
 27:     private $_tempArr = array();
 28: 
 29:     /**
 30:      * @var array
 31:      */
 32:     private $_channelData = array();
 33: 
 34:     /**
 35:      * @var array
 36:      */
 37:     private $_imageData = array();
 38: 
 39:     /**
 40:      * @var array
 41:      */
 42:     private $_items = array();
 43: 
 44:     public function __construct(&$input)
 45:     {
 46:         parent::__construct($input);
 47:         $this->useUtfEncoding();
 48:         $this->addTagHandler(new RssChannelHandler());
 49:         $this->addTagHandler(new RssTitleHandler());
 50:         $this->addTagHandler(new RssLinkHandler());
 51:         $this->addTagHandler(new RssGeneratorHandler());
 52:         $this->addTagHandler(new RssDescriptionHandler());
 53:         $this->addTagHandler(new RssCopyrightHandler());
 54:         $this->addTagHandler(new RssNameHandler());
 55:         $this->addTagHandler(new RssManagingEditorHandler());
 56:         $this->addTagHandler(new RssLanguageHandler());
 57:         $this->addTagHandler(new RssLastBuildDateHandler());
 58:         $this->addTagHandler(new RssWebMasterHandler());
 59:         $this->addTagHandler(new RssImageHandler());
 60:         $this->addTagHandler(new RssUrlHandler());
 61:         $this->addTagHandler(new RssWidthHandler());
 62:         $this->addTagHandler(new RssHeightHandler());
 63:         $this->addTagHandler(new RssItemHandler());
 64:         $this->addTagHandler(new RssCategoryHandler());
 65:         $this->addTagHandler(new RssPubDateHandler());
 66:         $this->addTagHandler(new RssCommentsHandler());
 67:         $this->addTagHandler(new RssSourceHandler());
 68:         $this->addTagHandler(new RssAuthorHandler());
 69:         $this->addTagHandler(new RssGuidHandler());
 70:         $this->addTagHandler(new RssTextInputHandler());
 71:     }
 72: 
 73:     /**
 74:      * @param string $name
 75:      * @param string $value
 76:      * @return void
 77:      */
 78:     public function setChannelData($name, &$value)
 79:     {
 80:         if (!isset($this->_channelData[$name])) {
 81:             $this->_channelData[$name] = $value;
 82:         } else {
 83:             $this->_channelData[$name] .= $value;
 84:         }
 85:     }
 86: 
 87:     /**
 88:      * @param string $name
 89:      * @return array|bool
 90:      */
 91:     public function getChannelData($name = null)
 92:     {
 93:         if (isset($name)) {
 94:             if (isset($this->_channelData[$name])) {
 95:                 return $this->_channelData[$name];
 96:             }
 97:             return false;
 98:         }
 99:         return $this->_channelData;
100:     }
101: 
102:     /**
103:      * @param string $name
104:      * @param string $value
105:      * @return void
106:      */
107:     public function setImageData($name, &$value)
108:     {
109:         $this->_imageData[$name] = $value;
110:     }
111: 
112:     /**
113:      * @param string $name
114:      * @return array|bool
115:      */
116:     public function getImageData($name = null)
117:     {
118:         if (isset($name)) {
119:             if (isset($this->_imageData[$name])) {
120:                 return $this->_imageData[$name];
121:             }
122:             $return = false;
123:             return $return;
124:         }
125:         return $this->_imageData;
126:     }
127: 
128:     /**
129:      * @param array $itemarr
130:      * @return void
131:      */
132:     public function setItems(&$itemarr)
133:     {
134:         $this->_items[] = $itemarr;
135:     }
136: 
137:     /**
138:      * @return array
139:      */
140:     public function getItems()
141:     {
142:         return $this->_items;
143:     }
144: 
145:     /**
146:      * @param string $name
147:      * @param array $value
148:      * @param string $delim
149:      * @return void
150:      */
151:     public function setTempArr($name, &$value, $delim = '')
152:     {
153:         if (!isset($this->_tempArr[$name])) {
154:             $this->_tempArr[$name] = $value;
155:         } else {
156:             $this->_tempArr[$name] .= $delim . $value;
157:         }
158:     }
159: 
160:     /**
161:      * @return array
162:      */
163:     public function getTempArr()
164:     {
165:         return $this->_tempArr;
166:     }
167: 
168:     /**
169:      * @return void
170:      */
171:     public function resetTempArr()
172:     {
173:         unset($this->_tempArr);
174:         $this->_tempArr = array();
175:     }
176: }
177: 
178: class RssChannelHandler extends XmlTagHandler
179: {
180:     /**
181:      * @return string
182:      */
183:     public function getName()
184:     {
185:         return 'channel';
186:     }
187: }
188: 
189: class RssTitleHandler extends XmlTagHandler
190: {
191:     /**
192:      * @return string
193:      */
194:     public function getName()
195:     {
196:         return 'title';
197:     }
198: 
199:     /**
200:      * @param XoopsXmlRss2Parser $parser
201:      * @param array $data
202:      * @return void
203:      */
204:     public function handleCharacterData(&$parser, &$data)
205:     {
206:         switch ($parser->getParentTag()) {
207:             case 'channel':
208:                 $parser->setChannelData('title', $data);
209:                 break;
210:             case 'image':
211:                 $parser->setImageData('title', $data);
212:                 break;
213:             case 'item':
214:             case 'textInput':
215:                 $parser->setTempArr('title', $data);
216:                 break;
217:             default:
218:                 break;
219:         }
220:     }
221: }
222: 
223: class RssLinkHandler extends XmlTagHandler
224: {
225:     /**
226:      * @return string
227:      */
228:     public function getName()
229:     {
230:         return 'link';
231:     }
232: 
233:     /**
234:      * @param XoopsXmlRss2Parser $parser
235:      * @param array $data
236:      * @return void
237:      */
238:     public function handleCharacterData(&$parser, &$data)
239:     {
240:         switch ($parser->getParentTag()) {
241:             case 'channel':
242:                 $parser->setChannelData('link', $data);
243:                 break;
244:             case 'image':
245:                 $parser->setImageData('link', $data);
246:                 break;
247:             case 'item':
248:             case 'textInput':
249:                 $parser->setTempArr('link', $data);
250:                 break;
251:             default:
252:                 break;
253:         }
254:     }
255: }
256: 
257: class RssDescriptionHandler extends XmlTagHandler
258: {
259:     /**
260:      * @return string
261:      */
262:     public function getName()
263:     {
264:         return 'description';
265:     }
266: 
267:     /**
268:      * @param XoopsXmlRss2Parser $parser
269:      * @param array $data
270:      * @return void
271:      */
272:     public function handleCharacterData(&$parser, &$data)
273:     {
274:         switch ($parser->getParentTag()) {
275:             case 'channel':
276:                 $parser->setChannelData('description', $data);
277:                 break;
278:             case 'image':
279:                 $parser->setImageData('description', $data);
280:                 break;
281:             case 'item':
282:             case 'textInput':
283:                 $parser->setTempArr('description', $data);
284:                 break;
285:             default:
286:                 break;
287:         }
288:     }
289: }
290: 
291: class RssGeneratorHandler extends XmlTagHandler
292: {
293: 
294:     /**
295:      * @return string
296:      */
297:     public function getName()
298:     {
299:         return 'generator';
300:     }
301: 
302:     /**
303:      * @param XoopsXmlRss2Parser $parser
304:      * @param array $data
305:      * @return void
306:      */
307:     public function handleCharacterData(&$parser, &$data)
308:     {
309:         switch ($parser->getParentTag()) {
310:             case 'channel':
311:                 $parser->setChannelData('generator', $data);
312:                 break;
313:             default:
314:                 break;
315:         }
316:     }
317: }
318: 
319: class RssCopyrightHandler extends XmlTagHandler
320: {
321:     /**
322:      * @return string
323:      */
324:     public function getName()
325:     {
326:         return 'copyright';
327:     }
328: 
329:     /**
330:      * @param XoopsXmlRss2Parser $parser
331:      * @param array $data
332:      * @return void
333:      */
334:     public function handleCharacterData(&$parser, &$data)
335:     {
336:         switch ($parser->getParentTag()) {
337:             case 'channel':
338:                 $parser->setChannelData('copyright', $data);
339:                 break;
340:             default:
341:                 break;
342:         }
343:     }
344: }
345: 
346: class RssNameHandler extends XmlTagHandler
347: {
348:     /**
349:      * @return string
350:      */
351:     public function getName()
352:     {
353:         return 'name';
354:     }
355: 
356:     /**
357:      * @param XoopsXmlRss2Parser $parser
358:      * @param array $data
359:      * @return void
360:      */
361:     public function handleCharacterData(&$parser, &$data)
362:     {
363:         switch ($parser->getParentTag()) {
364:             case 'textInput':
365:                 $parser->setTempArr('name', $data);
366:                 break;
367:             default:
368:                 break;
369:         }
370:     }
371: }
372: 
373: class RssManagingEditorHandler extends XmlTagHandler
374: {
375: 
376:     /**
377:      * @return string
378:      */
379:     public function getName()
380:     {
381:         return 'managingEditor';
382:     }
383: 
384:     /**
385:      * @param XoopsXmlRss2Parser $parser
386:      * @param array $data
387:      * @return void
388:      */
389:     public function handleCharacterData(&$parser, &$data)
390:     {
391:         switch ($parser->getParentTag()) {
392:             case 'channel':
393:                 $parser->setChannelData('editor', $data);
394:                 break;
395:             default:
396:                 break;
397:         }
398:     }
399: }
400: 
401: class RssLanguageHandler extends XmlTagHandler
402: {
403: 
404:     /**
405:      * @return string
406:      */
407:     public function getName()
408:     {
409:         return 'language';
410:     }
411: 
412:     /**
413:      * @param XoopsXmlRss2Parser $parser
414:      * @param array $data
415:      * @return void
416:      */
417:     public function handleCharacterData(&$parser, &$data)
418:     {
419:         switch ($parser->getParentTag()) {
420:             case 'channel':
421:                 $parser->setChannelData('language', $data);
422:                 break;
423:             default:
424:                 break;
425:         }
426:     }
427: }
428: 
429: class RssWebMasterHandler extends XmlTagHandler
430: {
431:     /**
432:      * @return string
433:      */
434:     public function getName()
435:     {
436:         return 'webMaster';
437:     }
438: 
439:     /**
440:      * @param XoopsXmlRss2Parser $parser
441:      * @param array $data
442:      * @return void
443:      */
444:     public function handleCharacterData(&$parser, &$data)
445:     {
446:         switch ($parser->getParentTag()) {
447:             case 'channel':
448:                 $parser->setChannelData('webmaster', $data);
449:                 break;
450:             default:
451:                 break;
452:         }
453:     }
454: }
455: 
456: class RssDocsHandler extends XmlTagHandler
457: {
458:     /**
459:      * @return string
460:      */
461:     public function getName()
462:     {
463:         return 'docs';
464:     }
465: 
466:     /**
467:      * @param XoopsXmlRss2Parser $parser
468:      * @param array $data
469:      * @return void
470:      */
471:     public function handleCharacterData(&$parser, &$data)
472:     {
473:         switch ($parser->getParentTag()) {
474:             case 'channel':
475:                 $parser->setChannelData('docs', $data);
476:                 break;
477:             default:
478:                 break;
479:         }
480:     }
481: }
482: 
483: class RssTtlHandler extends XmlTagHandler
484: {
485:     /**
486:      * @return string
487:      */
488:     public function getName()
489:     {
490:         return 'ttl';
491:     }
492: 
493:     /**
494:      * @param XoopsXmlRss2Parser $parser
495:      * @param array $data
496:      * @return void
497:      */
498:     public function handleCharacterData(&$parser, &$data)
499:     {
500:         switch ($parser->getParentTag()) {
501:             case 'channel':
502:                 $parser->setChannelData('ttl', $data);
503:                 break;
504:             default:
505:                 break;
506:         }
507:     }
508: }
509: 
510: class RssTextInputHandler extends XmlTagHandler
511: {
512:     /**
513:      * @return string
514:      */
515:     public function getName()
516:     {
517:         return 'textInput';
518:     }
519: 
520:     /**
521:      * @param XoopsXmlRss2Parser $parser
522:      * @param array $attributes
523:      * @return void
524:      */
525:     public function handleBeginElement(&$parser, &$attributes)
526:     {
527:         $parser->resetTempArr();
528:     }
529: 
530:     /**
531:      * @param XoopsXmlRss2Parser $parser
532:      * @return void
533:      */
534:     public function handleEndElement(&$parser)
535:     {
536:         $parser->setChannelData('textinput', $parser->getTempArr());
537:     }
538: }
539: 
540: class RssLastBuildDateHandler extends XmlTagHandler
541: {
542:     /**
543:      * @return string
544:      */
545:     public function getName()
546:     {
547:         return 'lastBuildDate';
548:     }
549: 
550:     /**
551:      * @param XoopsXmlRss2Parser $parser
552:      * @param array $data
553:      * @return void
554:      */
555:     public function handleCharacterData(&$parser, &$data)
556:     {
557:         switch ($parser->getParentTag()) {
558:             case 'channel':
559:                 $parser->setChannelData('lastbuilddate', $data);
560:                 break;
561:             default:
562:                 break;
563:         }
564:     }
565: }
566: 
567: class RssImageHandler extends XmlTagHandler
568: {
569:     /**
570:      * @return string
571:      */
572:     public function getName()
573:     {
574:         return 'image';
575:     }
576: }
577: 
578: class RssUrlHandler extends XmlTagHandler
579: {
580:     /**
581:      * @return string
582:      */
583:     public function getName()
584:     {
585:         return 'url';
586:     }
587: 
588:     /**
589:      * @param XoopsXmlRss2Parser $parser
590:      * @param array $data
591:      * @return void
592:      */
593:     public function handleCharacterData(&$parser, &$data)
594:     {
595:         if ($parser->getParentTag() === 'image') {
596:             $parser->setImageData('url', $data);
597:         }
598:     }
599: }
600: 
601: class RssWidthHandler extends XmlTagHandler
602: {
603:     /**
604:      * @return string
605:      */
606:     public function getName()
607:     {
608:         return 'width';
609:     }
610: 
611:     /**
612:      * @param XoopsXmlRss2Parser $parser
613:      * @param array $data
614:      * @return void
615:      */
616:     public function handleCharacterData(&$parser, &$data)
617:     {
618:         if ($parser->getParentTag() === 'image') {
619:             $parser->setImageData('width', $data);
620:         }
621:     }
622: }
623: 
624: class RssHeightHandler extends XmlTagHandler
625: {
626:     /**
627:      * @return string
628:      */
629:     public function getName()
630:     {
631:         return 'height';
632:     }
633: 
634:     /**
635:      * @param XoopsXmlRss2Parser $parser
636:      * @param array $data
637:      * @return void
638:      */
639:     public function handleCharacterData(&$parser, &$data)
640:     {
641:         if ($parser->getParentTag() === 'image') {
642:             $parser->setImageData('height', $data);
643:         }
644:     }
645: }
646: 
647: class RssItemHandler extends XmlTagHandler
648: {
649:     /**
650:      * @return string
651:      */
652:     public function getName()
653:     {
654:         return 'item';
655:     }
656: 
657:     /**
658:      * @param XoopsXmlRss2Parser $parser
659:      * @param array $attributes
660:      * @return void
661:      */
662:     public function handleBeginElement(&$parser, &$attributes)
663:     {
664:         $parser->resetTempArr();
665:     }
666: 
667:     /**
668:      * @param XoopsXmlRss2Parser $parser
669:      * @return void
670:      */
671:     public function handleEndElement(&$parser)
672:     {
673:         $items = $parser->getTempArr();
674:         $parser->setItems($items);
675:     }
676: }
677: 
678: class RssCategoryHandler extends XmlTagHandler
679: {
680:     /**
681:      * @return string
682:      */
683:     public function getName()
684:     {
685:         return 'category';
686:     }
687: 
688:     /**
689:      * @param XoopsXmlRss2Parser $parser
690:      * @param array $data
691:      * @return void
692:      */
693:     public function handleCharacterData(&$parser, &$data)
694:     {
695:         switch ($parser->getParentTag()) {
696:             case 'channel':
697:                 $parser->setChannelData('category', $data);
698:                 break;
699:             case 'item':
700:                 $parser->setTempArr('category', $data, ', ');
701:                 break;
702:             default:
703:                 break;
704:         }
705:     }
706: }
707: 
708: class RssCommentsHandler extends XmlTagHandler
709: {
710:     /**
711:      * @return string
712:      */
713:     public function getName()
714:     {
715:         return 'comments';
716:     }
717: 
718:     /**
719:      * @param XoopsXmlRss2Parser $parser
720:      * @param array $data
721:      * @return void
722:      */
723:     public function handleCharacterData(&$parser, &$data)
724:     {
725:         if ($parser->getParentTag() === 'item') {
726:             $parser->setTempArr('comments', $data);
727:         }
728:     }
729: }
730: 
731: class RssPubDateHandler extends XmlTagHandler
732: {
733:     /**
734:      * @return string
735:      */
736:     public function getName()
737:     {
738:         return 'pubDate';
739:     }
740: 
741:     /**
742:      * @param XoopsXmlRss2Parser $parser
743:      * @param array $data
744:      * @return void
745:      */
746:     public function handleCharacterData(&$parser, &$data)
747:     {
748:         switch ($parser->getParentTag()) {
749:             case 'channel':
750:                 $parser->setChannelData('pubdate', $data);
751:                 break;
752:             case 'item':
753:                 $parser->setTempArr('pubdate', $data);
754:                 break;
755:             default:
756:                 break;
757:         }
758:     }
759: }
760: 
761: class RssGuidHandler extends XmlTagHandler
762: {
763:     /**
764:      * @return string
765:      */
766:     public function getName()
767:     {
768:         return 'guid';
769:     }
770: 
771:     /**
772:      * @param XoopsXmlRss2Parser $parser
773:      * @param array $data
774:      * @return void
775:      */
776:     public function handleCharacterData(&$parser, &$data)
777:     {
778:         if ($parser->getParentTag() === 'item') {
779:             $parser->setTempArr('guid', $data);
780:         }
781:     }
782: }
783: 
784: class RssAuthorHandler extends XmlTagHandler
785: {
786:     /**
787:      * @return string
788:      */
789:     public function getName()
790:     {
791:         return 'author';
792:     }
793: 
794:     /**
795:      * @param XoopsXmlRss2Parser $parser
796:      * @param array $data
797:      * @return void
798:      */
799:     public function handleCharacterData(&$parser, &$data)
800:     {
801:         if ($parser->getParentTag() === 'item') {
802:             $parser->setTempArr('author', $data);
803:         }
804:     }
805: }
806: 
807: class RssSourceHandler extends XmlTagHandler
808: {
809:     /**
810:      * @return string
811:      */
812:     public function getName()
813:     {
814:         return 'source';
815:     }
816: 
817:     /**
818:      * @param XoopsXmlRss2Parser $parser
819:      * @param array $attributes
820:      * @return void
821:      */
822:     public function handleBeginElement(&$parser, &$attributes)
823:     {
824:         if ($parser->getParentTag() === 'item') {
825:             $parser->setTempArr('source_url', $attributes['url']);
826:         }
827:     }
828: 
829:     /**
830:      * @param XoopsXmlRss2Parser $parser
831:      * @param array $data
832:      * @return void
833:      */
834:     public function handleCharacterData(&$parser, &$data)
835:     {
836:         if ($parser->getParentTag() === 'item') {
837:             $parser->setTempArr('source', $data);
838:         }
839:     }
840: }
841: