[Sommaire] [Imprimer]

   1  <?php
   2  // $Id: xmlrss2parser.php 506 2006-05-26 23:10:37Z skalpa $

   3  //  ------------------------------------------------------------------------ //

   4  //                XOOPS - PHP Content Management System                      //

   5  //                    Copyright (c) 2000 XOOPS.org                           //

   6  //                       <http://www.xoops.org/>                             //

   7  //  ------------------------------------------------------------------------ //

   8  //  This program is free software; you can redistribute it and/or modify     //

   9  //  it under the terms of the GNU General Public License as published by     //

  10  //  the Free Software Foundation; either version 2 of the License, or        //

  11  //  (at your option) any later version.                                      //

  12  //                                                                           //

  13  //  You may not change or alter any portion of this comment or credits       //

  14  //  of supporting developers from this source code or any supporting         //

  15  //  source code which is considered copyrighted (c) material of the          //

  16  //  original comment or credit authors.                                      //

  17  //                                                                           //

  18  //  This program is distributed in the hope that it will be useful,          //

  19  //  but WITHOUT ANY WARRANTY; without even the implied warranty of           //

  20  //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            //

  21  //  GNU General Public License for more details.                             //

  22  //                                                                           //

  23  //  You should have received a copy of the GNU General Public License        //

  24  //  along with this program; if not, write to the Free Software              //

  25  //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA //

  26  //  ------------------------------------------------------------------------ //

  27  // Author: Kazumi Ono (AKA onokazu)                                          //

  28  // URL: http://www.myweb.ne.jp/, http://www.xoops.org/, http://jp.xoops.org/ //

  29  // Project: The XOOPS Project                                                //

  30  // ------------------------------------------------------------------------- //

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